ruvnet-brain 4.3.1 → 4.3.8

package/scripts/execution-policy.mjs

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+// One deterministic boundary between Brain knowledge and consequential execution.
+// This module is deliberately pure: it never loads credentials, calls a provider, or mutates state.
+
+const NATIVE_HOSTS = new Set(['claude', 'codex']);
+const API_EXECUTORS = new Set(['agent_execute', 'sdk', 'openrouter', 'api']);
+const ARCHITECTURE_TERMS = /\b(adr|ddd|architecture|release|deploy|qa|security|schema|migration)\b/i;
+const CONSEQUENTIAL_ACTIONS = new Set(['delegate', 'write', 'release', 'external']);
+const FRESHNESS_MS = 30 * 60 * 1000;
+
+const hex64 = (value) => /^[a-f0-9]{64}$/i.test(String(value || ''));
+const fresh = (value, now = Date.now()) => {
+  const time = Date.parse(String(value || ''));
+  return Number.isFinite(time) && time <= now && now - time <= FRESHNESS_MS;
+};
+
+/**
+ * The classifier used to trust caller-supplied routing fields. That made a correct memory lesson
+ * advisory: a caller could omit the live search and AgentDB read and still receive ALLOW. This is
+ * the evidence boundary used by the executable preflight. Receipts are intentionally structural;
+ * the producers (search_ruvnet and ruflo memory retrieve) own their contents and identities.
+ */
+export function validateEvidence(input = {}, now = Date.now()) {
+  const failures = [];
+  const grounding = input.groundingReceipt;
+  const memory = input.memoryReceipt;
+  if (!grounding || grounding.status !== 'success' || !fresh(grounding.observedAt, now)) {
+    failures.push('fresh successful search_ruvnet receipt is required');
+  } else if (!(Array.isArray(grounding.sources) && grounding.sources.length > 0)
+    && !hex64(grounding.sourceIdentity)) {
+    failures.push('grounding receipt must bind a source list or source identity');
+  }
+  if (!memory || memory.status !== 'retrieved' || !fresh(memory.observedAt, now)) {
+    failures.push('fresh exact AgentDB checkpoint retrieval is required');
+  } else {
+    if (!String(memory.path || '').endsWith('/.swarm/memory.db')) failures.push('memory receipt must use the project .swarm/memory.db');
+    if (!/^project-state-current-\d+$/.test(String(memory.key || ''))) failures.push('memory receipt must retrieve an append-only project-state-current key');
+    if (!hex64(memory.valueDigest)) failures.push('memory receipt must bind the retrieved value digest');
+  }
+  return { valid: failures.length === 0, failures };
+}
+
+export function classifyExecutionPolicy(input = {}) {
+  const action = String(input.action || 'read');
+  const description = String(input.description || '');
+  const changedFiles = [...new Set((input.changedFiles || []).map(String).filter(Boolean))];
+  const nativeHosts = [...new Set((input.nativeHosts || []).map(String).filter((h) => NATIVE_HOSTS.has(h)))];
+  const requestedExecutor = String(input.requestedExecutor || '');
+  const explicitSwarm = input.explicitSwarm === true;
+  const multiFile = changedFiles.length >= 3;
+  const architectureTask = ARCHITECTURE_TERMS.test(description) || ['release', 'external'].includes(action);
+  const swarmRequired = explicitSwarm || multiFile || architectureTask;
+  const swarmReason = explicitSwarm
+    ? 'explicit-swarm-request'
+    : multiFile
+      ? 'three-or-more-independent-file-surfaces'
+      : architectureTask
+        ? 'architecture-or-consequential-action'
+        : 'single-sequential-surface';
+
+  const evidence = CONSEQUENTIAL_ACTIONS.has(action) && input.enforceEvidence === true
+    ? validateEvidence(input, input.now ?? Date.now())
+    : { valid: true, failures: [] };
+  if (!evidence.valid) {
+    return {
+      schema: 'ruvnet-brain.execution-policy.v1',
+      verdict: 'REFUSE', action, swarmRequired, swarmReason,
+      executor: 'unknown', reason: 'live-evidence-preflight-failed', evidence,
+    };
+  }
+
+  if (action !== 'delegate') {
+    return {
+      schema: 'ruvnet-brain.execution-policy.v1',
+      verdict: 'ALLOW', action, swarmRequired, swarmReason, evidence,
+      executor: 'current-agent', reason: 'delegation-not-requested',
+    };
+  }
+
+  const nativeHost = NATIVE_HOSTS.has(input.activeHost) && nativeHosts.includes(input.activeHost)
+    ? input.activeHost : nativeHosts[0] || null;
+  if (API_EXECUTORS.has(requestedExecutor)) {
+    return {
+      schema: 'ruvnet-brain.execution-policy.v1',
+      verdict: nativeHost ? 'REFUSE' : 'DEGRADED', action, swarmRequired, swarmReason, evidence,
+      executor: nativeHost ? `native:${nativeHost}` : 'unknown',
+      reason: nativeHost
+        ? 'api-backed-executor-is-not-the-native-subscription-route'
+        : 'no-authenticated-native-host-is-available',
+    };
+  }
+  if (!nativeHost) {
+    return {
+      schema: 'ruvnet-brain.execution-policy.v1',
+      verdict: 'DEGRADED', action, swarmRequired, swarmReason, executor: 'unknown', evidence,
+      reason: 'no-authenticated-native-host-is-available',
+    };
+  }
+  return {
+    schema: 'ruvnet-brain.execution-policy.v1',
+    verdict: 'ALLOW', action, swarmRequired, swarmReason, evidence,
+    executor: `native:${nativeHost}`, reason: 'native-subscription-route-selected',
+  };
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const raw = process.argv[2] || '{}';
+  let input;
+  try { input = JSON.parse(raw); } catch { process.stderr.write('execution-policy: input must be JSON\n'); process.exit(2); }
+  process.stdout.write(`${JSON.stringify(classifyExecutionPolicy(input))}\n`);
+}

