ruvnet-brain 4.3.3 → 4.3.9

package/scripts/public-verification-aggregate.mjs

@@ -133,7 +133,7 @@ const identityOf = (leaf) => ({
   releaseTransactionId: leaf.releaseTransactionId,
 });
 
-export function buildPublicVerificationAggregate(leaves, reviews) {
+export function buildPublicVerificationAggregate(leaves) {
   if (!Array.isArray(leaves) || leaves.length !== PUBLIC_VERIFICATION_OS.length * PUBLIC_VERIFICATION_MODES.length) {
     throw new Error('public verification requires exactly nine leaves');
   }
@@ -168,25 +168,11 @@ export function buildPublicVerificationAggregate(leaves, reviews) {
   if (metrics.recallAt10 < 0.98 || metrics.deltaCitationRate !== 1 || metrics.skipped || metrics.unknown) {
     throw new Error('public verification aggregate retrieval acceptance failed');
   }
-  if (!Array.isArray(reviews) || reviews.length !== REQUIRED_REVIEW_MODELS.length) {
-    throw new Error('public verification aggregate requires exactly two independent reviews');
-  }
-  reviews.forEach(validateIndependentReviewReceipt);
-  const byModel = new Map(reviews.map((review) => [review.model, review]));
-  if (byModel.size !== REQUIRED_REVIEW_MODELS.length || REQUIRED_REVIEW_MODELS.some((model) => !byModel.has(model))) {
-    throw new Error('required independent review models are missing or duplicated');
-  }
-  const firstReview = byModel.get(REQUIRED_REVIEW_MODELS[0]);
-  const semanticIdentity = validateReviewOracleAgainstPlan(firstReview, first.retrievalPlan);
-  for (const model of REQUIRED_REVIEW_MODELS) {
-    const review = byModel.get(model);
-    const semantic = validateReviewOracleAgainstPlan(review, first.retrievalPlan);
-    if (review.sourceSha !== identity.sourceSha || review.artifactSha256 !== identity.artifactSha256
-      || review.payloadId !== identity.payloadId || review.productContractSha256 !== firstReview.productContractSha256
-      || review.rubricSha256 !== firstReview.rubricSha256
-      || semantic.recordSetSha256 !== semanticIdentity.recordSetSha256) {
-      throw new Error(`${model} review identity, rubric, or oracle identity differs`);
-    }
+  const oracle = first.retrievalPlan.oracle;
+  if (!oracle || !HEX64.test(String(oracle.receiptSha256 || ''))
+    || !HEX64.test(String(oracle.queryStoreSetSha256 || ''))
+    || oracle.queryStoreSetSha256 !== digest(first.retrievalPlan.denominator.eligibleStores)) {
+    throw new Error('sealed retrieval oracle identity is incomplete');
   }
   return {
     schemaVersion: 1,
@@ -194,17 +180,11 @@ export function buildPublicVerificationAggregate(leaves, reviews) {
     identity,
     coverage: first.coverage,
     lanes: required.map((lane) => ({ lane, leafSha256: byLane.get(lane).leafSha256 })),
-    reviews: REQUIRED_REVIEW_MODELS.map((model) => ({ model, receiptSha256: byModel.get(model).receiptSha256,
-      score: byModel.get(model).score })),
-    evidence: { leaves: required.map((lane) => structuredClone(byLane.get(lane))),
-      reviews: REQUIRED_REVIEW_MODELS.map((model) => structuredClone(byModel.get(model))) },
-    productContractSha256: firstReview.productContractSha256,
-    rubricSha256: firstReview.rubricSha256,
+    evidence: { leaves: required.map((lane) => structuredClone(byLane.get(lane))) },
     retrievalOracle: {
-      oracleReceiptSha256: semanticIdentity.oracleReceiptSha256,
-      queryStoreSetSha256: semanticIdentity.queryStoreSetSha256,
-      recordCount: semanticIdentity.recordCount,
-      recordSetSha256: semanticIdentity.recordSetSha256,
+      oracleReceiptSha256: oracle.receiptSha256,
+      queryStoreSetSha256: oracle.queryStoreSetSha256,
+      recordCount: first.retrievalPlan.denominator.eligibleStores.length,
     },
     metrics,
     verdict: 'PASS',
@@ -212,8 +192,8 @@ export function buildPublicVerificationAggregate(leaves, reviews) {
   };
 }
 
-export function signPublicVerificationAggregate({ leaves, reviews }, privateKey) {
-  const payload = buildPublicVerificationAggregate(leaves, reviews);
+export function signPublicVerificationAggregate({ leaves }, privateKey) {
+  const payload = buildPublicVerificationAggregate(leaves);
   const aggregateSha256 = digest(payload);
   const signed = { ...payload, aggregateSha256 };
   return { ...signed, signature: crypto.sign(null, Buffer.from(canonicalJson(signed)), privateKey).toString('base64') };
@@ -227,10 +207,10 @@ export function verifyPublicVerificationAggregate(aggregate, publicKey, expected
   }
   const payload = aggregatePayload(aggregate);
   if (digest(payload) !== aggregate.aggregateSha256) throw new Error('public verification aggregate digest mismatch');
-  if (!Array.isArray(aggregate.evidence?.leaves) || !Array.isArray(aggregate.evidence?.reviews)) {
-    throw new Error('public verification aggregate lacks raw leaf or review evidence');
+  if (!Array.isArray(aggregate.evidence?.leaves)) {
+    throw new Error('public verification aggregate lacks raw leaf evidence');
   }
-  const rebuilt = buildPublicVerificationAggregate(aggregate.evidence.leaves, aggregate.evidence.reviews);
+  const rebuilt = buildPublicVerificationAggregate(aggregate.evidence.leaves);
   if (canonicalJson(rebuilt) !== canonicalJson(payload)) {
     throw new Error('public verification aggregate differs from rebuilt raw evidence');
   }
@@ -249,17 +229,10 @@ export function verifyPublicVerificationAggregate(aggregate, publicKey, expected
     || aggregate.coverage.gistCurrent !== aggregate.coverage.gistTotal) {
     throw new Error('public verification aggregate evidence is incomplete');
   }
-  if (aggregate.reviews?.length !== REQUIRED_REVIEW_MODELS.length
-    || REQUIRED_REVIEW_MODELS.some((model) => !aggregate.reviews.some((row) => row.model === model
-      && Number.isInteger(row.score) && row.score >= 95 && HEX64.test(String(row.receiptSha256 || ''))))
-    || !HEX64.test(String(aggregate.productContractSha256 || '')) || !HEX64.test(String(aggregate.rubricSha256 || ''))) {
-    throw new Error('public verification aggregate reviews are incomplete');
-  }
   if (aggregate.retrievalOracle?.oracleReceiptSha256 !== aggregate.evidence.leaves[0].retrievalPlan.oracle.receiptSha256
     || aggregate.retrievalOracle?.queryStoreSetSha256 !== aggregate.evidence.leaves[0].retrievalPlan.oracle.queryStoreSetSha256
-    || aggregate.retrievalOracle?.recordCount !== aggregate.evidence.leaves[0].retrievalPlan.denominator.eligibleStores.length
-    || !HEX64.test(String(aggregate.retrievalOracle?.recordSetSha256 || ''))) {
-    throw new Error('public verification aggregate retrieval oracle review is incomplete');
+    || aggregate.retrievalOracle?.recordCount !== aggregate.evidence.leaves[0].retrievalPlan.denominator.eligibleStores.length) {
+    throw new Error('public verification aggregate retrieval oracle identity is incomplete');
   }
   if (expectedIdentity && canonicalJson(aggregate.identity) !== canonicalJson(expectedIdentity)) {
     throw new Error('public verification aggregate identity differs from the release transaction');
@@ -272,13 +245,13 @@ function parseCliArgs(argv) {
   for (let index = 0; index < argv.length; index += 2) {
     const flag = argv[index];
     const value = argv[index + 1];
-    if (!['--lanes', '--reviews', '--out'].includes(flag) || !value) {
-      throw new Error('usage: public-verification-aggregate.mjs --lanes <dir> --reviews <dir> --out <file>');
+    if (!['--lanes', '--out'].includes(flag) || !value) {
+      throw new Error('usage: public-verification-aggregate.mjs --lanes <dir> --out <file>');
     }
     parsed[flag.slice(2)] = value;
   }
-  if (!parsed.lanes || !parsed.reviews || !parsed.out || Object.keys(parsed).length !== 3) {
-    throw new Error('usage: public-verification-aggregate.mjs --lanes <dir> --reviews <dir> --out <file>');
+  if (!parsed.lanes || !parsed.out || Object.keys(parsed).length !== 2) {
+    throw new Error('usage: public-verification-aggregate.mjs --lanes <dir> --out <file>');
   }
   return parsed;
 }
@@ -314,12 +287,11 @@ function readLaneLeaves(directory) {
   return PUBLIC_VERIFICATION_OS.flatMap((osName) => byOs.get(osName));
 }
 
-export function generatePublicVerificationAggregate({ lanesDirectory, reviewsDirectory, outputFile, privateKey }) {
+export function generatePublicVerificationAggregate({ lanesDirectory, outputFile, privateKey }) {
   if (!privateKey) throw new Error('RUVNET_SIGNING_KEY is required');
   if (fs.existsSync(outputFile)) throw new Error(`refusing to overwrite existing aggregate: ${outputFile}`);
   const leaves = readLaneLeaves(lanesDirectory);
-  const reviews = readExactJsonFiles(reviewsDirectory, REQUIRED_REVIEW_MODELS.length, 'review');
-  const aggregate = signPublicVerificationAggregate({ leaves, reviews }, privateKey);
+  const aggregate = signPublicVerificationAggregate({ leaves }, privateKey);
   fs.writeFileSync(outputFile, `${JSON.stringify(aggregate, null, 2)}\n`, { flag: 'wx', mode: 0o600 });
   return aggregate;
 }
@@ -328,12 +300,11 @@ async function main() {
   const options = parseCliArgs(process.argv.slice(2));
   const aggregate = generatePublicVerificationAggregate({
     lanesDirectory: options.lanes,
-    reviewsDirectory: options.reviews,
     outputFile: options.out,
     privateKey: process.env.RUVNET_SIGNING_KEY,
   });
   process.stdout.write(`${JSON.stringify({ ok: true, aggregateSha256: aggregate.aggregateSha256,
-    leaves: aggregate.metrics.leaves, reviews: aggregate.reviews.length })}\n`);
+    leaves: aggregate.metrics.leaves })}\n`);
 }
 
 if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {

package/scripts/public-verification-lane.mjs

@@ -24,6 +24,32 @@ const HEX40 = /^[a-f0-9]{40}$/;
 const HEX64 = /^[a-f0-9]{64}$/;
 const normalizedDigest = (value) => String(value || '').replace(/^sha256:/, '');
 
+function failedCanaryCases(retrieval) {
+  return retrieval.cases.filter(({ cohort, status, retrievalHit, citationResolved }) =>
+    status !== 'COMPLETED' || retrievalHit !== true || (cohort === 'delta' && citationResolved !== true));
+}
+
+function publicVerificationFailure({ os, identity, failures, completedLeaves }) {
+  const payload = {
+    schemaVersion: 1,
+    kind: 'ruvnet-brain-public-verification-failure',
+    os,
+    sourceSha: identity.candidateSha,
+    artifactSha256: identity.packageSha256,
+    bundleSha256: identity.bundleSha256,
+    failures: failures.map(({ mode, reason, retrieval }) => ({
+      mode,
+      reason,
+      metrics: retrieval.metrics,
+      failedCaseIds: failedCanaryCases(retrieval).map(({ id }) => id),
+      failedCases: failedCanaryCases(retrieval),
+      retrievalReceiptSha256: retrieval.receiptSha256,
+    })),
+    completedLeaves: completedLeaves.map(({ mode, leafSha256 }) => ({ mode, leafSha256 })),
+  };
+  return { ...payload, failureSha256: digest(payload) };
+}
+
 function validateReleaseIdentity(identity) {
   if (identity?.repository !== 'stuinfla/ruvnet-brain' || identity?.package !== 'ruvnet-brain'
     || !HEX40.test(String(identity.candidateSha || '')) || !HEX64.test(String(identity.payloadId || ''))
@@ -118,6 +144,7 @@ export async function createPublicVerificationLane({
     releaseTransactionId: transactionIdFor(identity),
   };
   const leaves = [];
+  const failures = [];
   for (const mode of PUBLIC_VERIFICATION_MODES) {
     const installed = publication.installed?.[RECEIPT_MODE_NAMES[mode]];
     if (installed?.status !== 'PASS' || installed.doctorExit !== 0 || installed.version !== identity.version
@@ -132,10 +159,16 @@ export async function createPublicVerificationLane({
       search: ({ query, k }) => adapter.searchInstalled({ mode, query, k }),
       citationResolver: (matched, expected) => adapter.resolveInstalledCitation({ mode, matched, expected }),
     });
-    const verifiedRetrieval = validateRetrievalCanaryReceipt(
-      retrieval,
-      { plan: retrievalPlan, requireAcceptance: true },
-    );
+    let verifiedRetrieval;
+    try {
+      verifiedRetrieval = validateRetrievalCanaryReceipt(
+        retrieval,
+        { plan: retrievalPlan, requireAcceptance: true },
+      );
+    } catch (error) {
+      failures.push({ mode, reason: error.message, retrieval });
+      continue;
+    }
     leaves.push(createPublicVerificationLeaf({
       ...common,
       os,
@@ -152,6 +185,11 @@ export async function createPublicVerificationLane({
       unknown: 0,
     }));
   }
+  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 });
+    throw error;
+  }
   if (canonicalJson(leaves.map(({ mode }) => mode)) !== canonicalJson(PUBLIC_VERIFICATION_MODES)) {
     throw new Error('public verification lane modes are incomplete');
   }
@@ -211,6 +249,13 @@ export async function generatePublicVerificationLane({
     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)) {
+      fs.mkdirSync(path.dirname(output), { recursive: true });
+      fs.writeFileSync(output, `${JSON.stringify(error.publicVerificationFailure, null, 2)}\n`,
+        { flag: 'wx', mode: 0o600 });
+    }
+    throw error;
   } finally {
     await adapter.dispose?.();
     fs.rmSync(temp, { recursive: true, force: true });

package/scripts/publication-receipt.mjs

@@ -29,30 +29,62 @@ const DEADLINE_MS = 30_000;
 const sha256 = (file) => crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
 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 } = {}) {
+  if (platform === 'win32' && /^(?:npm|npx)$/i.test(name)) return {
+    executable: env.ComSpec || 'cmd.exe', args: ['/d', '/c', `${name}.cmd`, ...args],
+  };
+  return { executable: name, args };
+}
 function command(name, args, options = {}) {
-  const result = spawnSync(name, args, { encoding: 'utf8', ...options });
+  const { platform = process.platform, ...spawnOptions } = options;
+  const invocation = commandInvocation(name, args, { platform, env: spawnOptions.env || process.env });
+  const result = spawnSync(invocation.executable, invocation.args, { encoding: 'utf8', ...spawnOptions });
   if (result.error || result.status !== 0) {
     const detail = String(result.stderr || result.stdout || result.error?.message || '').trim();
     throw new Error(`${name} ${args.join(' ')} failed: ${detail || `exit ${result.status}`}`);
   }
   return String(result.stdout || '').trim();
 }
-
-function locate(name) {
-  try { return command('which', [name]); } catch { return null; }
+function locate(name, { platform = process.platform } = {}) {
+  const query = platform === 'win32' ? (name === 'node' ? 'node.exe' : `${name}.cmd`) : name;
+  try {
+    return command(platform === 'win32' ? 'where.exe' : 'which', [query], { platform })
+      .split(/\r?\n/).find(Boolean) || null;
+  } catch { return null; }
 }
-
-function isolatedPath(mode, temp) {
+export function createIsolatedPath(mode, temp, { platform = process.platform, env = process.env,
+  resolve = (name) => locate(name, { platform }) } = {}) {
   const bin = path.join(temp, `bin-${mode}`);
   fs.mkdirSync(bin);
   const hosts = mode === 'claudeOnly' ? ['claude'] : mode === 'codexOnly' ? ['codex'] : ['claude', 'codex'];
-  for (const name of ['node', 'npm', ...hosts]) {
-    const target = locate(name);
+  const names = platform === 'win32' ? ['npm', ...hosts] : ['node', 'npm', ...hosts];
+  for (const name of names) {
+    const target = resolve(name);
     if (!target) throw new Error(`${name} CLI unavailable for ${mode} public host fixture`);
-    fs.symlinkSync(target, path.join(bin, name));
+    if (platform === 'win32') {
+      fs.writeFileSync(path.join(bin, `${name}.cmd`), `@call "${target}" %*\r\n`, { flag: 'wx' });
+    } else {
+      fs.symlinkSync(target, path.join(bin, name));
+    }
+  }
+  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`);
+  return [bin, path.dirname(node), path.join(env.SystemRoot || 'C:\\Windows', 'System32'),
+    path.join(env.ProgramFiles || 'C:\\Program Files', 'Git', 'usr', 'bin')].join(path.win32.delimiter);
+}
+export function stageVerifiedBundle({ bundlePath, bundleSha256, packageRoot }) {
+  const source = path.resolve(bundlePath || '');
+  let stat;
+  try { stat = fs.lstatSync(source); } catch { throw new Error('verified public bundle is missing'); }
+  if (!stat.isFile() || stat.isSymbolicLink() || sha256(source) !== bundleSha256) {
+    throw new Error('verified bundle digest mismatch before installation');
   }
-  return `${bin}:/usr/bin:/bin`;
+  const destination = path.join(packageRoot, 'dist', 'ruvnet-brain.zip');
+  fs.mkdirSync(path.dirname(destination), { recursive: true });
+  fs.copyFileSync(source, destination, fs.constants.COPYFILE_EXCL);
+  if (sha256(destination) !== bundleSha256) throw new Error('staged verified bundle digest mismatch');
+  return destination;
 }
 
 async function download(url, destination, headers = {}) {
@@ -134,7 +166,8 @@ export function assertInstalledPayload(sourceRoot, installedRoot) {
   return checked;
 }
 
-function rpcSearch(server, env, query, timeoutMs = DEADLINE_MS) {
+export function rpcSearch(server, env, query, k = 5, timeoutMs = DEADLINE_MS) {
+  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'] });
     let stdout = '';
@@ -175,7 +208,7 @@ function rpcSearch(server, env, query, timeoutMs = DEADLINE_MS) {
       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 started = performance.now();
-      const searched = await call(3, 'tools/call', { name: 'search_ruvnet', arguments: { query, k: 5 } });
+      const searched = await call(3, 'tools/call', { name: 'search_ruvnet', arguments: { query, k } });
       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)}`);
@@ -213,14 +246,17 @@ export function livePublicationAdapter({ root = process.cwd() } = {}) {
       return { path: destination, tag: release.tag_name, sha: tagCommit(root, tag) };
     },
 
-    async installHosts({ artifactPath, artifactSha256, version }) {
+    async installHosts({ artifactPath, artifactSha256, bundlePath, bundleSha256, version }) {
       const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'ruvnet-public-install-'));
       installTemp = temp;
       const packageRoot = path.join(temp, 'package');
       command('tar', ['-xzf', artifactPath, '-C', temp]);
+      stageVerifiedBundle({ bundlePath, bundleSha256, packageRoot });
       const sealedPlugin = path.join(packageRoot, 'plugin');
       const results = {};
       let bundle = null;
+      const sharedModelCache = path.join(temp, 'models-cache');
+      fs.mkdirSync(sharedModelCache, { recursive: true });
       // 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])) {
@@ -233,26 +269,27 @@ export function livePublicationAdapter({ root = process.cwd() } = {}) {
         const env = {
           ...process.env,
           HOME: home,
+          ...(process.platform === 'win32' ? { USERPROFILE: home } : {}),
           CODEX_HOME: codexHome,
           RUVNET_BRAIN_HOME: brainHome,
           RUVNET_BRAIN_KB: kb,
+          KB_MODEL_CACHE: sharedModelCache,
           // Env comes from the ONE variant table (host-install-matrix VARIANTS.published), not a
           // second hand-written copy — this file's own header promises "ONE doctor rule and ONE mode
           // vocabulary, shared with the staged-side check", and the copy had already drifted: it
           // omitted the Codex hook-trust bypass the staged side carries, which failed the seal on
           // every release.
           ...VARIANTS.published.env({ packageRoot }),
+          RUVNET_STRICT_INSTALL: '0',
           CI: 'true',
-          PATH: isolatedPath(mode, temp),
+          PATH: createIsolatedPath(mode, temp),
         };
         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 });
-        command(process.execPath, [installer, '--doctor', '--hooks'], {
-          env, cwd: packageRoot, timeout: 300_000, maxBuffer: 32 * 1024 * 1024,
-        });
 
         const verified = {};
         if (mode !== 'codexOnly') {
@@ -270,7 +307,11 @@ export function livePublicationAdapter({ root = process.cwd() } = {}) {
           throw new Error(`${mode} installed public Brain bundle version mismatch`);
         }
         bundle ||= { brainVersion: source.brainVersion, releaseTag: source.releaseTag };
-        const searched = await rpcSearch(findMcpServer(home), env, 'How does RuvNet Brain prove a public release artifact?', DEADLINE_MS);
+        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,
+        });
         results[mode] = {
           status: 'PASS', doctorExit: 0, version, artifactSha256,
           functionalSearch: true, searchMs: searched.broadMs, hostsOnPath: mode,
@@ -291,16 +332,17 @@ export function livePublicationAdapter({ root = process.cwd() } = {}) {
       if (rvfs.length === 0) throw new Error('installed public Brain has no ruvnet-brain self RVF');
       const server = path.join(installContext.home, '.claude', 'ruvnet-brain', 'mcp', 'server.mjs');
       if (!fs.existsSync(server)) throw new Error('installed persistent MCP server is missing');
-      const result = await rpcSearch(server, installContext.env, 'How does RuvNet Brain prove a public release artifact?', DEADLINE_MS);
+      const result = await rpcSearch(server, installContext.env,
+        'How does RuvNet Brain prove a public release artifact?', 5, DEADLINE_MS);
       const readiness = readJson(path.join(installContext.brainHome, 'mcp-readiness.json'));
       if (readiness.state !== 'ready') throw new Error(`installed Brain readiness is ${readiness.state || 'missing'}`);
       return { status: 'PASS', selfStore: true, broadMs: result.broadMs, deadlineMs: DEADLINE_MS };
     },
 
-    async searchInstalled({ mode, query }) {
+    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, DEADLINE_MS);
+      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,
@@ -400,7 +442,8 @@ export async function generatePublicationReceipt({
     if (npm.version !== candidate.version || (npm.sha && npm.sha !== candidate.sha)) throw new Error('npm public identity mismatch');
     if (github.tag !== candidate.tag || github.sha !== candidate.sha) throw new Error('GitHub public identity mismatch');
 
-    const installed = await adapter.installHosts({ artifactPath: npm.path, artifactSha256: digest, version: candidate.version });
+    const installed = await adapter.installHosts({ artifactPath: npm.path, artifactSha256: digest,
+      bundlePath: githubBundle.path, bundleSha256: githubBundleDigest, version: candidate.version });
     const brain = await adapter.probeBrain({ sha: candidate.sha, artifactSha256: digest, version: candidate.version });
     const surface = await adapter.probePublishedSurface({ sha: candidate.sha, artifactSha256: digest, version: candidate.version });
     const publication = {

package/scripts/qa-runner.mjs

@@ -33,6 +33,7 @@ const lanes = [
     'tests/unit/codex-claude-hook-parity.test.mjs',
     'tests/unit/brain-stamp-resolve-built-from-sha.test.mjs',
     'tests/unit/qa-runner-concurrency.test.mjs',
+    'tests/unit/execution-preflight.test.mjs',
     '--reporter=dot']],
   ['mesh', 'npm', ['run', 'test:mesh']],
   ['plugin', 'npm', ['test']],

package/scripts/refresh-model-catalog.mjs

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 // scripts/refresh-model-catalog.mjs — pulls the LIVE OpenRouter model catalog and writes the committed
-// snapshot data/openrouter-catalog-snapshot.json (with a pulledAt stamp). verify-model-catalog.mjs then
+// snapshot data/openrouter-catalog-snapshot.json (with a pulledAt stamp) and synchronizes the catalog's
+// factual prices. verify-model-catalog.mjs then
 // enforces, offline in CI, that every model in data/model-catalog.json exists and is priced correctly
-// against this snapshot — and that the snapshot is fresh. Run nightly (the anti-rot mechanism) + on demand.
+// against this snapshot — and that the snapshot is fresh. Run weekly (the anti-rot mechanism) + on demand.
 // ADR-0016.
 //
 // It ALSO flags drift so a new flagship (e.g. a GPT-5.6-class release) surfaces instead of rotting:
@@ -45,6 +46,30 @@ export function detectDrift(catalog, models) {
   return missing;
 }
 
+/** Synchronize factual catalog prices from the same live map that backs the snapshot. */
+export function syncCatalogPrices(catalog, models, pulledAt) {
+  const changes = [];
+  for (const [provider, entry] of Object.entries(catalog.providers || {})) {
+    if (entry.aliasOf) continue;
+    for (const tier of ['frontier', 'mid', 'cheap']) {
+      const candidate = entry[tier];
+      if (!candidate?.model) continue;
+      const live = models[candidate.model]
+        || (!candidate.model.includes('/') ? models[`anthropic/${candidate.model}`] : null);
+      if (!live) continue;
+      if (candidate.in !== live.in || candidate.out !== live.out) {
+        changes.push({ provider, tier, model: candidate.model, from: { in: candidate.in, out: candidate.out }, to: live });
+        candidate.in = live.in;
+        candidate.out = live.out;
+      }
+    }
+  }
+  if (catalog._meta?.sources) {
+    catalog._meta.sources.prices = `OpenRouter /api/v1/models live catalog, pulled ${pulledAt.slice(0, 10)} (in/out USD per Mtok).`;
+  }
+  return changes;
+}
+
 export function shapeSnapshot(models, pulledAt) {
   return { _meta: { source: 'OpenRouter /api/v1/models (live metadata)', pulledAt, modelCount: Object.keys(models).length }, models };
 }
@@ -73,7 +98,8 @@ async function main() {
 
   const catalog = JSON.parse(fs.readFileSync(CATALOG, 'utf8'));
   const missing = detectDrift(catalog, models);
-  const snapshot = shapeSnapshot(models, new Date().toISOString());
+  const pulledAt = new Date().toISOString();
+  const snapshot = shapeSnapshot(models, pulledAt);
   const next = JSON.stringify(snapshot, null, 2) + '\n';
 
   if (check) {
@@ -86,8 +112,11 @@ async function main() {
     return;
   }
 
+  const priceChanges = syncCatalogPrices(catalog, models, pulledAt);
   fs.writeFileSync(SNAPSHOT, next);
+  fs.writeFileSync(CATALOG, JSON.stringify(catalog, null, 2) + '\n');
   console.log(`✓ wrote ${SNAPSHOT.replace(ROOT + '/', '')} — ${Object.keys(models).length} live models, pulledAt ${snapshot._meta.pulledAt}`);
+  console.log(`✓ synchronized ${priceChanges.length} catalog price field(s) from the same live response`);
   if (missing.length) {
     console.log(`\n⚠ DRIFT: ${missing.length} catalog model(s) no longer in the live catalog — update data/model-catalog.json:`);
     for (const m of missing) console.log('  - ' + m);

package/scripts/release-authority.mjs

@@ -11,7 +11,7 @@ const CANONICAL_PUBLISHERS = new Set([
   'scripts/release.mjs',
   'scripts/release-transaction-provider.mjs',
 ]);
-const SOURCE_EXTENSIONS = new Set(['.mjs', '.js', '.cjs', '.sh']);
+const SOURCE_EXTENSIONS = new Set(['.mjs', '.js', '.cjs', '.sh', '.yml', '.yaml']);
 
 function executableSource(source) {
   const withoutBlocks = source.replace(/\/\*[\s\S]*?\*\//g, '');
@@ -28,7 +28,7 @@ const ACTIONS = [
     jsPatterns: [
       /\[\s*['"]release['"]\s*,\s*['"]create['"]/,
     ],
-    shellPatterns: [/^\s*gh\s+release\s+create\b/m],
+    shellPatterns: [/^\s*(?:-\s*run:\s*)?gh\s+release\s+create\b/m],
   },
   {
     action: 'github-release-update',
@@ -36,7 +36,7 @@ const ACTIONS = [
       /['"]PATCH['"][\s\S]{0,120}releases\//,
       /\[\s*['"]release['"]\s*,\s*['"]edit['"]/,
     ],
-    shellPatterns: [/^\s*gh\s+(?:release\s+edit|api\s+.*releases\/.*PATCH)\b/m],
+    shellPatterns: [/^\s*(?:-\s*run:\s*)?gh\s+(?:release\s+edit|api\s+.*releases\/.*PATCH)\b/m],
   },
   {
     action: 'npm-publish',
@@ -44,7 +44,7 @@ const ACTIONS = [
       /(?:execFileSync|spawnSync)\(\s*['"]npm['"]\s*,\s*\[\s*['"]publish['"]/,
       /runOrDie\(\s*['"]npm publish['"]/,
     ],
-    shellPatterns: [/^\s*npm\s+publish\b/m],
+    shellPatterns: [/^\s*(?:-\s*run:\s*)?npm\s+publish\b/m],
   },
   {
     action: 'npm-dist-tag',
@@ -52,7 +52,7 @@ const ACTIONS = [
       /(?:execFileSync|spawnSync)\(\s*['"]npm['"]\s*,\s*\[\s*['"]dist-tag['"]\s*,\s*['"]add['"]/,
       /runOrDie\(\s*['"]npm dist-tag[^'"]*['"]/,
     ],
-    shellPatterns: [/^\s*npm\s+dist-tag\s+add\b/m],
+    shellPatterns: [/^\s*(?:-\s*run:\s*)?npm\s+dist-tag\s+add\b/m],
   },
 ];
 
@@ -60,7 +60,10 @@ export function detectPublisherActions(file, source) {
   const relative = file.split(path.sep).join('/');
   if (CANONICAL_PUBLISHERS.has(relative)) return [];
   const executable = executableSource(source);
-  const kind = path.extname(relative) === '.sh' ? 'shellPatterns' : 'jsPatterns';
+  const extension = path.extname(relative);
+  const kind = ['.sh', '.yml', '.yaml'].includes(extension) || relative.startsWith('package.json#scripts.')
+    ? 'shellPatterns'
+    : 'jsPatterns';
   return ACTIONS
     .filter((action) => action[kind].some((pattern) => pattern.test(executable)))
     .map(({ action }) => ({ file: relative, action }));
@@ -79,14 +82,23 @@ function sourceFiles(root) {
   visit(path.join(root, 'scripts'));
   visit(path.join(root, 'deploy'));
   visit(path.join(root, 'bin'));
+  visit(path.join(root, '.github', 'workflows'));
   return files;
 }
 
 export function findUnauthorizedPublishers(root = ROOT) {
-  return sourceFiles(root).flatMap((absolute) => {
+  const findings = sourceFiles(root).flatMap((absolute) => {
     const relative = path.relative(root, absolute).split(path.sep).join('/');
     return detectPublisherActions(relative, fs.readFileSync(absolute, 'utf8'));
   });
+  const packageFile = path.join(root, 'package.json');
+  if (fs.existsSync(packageFile)) {
+    const pkg = JSON.parse(fs.readFileSync(packageFile, 'utf8'));
+    for (const [name, command] of Object.entries(pkg.scripts || {})) {
+      findings.push(...detectPublisherActions(`package.json#scripts.${name}`, String(command)));
+    }
+  }
+  return findings;
 }
 
 export function main(root = ROOT) {

package/scripts/release-convergence-watchdog.mjs

@@ -11,18 +11,16 @@
  * for a month.
  *
  * WHAT IT WILL NOT DO. It does not publish. `scripts/self-update.mjs:56` refuses `--publish` and
- * only `protected-release.yml` may create a release, publish npm, or move a dist-tag. This script
- * DISPATCHES that workflow — the sanctioned path — and never substitutes for it. Every safety gate
- * (exact-SHA evidence, clean worktree, release-proof, host verification, post-publication seal)
- * still runs inside the workflow exactly as designed. Bypassing them to "get it done while nobody
- * is looking" would be the worst possible reading of an instruction to finish the job.
+ * `release-candidate-preflight.yml` owns the one-time long lanes and `protected-release.yml` is the
+ * sole publication controller. This watchdog is report-only: it never dispatches either phase and
+ * cannot manufacture typed candidate evidence.
  *
  * IT IS A NO-OP UNLESS EVERY PRECONDITION HOLDS. It runs from the nightly, unattended, for weeks.
  * A watchdog that acts on a partial picture is worse than no watchdog, so it refuses on anything
  * unexpected and says why. The default outcome is "nothing happened, here is the reason".
  *
  *   node scripts/release-convergence-watchdog.mjs           # report only, never acts
- *   node scripts/release-convergence-watchdog.mjs --dispatch # act, but only if ALL gates pass
+ *   node scripts/release-convergence-watchdog.mjs --dispatch # compatibility flag; still reports only
  */
 import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
@@ -99,21 +97,11 @@ const runsFor = (wf) => JSON.parse(tryShy(() => sh('gh', ['run', 'list', '--repo
 const greenAt = (wf) => runsFor(wf).find((r) => r.headSha === originMain && r.conclusion === 'success');
 
 const ci = greenAt('ci');
-const aggregate = greenAt('release-aggregate');
 if (!ci) stand_down(`no successful exact-SHA \`ci\` run at ${originMain.slice(0, 7)} yet`);
-if (!aggregate) stand_down(`no successful exact-SHA \`release-aggregate\` run at ${originMain.slice(0, 7)} yet`);
 
-log(`ALL GATES PASS — candidate=${originMain.slice(0, 7)} version=${version} ci=${ci.databaseId} aggregate=${aggregate.databaseId}`);
-if (!DISPATCH) {
-  log('report-only mode; pass --dispatch to actually invoke the protected release workflow.');
-  process.exit(0);
-}
-
-// ── 6. Dispatch THE SANCTIONED PUBLISHER. Nothing here publishes; the workflow does. ─────────────
-sh('gh', ['workflow', 'run', 'protected-release.yml', '--repo', REPO,
-  '-f', `candidate_sha=${originMain}`,
-  '-f', `version=${version}`,
-  '-f', `release_qe_run_id=${ci.databaseId}`,
-  '-f', `aggregate_run_id=${aggregate.databaseId}`]);
-log(`DISPATCHED protected-release for ${version}. The workflow owns every safety gate from here.`);
-log('Verify afterwards with: node scripts/published-surface-probe.mjs (D-version-coherence must PASS).');
+log(`PRECONDITIONS VISIBLE — candidate=${originMain.slice(0, 7)} version=${version} ci=${ci.databaseId}`);
+// ── 6. Never dispatch a publisher from the watchdog. ───────────────────────────────────────────
+// Only protected-release may derive the complete typed evidence chain and cross Production.
+// This unattended observer cannot turn visible preconditions into release authority.
+log(`PRECONDITIONS ONLY — no candidate artifact inferred and no action taken for ${version} at ${originMain}`);
+log('Run release-candidate-preflight on release/** once; fast-forward that exact SHA to main; then protected-release imports release-candidate-<SHA> without a run ID.');