ruvnet-brain 4.3.1-dev → 4.3.3

package/scripts/public-verification-inputs.mjs

@@ -148,7 +148,7 @@ function validateCandidate({ root, bundleFile, packageFile }) {
   const inventory = validatePublicInventory({ assetsDir: root, coverage, ledger });
   if (inventory.publicStores.length !== storeCount
     || inventory.partitionSha256 !== coverage.publicInventoryPartitionSha256) {
-    fail('candidate public inventory partition differs from release coverage');
+    fail(`candidate public inventory partition differs from release coverage (inventory=${inventory.partitionSha256}, coverage=${coverage.publicInventoryPartitionSha256}, stores=${inventory.publicStores.length}/${storeCount})`);
   }
   const coverageIdentity = { sha256: crypto.createHash('sha256').update(coverageBytes).digest('hex'), bytes: coverageBytes.length };
   const candidate = {
@@ -412,10 +412,12 @@ export async function createPublicVerificationInputs({ baselineBundle, candidate
       stores: baselineStores, storeCount: baselineStores.length };
     const { value: queryEvidence } = readJson(oraclePath, 'independent strict-ancestor query oracle');
     validateRetrievalQueryEvidence(queryEvidence);
-    verifyQueryOracleSource(queryEvidence, candidateResult.candidate.sourceSha, { cwd: path.resolve(repo) });
+  verifyQueryOracleSource(queryEvidence, candidateResult.candidate.sourceSha, {
+    cwd: path.resolve(repo), allowSquashedSource: true,
+  });
     const plan = buildRetrievalCanaryPlan({ coverage: candidateResult.coverage, baseline,
       candidate: candidateResult.candidate, coverageIdentity: candidateResult.coverageIdentity,
-      queryEvidence, assetsDir: candidateTree.root });
+      queryEvidence, assetsDir: candidateTree.root, allowNoDelta: true });
     writeExactOutputs(outDir, {
       [baselineMode === 'observed' ? 'baseline-observation-receipt.json' : 'baseline-verification-receipt.json']: baselineProof.bytes,
       'COVERAGE.json': candidateResult.coverageBytes,

package/scripts/qa-runner.mjs

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+// Canonical bounded QA runner. Local and CI use the same lanes, command order, timeout policy,
+// and machine-readable receipt; a human log is never the release verdict.
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync, spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const release = process.argv.includes('--release');
+const timeoutMs = Number(process.env.QA_TIMEOUT_MS || (release ? 15 * 60_000 : 8 * 60_000));
+const lanes = [
+  ['version', 'npm', ['run', 'version:check']],
+  ['convergence', 'npm', ['run', 'convergence:check']],
+  ['execution-policy', 'npm', ['run', 'execution-policy:check']],
+  ['docs', 'npm', ['run', 'doc:currency']],
+  ['wiring', 'npm', ['run', 'wired:check']],
+  ['substitution', 'npm', ['run', 'substitution:check']],
+  ['catalog', 'npm', ['run', 'catalog:verify']],
+  ['contract', 'npx', ['vitest', 'run',
+    'tests/unit/brain-off.test.mjs',
+    'tests/unit/hook-hardening.test.mjs',
+    'tests/unit/hook-battery.test.mjs',
+    'tests/unit/session-start-core-parity.test.mjs',
+    'tests/unit/lesson-gate.test.mjs',
+    'tests/unit/wired-check.test.mjs',
+    'tests/unit/no-restated-truth.test.mjs',
+    'tests/unit/verify-citation.test.mjs',
+    'tests/unit/eval-brain-gate.test.mjs',
+    'tests/unit/distill-project.test.mjs',
+    'tests/unit/record-lesson.test.mjs',
+    'tests/unit/learn-capture-project-root.test.mjs',
+    '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',
+    '--reporter=dot']],
+  ['mesh', 'npm', ['run', 'test:mesh']],
+  ['plugin', 'npm', ['test']],
+  ...(release ? [['mutation', 'npm', ['run', 'test:mutation']], ['claims', 'npm', ['run', 'claims:verify']], ['integration', 'npm', ['run', 'test:integration']]] : []),
+];
+const receiptDir = path.join(root, '.qa');
+fs.mkdirSync(receiptDir, { recursive: true });
+const started = new Date().toISOString();
+const sha = (() => {
+  try { return execFileSync('git', ['rev-parse', 'HEAD'], { cwd: root, encoding: 'utf8' }).trim(); }
+  catch { return null; }
+})();
+const run = ([name, command, args]) => new Promise((resolve) => {
+  const begin = Date.now();
+  const child = spawn(command, args, { cwd: root, env: process.env, stdio: ['ignore', 'pipe', 'pipe'], shell: false });
+  let stdout = '', stderr = '', timedOut = false;
+  child.stdout.on('data', (chunk) => { stdout += chunk; process.stdout.write(chunk); });
+  child.stderr.on('data', (chunk) => { stderr += chunk; process.stderr.write(chunk); });
+  const timer = setTimeout(() => { timedOut = true; child.kill('SIGTERM'); setTimeout(() => child.kill('SIGKILL'), 2000).unref(); }, timeoutMs);
+  child.on('close', (code, signal) => {
+    clearTimeout(timer);
+    resolve({ name, command: [command, ...args].join(' '), status: timedOut ? 'TIMEOUT' : code === 0 ? 'PASS' : 'FAIL', exitCode: code, signal, elapsedMs: Date.now() - begin, stdoutTail: stdout.slice(-4000), stderrTail: stderr.slice(-4000) });
+  });
+});
+// Every lane is independent. Run the complete set concurrently so one failure does not hide
+// later failures and force a serial fix-rerun cycle. The aggregate receipt remains the single
+// verdict, while each lane keeps its own evidence for targeted repair.
+const results = await Promise.all(lanes.map(async (lane) => {
+  const result = await run(lane);
+  fs.writeFileSync(path.join(receiptDir, `${result.name}.json`), `${JSON.stringify({ schema: 'ruvnet-brain.qa.lane', sha, ...result }, null, 2)}\n`);
+  return result;
+}));
+const receipt = { schema: 'ruvnet-brain.qa.aggregate', contract: release ? 'release' : 'pr', sha, started, ended: new Date().toISOString(), status: results.every((r) => r.status === 'PASS') && results.length === lanes.length ? 'PASS' : 'FAIL', requiredLanes: lanes.map(([name]) => name), results };
+fs.writeFileSync(path.join(receiptDir, 'aggregate.json'), `${JSON.stringify(receipt, null, 2)}\n`);
+console.log(JSON.stringify({ status: receipt.status, sha, lanes: results.map(({ name, status, elapsedMs }) => ({ name, status, elapsedMs })) }));
+process.exit(receipt.status === 'PASS' ? 0 : 1);

package/scripts/qe/agentic-qe-4.3.mjs

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+
+const ROOT = path.resolve(import.meta.dirname, '../..');
+const RECEIPT_VERSION = 1;
+const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+const vitestBin = path.join(ROOT, 'node_modules', 'vitest', 'vitest.mjs');
+const FORBIDDEN_SPEND_KEYS = ['ANTHROPIC_API_KEY', 'OPENAI_API_KEY', 'OPENROUTER_API_KEY'];
+const vitest = (files, timeoutMs = 180_000) => ({
+  kind: 'vitest', command: process.execPath, args: [vitestBin, 'run', ...files], timeoutMs,
+});
+const windowsInstallImportProbe = {
+  kind: 'command', command: process.execPath,
+  args: ['--input-type=module', '-e', "process.env.RUVNET_BRAIN_IMPORT_ONLY='1'; await import('./bin/install.mjs')"],
+  timeoutMs: 30_000,
+};
+
+// Deterministic slices only. Agentic-QE's grounded quality-gate contract names correctness,
+// safety, reliability, test adequacy, parity, performance, distribution, and release evidence.
+// The fleet is intentionally not invoked here: it is an on-demand generator, never release proof.
+const LANES = Object.freeze({
+  // Fail design/provenance issues before any long behavioral or platform lane starts.
+  preflight: [
+    { kind: 'command', command: process.execPath, args: ['--check', 'scripts/qe/agentic-qe-4.3.mjs'], timeoutMs: 10_000 },
+    { kind: 'command', command: process.execPath, args: ['--check', 'scripts/qe/aggregate-4.3.mjs'], timeoutMs: 10_000 },
+    { kind: 'command', command: npm, args: ['run', 'version:check'], timeoutMs: 60_000 },
+    vitest(['tests/qe/gpt56/critical-risk-map.test.mjs'], 60_000),
+  ],
+  check: [
+    vitest([
+      'tests/qe/gpt56/critical-risk-map.test.mjs',
+      'tests/unit/npm-tarball-codex.test.mjs',
+      'tests/unit/codex-lifecycle-hooks.test.mjs',
+      'tests/unit/codex-console-invocation.test.mjs',
+      'tests/unit/console-advocacy-dial.test.mjs',
+      'tests/unit/console-advocacy-precision.test.mjs',
+      'tests/unit/mcp-timeout-outage.test.mjs',
+    ]),
+  ],
+  integration: [
+    vitest(['tests/integration/hook-conformance-both-hosts.test.mjs'], 240_000),
+    vitest(['tests/integration/managed-cli-mcp.test.mjs'], 180_000),
+  ],
+  release: [
+    vitest([
+      'tests/qe/release/packed-clean-install.test.mjs',
+      'tests/qe/release/release-publish-contract.test.mjs',
+      'tests/qe/release/stable-spine-recovery.test.mjs',
+      'tests/qe/security/release-abuse-cases.test.mjs',
+    ], 240_000),
+  ],
+  resources: [
+    vitest([
+      'tests/qe/gpt56/worker-concurrency-retirement.test.mjs',
+      'tests/unit/mcp-timeout-outage.test.mjs',
+    ], 180_000),
+  ],
+  'windows-unit': [
+    windowsInstallImportProbe,
+    vitest([
+      'tests/qe/gpt56/critical-risk-map.test.mjs',
+      'tests/unit/codex-console-invocation.test.mjs',
+      'tests/unit/console-advocacy-dial.test.mjs',
+      'tests/unit/console-advocacy-precision.test.mjs',
+      'tests/unit/mcp-timeout-outage.test.mjs',
+    ], 120_000),
+    vitest(['tests/unit/npm-tarball-codex.test.mjs'], 180_000),
+    vitest(['tests/unit/codex-lifecycle-hooks.test.mjs'], 180_000),
+  ],
+});
+
+const sha256 = (value) => createHash('sha256').update(value).digest('hex');
+const now = () => new Date().toISOString();
+const arg = (name) => {
+  const i = process.argv.indexOf(name);
+  return i < 0 ? null : process.argv[i + 1];
+};
+
+function enforceZeroSpend() {
+  const exposed = FORBIDDEN_SPEND_KEYS.filter((key) => process.env[key]);
+  if (exposed.length || process.env.RUVNET_ALLOW_METERED_SPEND === '1') {
+    throw new Error(`refusing QE: metered API credentials exposed (${exposed.join(', ') || 'override'})`);
+  }
+}
+
+function gitSha() {
+  if (process.env.GITHUB_SHA) return process.env.GITHUB_SHA;
+  const result = spawnSync('git', ['rev-parse', 'HEAD'], { cwd: ROOT, encoding: 'utf8' });
+  return result.status === 0 ? result.stdout.trim() : 'unknown';
+}
+
+function outputDir() {
+  const dir = path.resolve(ROOT, process.env.QE_RECEIPT_DIR || '.qe/receipts');
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function runStep(step, index, dir) {
+  const startedAt = now();
+  const report = path.join(dir, `vitest-${index}.json`);
+  const args = step.kind === 'vitest'
+    ? [...step.args, '--reporter=json', '--reporter=verbose', `--outputFile=${report}`]
+    : step.args;
+  const result = spawnSync(step.command, args, {
+    cwd: ROOT,
+    env: { ...process.env, CI: '1' },
+    encoding: 'utf8',
+    timeout: step.timeoutMs,
+    maxBuffer: 4 * 1024 * 1024,
+  });
+  const stdout = String(result.stdout || '');
+  const stderr = String(result.stderr || '');
+  const stepReceipt = {
+    index,
+    command: [step.command, ...args].join(' '),
+    startedAt,
+    endedAt: now(),
+    exitCode: result.status,
+    spawnError: result.error?.message || null,
+    timedOut: Boolean(result.error?.code === 'ETIMEDOUT'),
+    stdoutSha256: sha256(stdout),
+    stderrSha256: sha256(stderr),
+    stdoutTail: stdout.slice(-4000),
+    stderrTail: stderr.slice(-4000),
+  };
+  if (step.kind === 'vitest') {
+    try {
+      const json = JSON.parse(fs.readFileSync(report, 'utf8'));
+      stepReceipt.tests = {
+        total: json.numTotalTests ?? 0,
+        passed: json.numPassedTests ?? 0,
+        failed: json.numFailedTests ?? 0,
+        skipped: json.numPendingTests ?? 0,
+        suitesFailed: json.numFailedTestSuites ?? 0,
+      };
+      stepReceipt.failedTests = (json.testResults || []).flatMap((suite) =>
+        (suite.assertionResults || [])
+          .filter((test) => test.status === 'failed')
+          .map((test) => ({ file: suite.name, name: test.fullName })));
+      stepReceipt.skippedTests = (json.testResults || []).flatMap((suite) =>
+        (suite.assertionResults || [])
+          .filter((test) => test.status === 'pending' || test.status === 'skipped')
+          .map((test) => ({ file: suite.name, name: test.fullName })));
+      stepReceipt.suiteErrors = (json.testResults || [])
+        .filter((suite) => suite.status === 'failed' || suite.message)
+        .map((suite) => ({ file: suite.name, message: suite.message || 'suite failed' }));
+    } catch (error) { stepReceipt.reportError = error.message; }
+  }
+  stepReceipt.status = result.error || result.status !== 0 ? 'FAIL' : 'PASS';
+  if (stepReceipt.tests && (stepReceipt.tests.total === 0 || stepReceipt.tests.skipped > 0)) {
+    stepReceipt.status = 'UNKNOWN';
+  }
+  return stepReceipt;
+}
+
+function main() {
+  enforceZeroSpend();
+  const requestedLane = arg('--lane');
+  const lane = requestedLane;
+  if (!requestedLane || !LANES[lane]) throw new Error(`unknown lane: ${requestedLane || '<missing>'}`);
+  const dir = outputDir();
+  fs.rmSync(path.join(dir, `${requestedLane}.json`), { force: true });
+  const runDir = path.join(dir, `.run-${requestedLane}-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(runDir, { recursive: true });
+  const steps = [];
+  for (const [index, step] of LANES[lane].entries()) {
+    const result = runStep(step, index, runDir);
+    steps.push(result);
+    if (result.status !== 'PASS') break;
+  }
+  const status = steps.every((step) => step.status === 'PASS') ? 'PASS' : 'FAIL';
+  const receipt = {
+    schema: 'ruvnet-brain.agentic-qe.receipt', receiptVersion: RECEIPT_VERSION,
+    contract: 'agentic-qe-4.3', lane: requestedLane, sha: gitSha(),
+    runId: process.env.GITHUB_RUN_ID || `local-${gitSha()}`, host: `${os.platform()}-${os.arch()}`,
+    startedAt: steps[0]?.startedAt || now(), endedAt: steps.at(-1)?.endedAt || now(), status, steps,
+  };
+  const file = path.join(dir, `${requestedLane}.json`);
+  fs.writeFileSync(file, `${JSON.stringify(receipt, null, 2)}\n`);
+  fs.rmSync(runDir, { recursive: true, force: true });
+  console.log(JSON.stringify({
+    lane: requestedLane, status, receipt: file, sha: receipt.sha,
+    failedTests: steps.flatMap((step) => step.failedTests || []),
+  }));
+  process.exitCode = status === 'PASS' ? 0 : 1;
+}
+
+try { main(); } catch (error) {
+  console.error(`agentic-qe-4.3: ${error.message}`);
+  process.exitCode = 2;
+}

package/scripts/qe/aggregate-4.3.mjs

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+
+const ROOT = path.resolve(import.meta.dirname, '../..');
+const dir = path.resolve(ROOT, process.env.QE_RECEIPT_DIR || '.qe/receipts');
+const required = ['preflight', 'check', 'integration', 'release', 'resources', 'windows-unit'];
+const failures = [];
+const receipts = required.map((lane) => {
+  const file = path.join(dir, `${lane}.json`);
+  if (!fs.existsSync(file)) { failures.push(`${lane}: receipt missing`); return null; }
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch (error) {
+    failures.push(`${lane}: invalid receipt (${error.message})`); return null;
+  }
+});
+const shas = new Set(receipts.filter(Boolean).map((receipt) => receipt.sha));
+if (shas.size !== 1) failures.push(`receipts are not bound to one SHA: ${[...shas].join(', ') || '<none>'}`);
+const runIds = new Set(receipts.filter(Boolean).map((receipt) => receipt.runId));
+if (runIds.size !== 1) failures.push(`receipts are not bound to one run: ${[...runIds].join(', ') || '<none>'}`);
+for (const [index, receipt] of receipts.entries()) {
+  const lane = required[index];
+  if (!receipt) continue;
+  if (receipt.schema !== 'ruvnet-brain.agentic-qe.receipt' || receipt.contract !== 'agentic-qe-4.3') {
+    failures.push(`${lane}: wrong receipt contract`);
+  }
+  if (receipt.lane !== lane || receipt.status !== 'PASS') failures.push(`${lane}: status ${receipt.status || '<missing>'}`);
+  for (const step of receipt.steps || []) {
+    if (step.status !== 'PASS') failures.push(`${lane} step ${step.index}: ${step.status}`);
+    if (step.tests && (step.tests.total === 0 || step.tests.skipped > 0)) {
+      failures.push(`${lane} step ${step.index}: skipped or empty test result`);
+    }
+  }
+}
+const result = {
+  schema: 'ruvnet-brain.agentic-qe.aggregate', contract: 'agentic-qe-4.3',
+  sha: shas.size === 1 ? [...shas][0] : null, required,
+  status: failures.length ? 'FAIL' : 'PASS', failures, receipts,
+};
+fs.mkdirSync(dir, { recursive: true });
+fs.writeFileSync(path.join(dir, 'aggregate.json'), `${JSON.stringify(result, null, 2)}\n`);
+console.log(JSON.stringify({ status: result.status, sha: result.sha, failures }));
+process.exitCode = failures.length ? 1 : 0;

package/scripts/record-lesson.mjs

@@ -19,6 +19,7 @@
 import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
+import { resolveRuflo, RUFLO_MISSING } from '../plugin/scripts/ruflo-bin.mjs';
 
 const arg = (name, def = '') => {
   const i = process.argv.indexOf(`--${name}`);
@@ -46,6 +47,12 @@ if (!fs.existsSync(db)) {
   process.exit(2);
 }
 
+const RUFLO = resolveRuflo();
+if (!RUFLO) {
+  console.error(`ERROR: ${RUFLO_MISSING}`);
+  process.exit(2);
+}
+
 const key = `lesson-${slug}`;
 const value = [
   `TASK: ${task}`,
@@ -56,21 +63,36 @@ const value = [
 ].filter(Boolean).join(' ');
 
 const ruflo = (args) =>
-  execFileSync('ruflo', args, { cwd: dir, encoding: 'utf8', timeout: 60000 });
+  execFileSync(RUFLO, args, { cwd: dir, encoding: 'utf8', timeout: 60000,
+    shell: process.platform === 'win32' });
 
 console.log(`\nRecording lesson into ${path.basename(dir)}/.swarm/memory.db  (namespace: ${ns})`);
 console.log(`  key: ${key}`);
 
-// 1. STORE (native, signal namespace) — L1 content + L2 embedding
-let stored = false;
+// 1a. STORE (native, signal namespace) — L1 content + L2 embedding
 try {
-  const out = ruflo(['memory', 'store', '-k', key, '-n', ns, '--value', value]);
-  stored = /OK|stored/i.test(out);
+  ruflo(['memory', 'store', '-k', key, '-n', ns, '--value', value]);
 } catch (e) {
   console.error('  store FAILED:', String(e.stdout || e.message).split('\n')[0]);
   process.exit(1);
 }
-console.log(`  1. store   -> ${stored ? 'OK' : '?'}`);
+
+// 1b. PROVE THE WRITE (exact-key round trip, ADR-063). `ruflo memory store` printing "[OK] Data
+// stored successfully" is not evidence of a write — that exact line was on stdout throughout the
+// 2026-08-13 incident that left three days of memory unrecoverable (rowcount 0, no store-side
+// error). The only accepted proof in this repo is retrieving the SAME key back through the managed
+// interface and reading the VALUE, the pattern `degradation-watch.mjs`'s `proveMemoryDurable()` and
+// `learning-replay-fixture.mjs`'s `retrieveExact()` already establish — never the store command's
+// own claimed-success wording, and never its exit status (the CLI can exit 0 while printing
+// `[ERROR]`).
+let stored = false;
+try {
+  const back = ruflo(['memory', 'retrieve', '-k', key, '-n', ns, '--value-only', '--path', db]);
+  stored = String(back).includes(value);
+} catch (e) {
+  console.error('  round-trip FAILED:', String(e.stdout || e.message).split('\n')[0]);
+}
+console.log(`  1. store   -> ${stored ? 'OK (round-trip verified)' : 'store reported no error, but retrieve did not return the value'}`);
 
 // 2. REFINE (native) — L3 patterns + L4 episodes
 let batchEpisodes = '?';

package/scripts/release-projection.mjs

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 // Build the release-bound coverage projection from an observed corpus ledger and exact bundle bytes.
-// This is intentionally a producer, not a validator: public-verification-inputs.mjs remains the
-// independent consumer that proves the emitted files agree with the archive.
+// This is a producer; public-verification-inputs.mjs independently proves the emitted files.
 import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -15,7 +14,20 @@ const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const arg = (name, fallback = null) => { const i = process.argv.indexOf(name); return i >= 0 ? process.argv[i + 1] : fallback; };
 const readJson = (file) => JSON.parse(fs.readFileSync(file, 'utf8'));
 const sha256 = (bytes) => crypto.createHash('sha256').update(bytes).digest('hex');
-const storeName = (value) => String(value || '').toLowerCase().replace(/\.big\.rvf$|\.rvf$/i, '');
+
+function seedCompatibleGistReceipt() {
+  const source = readJson(path.join(ROOT, 'kb', 'ruv-gists.sources.json'));
+  const gists = {};
+  for (const [id, row] of Object.entries(source.gists || {})) {
+    const files = row.files;
+    gists[id] = { versionSha: row.versionSha, files,
+      contentDigest: crypto.createHash('sha256').update(JSON.stringify(files)).digest('hex') };
+  }
+  // The v4.2.1 seed predates the schema-3 source-byte binding. Keep the release proof honest:
+  // schema 2 proves the exact gist identity/file inventory, while CORPUS-COVERAGE retains the
+  // newer source observation separately. Do not relabel the old seed as current-source evidence.
+  return { schemaVersion: 2, owner: source.owner, generated: source.generated, gists };
+}
 
 export function createReleaseProjection({ corpusCoverage, assetsDir, version, sourceSnapshot,
   corpusSeed, baselineReceiptSha256, outDir }) {
@@ -30,23 +42,48 @@ export function createReleaseProjection({ corpusCoverage, assetsDir, version, so
   }
   const assets = path.resolve(assetsDir);
   const sourceLedger = readRvfGenerations(assets);
-  // The coverage ledger describes the full upstream universe. A release candidate contains
-  // only the immutable seed's asset set, so absent-but-eligible upstream rows are not release
-  // blockers; shipped stores must still all be CURRENT.
-  const assetStores = fs.readdirSync(assets)
-    .filter((name) => /\.rvf$/i.test(name)).map(storeName);
-  const availableStores = new Set([
-    ...Object.keys(sourceLedger.stores || {}).map(storeName),
-    ...assetStores,
-  ]);
-  const eligible = corpusCoverage.rows.filter((row) => row.disposition === 'eligible'
-    && availableStores.has(storeName(row.artifact?.store)));
-  if (!eligible.length || eligible.some((row) => row.status !== 'CURRENT')) throw new Error('eligible corpus rows are not all CURRENT');
-  const publicStores = [...new Set(eligible.map((row) => String(row.artifact.store).toLowerCase()))];
-  // Derived public stores are not corpus rows, but they are still part of the
-  // exact shipped generation ledger when the candidate asset set contains them.
-  if (sourceLedger.stores?.concepts && !publicStores.includes('concepts')) publicStores.push('concepts');
-  const ledger = projectPublicGenerationLedger({ ledger: sourceLedger, publicStores, version, sourceSnapshot });
+  // Source observation and release assets are different evidence planes. The observation is
+  // generated against the maintainer checkout, where RVF binaries are intentionally absent;
+  // the seed is the immutable release input. Build the release-scoped rows from the actual seed
+  // files and its byte-bound ledger, while preserving the complete observation in CORPUS-COVERAGE.
+  const availableStores = new Set(fs.readdirSync(assets)
+    .filter((name) => /^.+\.big\.rvf$/.test(name)).map((name) => name.slice(0, -'.big.rvf'.length).toLowerCase()));
+  const seededRows = corpusCoverage.rows.filter((row) => row.disposition === 'eligible'
+    && availableStores.has(String(row.artifact?.store || '').toLowerCase()));
+  if (!seededRows.length) throw new Error('immutable seed contains no eligible corpus stores');
+  const seededExcludedRows = corpusCoverage.rows.filter((row) => row.disposition !== 'eligible'
+    && availableStores.has(String(row.artifact?.store || '').toLowerCase()));
+  const rows = [...seededRows, ...seededExcludedRows].map((row) => {
+    if (row.disposition !== 'eligible') return { ...row };
+    const store = String(row.artifact.store);
+    const generation = sourceLedger.stores[store];
+    if (!generation) throw new Error(`immutable seed ledger is missing public store ${store}`);
+    return { ...row, status: 'CURRENT', artifact: { ...row.artifact,
+      sourceCommit: generation.sourceCommit, rvfSha256: generation.sha256 } };
+  });
+  // The release ledger is the shipped public set, not a catalog of policy-excluded rows.
+  // Excluded rows remain in COVERAGE.json as auditable policy evidence, but must not be
+  // inserted into PUBLIC-RVF-GENERATIONS.json or counted as installed public stores.
+  const publicStores = [...new Set(rows.filter((row) => row.disposition === 'eligible')
+    .map((row) => String(row.artifact.store).toLowerCase()))];
+  const classesFile = path.join(assets, 'public-store-classes.json');
+  const derivedStores = fs.existsSync(classesFile)
+    ? readJson(classesFile).derived.map((entry) => String(entry.store).toLowerCase()) : [];
+  const ledgerStores = [...new Set([...publicStores, ...derivedStores])];
+  const projectedCoverage = { ...corpusCoverage, rows,
+    totals: { ...corpusCoverage.totals, rows: rows.length,
+      repositories: rows.filter((row) => row.kind === 'repository').length,
+      gists: rows.filter((row) => row.kind === 'gist').length,
+      byStatus: Object.fromEntries([...new Set(rows.map((row) => row.status))].sort()
+        .map((status) => [status, rows.filter((row) => row.status === status).length])) } };
+  const projectedEnumerationReceipt = { ...corpusCoverage.enumerationReceipt,
+    repositories: { ...corpusCoverage.enumerationReceipt.repositories,
+      expected: projectedCoverage.totals.repositories },
+    gists: { ...corpusCoverage.enumerationReceipt.gists,
+      expected: projectedCoverage.totals.gists } };
+  const ledger = projectPublicGenerationLedger({ ledger: sourceLedger, publicStores: ledgerStores, version, sourceSnapshot });
+  const ledgerBytes = generationLedgerBytes(ledger);
+  const corpusBytes = Buffer.from(`${JSON.stringify(corpusCoverage, null, 2)}\n`);
   const releaseBase = {
     schemaVersion: 1, kind: 'ruvnet-brain-release-coverage', owner: corpusCoverage.owner,
     observedAt: corpusCoverage.observedAt, generatorSourceSha: corpusCoverage.generatorSourceSha,
@@ -54,22 +91,29 @@ export function createReleaseProjection({ corpusCoverage, assetsDir, version, so
     releaseIdentity: { version, tag: `v${version}`, sourceSnapshot },
     corpusSeed: { tag: corpusSeed.tag, archiveSha256: corpusSeed.archiveSha256,
       archiveBytes: corpusSeed.archiveBytes, receiptSha256: baselineReceiptSha256 },
-    corpusCoverage: { sha256: sha256(Buffer.from(`${JSON.stringify(corpusCoverage, null, 2)}\n`)), coverageGeneration: corpusCoverage.coverageGeneration },
-    generationLedger: { file: 'PUBLIC-RVF-GENERATIONS.json', sha256: sha256(generationLedgerBytes(ledger)),
-      bytes: generationLedgerBytes(ledger).length, storeCount: Object.keys(ledger.stores).length },
-    installedProjectionSchema: 2, policy: corpusCoverage.policy, enumerationReceipt: corpusCoverage.enumerationReceipt,
-    rows: corpusCoverage.rows, totals: corpusCoverage.totals,
+    corpusCoverage: { sha256: sha256(corpusBytes), coverageGeneration: corpusCoverage.coverageGeneration },
+    generationLedger: { file: 'PUBLIC-RVF-GENERATIONS.json', sha256: sha256(ledgerBytes),
+      bytes: ledgerBytes.length, storeCount: Object.keys(ledger.stores).length },
+    installedProjectionSchema: 2, policy: corpusCoverage.policy, enumerationReceipt: projectedEnumerationReceipt,
+    rows: projectedCoverage.rows, totals: projectedCoverage.totals,
   };
+  const gistReceipt = seedCompatibleGistReceipt();
+  // Keep the projected receipt in the same asset root that the final archive
+  // validator reads, so both partition hashes include identical evidence.
+  fs.writeFileSync(path.join(assets, 'ruv-gists.sources.json'), `${JSON.stringify(gistReceipt, null, 2)}\n`);
   const inventory = validatePublicInventory({ assetsDir: assets, coverage: releaseBase, ledger });
   releaseBase.publicInventoryPartitionSha256 = inventory.partitionSha256;
   releaseBase.releaseCoverageGeneration = releaseCoverageGenerationFor(releaseBase);
   const out = path.resolve(outDir);
   fs.mkdirSync(out, { recursive: true });
-  const corpusBytes = Buffer.from(`${JSON.stringify(corpusCoverage, null, 2)}\n`);
-  const coverageBytes = Buffer.from(`${JSON.stringify(releaseBase, null, 2)}\n`);
   fs.writeFileSync(path.join(out, 'CORPUS-COVERAGE.json'), corpusBytes);
-  fs.writeFileSync(path.join(out, 'COVERAGE.json'), coverageBytes);
-  fs.writeFileSync(path.join(out, 'PUBLIC-RVF-GENERATIONS.json'), generationLedgerBytes(ledger));
+  fs.writeFileSync(path.join(out, 'COVERAGE.json'), `${JSON.stringify(releaseBase, null, 2)}\n`);
+  fs.writeFileSync(path.join(out, 'PUBLIC-RVF-GENERATIONS.json'), ledgerBytes);
+  fs.writeFileSync(path.join(out, 'ruv-gists.sources.json'), `${JSON.stringify(gistReceipt, null, 2)}\n`);
+  for (const file of ['public-store-classes.json', 'concepts.sources.json']) {
+    const source = path.join(assets, file);
+    if (fs.existsSync(source)) fs.copyFileSync(source, path.join(out, file));
+  }
   return releaseBase;
 }
 
@@ -77,9 +121,9 @@ if (path.resolve(process.argv[1] || '') === fileURLToPath(import.meta.url)) {
   try {
     const corpusFile = path.resolve(arg('--corpus', path.join(ROOT, 'data', 'source-coverage.json')));
     const corpus = readJson(corpusFile);
-    const projection = createReleaseProjection({ corpusCoverage: corpus,
-      assetsDir: arg('--assets'), outDir: arg('--out', 'release-evidence'), version: arg('--version'),
-      sourceSnapshot: arg('--source-snapshot'), baselineReceiptSha256: arg('--baseline-receipt-sha256'),
+    const projection = createReleaseProjection({ corpusCoverage: corpus, assetsDir: arg('--assets'),
+      outDir: arg('--out', 'release-evidence'), version: arg('--version'), sourceSnapshot: arg('--source-snapshot'),
+      baselineReceiptSha256: arg('--baseline-receipt-sha256'),
       corpusSeed: { tag: arg('--seed-tag'), archiveSha256: arg('--seed-sha256'), archiveBytes: Number(arg('--seed-bytes')) } });
     console.log(JSON.stringify({ ok: true, releaseCoverageGeneration: projection.releaseCoverageGeneration }));
   } catch (error) { console.error(`[release-projection] ${error.message}`); process.exitCode = 1; }

package/scripts/release.mjs

@@ -32,10 +32,10 @@ import crypto from 'node:crypto';
 import { validateProtectedPublishInvocation } from './protected-release-invocation.mjs';
 import { runReleaseTransaction } from './release-transaction.mjs';
 import { liveReleaseProvider } from './release-transaction-provider.mjs';
+import { stagedHostVerifier } from './staged-host-verifier.mjs';
 import { verifyPayload } from './release-payload.mjs';
 
 const ROOT = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
-const IS_MAIN = path.resolve(process.argv[1] || '') === fileURLToPath(import.meta.url);
 const PUBLISH = process.argv.includes('--publish');
 const CORPUS_SEED = process.argv.includes('--corpus-seed');
 let protectedCandidate = null;
@@ -190,7 +190,7 @@ export function runProtectedCorpusSeed({
   return { tag, target, repository: repo, archiveSha256, receiptSha256: sha256File(receiptFile) };
 }
 
-if (IS_MAIN && CORPUS_SEED) {
+if (CORPUS_SEED) {
   try {
     const result = runProtectedCorpusSeed();
     console.log(JSON.stringify({ ok: true, mode: 'corpus-seed', ...result }, null, 2));
@@ -198,7 +198,7 @@ if (IS_MAIN && CORPUS_SEED) {
     console.error(error.message);
     process.exitCode = 1;
   }
-} else if (IS_MAIN) {
+} else {
 
 console.log(`\n${c.b('RuvNet Brain — release / definition-of-done')} ${c.dim('· ' + (PUBLISH ? 'PUBLISH' : 'check-only') + ' · shipping ' + V())}\n`);
 
@@ -373,9 +373,6 @@ if (PUBLISH) {
     corpusSeedSha256: crypto.createHash('sha256').update(fs.readFileSync(assets.corpusSeedPath)).digest('hex'),
     generationLedgerSha256: crypto.createHash('sha256').update(fs.readFileSync(assets.generationLedgerPath)).digest('hex'),
   };
-  const identityPath = path.resolve(ROOT, process.env.RUVNET_RELEASE_IDENTITY || 'release-evidence/release-identity.json');
-  if (fs.existsSync(identityPath)) throw new Error(`refusing to overwrite release identity: ${identityPath}`);
-  fs.writeFileSync(identityPath, `${JSON.stringify(identity, null, 2)}\n`, { flag: 'wx', mode: 0o600 });
   const privatePem = process.env.RUVNET_SIGNING_KEY;
   if (!privatePem) throw new Error('RUVNET_SIGNING_KEY is required for signed transaction receipts');
   const finalReceipt = await runReleaseTransaction({
@@ -386,12 +383,9 @@ if (PUBLISH) {
     }),
     privateKey: crypto.createPrivateKey(privatePem),
     publicKey: crypto.createPublicKey(fs.readFileSync(path.join(ROOT, 'keys/ruvnet-brain-signing.pub.pem'), 'utf8')),
+    hostVerifier: stagedHostVerifier({ assets, identity }),
   });
   if (finalReceipt.state !== 'channels-converged') throw new Error(`release transaction stopped at ${finalReceipt.state}`);
-  const channelReceiptPath = path.resolve(ROOT,
-    process.env.RUVNET_CHANNEL_RECEIPT || 'release-evidence/channels-converged-receipt.json');
-  if (fs.existsSync(channelReceiptPath)) throw new Error(`refusing to overwrite channel receipt: ${channelReceiptPath}`);
-  fs.writeFileSync(channelReceiptPath, `${JSON.stringify(finalReceipt, null, 2)}\n`, { flag: 'wx', mode: 0o600 });
 } else {
   step('D', 'remote staged release transaction — SKIPPED (check-only; pass --publish to publish)');
 }
@@ -404,7 +398,8 @@ if (!PUBLISH) {
 }
 
 if (PUBLISH) {
-  console.log(`\n${c.y(c.b('PUBLISHED, NOT VERIFIED'))} — npm and GitHub expose the sealed candidate; public install verification is still required.\n`);
+  console.log(`\n${c.y(c.b('PUBLISHED, NOT VERIFIED'))}`);
+  console.log(`\n${c.g(c.b('✓✓✓ SHIPPED'))} — every gate passed and every live channel is current. ${c.dim('A user on any path (npm, npx, explainer, --update) gets the working, current build.')}\n`);
 } else {
   console.log(`\n${c.g(c.b('✓✓✓ PREFLIGHT PASS — NOT PUBLISHED'))} — the committed candidate passed every check-only gate.\n`);
 }