package/scripts/execution-preflight.mjs

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+// Enforced knowledge-to-execution boundary. The caller must provide receipts produced by the
+// live Brain search and exact project AgentDB retrieval; prose, memory, and guessed host state do
+// not satisfy this command.
+import { classifyExecutionPolicy } from './execution-policy.mjs';
+
+export function runExecutionPreflight(input = {}) {
+  return classifyExecutionPolicy({ ...input, enforceEvidence: true });
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  let input;
+  try { input = JSON.parse(process.argv[2] || '{}'); }
+  catch { process.stderr.write('execution-preflight: input must be JSON\n'); process.exit(2); }
+  const result = runExecutionPreflight(input);
+  process.stdout.write(`${JSON.stringify(result)}\n`);
+  process.exit(result.verdict === 'ALLOW' ? 0 : 2);
+}

package/scripts/git-hooks/pre-push

@@ -114,6 +114,22 @@ if [ "$commands_status" -ne 0 ]; then
   exit 1
 fi
 
+# The convergence manifest is the exact source/version/ADR identity consumed by hosted QA.
+# Check it here so a push cannot publish a commit whose generated identity was produced before
+# the final source edit (the failure mode that repeatedly escaped local pre-push validation).
+if [ -f "$ROOT/scripts/convergence-manifest.mjs" ]; then
+  node "$ROOT/scripts/convergence-manifest.mjs"
+  convergence_status=$?
+else
+  convergence_status=0
+fi
+if [ "$convergence_status" -ne 0 ]; then
+  echo ""
+  echo "  ⛔ pre-push gate refused this push — convergence identity is stale."
+  echo "     Run: npm run convergence:write"
+  exit 1
+fi
+
 # ── DOCUMENT CURRENCY (ADR-056 §5) ─────────────────────────────────────────────────────────────────
 # The tool was written and tested on 2026-07-22 and then invoked by NOTHING for five days — absent
 # from this hook, gate.sh, gates.mjs and every workflow, while `wired-check` reported it "wired"

