ruvnet-brain 4.3.9 → 4.3.11

package/scripts/public-verification-lane.mjs

@@ -3,11 +3,12 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import osModule from 'node:os';
 import path from 'node:path';
+import { execFileSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { canonicalJson, digest, validateCoverageLedger } from './coverage-integrity.mjs';
 import { validateHostRegistry } from './host-registry.mjs';
 import { RECEIPT_MODE_NAMES } from './host-install-matrix.mjs';
-import { generatePublicationReceipt, livePublicationAdapter } from './publication-receipt.mjs';
+import { generatePublicationReceipt, livePublicationAdapter, validateCandidateSource } from './publication-receipt.mjs';
 import {
   createPublicVerificationLeaf,
   PUBLIC_VERIFICATION_MODES,
@@ -29,12 +30,13 @@ function failedCanaryCases(retrieval) {
     status !== 'COMPLETED' || retrievalHit !== true || (cohort === 'delta' && citationResolved !== true));
 }
 
-function publicVerificationFailure({ os, identity, failures, completedLeaves }) {
+function publicVerificationFailure({ os, identity, verifierSha, failures, completedLeaves }) {
   const payload = {
     schemaVersion: 1,
     kind: 'ruvnet-brain-public-verification-failure',
     os,
     sourceSha: identity.candidateSha,
+    ...(verifierSha === undefined ? {} : { verifierSha }),
     artifactSha256: identity.packageSha256,
     bundleSha256: identity.bundleSha256,
     failures: failures.map(({ mode, reason, retrieval }) => ({
@@ -102,6 +104,9 @@ function coverageProjection(coverage) {
 
 export async function createPublicVerificationLane({
   os,
+  verifierSha,
+  workflowRunId,
+  publicKey,
   candidate,
   publication,
   identity,
@@ -112,6 +117,8 @@ export async function createPublicVerificationLane({
   adapter,
 } = {}) {
   if (!PUBLIC_VERIFICATION_OS.includes(os)) throw new Error(`unsupported public verification OS: ${os || '(missing)'}`);
+  if (verifierSha !== undefined && !HEX40.test(String(verifierSha))) throw new Error('verifier SHA must be a full commit identity');
+  if (!/^[1-9][0-9]*$/.test(String(workflowRunId || ''))) throw new Error('workflow run ID is required');
   validateReleaseIdentity(identity);
   validatePublicEvidence({ candidate, publication, identity });
   const registry = validateHostRegistry(hostRegistry);
@@ -132,7 +139,9 @@ export async function createPublicVerificationLane({
     throw new Error('public verification lane adapter is incomplete');
   }
   const common = {
+    workflowRunId: String(workflowRunId),
     sourceSha: identity.candidateSha,
+    ...(verifierSha === undefined ? {} : { verifierSha }),
     version: identity.version,
     tag: identity.tag,
     artifactSha256: identity.packageSha256,
@@ -169,8 +178,15 @@ export async function createPublicVerificationLane({
       failures.push({ mode, reason: error.message, retrieval });
       continue;
     }
+    let nativeNightly;
+    if (mode === 'dual') {
+      if (typeof adapter.runNativeNightly !== 'function') throw new Error('native nightly proof adapter is required');
+      nativeNightly = await adapter.runNativeNightly({ identity, workflowRunId: String(workflowRunId) });
+    }
     leaves.push(createPublicVerificationLeaf({
       ...common,
+      ...(publication.acceptancePolicy ? { acceptancePolicy: publication.acceptancePolicy, searchTiming: { firstSearchMs: installed.searchMs, broadMs: publication.brain.broadMs, deadlineMs: publication.brain.deadlineMs } } : {}),
+      ...(nativeNightly === undefined ? {} : { nativeNightly }),
       os,
       mode,
       status: verifiedRetrieval.receiptSha256 === retrieval.receiptSha256 ? 'completed' : 'failed',
@@ -183,11 +199,11 @@ export async function createPublicVerificationLane({
       untested: [],
       skipped: 0,
       unknown: 0,
-    }));
+    }, { publicKey }));
   }
   if (failures.length) {
     const error = new Error(`retrieval canary acceptance failed for ${failures.map(({ mode }) => mode).join(', ')}`);
-    error.publicVerificationFailure = publicVerificationFailure({ os, identity, failures, completedLeaves: leaves });
+    error.publicVerificationFailure = publicVerificationFailure({ os, identity, verifierSha, failures, completedLeaves: leaves });
     throw error;
   }
   if (canonicalJson(leaves.map(({ mode }) => mode)) !== canonicalJson(PUBLIC_VERIFICATION_MODES)) {
@@ -206,8 +222,22 @@ function regularJson(file, label) {
   return { absolute, bytes: fs.readFileSync(absolute), value: JSON.parse(fs.readFileSync(absolute, 'utf8')) };
 }
 
+export function resolveVerifierSha(root, expected) {
+  const options = { cwd: root, encoding: 'utf8' };
+  const actual = execFileSync('git', ['rev-parse', 'HEAD'], options).trim();
+  if (!HEX40.test(actual) || (expected !== undefined && expected !== actual)) {
+    throw new Error('verifier SHA differs from the executing checkout');
+  }
+  if (execFileSync('git', ['status', '--porcelain', '--untracked-files=no'], options).trim()) {
+    throw new Error('verifier checkout has tracked changes');
+  }
+  return actual;
+}
+
 export async function generatePublicVerificationLane({
   os,
+  verifierSha: expectedVerifierSha,
+  workflowRunId,
   candidatePath,
   identityPath,
   coveragePath,
@@ -215,10 +245,19 @@ export async function generatePublicVerificationLane({
   registryPath,
   outPath,
   root = process.cwd(),
-  adapter = livePublicationAdapter({ root }),
+  candidateRoot = root,
+  adapter = livePublicationAdapter({ root, candidateRoot }),
 } = {}) {
   if (os !== hostOperatingSystem()) throw new Error(`runner OS ${hostOperatingSystem() || process.platform} cannot produce ${os || '(missing)'}`);
+  const rootDirectory = fs.statSync(root, { bigint: true });
+  const scriptDirectory = fs.statSync(fileURLToPath(new URL('..', import.meta.url)), { bigint: true });
+  if (!rootDirectory.isDirectory() || rootDirectory.ino <= 0n
+    || rootDirectory.dev !== scriptDirectory.dev || rootDirectory.ino !== scriptDirectory.ino) {
+    throw new Error('verifier root differs from the executing script checkout');
+  }
+  const verifierSha = resolveVerifierSha(root, expectedVerifierSha);
   const candidate = regularJson(candidatePath, 'candidate receipt');
+  validateCandidateSource(candidateRoot, candidate.value);
   const identity = regularJson(identityPath, 'release identity');
   const releaseCoverage = regularJson(coveragePath, 'release coverage');
   const retrievalPlan = regularJson(planPath, 'retrieval plan');
@@ -234,6 +273,8 @@ export async function generatePublicVerificationLane({
     const publication = JSON.parse(fs.readFileSync(publicationPath, 'utf8'));
     const leaves = await createPublicVerificationLane({
       os,
+      verifierSha,
+      workflowRunId,
       candidate: candidate.value,
       publication,
       identity: identity.value,
@@ -244,15 +285,27 @@ export async function generatePublicVerificationLane({
       hostRegistry: hostRegistry.value,
       adapter,
     });
-    const payload = { schemaVersion: 1, kind: 'ruvnet-brain-public-verification-os-lane', os, leaves };
+    resolveVerifierSha(root, verifierSha);
+    validateCandidateSource(candidateRoot, candidate.value);
+    const payload = { schemaVersion: 1, kind: 'ruvnet-brain-public-verification-os-lane', os,
+      verifierSha, sourceSha: identity.value.candidateSha, leaves };
     const receipt = { ...payload, laneSha256: digest(payload) };
     fs.mkdirSync(path.dirname(output), { recursive: true });
     fs.writeFileSync(output, `${JSON.stringify(receipt, null, 2)}\n`, { flag: 'wx', mode: 0o600 });
     return receipt;
   } catch (error) {
-    if (error.publicVerificationFailure && !fs.existsSync(output)) {
+    if (!fs.existsSync(output)) {
+      const failure = error.publicVerificationFailure || (() => {
+        const payload = { schemaVersion: 1, kind: 'ruvnet-brain-public-verification-failure',
+          os, verifierSha, sourceSha: identity.value.candidateSha,
+          artifactSha256: identity.value.packageSha256, bundleSha256: identity.value.bundleSha256,
+          workflowRunId: String(workflowRunId || ''),
+          failures: [{ stage: 'public-install-and-native-update', reason: String(error.message).slice(0, 2000) }],
+          completedLeaves: [] };
+        return { ...payload, failureSha256: digest(payload) };
+      })();
       fs.mkdirSync(path.dirname(output), { recursive: true });
-      fs.writeFileSync(output, `${JSON.stringify(error.publicVerificationFailure, null, 2)}\n`,
+      fs.writeFileSync(output, `${JSON.stringify(failure, null, 2)}\n`,
         { flag: 'wx', mode: 0o600 });
     }
     throw error;
@@ -271,6 +324,9 @@ export async function main(args = process.argv.slice(2)) {
   try {
     const receipt = await generatePublicVerificationLane({
       os: argument(args, '--os'),
+      verifierSha: argument(args, '--verifier-sha') ?? undefined,
+      workflowRunId: argument(args, '--workflow-run-id'),
+      candidateRoot: argument(args, '--candidate-root') ?? undefined,
       candidatePath: argument(args, '--candidate'),
       identityPath: argument(args, '--identity'),
       coveragePath: argument(args, '--coverage'),

package/scripts/publication-receipt.mjs

@@ -7,7 +7,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { pipeline } from 'node:stream/promises';
 import { Readable } from 'node:stream';
-import readline from 'node:readline';
+import { createRequire } from 'node:module';
 import { spawn, spawnSync } from 'node:child_process';
 // ONE doctor rule and ONE mode vocabulary, shared with the staged-side check in
 // scripts/staged-host-verifier.mjs. This file kept its own copies, spelled claudeOnly/
@@ -15,12 +15,13 @@ import { spawn, spawnSync } from 'node:child_process';
 // `fixtures.claude` described the same fixture and nothing could tell. The richer
 // post-publication proofs below (payload assertions, MCP wiring, SOURCE.json, rpcSearch)
 // stay here — they are this side's job, not duplication.
-import { HOST_MODES, RECEIPT_MODE_NAMES, MODE_FROM_RECEIPT_NAME, classifyDoctor, VARIANTS } from './host-install-matrix.mjs';
-import { pathToFileURL } from 'node:url';
+import { HOST_MODES, RECEIPT_MODE_NAMES, MODE_FROM_RECEIPT_NAME, classifyDoctor, VARIANTS, createInstalledMcpSession } from './host-install-matrix.mjs';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { evaluateCandidateReceipt, evaluatePublicationReceipt } from './release-proof.mjs';
 import { verifyPayload } from './release-payload.mjs';
-import { digest, sha256File } from './coverage-integrity.mjs';
-import { parseCitations } from '../kb/verify-citation.mjs';
+import { resolveInstalledCanaryCitation } from './retrieval-canary.mjs';
+import { runNightlyTwoRunProof, validateNightlyProofReceipt } from './nightly-two-run-proof.mjs';
+import { parseRetrievalResult } from '../kb/retrieval-result.mjs';
 
 const REPO = 'stuinfla/ruvnet-brain';
 const PACKAGE = 'ruvnet-brain';
@@ -30,11 +31,24 @@ const sha256 = (file) => crypto.createHash('sha256').update(fs.readFileSync(file
 const readJson = (file) => JSON.parse(fs.readFileSync(file, 'utf8'));
 const receiptDigest = (candidate) => String(candidate?.artifact?.sha256 || '').replace(/^sha256:/, '');
 export function commandInvocation(name, args, { platform = process.platform, env = process.env } = {}) {
+  // Git Bash's GNU tar cannot consume native drive-letter extraction destinations.
+  // Select the Windows system tar explicitly so PATH order cannot change path semantics.
+  if (platform === 'win32' && name === 'tar') return {
+    executable: path.win32.join(env.SystemRoot || 'C:\\Windows', 'System32', 'tar.exe'), args,
+  };
   if (platform === 'win32' && /^(?:npm|npx)$/i.test(name)) return {
     executable: env.ComSpec || 'cmd.exe', args: ['/d', '/c', `${name}.cmd`, ...args],
   };
   return { executable: name, args };
 }
+export function tarExtractionInvocation(artifactPath, destination, { platform = process.platform } = {}) {
+  const paths = platform === 'win32' ? path.win32 : path;
+  const archive = paths.resolve(artifactPath);
+  // A relative archive argument avoids GNU tar's drive-letter remote-host syntax and also
+  // works with Windows BSD tar, which does not support GNU's --force-local option.
+  return { args: ['-xzf', `./${paths.basename(archive)}`, '-C', paths.resolve(destination)],
+    cwd: paths.dirname(archive) };
+}
 function command(name, args, options = {}) {
   const { platform = process.platform, ...spawnOptions } = options;
   const invocation = commandInvocation(name, args, { platform, env: spawnOptions.env || process.env });
@@ -45,13 +59,50 @@ function command(name, args, options = {}) {
   }
   return String(result.stdout || '').trim();
 }
+export function validateCandidateSource(root, { sha, version }) {
+  const candidateRoot = fs.realpathSync(root);
+  const options = { cwd: candidateRoot };
+  const top = command('git', ['rev-parse', '--show-toplevel'], options);
+  const head = command('git', ['rev-parse', 'HEAD'], options);
+  // Git and Node can spell the same Windows directory with different casing/separators.
+  // Compare actual directory identity, never case-fold distinct source paths.
+  const candidateDirectory = fs.statSync(candidateRoot, { bigint: true });
+  const topDirectory = fs.statSync(top, { bigint: true });
+  if (!candidateDirectory.isDirectory() || !topDirectory.isDirectory()
+    || candidateDirectory.ino <= 0n || topDirectory.ino <= 0n
+    || candidateDirectory.dev !== topDirectory.dev || candidateDirectory.ino !== topDirectory.ino
+    || !/^[a-f0-9]{40}$/.test(String(sha)) || head !== sha) {
+    throw new Error(`candidate checkout ${head} does not match candidate ${sha}`);
+  }
+  if (command('git', ['status', '--porcelain', '--untracked-files=no'], options)) {
+    throw new Error('candidate checkout has tracked changes');
+  }
+  const manifest = path.join(candidateRoot, 'package.json');
+  const stat = fs.lstatSync(manifest);
+  if (!stat.isFile() || stat.isSymbolicLink() || !version || readJson(manifest).version !== version) {
+    throw new Error('candidate checkout package version differs from the released candidate');
+  }
+  return candidateRoot;
+}
 function locate(name, { platform = process.platform } = {}) {
-  const query = platform === 'win32' ? (name === 'node' ? 'node.exe' : `${name}.cmd`) : name;
+  const query = platform === 'win32' ? (['node', 'git'].includes(name) ? `${name}.exe` : `${name}.cmd`) : name;
   try {
     return command(platform === 'win32' ? 'where.exe' : 'which', [query], { platform })
       .split(/\r?\n/).find(Boolean) || null;
   } catch { return null; }
 }
+export function nativeCodexExecutable({ platform = process.platform, arch = process.arch,
+  wrapper = platform === 'win32' ? locate('codex') : null } = {}) {
+  if (platform !== 'win32') return null;
+  if (!wrapper || !['x64', 'arm64'].includes(arch)) throw new Error('native Windows Codex CLI unavailable');
+  const require = createRequire(import.meta.url);
+  const packageFile = require.resolve('@openai/codex/package.json', { paths: [path.dirname(wrapper)] });
+  const platformFile = require.resolve(`@openai/codex-win32-${arch}/package.json`, { paths: [path.dirname(packageFile)] });
+  const target = arch === 'x64' ? 'x86_64' : 'aarch64';
+  const executable = path.join(path.dirname(platformFile), 'vendor', `${target}-pc-windows-msvc`, 'bin', 'codex.exe');
+  if (!fs.statSync(executable).isFile()) throw new Error('native Windows Codex executable missing');
+  return executable;
+}
 export function createIsolatedPath(mode, temp, { platform = process.platform, env = process.env,
   resolve = (name) => locate(name, { platform }) } = {}) {
   const bin = path.join(temp, `bin-${mode}`);
@@ -70,7 +121,10 @@ export function createIsolatedPath(mode, temp, { platform = process.platform, en
   if (platform !== 'win32') return `${bin}:/usr/bin:/bin`;
   const node = resolve('node');
   if (!node) throw new Error(`node CLI unavailable for ${mode} public host fixture`);
+  const git = resolve('git');
+  if (!git) throw new Error(`git CLI unavailable for ${mode} public host fixture`);
   return [bin, path.dirname(node), path.join(env.SystemRoot || 'C:\\Windows', 'System32'),
+    path.dirname(git),
     path.join(env.ProgramFiles || 'C:\\Program Files', 'Git', 'usr', 'bin')].join(path.win32.delimiter);
 }
 export function stageVerifiedBundle({ bundlePath, bundleSha256, packageRoot }) {
@@ -166,18 +220,35 @@ export function assertInstalledPayload(sourceRoot, installedRoot) {
   return checked;
 }
 
-export function rpcSearch(server, env, query, k = 5, timeoutMs = DEADLINE_MS) {
+export function rpcSearch(server, env, query, k = 5, timeoutMs = DEADLINE_MS, {
+  requiredRepo = 'ruvnet-brain',
+} = {}) {
   if (!Number.isSafeInteger(k) || k < 1 || k > 50) throw new Error(`invalid search result count: ${k}`);
   return new Promise((resolve, reject) => {
     const child = spawn(process.execPath, [server], { env, stdio: ['pipe', 'pipe', 'pipe'] });
+    // Preserve multibyte characters across pipe chunks before checking source-content hashes.
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
     let stdout = '';
     let stderr = '';
     let timer;
+    let killTimer;
+    let closeTimer;
+    let outcome;
     const pending = new Map();
     const finish = (error, value) => {
+      if (outcome) return;
+      outcome = { error, value };
       clearTimeout(timer);
+      pending.clear();
+      // Do not let the next doctor/search probe contend with this process while it exits.
+      // A child that ignores graceful shutdown must not leave the verifier hanging either.
+      killTimer = setTimeout(() => {
+        outcome.error = new Error('installed Brain did not shut down within 5000ms');
+        child.kill('SIGKILL');
+        closeTimer = setTimeout(() => reject(new Error('installed Brain process did not close after SIGKILL')), 1000);
+      }, 5000);
       child.kill('SIGTERM');
-      error ? reject(error) : resolve(value);
     };
     timer = setTimeout(() => finish(new Error(`installed Brain exceeded ${timeoutMs}ms deadline`)), timeoutMs);
     child.stderr.on('data', (chunk) => { stderr += chunk; });
@@ -195,8 +266,12 @@ export function rpcSearch(server, env, query, k = 5, timeoutMs = DEADLINE_MS) {
       }
     });
     child.on('error', (error) => finish(error));
-    child.on('exit', (code) => {
-      if (pending.size) finish(new Error(`installed Brain exited ${code}: ${stderr.slice(0, 400)}`));
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      clearTimeout(killTimer);
+      clearTimeout(closeTimer);
+      const result = outcome || { error: new Error(`installed Brain exited ${code}: ${stderr.slice(0, 400)}`) };
+      result.error ? reject(result.error) : resolve(result.value);
     });
     const call = (id, method, params = {}) => new Promise((done) => {
       pending.set(id, done);
@@ -212,14 +287,19 @@ export function rpcSearch(server, env, query, k = 5, timeoutMs = DEADLINE_MS) {
       const broadMs = Math.round(performance.now() - started);
       const text = (searched.result?.content || []).map((item) => item.text || '').join('\n');
       if (searched.error || searched.result?.isError || /search_ruvnet error:/i.test(text)) throw new Error(`installed Brain search failed: ${text.slice(0, 400)}`);
-      if (!/repo=ruvnet-brain/i.test(text) || !/path\s*:/i.test(text)) throw new Error('installed Brain search returned no ruvnet-brain source citation');
-      finish(null, { broadMs, text });
+      if (!/repo=/i.test(text) || !/path\s*:/i.test(text)) throw new Error('installed Brain search returned no source citation');
+      const repos = [...text.matchAll(/repo=([\w.-]+)/gi)].map((match) => match[1].toLowerCase());
+      if (requiredRepo && !repos.includes(String(requiredRepo).toLowerCase())) {
+        throw new Error(`installed Brain search returned no ${requiredRepo} source citation`);
+      }
+      finish(null, { broadMs, text, mcpResult: searched.result });
     })().catch((error) => finish(error));
   });
 }
 
-export function livePublicationAdapter({ root = process.cwd() } = {}) {
+export function livePublicationAdapter({ root = process.cwd(), candidateRoot = root } = {}) {
   const installContexts = new Map();
+  const mcpSessions = new Map();
   const passageFileDigests = new Map();
   let installTemp = null;
   return {
@@ -246,11 +326,40 @@ export function livePublicationAdapter({ root = process.cwd() } = {}) {
       return { path: destination, tag: release.tag_name, sha: tagCommit(root, tag) };
     },
 
+    async runNativeNightly({ identity, workflowRunId }) {
+      const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'ruvnet-public-nightly-'));
+      let completed = false;
+      try {
+        const npm = await this.downloadNpm({ version: identity.version,
+          destination: path.join(temp, 'package.tgz') });
+        const bundle = await this.downloadGithub({ tag: identity.tag, assetName: 'ruvnet-brain.zip',
+          destination: path.join(temp, 'ruvnet-brain.zip') });
+        const signature = await this.downloadGithub({ tag: identity.tag, assetName: 'ruvnet-brain.zip.sig',
+          destination: path.join(temp, 'ruvnet-brain.zip.sig') });
+        if (sha256(npm.path) !== identity.packageSha256 || sha256(bundle.path) !== identity.bundleSha256
+          || npm.version !== identity.version || bundle.sha !== identity.candidateSha
+          || signature.sha !== identity.candidateSha) throw new Error('nightly public artifact identity mismatch');
+        const proof = await runNightlyTwoRunProof({ packagePath: npm.path, bundlePath: bundle.path,
+          signaturePath: signature.path, sourceSha: identity.candidateSha, workflowRunId,
+          out: path.join(temp, 'nightly-proof.json') });
+        const validation = validateNightlyProofReceipt(proof, { platform: process.platform, version: identity.version,
+          packageSha256: identity.packageSha256, bundleSha256: identity.bundleSha256,
+          sourceSha: identity.candidateSha, workflowRunId });
+        if (!validation.ok) throw new Error(`public nightly proof failed: ${validation.failures.join('; ')}`);
+        completed = true;
+        return proof;
+      } finally {
+        if (completed) fs.rmSync(temp, { recursive: true, force: true });
+        else console.error(`Native public artifact diagnostics retained at ${temp}`);
+      }
+    },
+
     async installHosts({ artifactPath, artifactSha256, bundlePath, bundleSha256, version }) {
-      const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'ruvnet-public-install-'));
+      const temp = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'ruvnet-public-install-')));
       installTemp = temp;
       const packageRoot = path.join(temp, 'package');
-      command('tar', ['-xzf', artifactPath, '-C', temp]);
+      const extraction = tarExtractionInvocation(artifactPath, temp);
+      command('tar', extraction.args, { cwd: extraction.cwd });
       stageVerifiedBundle({ bundlePath, bundleSha256, packageRoot });
       const sealedPlugin = path.join(packageRoot, 'plugin');
       const results = {};
@@ -260,6 +369,7 @@ export function livePublicationAdapter({ root = process.cwd() } = {}) {
       // Derived from HOST_MODES, so a fourth host shape is added in ONE place and this loop
       // cannot fall behind the staged-side check the way it did.
       for (const mode of HOST_MODES.map((m) => RECEIPT_MODE_NAMES[m])) {
+        console.log(`Public verification: installing ${mode} on ${process.platform}`);
         const home = path.join(temp, `home-${mode}`);
         const codexHome = path.join(home, '.codex');
         const brainHome = path.join(home, '.cache', 'ruvnet-brain');
@@ -283,13 +393,20 @@ export function livePublicationAdapter({ root = process.cwd() } = {}) {
           RUVNET_STRICT_INSTALL: '0',
           CI: 'true',
           PATH: createIsolatedPath(mode, temp),
+          ...(process.platform === 'win32' && mode !== 'claudeOnly'
+            ? { CODEX_BIN: nativeCodexExecutable() } : {}),
         };
+        if (mode !== 'claudeOnly') {
+          command(env.CODEX_BIN || 'codex', ['--version'], { env, timeout: 30_000, stdio: 'inherit' });
+          command(env.CODEX_BIN || 'codex', ['plugin', 'list', '--json'], { env, timeout: 30_000, stdio: 'inherit' });
+        }
+        if (process.platform === 'win32') command('git', ['--version'], { env, timeout: 30_000, stdio: 'inherit' });
         const installer = path.join(packageRoot, 'bin', 'install.mjs');
         command(process.execPath, [
           installer, '--yes', '--force', '--version', `v${version}`,
           '--no-nightly-prompt', '--no-telemetry', '--no-stack', '--no-enhance', '--no-statusline',
           '--no-selfcheck', '--no-verify',
-        ], { env, cwd: packageRoot, timeout: 1_200_000, maxBuffer: 32 * 1024 * 1024 });
+        ], { env, cwd: packageRoot, timeout: 1_200_000, stdio: 'inherit' });
 
         const verified = {};
         if (mode !== 'codexOnly') {
@@ -310,7 +427,7 @@ export function livePublicationAdapter({ root = process.cwd() } = {}) {
         const searched = await rpcSearch(findMcpServer(home), env,
           'How does RuvNet Brain prove a public release artifact?', 5, DEADLINE_MS);
         command(process.execPath, [installer, '--doctor', '--hooks'], {
-          env, cwd: packageRoot, timeout: 300_000, maxBuffer: 32 * 1024 * 1024,
+          env, cwd: packageRoot, timeout: 300_000, stdio: 'inherit',
         });
         results[mode] = {
           status: 'PASS', doctorExit: 0, version, artifactSha256,
@@ -342,46 +459,32 @@ export function livePublicationAdapter({ root = process.cwd() } = {}) {
     async searchInstalled({ mode, query, k }) {
       const context = installContexts.get(mode);
       if (!context) throw new Error(`${mode} public host is not installed`);
-      const result = await rpcSearch(findMcpServer(context.home), context.env, query, k, DEADLINE_MS);
-      return parseCitations(result.text).map((citation) => ({
-        repo: citation.repo.toLowerCase(),
-        path: citation.docPath,
-      }));
+      // Keep one MCP worker per installed host. Starting a fresh worker for every canary reloads
+      // the local embedding model repeatedly and can exceed the fixed 30-second public deadline
+      // on macOS, even when the installed Brain itself is healthy.
+      let session = mcpSessions.get(mode);
+      if (!session) {
+        session = createInstalledMcpSession({ serverPath: findMcpServer(context.home), env: context.env, timeout: DEADLINE_MS });
+        mcpSessions.set(mode, session);
+      }
+      const result = await session.search({ query, k });
+      return parseRetrievalResult(result.mcpResult, { query, k });
     },
 
     async resolveInstalledCitation({ mode, matched, expected }) {
       const context = installContexts.get(mode);
       if (!context) throw new Error(`${mode} public host is not installed`);
-      if (String(matched?.repo || '').toLowerCase() !== expected.repo || matched?.path !== expected.path) {
-        return { resolved: false };
-      }
-      const files = [
-        path.join(context.kb, `${expected.repo}.passages.jsonl`),
-        path.join(context.kb, `${expected.repo}.big.passages.jsonl`),
-      ].filter((file) => fs.existsSync(file));
-      for (const file of files) {
-        const rows = readline.createInterface({ input: fs.createReadStream(file), crlfDelay: Infinity });
-        try {
-          for await (const line of rows) {
-            let record;
-            try { record = JSON.parse(line); } catch { continue; }
-            if (record?.path !== expected.path) continue;
-            const passageSha256 = digest(record);
-            if (passageSha256 !== expected.passageSha256) return { resolved: false };
-            if (!passageFileDigests.has(file)) passageFileDigests.set(file, sha256File(file));
-            return { resolved: true, evidence: { passageSha256, passageFileSha256: passageFileDigests.get(file) } };
-          }
-        } finally { rows.close(); }
-      }
-      return { resolved: false };
+      return resolveInstalledCanaryCitation({ kbDir: context.kb, matched, expected, passageFileDigests });
     },
 
-    async probePublishedSurface({ sha }) {
-      const head = command('git', ['rev-parse', 'HEAD'], { cwd: root });
-      if (head !== sha) throw new Error(`published-surface probe checkout ${head} does not match candidate ${sha}`);
-      const result = spawnSync(process.execPath, ['scripts/published-surface-probe.mjs', '--json'], {
-        cwd: root, env: process.env, encoding: 'utf8', timeout: 600_000,
+    async probePublishedSurface({ sha, version }) {
+      const source = validateCandidateSource(candidateRoot, { sha, version });
+      // The verifier supplies executable checks; the candidate supplies only the released source.
+      const script = fileURLToPath(new URL('./published-surface-probe.mjs', import.meta.url));
+      const result = spawnSync(process.execPath, [script, '--json'], {
+        cwd: source, env: process.env, encoding: 'utf8', timeout: 600_000,
       });
+      validateCandidateSource(candidateRoot, { sha, version });
       let parsed;
       try { parsed = JSON.parse(String(result.stdout || '')); } catch { throw new Error(`published-surface-probe emitted invalid JSON: ${String(result.stderr || '').slice(0, 300)}`); }
       if (result.status !== 0 || parsed.verdict !== 'PASS') throw new Error(`published-surface-probe is ${parsed.verdict || `exit ${result.status}`}`);
@@ -389,6 +492,8 @@ export function livePublicationAdapter({ root = process.cwd() } = {}) {
     },
 
     async dispose() {
+      await Promise.all([...mcpSessions.values()].map((session) => session.close()));
+      mcpSessions.clear();
       if (installTemp) fs.rmSync(installTemp, { recursive: true, force: true });
       installTemp = null;
       installContexts.clear();
@@ -449,6 +554,7 @@ export async function generatePublicationReceipt({
     const publication = {
       schemaVersion: 2,
       phase: 'publication',
+      acceptancePolicy: 'stabilization-public-deadline-v1',
       sha: candidate.sha,
       artifactSha256: digest,
       version: candidate.version,
@@ -468,7 +574,7 @@ export async function generatePublicationReceipt({
       postPublicationChecks: [surface],
     };
     const result = evaluatePublicationReceipt(candidate, publication);
-    if (result.verdict !== 'PASS') throw new Error(`publication seal failed: ${result.failures.map(({ code }) => code).join(',')}`);
+    if (result.verdict !== 'PASS') throw new Error(`publication seal failed: ${JSON.stringify({ failures: result.failures, installed: publication.installed, brain: publication.brain })}`);
     fs.mkdirSync(path.dirname(outPath), { recursive: true });
     fs.writeFileSync(outPath, `${JSON.stringify(publication, null, 2)}\n`, { flag: 'wx', mode: 0o600 });
     return result;

package/scripts/published-surface-probe.mjs

@@ -52,6 +52,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
 
 export const EXIT = Object.freeze({ PASS: 0, FAIL: 1, UNKNOWN: 4 });
 
@@ -127,6 +128,12 @@ async function probeRegistry() {
 }
 
 // ── B. EXECUTE the published package, from the registry ────────────────────────────────────────
+export function npxInvocation(args, { platform = process.platform, env = process.env } = {}) {
+  if (platform === 'win32') return {
+    executable: env.ComSpec || 'cmd.exe', args: ['/d', '/c', 'npx.cmd', ...args],
+  };
+  return { executable: 'npx', args };
+}
 function probeExec() {
   const home = fs.mkdtempSync(path.join(os.tmpdir(), 'ruvnet-brain-probe-'));
   try {
@@ -134,7 +141,8 @@ function probeExec() {
     // (npm resolve → download → unpack → bin mapping → node parses every module it imports) while
     // touching NOTHING on the machine. `--doctor`/`--plan` reach the network and the brain dir; this
     // probe must never be the reason a surface changes.
-    const r = spawnSync('npx', ['-y', `${PKG}@latest`, '--help'], {
+    const invocation = npxInvocation(['-y', `${PKG}@latest`, '--help']);
+    const r = spawnSync(invocation.executable, invocation.args, {
       encoding: 'utf8',
       timeout: 300_000,
       cwd: home,
@@ -237,5 +245,5 @@ export async function main() {
   return EXIT[verdict];
 }
 
-const invokedDirectly = process.argv[1] && path.resolve(process.argv[1]) === path.resolve(new URL(import.meta.url).pathname);
+const invokedDirectly = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
 if (invokedDirectly) process.exit(await main());

package/scripts/qa-contract.mjs

@@ -0,0 +1,57 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+
+export function verdictOf(results) {
+  if (results.some(({ status }) => ['FAIL', 'TIMEOUT', 'BLOCKED'].includes(status))) return 'FAIL';
+  return results.length && results.every(({ status }) => status === 'PASS') ? 'PASS' : 'UNKNOWN';
+}
+
+// A source digest includes dirty tracked files and untracked source, never ignored build outputs.
+export function sourceIdentity(root) {
+  const git = (args) => execFileSync('git', args, { cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+  let sha = null;
+  try { sha = git(['rev-parse', 'HEAD']).trim(); } catch { /* unborn repository */ }
+  const files = [...new Set(git(['ls-files', '-z', '--cached', '--others', '--exclude-standard']).split('\0').filter(Boolean))].sort();
+  const hash = createHash('sha256');
+  for (const relative of files) {
+    const file = path.join(root, relative);
+    let bytes = Buffer.from('deleted');
+    try {
+      const stat = fs.lstatSync(file);
+      bytes = stat.isSymbolicLink() ? Buffer.from(`symlink:${fs.readlinkSync(file)}`)
+        : stat.isFile() ? Buffer.concat([Buffer.from(`${stat.mode & 0o777}:`), fs.readFileSync(file)]) : Buffer.from('directory');
+    } catch (error) { if (error.code !== 'ENOENT') throw error; }
+    hash.update(JSON.stringify([relative, createHash('sha256').update(bytes).digest('hex')]));
+  }
+  return { sha, dirty: Boolean(git(['status', '--porcelain']).trim()), digest: hash.digest('hex'), files: files.length, recipe: 'git-source-bytes-v1' };
+}
+
+export async function runLanes(lanes, execute, concurrency = 2) {
+  if (!Number.isInteger(concurrency) || concurrency < 1) throw new Error('invalid QA concurrency');
+  const names = new Set(lanes.map(({ name }) => name));
+  if (names.size !== lanes.length || lanes.some((lane) => (lane.dependsOn || []).some((name) => !names.has(name)))) throw new Error('invalid QA dependency');
+  const pending = [...lanes], completed = new Map();
+  while (pending.length) {
+    const resources = new Set(), batch = [];
+    for (const lane of pending) {
+      if (!(lane.dependsOn || []).every((name) => completed.has(name))) continue;
+      if ((lane.dependsOn || []).some((name) => completed.get(name).status !== 'PASS')) {
+        completed.set(lane.name, { name: lane.name, status: 'BLOCKED', reason: 'required prerequisite did not pass' });
+        continue;
+      }
+      if (batch.length >= concurrency || (lane.resource && resources.has(lane.resource))) continue;
+      batch.push(lane); resources.add(lane.resource);
+    }
+    if (!batch.length && !pending.some(({ name }) => completed.has(name))) throw new Error('QA dependency cycle');
+    await Promise.all(batch.map(async (lane) => {
+      let result;
+      try { result = await execute(lane); }
+      catch (error) { result = { name: lane.name, status: 'FAIL', reason: error.message }; }
+      completed.set(lane.name, result);
+    }));
+    for (let index = pending.length - 1; index >= 0; index--) if (completed.has(pending[index].name)) pending.splice(index, 1);
+  }
+  return lanes.map(({ name }) => completed.get(name));
+}