ruvnet-brain 4.3.8 → 4.3.9

package/README.md

@@ -4,7 +4,7 @@
 
 # 🧠 RuvNet Brain
 
-### 🧠 RuvNet Brain — [![RuvNet Brain version 4.3.8 — updated 2026-07-30 03:24 EDT](https://img.shields.io/badge/version_4.3.8-updated_2026--07--30_03:24_EDT-1E90FF?style=for-the-badge&labelColor=0757BA)](https://github.com/stuinfla/ruvnet-brain/blob/main/plugin/.claude-plugin/plugin.json)
+### 🧠 RuvNet Brain — [![RuvNet Brain version 4.3.9 — updated 2026-07-30 03:24 EDT](https://img.shields.io/badge/version_4.3.9-updated_2026--07--30_03:24_EDT-1E90FF?style=for-the-badge&labelColor=0757BA)](https://github.com/stuinfla/ruvnet-brain/blob/main/plugin/.claude-plugin/plugin.json)
 
 **A portable, source-grounded brain over Reuven Cohen's (rUv's) RuvNet stack — delivered as a Claude Code plugin that makes Claude _use_ the stack instead of fighting it.**
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ruvnet-brain",
-  "version": "4.3.8",
+  "version": "4.3.9",
   "description": "One-command installer for RuvNet Brain — a portable, source-grounded brain over rUv's RuvNet building blocks, delivered as a Claude Code plugin so Claude uses the stack instead of fighting it.",
   "type": "module",
   "bin": {

package/plugin/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "ruvnet-brain",
   "description": "RuvNet brain transplant for Claude Code — grounds every RuvNet decision in real source across 77 rUv repositories, prefers Ruflo / RuVector-RVF / AgentDB over training-prior defaults (pgvector, Pinecone, hand-rolled cosine), and can pull in any RuvNet repo on demand. Ships an enforced UserPromptSubmit retrieve-and-inject grounding hook that sharply reduces drift.",
-  "version": "4.3.8",
+  "version": "4.3.9",
   "author": {
     "name": "Stuart Kerr"
   },

package/plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "ruvnet-brain",
-  "version": "4.3.8",
+  "version": "4.3.9",
   "description": "Source-grounded RuvNet knowledge, lifecycle enforcement, and learning for Codex.",
   "author": {
     "name": "Stuart Kerr"

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/release-publication-handoff.mjs

@@ -0,0 +1,101 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { canonicalJson, transactionIdFor, verifyReceipt } from './release-transaction.mjs';
+
+const jsonBytes = (value) => Buffer.from(`${JSON.stringify(value, null, 2)}\n`);
+
+function trustedEvidenceDirectory(root) {
+  const evidenceRoot = path.join(path.resolve(root), 'release-evidence');
+  let stat;
+  try { stat = fs.lstatSync(evidenceRoot); } catch { throw new Error('release-evidence directory is missing'); }
+  if (!stat.isDirectory() || stat.isSymbolicLink()) {
+    throw new Error('release-evidence must be a trusted directory');
+  }
+  return evidenceRoot;
+}
+
+export function resolvePublicationHandoffPaths({ root, identityPath, receiptPath } = {}) {
+  const evidenceRoot = trustedEvidenceDirectory(root);
+  const resolveTarget = (configured, label) => {
+    if (typeof configured !== 'string' || !configured.trim()) throw new Error(`${label} output is required`);
+    const target = path.resolve(root, configured);
+    if (path.dirname(target) !== evidenceRoot || path.extname(target) !== '.json') {
+      throw new Error(`${label} output must be a direct JSON file inside release-evidence`);
+    }
+    if (fs.existsSync(target)) throw new Error(`${label} output must be a new file`);
+    return target;
+  };
+  const identity = resolveTarget(identityPath, 'release identity');
+  const receipt = resolveTarget(receiptPath, 'channel receipt');
+  if (identity === receipt) throw new Error('release identity and channel receipt outputs must differ');
+  return { evidenceRoot, identity, receipt };
+}
+
+export function validatePublicationHandoff({ identity, receipt, publicKey } = {}) {
+  verifyReceipt(receipt, publicKey);
+  if (receipt.schemaVersion !== 3 || receipt.state !== 'channels-converged'
+    || receipt.observation?.verdict !== 'PUBLISHED_NOT_VERIFIED') {
+    throw new Error('channel receipt is not signed PUBLISHED_NOT_VERIFIED convergence evidence');
+  }
+  if (receipt.transactionId !== transactionIdFor(identity)
+    || canonicalJson(receipt.identity) !== canonicalJson(identity)) {
+    throw new Error('channel receipt identity differs from the release identity');
+  }
+  return receipt;
+}
+
+function writePrivateTemp(directory, label, bytes) {
+  const temp = path.join(directory, `.${label}.${process.pid}.${crypto.randomUUID()}.tmp`);
+  const fd = fs.openSync(temp, 'wx', 0o600);
+  let closed = false;
+  try {
+    fs.writeFileSync(fd, bytes);
+    fs.fsyncSync(fd);
+    fs.closeSync(fd);
+    closed = true;
+    return temp;
+  } catch (error) {
+    if (!closed) {
+      try { fs.closeSync(fd); } catch { /* preserve the write failure */ }
+    }
+    fs.rmSync(temp, { force: true });
+    throw error;
+  }
+}
+
+function removeOwnedLink(destination, temporary) {
+  try {
+    const linked = fs.lstatSync(destination);
+    const source = fs.lstatSync(temporary);
+    if (linked.dev === source.dev && linked.ino === source.ino) fs.unlinkSync(destination);
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+  }
+}
+
+export function materializePublicationHandoff({ paths, identity, receipt, publicKey } = {}) {
+  if (!paths?.evidenceRoot || path.dirname(paths.identity || '') !== paths.evidenceRoot
+    || path.dirname(paths.receipt || '') !== paths.evidenceRoot || paths.identity === paths.receipt) {
+    throw new Error('publication handoff paths were not validated');
+  }
+  validatePublicationHandoff({ identity, receipt, publicKey });
+  const temporary = [];
+  let identityLinked = false;
+  let receiptLinked = false;
+  try {
+    temporary.push(writePrivateTemp(paths.evidenceRoot, 'release-identity', jsonBytes(identity)));
+    temporary.push(writePrivateTemp(paths.evidenceRoot, 'channels-converged', jsonBytes(receipt)));
+    fs.linkSync(temporary[0], paths.identity);
+    identityLinked = true;
+    fs.linkSync(temporary[1], paths.receipt);
+    receiptLinked = true;
+  } catch (error) {
+    if (receiptLinked) removeOwnedLink(paths.receipt, temporary[1]);
+    if (identityLinked) removeOwnedLink(paths.identity, temporary[0]);
+    throw new Error(`publication handoff materialization failed: ${error.message}`);
+  } finally {
+    for (const temp of temporary) fs.rmSync(temp, { force: true });
+  }
+  return { identityPath: paths.identity, receiptPath: paths.receipt };
+}

package/scripts/release.mjs

@@ -31,6 +31,7 @@ import fs from 'node:fs';
 import crypto from 'node:crypto';
 import { validateProtectedPublishEnvironment, validateProtectedPublishInvocation } from './protected-release-invocation.mjs';
 import { runReleaseTransaction } from './release-transaction.mjs';
+import { materializePublicationHandoff, resolvePublicationHandoffPaths } from './release-publication-handoff.mjs';
 import { liveReleaseProvider } from './release-transaction-provider.mjs';
 import { stagedHostVerifier } from './staged-host-verifier.mjs';
 import { verifyPayload } from './release-payload.mjs';
@@ -44,6 +45,7 @@ let publicationReceiptPath = null;
 let protectedReleaseMode = 'strict';
 let verifiedPayload = null;
 let aggregateEnvelope = null;
+let publicationHandoffPaths = null;
 const c = { g: (s) => `\x1b[32m${s}\x1b[0m`, r: (s) => `\x1b[31m${s}\x1b[0m`, y: (s) => `\x1b[33m${s}\x1b[0m`, b: (s) => `\x1b[1m${s}\x1b[0m`, dim: (s) => `\x1b[2m${s}\x1b[0m` };
 const V = () => JSON.parse(fs.readFileSync(path.join(ROOT, 'plugin/.claude-plugin/plugin.json'), 'utf8')).version;
 
@@ -222,6 +224,11 @@ if (PUBLISH) {
     console.error(`\n${c.r('✗ PROTECTED RELEASE GATE FAILED')}\n  publication receipt output must be a new file inside release-evidence\n`);
     process.exit(1);
   }
+  publicationHandoffPaths = resolvePublicationHandoffPaths({
+    root: ROOT,
+    identityPath: process.env.RUVNET_RELEASE_IDENTITY,
+    receiptPath: process.env.RUVNET_CHANNEL_RECEIPT,
+  });
   const payloadManifestPath = path.resolve(ROOT, process.env.RUVNET_CANDIDATE_PAYLOAD || '');
   const payloadSignaturePath = path.resolve(ROOT, process.env.RUVNET_CANDIDATE_PAYLOAD_SIGNATURE || '');
   const aggregatePath = path.resolve(ROOT, process.env.RUVNET_AGGREGATE_ENVELOPE || '');
@@ -375,6 +382,7 @@ if (PUBLISH) {
   };
   const privatePem = process.env.RUVNET_SIGNING_KEY;
   if (!privatePem) throw new Error('RUVNET_SIGNING_KEY is required for signed transaction receipts');
+  const publicKey = crypto.createPublicKey(fs.readFileSync(path.join(ROOT, 'keys/ruvnet-brain-signing.pub.pem'), 'utf8'));
   const finalReceipt = await runReleaseTransaction({
     identity, assets, adapter: liveReleaseProvider({
       root: ROOT,
@@ -382,10 +390,11 @@ if (PUBLISH) {
       publicationReceipt: process.env.RUVNET_PUBLICATION_RECEIPT,
     }),
     privateKey: crypto.createPrivateKey(privatePem),
-    publicKey: crypto.createPublicKey(fs.readFileSync(path.join(ROOT, 'keys/ruvnet-brain-signing.pub.pem'), 'utf8')),
+    publicKey,
     hostVerifier: stagedHostVerifier({ assets, identity }),
   });
   if (finalReceipt.state !== 'channels-converged') throw new Error(`release transaction stopped at ${finalReceipt.state}`);
+  materializePublicationHandoff({ paths: publicationHandoffPaths, identity, receipt: finalReceipt, publicKey });
 } else {
   step('D', 'remote staged release transaction — SKIPPED (check-only; pass --publish to publish)');
 }