package/scripts/health-repair.mjs

@@ -25,11 +25,15 @@ import os from 'node:os';
 import { execFileSync, spawnSync } from 'node:child_process';
 import { findStores, diagnose } from './memory-doctor.mjs';
 import { learnerCwd, loadRuntimePreferences } from '../plugin/scripts/runtime-preferences.mjs';
+import { projectDirectory } from '../plugin/scripts/project-identity.mjs';
 
 const HOME = os.homedir();
 // The SAME project root learn-flush.mjs computes, by the same rule — the two halves of the flush
 // have to agree about which project they mean or they address different queues (issue #104).
-const PROJECT = process.env.RUVNET_BRAIN_PROJECT_DIR || process.cwd();
+// RESIDUAL of #134: RUVNET_BRAIN_PROJECT_DIR is never set by real hook dispatch on either host, so
+// consult `projectDirectory()` (project-identity.mjs) — the CLAUDE_PROJECT_DIR-with-containment
+// rule #85/#107 already established, reused rather than trusting the variable unconditionally.
+const PROJECT = process.env.RUVNET_BRAIN_PROJECT_DIR || projectDirectory();
 const argv = process.argv.slice(2);
 const has = (f) => argv.includes(f);
 

package/scripts/host-install-matrix.mjs

@@ -25,7 +25,8 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { spawnSync } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
+import { pathToFileURL } from 'node:url';
 
 /** The three host shapes a release must survive. ONE name each, for every consumer. */
 export const HOST_MODES = Object.freeze(['claude', 'codex', 'dual']);
