ruvnet-brain 4.3.3 → 4.3.8

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)' };

package/scripts/prepublication-evidence.mjs

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { aggregateEvidence } from './release-evidence-aggregate.mjs';
+import { canonicalJson } from './release-transaction.mjs';
+import { EXCLUSION_POLICY } from './integration-evidence.mjs';
+
+const sha256 = (bytes) => crypto.createHash('sha256').update(bytes).digest('hex');
+
+function readJson(file) {
+  const bytes = fs.readFileSync(file);
+  return { value: JSON.parse(bytes), digest: sha256(bytes) };
+}
+
+function requireExactSet(actual, expected, label) {
+  const got = [...actual].sort();
+  const want = [...expected].sort();
+  if (canonicalJson(got) !== canonicalJson(want)) {
+    throw new Error(`${label} differs: expected ${want.join(', ')}, got ${got.join(', ')}`);
+  }
+}
+
+function passLeaf({ name, sha, payloadId, source, receiptSha256, ...details }) {
+  const validated = /^[a-f0-9]{64}$/.test(receiptSha256 || '');
+  return {
+    name,
+    sha,
+    payloadId,
+    status: validated ? 'completed' : 'failed',
+    conclusion: validated ? 'success' : 'failure',
+    verdict: validated ? 'PASS' : 'FAIL',
+    source,
+    receiptSha256,
+    ...details,
+  };
+}
+
+export function buildPrepublicationEvidence({
+  sha,
+  version,
+  runId,
+  manifestFile,
+  payloadProofFile,
+  hostFile,
+  ciFile,
+  integrationFile,
+  uxFiles,
+  strangerFile,
+}) {
+  if (!/^[a-f0-9]{40}$/.test(sha || '') || !/^\d+\.\d+\.\d+$/.test(version || '') || !Number.isSafeInteger(runId) || runId <= 0) {
+    throw new Error('prepublication identity is malformed');
+  }
+
+  const manifestBytes = fs.readFileSync(manifestFile);
+  const manifest = JSON.parse(manifestBytes);
+  const payload = JSON.parse(fs.readFileSync(payloadProofFile));
+  if (manifest.candidateSha !== sha || manifest.version !== version || manifest.tag !== `v${version}`) {
+    throw new Error('candidate manifest identity mismatch');
+  }
+  if (!/^[a-f0-9]{64}$/.test(payload.payloadId || '')) throw new Error('payload identity is malformed');
+
+  const host = readJson(hostFile);
+  if (host.value.schemaVersion !== 1 || host.value.sha !== sha || host.value.payloadId !== payload.payloadId
+    || !/^[a-f0-9]{64}$/.test(host.value.artifactSha256 || '') || host.value.leaves?.length !== 3) {
+    throw new Error('candidate host evidence identity or shape mismatch');
+  }
+  requireExactSet(host.value.leaves.map(({ name }) => name), ['claude-only', 'codex-only', 'dual-host'], 'candidate host leaves');
+  for (const leaf of host.value.leaves) {
+    const grounding = leaf.grounding;
+    const grounded = grounding && ['repo', 'path', 'file', 'storedPath']
+      .every((field) => typeof grounding[field] === 'string' && grounding[field].trim());
+    if (leaf.sha !== sha || leaf.payloadId !== payload.payloadId || leaf.status !== 'completed'
+      || leaf.conclusion !== 'success' || leaf.verdict !== 'PASS'
+      || leaf.functionalSearch !== true || leaf.searchExit !== 0 || !grounded
+      || leaf.artifactSha256 !== host.value.artifactSha256) {
+      throw new Error(`candidate host leaf is not an exact PASS: ${leaf.name || '(missing)'}`);
+    }
+  }
+
+  const ci = readJson(ciFile);
+  const requiredCiJobs = ['candidate-preflight', 'check', 'windows-unit', 'warm-brain', 'release-qe'];
+  if (ci.value.schemaVersion !== 1 || ci.value.kind !== 'ruvnet-brain-candidate-ci-evidence'
+    || ci.value.sourceSha !== sha || ci.value.version !== version || ci.value.payloadId !== payload.payloadId
+    || ci.value.payloadManifestSha256 !== sha256(manifestBytes) || ci.value.workflow !== 'ci'
+    || ci.value.runId !== runId || ci.value.verdict !== 'PASS' || ci.value.skipped !== 0 || ci.value.unknown !== 0) {
+    throw new Error('candidate CI receipt identity or verdict mismatch');
+  }
+  requireExactSet(ci.value.jobs?.map(({ name }) => name) || [], requiredCiJobs, 'candidate CI jobs');
+  if (ci.value.jobs.some(({ conclusion }) => conclusion !== 'success')) throw new Error('candidate CI receipt contains a non-success job');
+
+  const integration = readJson(integrationFile);
+  if (integration.value.schemaVersion !== 1 || integration.value.kind !== 'ruvnet-brain-integration-evidence'
+    || integration.value.sourceSha !== sha || integration.value.workflow !== 'integration-linux'
+    || integration.value.runId !== runId || integration.value.verdict !== 'PASS'
+    || integration.value.total <= 0
+    || integration.value.passed + Number(integration.value.todo || 0) + Number(integration.value.skipped || 0) !== integration.value.total
+    || integration.value.failed !== 0
+    || !Array.isArray(integration.value.skippedTests)
+    || integration.value.skippedTests.length !== integration.value.skipped
+    || integration.value.skippedTests.some((name) => typeof name !== 'string' || !name.trim())) {
+    throw new Error('integration receipt is not an exact, fully accounted PASS');
+  }
+  if (integration.value.exclusionPolicy !== EXCLUSION_POLICY
+    || !Array.isArray(integration.value.todoTests)
+    || integration.value.todoTests.length !== Number(integration.value.todo || 0)
+    || !/^[a-f0-9]{64}$/.test(integration.value.exclusionsSha256 || '')) {
+    throw new Error('integration receipt exclusions are not governed and fully enumerated');
+  }
+
+  if (!Array.isArray(uxFiles) || uxFiles.length !== 3) throw new Error('exactly three UX receipts are required');
+  const ux = uxFiles.map(readJson);
+  requireExactSet(ux.map(({ value }) => value.platform), ['darwin', 'linux', 'win32'], 'UX platforms');
+  for (const receipt of ux) {
+    const value = receipt.value;
+    if (value.schemaVersion !== 1 || value.suite !== 'ruvnet-brain-ux-qe' || value.gitSha !== sha
+      || value.pass !== true || !Array.isArray(value.hardFailures) || value.hardFailures.length !== 0) {
+      throw new Error(`UX receipt is not an exact PASS: ${value.platform || '(missing)'}`);
+    }
+  }
+  const uxDigest = sha256(Buffer.from(canonicalJson(ux.map(({ value, digest }) => ({ platform: value.platform, digest }))
+    .sort((a, b) => a.platform.localeCompare(b.platform)))));
+
+  const stranger = readJson(strangerFile);
+  const strangerJobs = ['ubuntu', 'macos', 'windows-gitbash', 'windows-powershell', 'hostile'];
+  if (stranger.value.schemaVersion !== 1 || stranger.value.sha !== sha || stranger.value.payloadId !== payload.payloadId
+    || Number(stranger.value.sourceCiRunId) !== runId || Number(stranger.value.strangerRunId) !== runId
+    || stranger.value.verdict !== 'PASS') {
+    throw new Error('stranger receipt identity or verdict mismatch');
+  }
+  requireExactSet(stranger.value.jobs || [], strangerJobs, 'stranger jobs');
+
+  const common = { sha, payloadId: payload.payloadId, runId };
+  const leaves = [
+    passLeaf({ ...common, name: 'source-quality', source: 'candidate-ci-receipt:check', receiptSha256: ci.digest }),
+    passLeaf({ ...common, name: 'ux-qe', source: 'ux-qe-receipts:darwin,linux,win32', receiptSha256: uxDigest }),
+    passLeaf({ ...common, name: 'release-qe', source: 'candidate-ci-receipt:release-qe', receiptSha256: ci.digest }),
+    passLeaf({ ...common, name: 'integration-linux', source: 'integration-receipt', receiptSha256: integration.digest,
+      skipped: integration.value.skipped, todo: integration.value.todo }),
+    passLeaf({ ...common, name: 'stranger-linux', source: 'stranger-receipt:ubuntu', receiptSha256: stranger.digest }),
+    passLeaf({ ...common, name: 'stranger-macos', source: 'stranger-receipt:macos', receiptSha256: stranger.digest }),
+    passLeaf({ ...common, name: 'stranger-windows', source: 'stranger-receipt:windows', receiptSha256: stranger.digest }),
+    ...host.value.leaves.map((leaf) => ({ ...leaf, runId, receiptSha256: host.digest })),
+  ];
+  return { leaves, envelope: aggregateEvidence({ sha, payloadId: payload.payloadId, leaves }) };
+}
+
+const isCli = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isCli) {
+  const arg = (name) => {
+    const index = process.argv.indexOf(name);
+    return index >= 0 ? process.argv[index + 1] : null;
+  };
+  const uxDir = path.resolve(arg('--ux-dir'));
+  const uxFiles = fs.readdirSync(uxDir).filter((name) => name.endsWith('.json')).sort().map((name) => path.join(uxDir, name));
+  const result = buildPrepublicationEvidence({
+    sha: arg('--sha'),
+    version: arg('--version'),
+    runId: Number(arg('--run-id')),
+    manifestFile: path.resolve(arg('--manifest')),
+    payloadProofFile: path.resolve(arg('--payload-proof')),
+    hostFile: path.resolve(arg('--hosts')),
+    ciFile: path.resolve(arg('--ci')),
+    integrationFile: path.resolve(arg('--integration')),
+    uxFiles,
+    strangerFile: path.resolve(arg('--stranger')),
+  });
+  const leavesOut = path.resolve(arg('--leaves-out'));
+  const envelopeOut = path.resolve(arg('--envelope-out'));
+  fs.writeFileSync(leavesOut, `${JSON.stringify(result.leaves, null, 2)}\n`, { flag: 'wx', mode: 0o600 });
+  fs.writeFileSync(envelopeOut, `${canonicalJson(result.envelope)}\n`, { flag: 'wx', mode: 0o600 });
+  process.stdout.write(`${JSON.stringify({ verdict: result.envelope.verdict, evidenceDigest: result.envelope.evidenceDigest })}\n`);
+}

