ruvnet-brain 4.3.15 → 4.3.16

package/README.md

@@ -7,7 +7,7 @@ Created: 2026-06-29 22:36:38 EDT
 
 # 🧠 RuvNet Brain
 
-### 🧠 RuvNet Brain — [![RuvNet Brain version 4.3.15 — updated 2026-07-30 03:24 EDT](https://img.shields.io/badge/version_4.3.15-updated_2026--07--30_03:24_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 4.3.16 — updated 2026-07-30 03:24 EDT](https://img.shields.io/badge/version_4.3.16-updated_2026--07--30_03:24_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.**
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ruvnet-brain",
-  "version": "4.3.15",
+  "version": "4.3.16",
   "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 an enforced UserPromptSubmit retrieve-and-inject grounding hook that sharply reduces drift.",
-  "version": "4.3.15",
+  "version": "4.3.16",
   "author": {
     "name": "Stuart Kerr"
   },

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

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

package/plugin/skills/ruvnet-brain/SKILL.md

@@ -106,6 +106,11 @@ verification → at most one revision. Both hosts design the ADR, DDD and intend
 Agentic-QE then generates and executes the measurable test artifacts. A host merely completing is
 not an accepted outcome.
 
+When the duel returns `learningPersistenceRequest`, pass that request to Ruflo's structured
+`memory_store` tool and verify the exact returned key. The coordinator never starts a second Ruflo
+memory driver itself; without an MCP-aware caller it leaves `learningPersisted: false` and prints
+the pending request so the completed duel is not mistaken for a persisted learning event.
+
 Subscription-only is a billing boundary: verify with `claude auth status --json` and
 `codex login status`, strip provider API-key variables from both child processes, and never fall back
 to an API when a subscription is absent or capacity-limited. Subscription use consumes plan

package/scripts/dual-host-deliberation.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import { createHash } from 'node:crypto';
-import { spawn, spawnSync } from 'node:child_process';
+import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { probeSubscriptionHosts, subscriptionOnlyEnv } from './subscription-hosts.mjs';
 
@@ -67,15 +67,34 @@ function parseHostValue(host, stdout) {
   }
 }
 
-function spawnHost(binary, args, options) {
+function spawnHost(binary, args, options, input = '') {
   return new Promise((resolve) => {
     const child = spawn(binary, args, options);
     let stdout = '';
     let stderr = '';
+    let inputError = null;
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      resolve(result);
+    };
     child.stdout.on('data', (chunk) => { stdout += chunk; });
     child.stderr.on('data', (chunk) => { stderr += chunk; });
-    child.on('error', (error) => resolve({ status: null, stdout, stderr: error.message }));
-    child.on('close', (status) => resolve({ status, stdout, stderr }));
+    child.stdin.on('error', (error) => {
+      inputError = error;
+      stderr += `${stderr ? '\n' : ''}${error.message}`;
+      try { child.kill(); } catch { /* child may already be gone */ }
+    });
+    child.on('error', (error) => finish({ status: null, stdout, stderr: error.message, error }));
+    try {
+      child.stdin.end(input);
+    } catch (error) {
+      inputError = error;
+      stderr += `${stderr ? '\n' : ''}${error.message}`;
+      try { child.kill(); } catch { /* child may already be gone */ }
+    }
+    child.on('close', (status) => finish({ status, stdout, stderr, error: inputError }));
   });
 }
 