@@ -58,7 +59,7 @@ export const MODE_FROM_RECEIPT_NAME = Object.freeze({ claudeOnly: 'claude', code
 export const VARIANTS = Object.freeze({
   staged: Object.freeze({
     installerArgs: (_v) => ['--local', '--yes', '--force', '--no-nightly-prompt',
-      '--no-telemetry', '--no-stack', '--no-enhance', '--no-statusline', '--no-selfcheck'],
+      '--no-telemetry', '--no-stack', '--no-enhance', '--no-statusline', '--no-selfcheck', '--no-verify'],
     env: ({ packageRoot }) => ({
       RUVNET_CLAUDE_MARKETPLACE_SOURCE: packageRoot,
       RUVNET_CODEX_HOOK_TRUST_MODE: 'bypass',
@@ -131,46 +132,252 @@ export function runHostMatrix({ packageRoot, version, variant = 'staged', locate
   let error;
 
   for (const mode of HOST_MODES) {
-    try {
-      const home = path.join(workspace, `home-${mode}`);
-      const codexHome = path.join(home, '.codex');
-      const brainHome = path.join(home, '.cache', 'ruvnet-brain');
-      fs.mkdirSync(path.join(home, '.claude'), { recursive: true });
-      if (mode !== 'claude') fs.mkdirSync(codexHome, { recursive: true });
-      const env = {
-        ...process.env,
-        HOME: home,
-        CODEX_HOME: codexHome,
-        RUVNET_BRAIN_HOME: brainHome,
-        RUVNET_BRAIN_KB: path.join(brainHome, 'kb'),
-        CI: 'true',
-        PATH: fixturePath(mode, workspace, locate),
-        ...spec.env({ packageRoot }),
-      };
-      const install = run(process.execPath, [installer, ...spec.installerArgs(version)], {
-        cwd: packageRoot, env, encoding: 'utf8', timeout: 1_200_000, maxBuffer: 32 * 1024 * 1024,
-      });
-      if (install.error || install.status !== 0) {
-        throw new Error(`install failed for ${mode}: ${(install.stderr || install.error?.message || '').slice(-4000)}`);
-      }
-      const doctor = run(process.execPath, [installer, '--doctor', '--hooks'], {
-        cwd: packageRoot, env, encoding: 'utf8', timeout: 300_000, maxBuffer: 32 * 1024 * 1024,
-      });
-      const classified = classifyDoctor(doctor);
-      fixtures[mode] = { status: classified.status, doctorExit: doctor.status, version };
-      if (!classified.accepted) {
-        verdict = 'FAIL';
-        fixtures[mode].output = classified.output.slice(-5000);
-        // The output belongs IN the error. The previous harness put it there and I dropped it in
-        // the consolidation, so CI reported a bare "doctor failed for claude" and the one thing
-        // needed to act on it — what the doctor actually said — was thrown away.
-        error = error || `doctor failed for ${mode} (exit ${doctor.status}): ${classified.output.slice(-4000)}`;
-      }
-    } catch (e) {
+    const result = runHostMode({ mode, packageRoot, version, spec, workspace, locate, run });
+    if (result.error) {
       verdict = 'FAIL';
-      fixtures[mode] = { status: 'FAIL', error: e.message };
-      error = error || e.message;
+      fixtures[mode] = result.fixture;
+      error = error || result.error;
+    } else {
+      fixtures[mode] = result.fixture;
     }
   }
   return error ? { verdict, fixtures, error } : { verdict, fixtures };
 }
+
+function runHostMode({ mode, packageRoot, version, spec, workspace, locate, run }) {
+  try {
+    const home = path.join(workspace, `home-${mode}`);
+    const codexHome = path.join(home, '.codex');
+    const brainHome = path.join(home, '.cache', 'ruvnet-brain');
+    fs.mkdirSync(path.join(home, '.claude'), { recursive: true });
+    if (mode !== 'claude') fs.mkdirSync(codexHome, { recursive: true });
+    const env = {
+      ...process.env,
+      HOME: home,
+      CODEX_HOME: codexHome,
+      RUVNET_BRAIN_HOME: brainHome,
+      RUVNET_BRAIN_KB: path.join(brainHome, 'kb'),
+      CI: 'true',
+      PATH: fixturePath(mode, workspace, locate),
+      ...spec.env({ packageRoot }),
+    };
+    const installer = path.join(packageRoot, 'bin', 'install.mjs');
+    const install = run(process.execPath, [installer, ...spec.installerArgs(version)], {
+      cwd: packageRoot, env, encoding: 'utf8', timeout: 1_200_000, maxBuffer: 32 * 1024 * 1024,
+    });
+    if (install.error || install.status !== 0) {
+      throw new Error(`install failed for ${mode}: ${(install.stderr || install.error?.message || '').slice(-4000)}`);
+    }
+    const doctor = run(process.execPath, [installer, '--doctor', '--hooks'], {
+      cwd: packageRoot, env, encoding: 'utf8', timeout: 300_000, maxBuffer: 32 * 1024 * 1024,
+    });
+    const classified = classifyDoctor(doctor);
+    const fixture = { status: classified.status, doctorExit: doctor.status, version };
+    if (!classified.accepted) {
+      fixture.output = classified.output.slice(-5000);
+      return {
+        fixture,
+        error: `doctor failed for ${mode} (exit ${doctor.status}): ${classified.output.slice(-4000)}`,
+      };
+    }
+    return { fixture };
+  } catch (e) {
+    return { fixture: { status: 'FAIL', error: e.message }, error: e.message };
+  }
+}
+
+/**
+ * Async equivalent used by hosted release qualification. Each mode owns its HOME and PATH, so
+ * the expensive installer/doctor pairs can run concurrently without sharing mutable state.
+ * Results are reassembled in HOST_MODES order before the single caller writes its receipt.
+ */
+export async function runHostMatrixAsync({
+  packageRoot,
+  version,
+  variant = 'staged',
+  locate,
+  temp,
+  runCommand = spawnCommand,
+  runMcpSearch = runInstalledMcpSearch,
+  verifyGrounding = verifyInstalledGrounding,
+  resolveMcpServer = resolveInstalledMcpServer,
+}) {
+  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 sharedModelCache = path.join(workspace, 'models-cache');
+  fs.mkdirSync(sharedModelCache, { recursive: true });
+  const contexts = HOST_MODES.map((mode) => {
+    const home = path.join(workspace, `home-${mode}`);
+    const codexHome = path.join(home, '.codex');
+    const brainHome = path.join(home, '.cache', 'ruvnet-brain');
+    fs.mkdirSync(path.join(home, '.claude'), { recursive: true });
+    if (mode !== 'claude') fs.mkdirSync(codexHome, { recursive: true });
+    const env = {
+      ...process.env,
+      HOME: home,
+      CODEX_HOME: codexHome,
+      RUVNET_BRAIN_HOME: brainHome,
+      RUVNET_BRAIN_KB: path.join(brainHome, 'kb'),
+      KB_MODEL_CACHE: sharedModelCache,
+      CI: 'true',
+      PATH: fixturePath(mode, workspace, locate),
+      ...spec.env({ packageRoot }),
+    };
+    return { mode, home, env };
+  });
+  const installer = path.join(packageRoot, 'bin', 'install.mjs');
+  const installs = await Promise.all(contexts.map(async (context) => {
+    const processResult = await runCommand(process.execPath, [installer, ...spec.installerArgs(version)], {
+      cwd: packageRoot, env: context.env, timeout: 1_200_000,
+    });
+    return { context, processResult };
+  }));
+  const failedInstall = installs.find(({ processResult }) => processResult.error || processResult.status !== 0);
+  if (failedInstall) {
+    const detail = processDiagnostic(failedInstall.processResult);
+    return {
+      verdict: 'FAIL',
+      fixtures: Object.fromEntries(contexts.map(({ mode }) => [mode, {
+        status: mode === failedInstall.context.mode ? 'FAIL' : 'NOT_PROBED',
+        ...(mode === failedInstall.context.mode ? { process: processIdentity(failedInstall.processResult) } : {}),
+      }])),
+      error: `install failed for ${failedInstall.context.mode} (${detail})`,
+    };
+  }
+
+  const prewarmContext = contexts[0];
+  const prewarmReader = path.join(prewarmContext.env.RUVNET_BRAIN_KB, 'forge-ask-all.mjs');
+  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'], {
+    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 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 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 };
+  }));
+  const fixtures = Object.fromEntries(searches.map(({ context, processResult, grounding, error }) => [context.mode, {
+    status: error ? 'FAIL' : 'PASS',
+    version,
+    process: processIdentity(processResult),
+    ...(grounding?.receipt ? { grounding: grounding.receipt } : {}),
+    ...(error ? { error } : {}),
+  }]));
+  const error = searches.find((result) => result.error)?.error;
+  return error ? { verdict: 'FAIL', fixtures, error } : { verdict: 'PASS', fixtures };
+}
+
+export function resolveInstalledMcpServer({ mode, home }) {
+  if (mode !== 'claude') return path.join(home, '.claude', 'ruvnet-brain', 'mcp', 'server.mjs');
+  const registry = path.join(home, '.claude', 'plugins', 'installed_plugins.json');
+  const rows = JSON.parse(fs.readFileSync(registry, 'utf8'))?.plugins?.['ruvnet-brain@ruvnet-brain'];
+  const installPath = Array.isArray(rows) ? rows.find(({ scope }) => scope === 'user')?.installPath : null;
+  if (!installPath) throw new Error('Claude fixture has no user-scoped ruvnet-brain plugin install');
+  const managedRoot = path.resolve(home, '.claude', 'plugins', 'cache', 'ruvnet-brain', 'ruvnet-brain');
+  const resolved = path.resolve(installPath);
+  if (resolved !== managedRoot && !resolved.startsWith(`${managedRoot}${path.sep}`)) {
+    throw new Error('Claude fixture plugin install path escapes its managed cache');
+  }
+  const server = path.join(resolved, 'mcp', 'server.mjs');
+  if (!fs.existsSync(server)) throw new Error(`Claude fixture MCP server missing from installed plugin: ${server}`);
+  return server;
+}
+
+function processIdentity(result) {
+  return {
+    status: result.status ?? null,
+    signal: result.signal ?? null,
+    errorCode: result.error?.code ?? null,
+    errorMessage: result.error?.message ?? null,
+  };
+}
+
+function processDiagnostic(result) {
+  const process = processIdentity(result);
+  return `status=${process.status} signal=${process.signal || 'none'} error=${process.errorCode ? `${process.errorCode}: ${process.errorMessage}` : 'none'}`;
+}
+
+async function verifyInstalledGrounding(output, kbDir) {
+  const verifier = path.join(kbDir, 'verify-citation.mjs');
+  const { verifyGrounding } = await import(pathToFileURL(verifier).href);
+  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 }));
+  });
+}
+
+function spawnCommand(command, args, options) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, options);
+    const stdout = [];
+    const stderr = [];
+    child.stdout?.on('data', (chunk) => stdout.push(chunk));
+    child.stderr?.on('data', (chunk) => stderr.push(chunk));
+    child.on('close', (status, signal) => resolve({ status, signal, stdout: Buffer.concat(stdout).toString(), stderr: Buffer.concat(stderr).toString() }));
+    child.on('error', (error) => resolve({ status: null, error, stdout: Buffer.concat(stdout).toString(), stderr: Buffer.concat(stderr).toString() }));
+  });
+}

