ruvnet-brain 4.3.9 → 4.3.11

package/scripts/host-install-matrix.mjs

@@ -27,6 +27,8 @@ import os from 'node:os';
 import path from 'node:path';
 import { spawn, spawnSync } from 'node:child_process';
 import { pathToFileURL } from 'node:url';
+import { parseRetrievalResult } from '../kb/retrieval-result.mjs';
+import { runRetrievalCanaries, validateRetrievalCanaryReceipt, resolveInstalledCanaryCitation } from './retrieval-canary.mjs';
 
 /** The three host shapes a release must survive. ONE name each, for every consumer. */
 export const HOST_MODES = Object.freeze(['claude', 'codex', 'dual']);
@@ -125,7 +127,7 @@ export function fixturePath(mode, temp, locate) {
 export function runHostMatrix({ packageRoot, version, variant = 'staged', locate, temp, run = spawnSync }) {
   const spec = VARIANTS[variant];
   if (!spec) throw new Error(`unknown host-matrix variant: ${variant}`);
-  const workspace = temp || fs.mkdtempSync(path.join(os.tmpdir(), 'ruvnet-host-matrix-'));
+  const workspace = fs.realpathSync(temp || fs.mkdtempSync(path.join(os.tmpdir(), 'ruvnet-host-matrix-')));
   const installer = path.join(packageRoot, 'bin', 'install.mjs');
   const fixtures = {};
   let verdict = 'PASS';
@@ -201,10 +203,11 @@ export async function runHostMatrixAsync({
   runMcpSearch = runInstalledMcpSearch,
   verifyGrounding = verifyInstalledGrounding,
   resolveMcpServer = resolveInstalledMcpServer,
+  retrieval,
 }) {
   const spec = VARIANTS[variant];
   if (!spec) throw new Error(`unknown host-matrix variant: ${variant}`);
-  const workspace = temp || fs.mkdtempSync(path.join(os.tmpdir(), 'ruvnet-host-matrix-'));
+  const workspace = fs.realpathSync(temp || fs.mkdtempSync(path.join(os.tmpdir(), 'ruvnet-host-matrix-')));
   const sharedModelCache = path.join(workspace, 'models-cache');
   fs.mkdirSync(sharedModelCache, { recursive: true });
   const contexts = HOST_MODES.map((mode) => {
@@ -261,21 +264,43 @@ export async function runHostMatrixAsync({
   }
 
   const searches = await Promise.all(contexts.map(async (context) => {
-    const serverPath = resolveMcpServer(context);
-    const processResult = await runMcpSearch({ mode: context.mode, serverPath, env: context.env });
-    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)}` };
-    }
-    const grounding = await verifyGrounding(output, context.env.RUVNET_BRAIN_KB);
-    if (!grounding?.grounded) return { context, processResult, error: `MCP search grounding unproven for ${context.mode}` };
-    return { context, processResult, grounding };
+    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 });
+      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)}` };
+      }
+      const grounding = await verifyGrounding(output, context.env.RUVNET_BRAIN_KB);
+      if (!grounding?.grounded) return { context, processResult, 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 });
+            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}` }; }
+      }
+      return { context, processResult, 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, error }) => [context.mode, {
+  const fixtures = Object.fromEntries(searches.map(({ context, processResult, grounding, retrieval, error }) => [context.mode, {
     status: error ? 'FAIL' : 'PASS',
     version,
     process: processIdentity(processResult),
     ...(grounding?.receipt ? { grounding: grounding.receipt } : {}),
+    ...(retrieval ? { retrieval } : {}),
     ...(error ? { error } : {}),
   }]));
   const error = searches.find((result) => result.error)?.error;
@@ -318,56 +343,95 @@ async function verifyInstalledGrounding(output, kbDir) {
   return verifyGrounding(output, kbDir);
 }
 
-function runInstalledMcpSearch({ serverPath, env, query = 'How does RuvNet Brain prove a public release artifact?', timeout = 300_000 }) {
-  return new Promise((resolve) => {
-    const child = spawn(process.execPath, [serverPath], { env, stdio: ['pipe', 'pipe', 'pipe'] });
-    let stdout = '';
-    let stderr = '';
-    const pending = new Map();
-    let settled = false;
-    const finish = (result) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      child.kill('SIGTERM');
-      resolve({ status: result.status ?? null, signal: result.signal ?? null, error: result.error ?? null, stdout, stderr });
-    };
-    const timer = setTimeout(() => finish({ status: null, signal: 'SIGKILL', error: Object.assign(new Error('MCP search timed out'), { code: 'ETIMEDOUT' }) }), timeout);
-    child.stderr.on('data', (chunk) => { stderr += chunk; });
-    child.stdout.on('data', (chunk) => {
-      stdout += chunk;
-      for (;;) {
-        const newline = stdout.indexOf('\n');
-        if (newline < 0) break;
-        const line = stdout.slice(0, newline).trim();
-        stdout = stdout.slice(newline + 1);
-        if (!line) continue;
-        let message;
-        try { message = JSON.parse(line); } catch { continue; }
-        const handler = pending.get(message.id);
-        if (handler) { pending.delete(message.id); handler(message); }
-      }
-    });
-    child.on('error', (error) => finish({ status: null, error }));
-    child.on('exit', (status, signal) => {
-      if (!settled) finish({ status, signal, ...(status === 0 ? {} : { error: new Error(`MCP server exited ${status}`) }) });
-    });
-    const call = (id, method, params = {}) => new Promise((done) => {
-      pending.set(id, done);
-      child.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id, method, params })}\n`);
-    });
-    (async () => {
-      const initialized = await call(1, 'initialize', { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'release-host-matrix', version: '1' } });
-      if (initialized.error) throw new Error(`MCP initialize failed: ${JSON.stringify(initialized.error)}`);
-      const listed = await call(2, 'tools/list');
-      if (!listed.result?.tools?.some((tool) => tool.name === 'search_ruvnet')) throw new Error('installed MCP does not advertise search_ruvnet');
-      const searched = await call(3, 'tools/call', { name: 'search_ruvnet', arguments: { query, k: 5 } });
-      const text = (searched.result?.content || []).map((item) => item.text || '').join('\n');
-      if (searched.error || searched.result?.isError) throw new Error(`installed Brain search failed: ${text.slice(0, 400)}`);
-      stdout = text;
-      finish({ status: 0 });
-    })().catch((error) => finish({ status: null, error }));
+export function createInstalledMcpSession({ serverPath, env, timeout = 300_000, shutdownTimeout = 5000 }) {
+  const child = spawn(process.execPath, [serverPath], { env, stdio: ['pipe', 'pipe', 'pipe'] });
+  // Decode across chunk boundaries so split UTF-8 cannot corrupt content-bound citations.
+  child.stdout.setEncoding('utf8');
+  child.stderr.setEncoding('utf8');
+  const pending = new Map();
+  let buffer = '', stderr = '', nextId = 0, initialized = false;
+  let terminalError = null, closePromise, exited = false, exitSignal = null;
+  let queue = Promise.resolve();
+  let resolveExit;
+  const exit = new Promise((resolve) => { resolveExit = resolve; });
+  const close = (error = new Error('MCP session closed')) => {
+    if (closePromise) return closePromise;
+    terminalError ||= error;
+    for (const { reject } of pending.values()) reject(terminalError);
+    pending.clear();
+    closePromise = (async () => {
+      if (exited) return;
+      // EOF lets the installed proxy await its worker shutdown on Windows as well as POSIX.
+      child.stdin.end();
+      const escalation = setTimeout(() => { if (!exited) child.kill('SIGKILL'); }, shutdownTimeout);
+      try { await exit; } finally { clearTimeout(escalation); }
+    })();
+    return closePromise;
+  };
+  child.stderr.on('data', (chunk) => { stderr += chunk; });
+  child.stdout.on('data', (chunk) => {
+    buffer += chunk;
+    for (;;) {
+      const newline = buffer.indexOf('\n');
+      if (newline < 0) break;
+      const line = buffer.slice(0, newline).trim();
+      buffer = buffer.slice(newline + 1);
+      if (!line) continue;
+      let message;
+      try { message = JSON.parse(line); } catch { continue; }
+      const handler = pending.get(message.id);
+      if (handler) { pending.delete(message.id); handler.resolve(message); }
+    }
+  });
+  child.on('error', (error) => { void close(error); });
+  child.stdin.on('error', (error) => { void close(error); });
+  child.on('close', (status, signal) => {
+    exited = true; exitSignal = signal; resolveExit();
+    void close(new Error(`MCP server exited ${status}`));
+  });
+  const call = (method, params = {}) => new Promise((resolve, reject) => {
+    if (terminalError) { reject(terminalError); return; }
+    const id = ++nextId;
+    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 } = {}) => {
+    if (terminalError) return { status: null, error: terminalError, signal: exitSignal, stdout: '', stderr };
+    stderr = '';
+    const timer = setTimeout(() => {
+      void close(Object.assign(new Error('MCP search timed out'), { code: 'ETIMEDOUT' }));
+    }, timeout);
+    try {
+      if (!initialized) {
+        const ready = await call('initialize', { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'release-host-matrix', version: '1' } });
+        if (ready.error) throw new Error(`MCP initialize failed: ${JSON.stringify(ready.error)}`);
+        const listed = await call('tools/list');
+        if (!listed.result?.tools?.some((tool) => tool.name === 'search_ruvnet')) throw new Error('installed MCP does not advertise search_ruvnet');
+        initialized = true;
+      }
+      const searched = await call('tools/call', { name: 'search_ruvnet', arguments: { query, k } });
+      const stdout = (searched.result?.content || []).map((item) => item.text || '').join('\n');
+      if (searched.error || searched.result?.isError) throw new Error(`installed Brain search failed: ${stdout.slice(0, 400)}`);
+      return { status: 0, signal: null, error: null, stdout, stderr, mcpResult: searched.result };
+    } catch (error) {
+      await close(error);
+      return { status: null, signal: exitSignal, error: terminalError, stdout: '', stderr };
+    } finally { clearTimeout(timer); }
+  };
+  return {
+    // The scorer may schedule concurrent cases; only one reaches this model worker at a time.
+    search(args) {
+      const result = queue.then(() => execute(args));
+      queue = result.then(() => undefined, () => undefined);
+      return result;
+    },
+    close,
+  };
+}
+
+async function runInstalledMcpSearch(options) {
+  const session = createInstalledMcpSession(options);
+  try { return await session.search(options); } finally { await session.close(); }
 }
 
 function spawnCommand(command, args, options) {

package/scripts/integration-evidence.mjs

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import crypto from 'node:crypto';
+import { validateQualificationReceipt } from './release-qualification.mjs';
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -8,11 +9,6 @@ export const EXCLUSION_POLICY = 'release-linux-v1';
 
 const ALLOWED_LINUX_SKIP_TITLES = new Set([
   'stores, exact-retrieves, and strictly deduplicates through a temp real AgentDB',
-  'exposes self-contained native Console and What is New skills through the real plugin loader',
-  'repairs a missing Brain-owned marketplace snapshot before Codex reads plugin state',
-  'repairs a malformed Brain-owned marketplace snapshot before Codex reads plugin state',
-  'repairs the snapshot without re-enabling an explicitly disabled Codex plugin',
-  'reports a marketplace preparation failure without changing Codex configuration',
   'bridges, ranks, and is delivered as additionalContext at the write-code decision point',
   'TEETH: an UNTAGGED row travels no further than the store — the chain is genuinely load-bearing',
   'TEETH: a lesson tagged for a DIFFERENT moment does not fire at this one',
@@ -63,10 +59,19 @@ export function buildIntegrationEvidence(report, { sourceSha, runId, runAttempt
   };
 }
 
+export const RELEASE_QUALIFICATION_POLICY = 'reviewed-release-integration-v1';
+export function buildQualifiedIntegrationEvidence(report, identity) {
+  validateQualificationReceipt(report, { suite: 'integration', platform: 'linux', sourceSha: identity.sourceSha });
+  const evidence = buildIntegrationEvidence(report.testReport, identity);
+  return { ...evidence, exclusionPolicy: RELEASE_QUALIFICATION_POLICY,
+    qualificationReceiptSha256: report.receiptSha256, requirements: report.requirements };
+}
+
 const isCli = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
 if (isCli) {
   const value = (name) => process.argv[process.argv.indexOf(name) + 1];
-  const receipt = buildIntegrationEvidence(JSON.parse(fs.readFileSync(value('--report'), 'utf8')), {
+  const build = process.argv.includes('--qualified') ? buildQualifiedIntegrationEvidence : buildIntegrationEvidence;
+  const receipt = build(JSON.parse(fs.readFileSync(value('--report'), 'utf8')), {
     sourceSha: value('--sha'), runId: value('--run-id'), runAttempt: value('--run-attempt'),
   });
   fs.writeFileSync(value('--out'), `${JSON.stringify(receipt, null, 2)}\n`, { flag: 'wx' });

package/scripts/learning-replay-fixture.mjs

@@ -246,10 +246,30 @@ function writeSettings(file, { dirs, stateDir, attemptsFile }) {
   return file;
 }
 
+// The product plugin may intentionally be disabled. Register only this replay's two hooks
+// in the invocation layer; never edit user config or depend on an ambient installed manifest.
+export function codexReplayHookArgs(brainHome) {
+  if (!brainHome || !path.isAbsolute(brainHome)) throw new Error('explicit absolute replay Brain home is required');
+  const quote = (value) => "'" + String(value).replaceAll("'", "'\"'\"'") + "'";
+  const wrapper = `${quote(process.execPath)} ${quote(path.join(brainHome, 'codex-hook.mjs'))}`;
+  const hook = (event, suffix, matcher = '') => `hooks.${event}=[{${matcher}hooks=[{type="command",command=${JSON.stringify(`${wrapper} unprompted-speech ${suffix}`)},timeout=20}]}]`;
+  return ['-c', hook('UserPromptSubmit', 'UserPromptSubmit'),
+    '-c', hook('PreToolUse', 'PreToolUse-bash', 'matcher=".*",')];
+}
+
+export function codexReplayInstrumentationError(events, sequence, attempts) {
+  if (attempts.length && sequence.some((event) => event.kind === 'tool')) return null;
+  const executed = events.filter((event) => event.type === 'item.completed'
+    && event.item?.type === 'command_execution').length;
+  return `Codex replay recorder did not observe a tool invocation (${executed} command execution event(s) in the native stream); `
+    + 'fixture hook instrumentation is missing, so command absence and learning cannot be graded';
+}
+
 export function buildCodexArgv({
   model = 'gpt-5.6-sol',
   prompt = REPLAY_PROMPT,
   appendSystemPrompt = null,
+  brainHome,
 } = {}) {
   const fullPrompt = appendSystemPrompt ? `${appendSystemPrompt}\n\n${prompt}` : prompt;
   return [
@@ -257,6 +277,7 @@ export function buildCodexArgv({
     '--ignore-rules', '--dangerously-bypass-hook-trust', '-m', model,
     '-c', 'model_reasoning_effort="low"',
     '-c', 'shell_environment_policy.inherit="all"',
+    ...codexReplayHookArgs(brainHome),
     fullPrompt,
   ];
 }
@@ -312,7 +333,7 @@ export function runArm({
   let argv;
   if (host === 'codex') {
     binary = CODEX_BIN;
-    argv = buildCodexArgv({ model, prompt: spec.prompt, appendSystemPrompt });
+    argv = buildCodexArgv({ model, prompt: spec.prompt, appendSystemPrompt, brainHome: dirs.brainHome });
   } else {
     const settings = writeSettings(path.join(dirs.base, `settings-${tag}.json`), {
       dirs,
@@ -410,7 +431,7 @@ export function runArm({
     transcript: path.relative(ROOT, streamFile),
     exit: result.status,
     spawnError: host === 'codex'
-      ? parseCodexRunError(events, result)
+      ? parseCodexRunError(events, result) || codexReplayInstrumentationError(events, sequence, attemptLines)
       : replayRunError(events, result),
   };
 }

package/scripts/nightly-package-observation.mjs

@@ -0,0 +1,67 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+
+const hash = (value) => crypto.createHash('sha256').update(value).digest('hex');
+
+// npm dependencies are separately installed outside the immutable package payload.
+export function packageTreeObservation(root) {
+  const files = [];
+  const visit = (dir, prefix = '') => {
+    for (const name of fs.readdirSync(dir).sort()) {
+      if (!prefix && name === 'node_modules') continue;
+      const file = path.join(dir, name);
+      const relative = prefix ? `${prefix}/${name}` : name;
+      const stat = fs.lstatSync(file);
+      if (stat.isDirectory()) visit(file, relative);
+      else if (stat.isFile()) files.push({ path: relative, sha256: hash(fs.readFileSync(file)) });
+      else throw new Error(`npm package contains an unsupported entry: ${relative}`);
+    }
+  };
+  visit(root);
+  const manifest = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+  return { name: manifest.name, version: manifest.version, fileCount: files.length,
+    treeSha256: hash(JSON.stringify(files)) };
+}
+
+export function observeNpxPackage(npmCache, expected) {
+  const base = path.join(npmCache, '_npx');
+  const roots = fs.existsSync(base) ? fs.readdirSync(base).map((name) =>
+    path.join(base, name, 'node_modules', 'ruvnet-brain')).filter((root) => fs.existsSync(root)) : [];
+  if (roots.length !== 1) throw new Error(`expected exactly one isolated npx Brain package, found ${roots.length}`);
+  const observed = packageTreeObservation(roots[0]);
+  if (JSON.stringify(observed) !== JSON.stringify(expected)) throw new Error('npx package bytes differ from verified public package');
+  return { ...observed, path: roots[0], observedAt: new Date().toISOString() };
+}
+
+export function validateNpxObservations(proof) {
+  const expected = proof.packageExecution?.expected;
+  const observations = proof.packageExecution?.observations;
+  if (proof.packageExecution?.policy !== 'production-latest-exact-cache-v1'
+    || proof.registration?.packageTarget?.spec !== 'ruvnet-brain@latest'
+    || proof.registration.packageTarget.sha256 !== null
+    || expected?.packageSha256 !== proof.candidate?.sha256
+    || expected?.name !== 'ruvnet-brain' || expected.version !== proof.candidate?.version
+    || !/^[a-f0-9]{64}$/.test(expected.treeSha256 || '') || !Number.isSafeInteger(expected.fileCount)
+    || expected.fileCount <= 0 || !Array.isArray(observations) || observations.length !== 3) {
+    return ['native production package execution evidence is incomplete'];
+  }
+  const failures = [];
+  for (const observed of observations) {
+    if (observed.name !== expected.name || observed.version !== expected.version
+      || observed.treeSha256 !== expected.treeSha256 || observed.fileCount !== expected.fileCount
+      || typeof observed.path !== 'string' || !observed.path
+      || !Number.isFinite(Date.parse(observed.observedAt))) failures.push('native npx package identity differs');
+  }
+  if (!Array.isArray(proof.runs) || proof.runs.length !== 2) return [...failures, 'native package run evidence is missing'];
+  for (let i = 0; i < 2; i++) {
+    const run = proof.runs[i].receipt;
+    if (run?.desiredVersion !== expected.version
+      || Date.parse(observations[i].observedAt) > Date.parse(run?.startedAt)
+      || Date.parse(observations[i + 1].observedAt) < Date.parse(run?.finishedAt)
+      || Date.parse(observations[i + 1].observedAt) > Date.parse(proof.observedAt)) {
+      failures.push('native package observation does not bound the exact-version run');
+    }
+  }
+  return failures;
+}