ruvnet-brain 4.3.27 → 4.3.29

package/scripts/host-install-matrix.mjs

@@ -32,6 +32,14 @@ import { runRetrievalCanaries, validateRetrievalCanaryReceipt, resolveInstalledC
 
 /** The three host shapes a release must survive. ONE name each, for every consumer. */
 export const HOST_MODES = Object.freeze(['claude', 'codex', 'dual']);
+export const SELF_STORE_PROOF_QUERY = 'repo:ruvnet-brain What is the RuvNet Brain release evidence workflow?';
+export const SELF_STORE_PROOF_K = 1;
+export const RELEASE_SEARCH_QUERY = 'repo:ruvnet-brain How does RuvNet Brain prove a public release artifact?';
+export const HOST_WARMUP_TIMEOUT_MS = 300_000;
+export const RELEASE_SEARCH_DEADLINE_MS = 30_000;
+// The shared model-cache prewarm's own candidate pool size, named so the test asserting on it
+// derives from this constant instead of restating the digit as a second, driftable literal.
+export const PREWARM_POOL_SIZE = 8;
 
 /** Which CLIs each mode is allowed to see. A codex-only box genuinely has no `claude`. */
 export const MODE_HOSTS = Object.freeze({
@@ -204,6 +212,7 @@ export async function runHostMatrixAsync({
   verifyGrounding = verifyInstalledGrounding,
   resolveMcpServer = resolveInstalledMcpServer,
   retrieval,
+  sequentialSearches = false,
 }) {
   const spec = VARIANTS[variant];
   if (!spec) throw new Error(`unknown host-matrix variant: ${variant}`);
@@ -251,54 +260,91 @@ export async function runHostMatrixAsync({
 
   const prewarmContext = contexts[0];
   const prewarmReader = path.join(prewarmContext.env.RUVNET_BRAIN_KB, 'forge-ask-all.mjs');
+  // This query only primes the shared model cache. Keep it in the Brain's own bounded store so
+  // Mac/Windows/Linux runner speed does not determine whether the later real host searches run.
+  // The following MCP matrix remains the measured, source-grounded candidate acceptance.
   const prewarm = await runCommand(process.execPath, [prewarmReader, '--dir', prewarmContext.env.RUVNET_BRAIN_KB,
-    '--q', 'How does RuvNet Brain prove a public release artifact?', '--k', '1'], {
+    '--q', RELEASE_SEARCH_QUERY, '--k', '1', '--pool', String(PREWARM_POOL_SIZE),
+    '--repos', 'ruvnet-brain', '--bounded'], {
     cwd: prewarmContext.env.RUVNET_BRAIN_KB, env: prewarmContext.env, timeout: 300_000,
   });
   if (prewarm.error || prewarm.status !== 0) {
-    return { verdict: 'FAIL', fixtures: {}, error: `shared model prewarm failed (${processDiagnostic(prewarm)})` };
+    const detail = String(prewarm.stderr || prewarm.stdout || '').trim().split('\n').slice(-8).join(' | ').slice(-1600);
+    return { verdict: 'FAIL', fixtures: {}, error: `shared model prewarm failed (${processDiagnostic(prewarm)})${detail ? `; ${detail}` : ''}` };
   }
   const prewarmGrounding = await verifyGrounding(String(prewarm.stdout || ''), prewarmContext.env.RUVNET_BRAIN_KB);
   if (!prewarmGrounding?.grounded) {
     return { verdict: 'FAIL', fixtures: {}, error: 'shared model prewarm returned no grounded source receipt' };
   }
 
-  const searches = await Promise.all(contexts.map(async (context) => {
+  const searchOne = async (context) => {
     let session;
     try {
       const serverPath = resolveMcpServer(context);
       // One installed worker per host: model/store state survives smoke and every sealed case.
       session = runMcpSearch === runInstalledMcpSearch ? createInstalledMcpSession({ serverPath, env: context.env }) : null;
       const searchMcp = session ? (args) => session.search(args) : runMcpSearch;
-      const processResult = await searchMcp({ mode: context.mode, serverPath, env: context.env });
+      // The installed shell warms its in-process models and stores asynchronously from MCP
+      // initialize. Candidate qualification must give that same worker the same cited readiness
+      // probe used by the public verifier before timing the first user search; a separate CLI
+      // prewarm only primes disk cache and cannot warm this worker's process memory.
+      const warmupResult = await searchMcp({ mode: context.mode, serverPath, env: context.env,
+        query: SELF_STORE_PROOF_QUERY, k: SELF_STORE_PROOF_K, timeoutMs: HOST_WARMUP_TIMEOUT_MS });
+      const warmupOutput = `${warmupResult.stdout || ''}${warmupResult.stderr || ''}`;
+      if (warmupResult.error || warmupResult.status !== 0) {
+        return { context, processResult: warmupResult,
+          error: `MCP warmup failed for ${context.mode} (${processDiagnostic(warmupResult)}): ${warmupOutput.slice(-2000)}` };
+      }
+      const warmupGrounding = await verifyGrounding(warmupOutput, context.env.RUVNET_BRAIN_KB);
+      if (!warmupGrounding?.grounded || warmupGrounding.receipt?.repo !== 'ruvnet-brain') {
+        return { context, processResult: warmupResult, warmupMs: warmupResult.broadMs,
+          error: `MCP self-store warmup grounding unproven for ${context.mode}` };
+      }
+      const processResult = await searchMcp({ mode: context.mode, serverPath, env: context.env,
+        query: RELEASE_SEARCH_QUERY, k: 5,
+        timeoutMs: RELEASE_SEARCH_DEADLINE_MS });
       const output = `${processResult.stdout || ''}${processResult.stderr || ''}`;
       if (processResult.error || processResult.status !== 0) {
-        return { context, processResult, error: `MCP search failed for ${context.mode} (${processDiagnostic(processResult)}): ${output.slice(-2000)}` };
+        return { context, processResult, warmupMs: warmupResult.broadMs, warmupGrounding,
+          error: `MCP search failed for ${context.mode} (${processDiagnostic(processResult)}): ${output.slice(-2000)}` };
       }
       const grounding = await verifyGrounding(output, context.env.RUVNET_BRAIN_KB);
-      if (!grounding?.grounded) return { context, processResult, error: `MCP search grounding unproven for ${context.mode}` };
+      if (!grounding?.grounded) return { context, processResult, warmupMs: warmupResult.broadMs,
+        warmupGrounding, error: `MCP search grounding unproven for ${context.mode}` };
       let receipt;
       if (retrieval) {
-        receipt = await runRetrievalCanaries({ ...retrieval,
-          search: async ({ query, k }) => {
-            const result = await searchMcp({ mode: context.mode, serverPath, env: context.env, query, k });
+        receipt = await runRetrievalCanaries({ ...retrieval, searchTimeoutMs: RELEASE_SEARCH_DEADLINE_MS,
+          search: async ({ query, k, timeoutMs }) => {
+            const result = await searchMcp({ mode: context.mode, serverPath, env: context.env, query, k, timeoutMs });
             if (result.error || result.status !== 0) throw new Error(`canary MCP search failed: ${processDiagnostic(result)}`);
             return parseRetrievalResult(result.mcpResult, { query, k });
           },
           citationResolver: (matched, expected) => resolveInstalledCanaryCitation({ kbDir: context.env.RUVNET_BRAIN_KB, matched, expected }),
         });
         try { validateRetrievalCanaryReceipt(receipt, { plan: retrieval.plan }); }
-        catch (error) { return { context, processResult, grounding, retrieval: receipt, error: `${context.mode} canary rejected: ${error.message}` }; }
+        catch (error) { return { context, processResult, warmupMs: warmupResult.broadMs,
+          warmupGrounding, grounding, retrieval: receipt, error: `${context.mode} canary rejected: ${error.message}` }; }
       }
-      return { context, processResult, grounding, ...(receipt ? { retrieval: receipt } : {}) };
+      return { context, processResult, warmupMs: warmupResult.broadMs, warmupGrounding,
+        grounding, ...(receipt ? { retrieval: receipt } : {}) };
     } catch (error) {
       return { context, processResult: { status: null, error }, error: `${context.mode} host search failed: ${error.message}` };
     } finally { await session?.close(); }
-  }));
-  const fixtures = Object.fromEntries(searches.map(({ context, processResult, grounding, retrieval, error }) => [context.mode, {
+  };
+  const searches = [];
+  if (sequentialSearches) {
+    for (const context of contexts) searches.push(await searchOne(context));
+  } else {
+    searches.push(...await Promise.all(contexts.map(searchOne)));
+  }
+  const fixtures = Object.fromEntries(searches.map(({ context, processResult, warmupMs, warmupGrounding,
+    grounding, retrieval, error }) => [context.mode, {
     status: error ? 'FAIL' : 'PASS',
     version,
     process: processIdentity(processResult),
+    warmupMs: Number.isFinite(warmupMs) ? warmupMs : null,
+    ...(warmupGrounding?.receipt ? { warmupGrounding: warmupGrounding.receipt } : {}),
+    searchMs: Number.isFinite(processResult.broadMs) ? processResult.broadMs : null,
     ...(grounding?.receipt ? { grounding: grounding.receipt } : {}),
     ...(retrieval ? { retrieval } : {}),
     ...(error ? { error } : {}),
@@ -395,7 +441,7 @@ export function createInstalledMcpSession({ serverPath, env, timeout = 300_000,
     pending.set(id, { resolve, reject });
     child.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id, method, params })}\n`);
   });
-  const execute = async ({ query = 'How does RuvNet Brain prove a public release artifact?', k = 5,
+  const execute = async ({ query = RELEASE_SEARCH_QUERY, k = 5,
     timeoutMs = timeout } = {}) => {
     if (terminalError) return { status: null, error: terminalError, signal: exitSignal, stdout: '', stderr };
     stderr = '';

package/scripts/independent-review-receipt.mjs

@@ -5,12 +5,11 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { canonicalJson, digest } from './coverage-integrity.mjs';
 import { transactionIdFor } from './release-transaction.mjs';
+import { CLAUDE_FABLE_5_ID, GPT_5_6_SOL_ID, LEGACY_REVIEWER_IDENTITIES } from './review-model-defaults.mjs';
 const HEX40 = /^[a-f0-9]{40}$/;
 const HEX64 = /^[a-f0-9]{64}$/;
 const BASE64 = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
-export const ALLOWED_INDEPENDENT_REVIEWERS = Object.freeze([
-  Object.freeze({ identity: 'claude-fable-5', model: 'claude-fable-5', provider: 'firstParty' }),
-  Object.freeze({ identity: 'gpt-5.6-sol', model: 'gpt-5.6-sol', provider: 'openai' })]);
+export const ALLOWED_INDEPENDENT_REVIEWERS = LEGACY_REVIEWER_IDENTITIES;
 
 const INPUT_KEYS = Object.freeze([
   'artifactSha256', 'deductions', 'execution', 'findings', 'id', 'independent', 'model', 'payloadId',
@@ -222,17 +221,17 @@ function reviewerFor(input) {
 }
 
 function normalizeExecution(execution, reviewer) {
-  const required = reviewer.identity === 'gpt-5.6-sol'
+  const required = reviewer.identity === GPT_5_6_SOL_ID
     ? ['catalogRowSha256', 'invocationDigest', 'subscriptionAuthenticated', 'threadId']
     : ['invocationDigest', 'subscriptionAuthenticated'];
-  if (reviewer.identity === 'gpt-5.6-sol'
+  if (reviewer.identity === GPT_5_6_SOL_ID
     && (!Object.hasOwn(execution || {}, 'threadId') || !Object.hasOwn(execution || {}, 'catalogRowSha256'))) {
     throw new Error('GPT review thread and catalog evidence are required');
   }
   exactKeys(execution, required, 'review execution');
   if (execution.subscriptionAuthenticated !== true) throw new Error('review execution is not subscription authenticated');
   hex(execution.invocationDigest, HEX64, 'review invocation digest');
-  if (reviewer.identity === 'gpt-5.6-sol') {
+  if (reviewer.identity === GPT_5_6_SOL_ID) {
     text(execution.threadId, 'GPT review thread');
     hex(execution.catalogRowSha256, HEX64, 'GPT review catalog row');
   }
@@ -479,8 +478,8 @@ export function main(args = process.argv.slice(2), runtime = {}) {
       readJson(options['--sol'], 'Sol review receipt')];
     const ordered = validateIndependentReviewPair(receipts, {
       publicKeysByReviewer: {
-        'claude-fable-5': readRegular(options['--fable-public-key'], 'Fable review public key'),
-        'gpt-5.6-sol': readRegular(options['--sol-public-key'], 'Sol review public key'),
+        [CLAUDE_FABLE_5_ID]: readRegular(options['--fable-public-key'], 'Fable review public key'),
+        [GPT_5_6_SOL_ID]: readRegular(options['--sol-public-key'], 'Sol review public key'),
       },
       expectedIdentity: options['--expected-identity']
         ? readJson(options['--expected-identity'], 'expected review identity') : null,

package/scripts/ingest-repo.mjs

@@ -21,6 +21,7 @@ import { execFileSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { FULL_HINTS, KEEP_DIRS } from './full-hints.mjs';
 import { storeRoot } from '../kb/store-root.mjs';
+import { applyPrivateOverlay } from './private-overlay.mjs';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const arg = (f, d) => { const i = process.argv.indexOf(f); return i >= 0 && process.argv[i + 1] ? process.argv[i + 1] : d; };
@@ -118,15 +119,58 @@ const carded = (() => {
 // The stores themselves cannot be committed. The FACT that they were ingested can, so a wipe
 // becomes detectable and replayable instead of silent and permanent. This record is the recipe.
 if (ok) {
+  let rest = [];
   try {
     const ledger = path.join(ROOT, 'kb', 'local-ingests.json');
     const prior = fs.existsSync(ledger) ? JSON.parse(fs.readFileSync(ledger, 'utf8')) : { ingests: [] };
-    const rest = (prior.ingests || []).filter((e) => e.name !== NAME);
+    rest = (prior.ingests || []).filter((e) => e.name !== NAME);
     rest.push({ name: NAME, org: ORG, at: new Date().toISOString(), store: kb });
     rest.sort((a, b) => a.name.localeCompare(b.name));
     fs.writeFileSync(ledger, `${JSON.stringify({ ingests: rest }, null, 2)}\n`);
     console.log(`[record] kb/local-ingests.json — ${rest.length} local ingest(s) recorded. COMMIT THIS.`);
   } catch (e) { console.log(`[record] could not record the ingest: ${e.message}`); }
+
+  // S3 (explicit local ownership): stamp updateManaged:false + origin:'local-ingest' into the LIVE
+  // store root's own SOURCE.json (via scripts/private-overlay.mjs's writer — --from equals --root
+  // here, since forge-refresh.mjs already wrote the bytes directly into KB; the writer degenerates
+  // to registry-stamping only, see its own header). Without this a store built through THIS script
+  // reads exactly like a normal public store to kb/forge-update.mjs — unmarked, and therefore
+  // silently deleted the moment it is absent from an incoming public bundle.
+  //
+  // ONE-TIME MIGRATION for stores this script ingested BEFORE this fix shipped: every OTHER name
+  // this ledger already recorded is retroactively re-stamped too, provided its files still exist and
+  // it is not already an update-managed (public) SOURCE.json entry. This runs HERE — where the
+  // recipe ledger (kb/local-ingests.json, git-tracked in the checkout) and the live store root (KB,
+  // ~/.cache/ruvnet-brain/kb by default — a DIFFERENT, non-git-tracked directory, see kb/store-
+  // root.mjs) are both actually in scope in the same process — rather than inside kb/forge-update.mjs,
+  // which runs against an installed KB tree with no reliable path back to this checkout's ledger.
+  const candidateNames = [...new Set([kb, ...rest.map((e) => e.store).filter(Boolean)])];
+  const sourceFile = path.join(KB, 'SOURCE.json');
+  let liveSourceStores = {};
+  try { liveSourceStores = JSON.parse(fs.readFileSync(sourceFile, 'utf8')).stores || {}; } catch { /* handled by applyPrivateOverlay below */ }
+  const toStamp = candidateNames.filter((name) => {
+    const existing = liveSourceStores[name];
+    if (existing && existing.updateManaged !== false) return false; // a real public store — never shadow it
+    return [`${name}.big.rvf`, `${name}.big.rvf.embed.json`, `${name}.big.rvf.idmap.json`, `${name}.meta.json`, `${name}.passages.jsonl`]
+      .every((file) => fs.existsSync(path.join(KB, file)));
+  });
+  if (toStamp.length) {
+    try {
+      const fenceFile = path.join(KB, 'PRIVATE-STORES.json');
+      const fence = fs.existsSync(fenceFile) ? JSON.parse(fs.readFileSync(fenceFile, 'utf8')) : { privateStores: [] };
+      const fenceNames = new Set((fence.privateStores || []).map((n) => String(n).toLowerCase()));
+      const additions = toStamp.filter((name) => !fenceNames.has(name.toLowerCase()));
+      if (additions.length) {
+        fence.privateStores = [...new Set([...(fence.privateStores || []), ...additions])].sort();
+        fs.writeFileSync(fenceFile, `${JSON.stringify(fence, null, 2)}\n`);
+      }
+      const receipt = applyPrivateOverlay({ root: KB, from: KB, stores: toStamp, origin: 'local-ingest' });
+      const stamped = receipt.stores.filter((entry) => entry.changes.includes('SOURCE.json')).map((entry) => entry.name);
+      if (stamped.length) console.log(`[local-ownership] marked updateManaged:false (origin: local-ingest) — ${stamped.join(', ')}`);
+    } catch (e) {
+      console.log(`[local-ownership] could not stamp local ownership (${e.message}); the next forge-update.mjs --apply may remove ${toStamp.join(', ')} if they are absent from the incoming bundle`);
+    }
+  }
 }
 
 console.log(!ok

package/scripts/learning-replay-cli.mjs

@@ -35,6 +35,7 @@ import {
   writeArtifact,
 } from './learning-replay-proof.mjs';
 import { ROOT } from './learning-replay-contract.mjs';
+import { GPT_5_6_SOL_ID } from './review-model-defaults.mjs';
 
 const usage = () => `Usage:
   node scripts/learning-replay.mjs [--trap ${TRAP.MEMORY_SEARCH}|${TRAP.POST_TASK}] [--n N] [--host codex|claude-code] [--model MODEL]
@@ -94,7 +95,7 @@ export async function main(argv = process.argv.slice(2)) {
   const mutant = arg('--mutant', null);
   const trap = arg('--trap', TRAP.MEMORY_SEARCH);
   const host = arg('--host', 'codex');
-  const model = arg('--model', host === 'codex' ? 'gpt-5.6-sol' : 'haiku');
+  const model = arg('--model', host === 'codex' ? GPT_5_6_SOL_ID : 'haiku');
   const n = Math.max(1, parseInt(arg('--n', mutant ? '1' : '3'), 10) || 1);
   const outFile = arg('--out', mutant
     ? MUTANT_RESULT_FILES[trap]?.[mutant]

package/scripts/learning-replay-fixture.mjs

@@ -19,6 +19,7 @@ import {
   PROJECT_B_MEMORY_VALUE,
   RUFLO_BIN,
 } from './learning-replay-execution.mjs';
+import { GPT_5_6_SOL_ID } from './review-model-defaults.mjs';
 
 const CLAUDE_BIN = process.env.RUVNET_CLAUDE_BIN
   || path.join(os.homedir(), '.npm-global', 'bin', 'claude');
@@ -266,7 +267,7 @@ export function codexReplayInstrumentationError(events, sequence, attempts) {
 }
 
 export function buildCodexArgv({
-  model = 'gpt-5.6-sol',
+  model = GPT_5_6_SOL_ID,
   prompt = REPLAY_PROMPT,
   appendSystemPrompt = null,
   brainHome,

package/scripts/learnings.mjs

@@ -8,13 +8,22 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { learningScope, learnerCwd } from '../plugin/scripts/runtime-preferences.mjs';
 
 const HOME = os.homedir();
 
-/** @param {{statsPath?:string, queueDir?:string, now?:number}} [opts] */
-export function learnings({ statsPath, queueDir, now = Date.now() } = {}) {
-  const sp = statsPath || path.join(HOME, '.claude-flow/neural/stats.json');
-  const qd = queueDir || path.join(HOME, '.cache/ruvnet-brain/learn');
+/** @param {{statsPath?:string, queueDir?:string, now?:number, cwd?:string, env?:object, home?:string}} [opts] */
+export function learnings({ statsPath, queueDir, now = Date.now(), cwd, env, home } = {}) {
+  // The flusher and the console must inspect the same learner. A fixed HOME path made the panel
+  // report a stale global learner while project-scoped captures were fed under the active project.
+  // Keep injectable paths for callers/tests, but derive both defaults from the shared scope owner.
+  const project = cwd || process.env.RUVNET_BRAIN_PROJECT_DIR || process.cwd();
+  const scope = learningScope({ cwd: project, env: env || process.env });
+  const learner = learnerCwd({ cwd: project, env: env || process.env, home: home || HOME });
+  const sp = statsPath || path.join(learner, '.claude-flow', 'neural', 'stats.json');
+  const qd = queueDir || (scope === 'user'
+    ? path.join(home || HOME, '.cache', 'ruvnet-brain', 'learn')
+    : path.join(project, '.swarm', 'ruvnet-brain-learn'));
 
   let stats = {};
   try { stats = JSON.parse(fs.readFileSync(sp, 'utf8')); } catch { /* no learner yet */ }
@@ -53,7 +62,12 @@ export function learnings({ statsPath, queueDir, now = Date.now() } = {}) {
     lastAdaptation: lastMs ? new Date(lastMs).toISOString() : null,
     daysSinceLastAdaptation: daysSince,
     recentWorkflow,
-    note: 'Learnings are how you work — shared across all your projects and getting smarter over time. Project facts stay isolated per project; nothing here is project data.',
+    note: scope === 'user'
+      ? 'Learnings are how you work — shared across your projects and getting smarter over time. Project facts stay isolated per project; nothing here is project data.'
+      : 'Learnings are how you work in this project and getting smarter over time. User-scoped learning remains isolated from this project; nothing here is project data.',
+    scope,
+    statsPath: sp,
+    queueDir: qd,
   };
 }