package/scripts/integration-evidence.mjs

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+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',
+  'TEETH: a value too long to read from search output resolves in FULL via retrieve',
+  'a USER-LEVEL store at an explicit --path is reachable the same way',
+  'TEETH: a MISSING key reports not-found rather than inventing content',
+  '`-y` alone does NOT install the nightly LaunchAgent',
+  '`--yes` alone does NOT install the spend-watchdog LaunchAgent',
+  'embeds only the changed file on pass two and preserves the unchanged stable ID',
+]);
+
+const digestNames = (names) => crypto.createHash('sha256')
+  .update(`${JSON.stringify([...names].sort())}\n`)
+  .digest('hex');
+
+export function buildIntegrationEvidence(report, { sourceSha, runId, runAttempt }) {
+  const total = Number(report.numTotalTests || 0);
+  const failed = Number(report.numFailedTests || 0) + Number(report.numFailedTestSuites || 0);
+  const skipped = Number(report.numPendingTests || 0);
+  const todo = Number(report.numTodoTests || 0);
+  const passed = Number(report.numPassedTests || 0);
+  const assertions = (report.testResults || []).flatMap((suite) => suite.assertionResults || []);
+  // Vitest 4 calls skipped assertions `skipped` while older JSON reporters called them
+  // `pending`; numPendingTests remains the aggregate count in both schemas.
+  const skippedTests = assertions.filter(({ status }) => status === 'skipped' || status === 'pending')
+    .map(({ fullName, title }) => ({ fullName: fullName || title, title }))
+    .filter(({ fullName, title }) => Boolean(fullName && title));
+  const todoTests = assertions.filter(({ status }) => status === 'todo')
+    .map(({ fullName, title }) => fullName || title)
+    .filter(Boolean);
+  const unknownSkips = skippedTests.filter(({ title }) => !ALLOWED_LINUX_SKIP_TITLES.has(title));
+  if (total <= 0 || failed !== 0 || passed + todo + skipped !== total
+    || skippedTests.length !== skipped || todoTests.length !== todo || unknownSkips.length > 0) {
+    const names = unknownSkips.map(({ fullName }) => fullName).join('; ');
+    throw new Error(`integration report is not an exact governed pass (${passed} passed, ${todo} todo, ${total} total, ${skipped} skipped; unknown skips: ${names || 'none'})`);
+  }
+  return {
+    schemaVersion: 1, kind: 'ruvnet-brain-integration-evidence', sourceSha,
+    workflow: 'integration-linux', runId: Number(runId), runAttempt: Number(runAttempt),
+    total, passed, failed: 0, skipped,
+    skippedTests: skippedTests.map(({ fullName }) => fullName).sort(),
+    todo, todoTests: todoTests.sort(), exclusionPolicy: EXCLUSION_POLICY,
+    exclusionsSha256: digestNames([
+      ...skippedTests.map(({ fullName }) => `skip:${fullName}`),
+      ...todoTests.map((name) => `todo:${name}`),
+    ]),
+    verdict: 'PASS',
+  };
+}
+
+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')), {
+    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/nightly-wrapper.sh