package/scripts/protected-release-invocation.mjs

@@ -4,6 +4,7 @@
 import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
+import { pathToFileURL } from 'node:url';
 import { evaluateCandidateReceipt } from './release-proof.mjs';
 import { getVersion } from './version.mjs';
 
@@ -13,12 +14,27 @@ export const PROTECTED_VERSION = getVersion();
 const hex = (value, length) => new RegExp(`^[0-9a-f]{${length}}$`).test(String(value || ''));
 const digestOf = (receipt) => String(receipt?.artifact?.sha256 || '').replace(/^sha256:/, '');
 
-export function validateProtectedPublishInvocation({ root = process.cwd(), env = process.env } = {}) {
+export function validatePublishableVersion(version) {
+  return /^\d+\.\d+\.\d+$/.test(String(version || ''))
+    ? []
+    : ['development versions cannot be published'];
+}
+
+export function validateProtectedPublishEnvironment(env = process.env) {
   const failures = [];
-  let releaseMode = 'unknown';
-  if (env.GITHUB_ACTIONS !== 'true' || env.GITHUB_WORKFLOW !== PROTECTED_WORKFLOW) {
-    failures.push('publication is allowed only inside the protected-release GitHub workflow');
+  if (env.GITHUB_ACTIONS !== 'true'
+    || env.GITHUB_WORKFLOW !== PROTECTED_WORKFLOW
+    || env.GITHUB_REPOSITORY !== 'stuinfla/ruvnet-brain'
+    || env.GITHUB_EVENT_NAME !== 'workflow_dispatch'
+    || env.GITHUB_REF_PROTECTED !== 'true') {
+    failures.push('publication is allowed only inside the protected-release GitHub workflow on a protected workflow_dispatch ref');
   }
+  return failures;
+}
+
+export function validateProtectedPublishInvocation({ root = process.cwd(), env = process.env } = {}) {
+  const failures = [...validateProtectedPublishEnvironment(env)];
+  let releaseMode = 'unknown';
 
   const expectedSha = String(env.RUVNET_EXPECTED_SHA || '');
   const expectedDigest = String(env.RUVNET_EXPECTED_ARTIFACT_SHA256 || '').replace(/^sha256:/, '');
@@ -26,6 +42,7 @@ export function validateProtectedPublishInvocation({ root = process.cwd(), env =
   if (!hex(expectedSha, 40)) failures.push('expected candidate SHA is missing or malformed');
   if (!hex(expectedDigest, 64)) failures.push('expected artifact digest is missing or malformed');
   if (expectedVersion !== PROTECTED_VERSION) failures.push(`release generation must be ${PROTECTED_VERSION}`);
+  failures.push(...validatePublishableVersion(expectedVersion));
 
   const receiptRelative = String(env.RUVNET_CANDIDATE_RECEIPT || '');
   const evidenceRoot = path.resolve(root, 'release-evidence');
@@ -74,3 +91,14 @@ export function validateProtectedPublishInvocation({ root = process.cwd(), env =
     failures,
   };
 }
+
+if (process.argv[1] && pathToFileURL(path.resolve(process.argv[1])).href === import.meta.url) {
+  const result = validateProtectedPublishInvocation();
+  if (result.verdict !== 'PASS') {
+    console.error('[protected-release] publication refused:');
+    for (const failure of result.failures) console.error(`  - ${failure}`);
+    process.exitCode = 1;
+  } else {
+    console.log('[protected-release] exact candidate publication authority verified');
+  }
+}