@@ -87,20 +106,21 @@ export async function runSubscriptionHost(host, stage, payload, { cwd = process.
         binary: 'claude',
         args: [
           '-p', '--output-format', 'json', '--permission-mode', 'plan',
-          '--tools', 'Read,Grep,Glob', '--no-session-persistence', '--effort', 'high', prompt,
+          '--tools', 'Read,Grep,Glob', '--no-session-persistence', '--effort', 'high',
         ],
       }
     : {
         binary: 'codex',
         args: [
           'exec', '--ephemeral', '--sandbox', 'read-only', '--color', 'never', '--json',
-          '-m', 'gpt-5.6-sol', '-c', 'model_reasoning_effort="high"', prompt,
+          '-m', 'gpt-5.6-sol', '-c', 'model_reasoning_effort="high"',
         ],
       };
-  const result = await spawnHost(command.binary, command.args, { cwd, env, stdio: ['ignore', 'pipe', 'pipe'] });
+  const result = await spawnHost(command.binary, command.args, { cwd, env, stdio: ['pipe', 'pipe', 'pipe'] }, prompt);
   if (result.status !== 0) {
     return {
       ok: false,
+      error: result.stderr || `host exited without a status (${result.status})`,
       reason: /limit|quota|capacity|usage/i.test(result.stderr)
         ? 'capacity-limited'
         : 'host-failed',
@@ -109,11 +129,7 @@ export async function runSubscriptionHost(host, stage, payload, { cwd = process.
   return { ok: true, value: parseHostValue(host, result.stdout) };
 }
 
-export async function persistDeliberationReceipt(receipt, {
-  cwd = process.cwd(),
-  now = Date.now,
-  run = spawnSync,
-} = {}) {
+export function deliberationMemoryStoreRequest(receipt, { now = Date.now } = {}) {
   const recordedAt = now();
   const value = {
     protocol: receipt.protocol,
@@ -125,21 +141,28 @@ export async function persistDeliberationReceipt(receipt, {
     recordedAt: new Date(recordedAt).toISOString(),
   };
   const key = `dual-deliberation-${recordedAt}-${receipt.taskHash.slice(0, 12)}`;
-  const result = run('ruflo', [
-    'memory', 'store',
-    '-k', key,
-    '--value', JSON.stringify(value),
-    '--namespace', 'ruvnet-brain',
-    '--path', '.swarm/memory.db',
-    '--no-upsert',
-    '--scan-content',
-  ], {
-    cwd,
-    encoding: 'utf8',
-    env: subscriptionOnlyEnv(),
-    timeout: 15_000,
-  });
-  return result?.status === 0;
+  return {
+    tool: 'memory_store',
+    name: 'memory_store',
+    arguments: { key, value: JSON.stringify(value), namespace: 'ruvnet-brain' },
+  };
+}
+
+function persistenceProof(proof, key) {
+  return proof === true || (proof?.stored === true && proof?.verified === true && proof?.key === key);
+}
+
+export async function persistDeliberationReceipt(receipt, {
+  now = Date.now,
+  memoryStore,
+} = {}) {
+  const request = deliberationMemoryStoreRequest(receipt, { now });
+  if (typeof memoryStore !== 'function') return request;
+  try {
+    return persistenceProof(await memoryStore(request), request.arguments.key);
+  } catch {
+    return false;
+  }
 }
 
 function missingHosts(probes) {
@@ -164,7 +187,6 @@ export async function deliberate(task, options = {}) {
     runSubscriptionHost(host, stage, payload, { cwd: options.cwd })
   ));
   const cwd = options.cwd ?? process.cwd();
-  const persist = options.persist ?? ((receipt) => persistDeliberationReceipt(receipt, { cwd }));
   const eligibleHosts = HOSTS.filter((host) => probes[hostKey(host)]?.eligible);
 
   if (eligibleHosts.length === 0) {
@@ -247,7 +269,18 @@ export async function deliberate(task, options = {}) {
     roles,
     accepted,
   };
-  const learningPersisted = accepted ? Boolean(await persist(receipt)) : false;
+  const learningPersistenceRequest = accepted
+    ? deliberationMemoryStoreRequest(receipt, { now: options.now ?? Date.now })
+    : undefined;
+  let learningPersisted = false;
+  if (accepted && typeof options.persist === 'function') {
+    try {
+      const persisted = await options.persist(learningPersistenceRequest, receipt);
+      learningPersisted = persistenceProof(persisted, learningPersistenceRequest.arguments.key);
+    } catch {
+      learningPersisted = false;
+    }
+  }
   return {
     status: accepted ? 'accepted' : 'unresolved',
     dual: true,
@@ -256,6 +289,7 @@ export async function deliberate(task, options = {}) {
     verification: verification.ok ? verification.value : undefined,
     verifiedOutcome: accepted,
     learningPersisted,
+    ...(learningPersistenceRequest ? { learningPersistenceRequest } : {}),
   };
 }