@@ -199,9 +199,10 @@ sh scripts/memdb-health.sh "$RUVNET_PROJECT_MEMORY_DB" >> "$LOG" 2>&1 \
 # maintainer away for a month. So the last step is handed to the nightly, which is already the thing
 # that runs unattended.
 #
-# It does NOT publish. self-update.mjs:56 refuses --publish and only protected-release.yml may ship;
-# this DISPATCHES that workflow, so every gate (exact-SHA evidence, clean worktree, release-proof,
-# host verification, post-publication seal) still runs exactly as designed. It stands down on any
+# It does NOT publish or dispatch a publisher. The watchdog is report-only: release-candidate-
+# preflight runs long qualification once on release/**, then protected-release imports the artifact
+# by exact-SHA name, revalidates it, publishes, executes public 3x3, and appends install-verified.
+# Change-triggered architecture/oracle review is evidence, not publication authority. It stands down on any
 # unexpected state — dirty tree, open PRs, no green exact-SHA evidence, a -dev version, a stalled
 # Actions plane — because a watchdog acting on a partial picture is worse than no watchdog.
 # ── GITHUB HEALTH (2026-08-08). Stuart: "You should never ever let it be in a situation where

package/scripts/onboarding-console.mjs

@@ -460,11 +460,11 @@ export function resolveMemoryDb(projectDir) {
   })[0];
 }
 
-function probeMemory(projectDir) {
+function probeMemory(projectDir, { now = Date.now() } = {}) {
   const db = resolveMemoryDb(projectDir);
   const probes = {};
   // compaction survival + session surfacing are filesystem facts, always checkable
-  const snapshot = inspectSessionSnapshots(projectDir);
+  const snapshot = inspectSessionSnapshots(projectDir, { now });
   const snapshotDetail = snapshot.kind === 'canonical'
     ? 'a fresh versioned PreCompact snapshot is present in .swarm/agentdb-sessions.jsonl'
     : snapshot.kind === 'legacy'
@@ -508,7 +508,7 @@ function probeMemory(projectDir) {
 
   const cp = robustRead(db, "SELECT max(updated_at) FROM memory_entries WHERE key LIKE 'project-state-current%';");
   if (cp.ok && cp.value) {
-    const ageH = (Date.now() - Number(cp.value) * (String(cp.value).length <= 10 ? 1000 : 1)) / 3.6e6;
+    const ageH = (now - Number(cp.value) * (String(cp.value).length <= 10 ? 1000 : 1)) / 3.6e6;
     probes.coverage = Number.isFinite(ageH) && ageH < 48
       ? { status: 'ok', detail: `project checkpoint present, ~${Math.max(0, ageH).toFixed(0)}h old` }
       : { status: 'warn', detail: 'project checkpoint present but stale (>2 days)' };