ruvnet-brain 4.0.36 → 4.2.2-dev

package/scripts/rebuild-gists-from-receipts.mjs

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+// Deterministically reconstruct gist passages from tracked, exact-version source receipts.
+// This intentionally does not call the GitHub API, build vectors, or publish artifacts.
+
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const NAME = 'ruv-gists';
+const HEX_GIST = /^[a-f0-9]{20,64}$/;
+const HEX40 = /^[a-f0-9]{40}$/;
+const HEX64 = /^[a-f0-9]{64}$/;
+
+function fail(message) {
+  throw new Error(`[rebuild-gists-from-receipts] ${message}`);
+}
+
+const sha256 = (value) => crypto.createHash('sha256').update(value).digest('hex');
+const jsonLine = (value) => JSON.stringify(value).replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
+
+function validDate(value) {
+  return typeof value === 'string' && /^\d{4}-\d{2}-\d{2}T/.test(value) && Number.isFinite(Date.parse(value));
+}
+
+function validateFilename(filename, label) {
+  if (typeof filename !== 'string' || !filename || filename.includes('\0')
+    || filename.split(/[\\/]/).some((segment) => !segment || segment === '.' || segment === '..')) {
+    fail(`${label} has an unsafe or missing filename`);
+  }
+}
+
+export function validateSourceReceipts(source) {
+  if (![1, 2].includes(source?.schemaVersion)) fail('source receipt schemaVersion must be 1 or 2');
+  if (!/^[A-Za-z0-9-]{1,39}$/.test(String(source.owner || ''))) fail('source receipt owner is malformed');
+  if (!validDate(source.generated)) fail('source receipt generated timestamp is malformed');
+  if (!source.gists || typeof source.gists !== 'object' || Array.isArray(source.gists)) {
+    fail('source receipt gists must be an object');
+  }
+  if (Object.keys(source.gists).length === 0) fail('source receipt has no gist receipts');
+
+  for (const [gistId, receipt] of Object.entries(source.gists)) {
+    const label = `gist ${gistId}`;
+    if (!HEX_GIST.test(gistId)) fail(`${label} id is malformed`);
+    if (!receipt || typeof receipt !== 'object' || Array.isArray(receipt)) fail(`${label} receipt is malformed`);
+    if (receipt.complete !== true) fail(`${label} receipt is incomplete`);
+    if (!HEX40.test(String(receipt.versionSha || ''))) fail(`${label} versionSha is malformed`);
+    if (!validDate(receipt.updatedAt) || !validDate(receipt.ingestedAt)) fail(`${label} timestamps are malformed`);
+    if (!Array.isArray(receipt.files) || receipt.files.length === 0) fail(`${label} has no complete file inventory`);
+    const filenames = new Set();
+    for (const file of receipt.files) {
+      validateFilename(file?.filename, label);
+      if (filenames.has(file.filename)) fail(`${label} has duplicate filename ${file.filename}`);
+      filenames.add(file.filename);
+      if (file.included === true) {
+        if (!HEX64.test(String(file.sha256 || '')) || !Number.isSafeInteger(file.bytes) || file.bytes < 0) {
+          fail(`${label}/${file.filename} has malformed included-file identity`);
+        }
+      } else if (file.included !== false || typeof file.reason !== 'string' || !file.reason
+        || !(file.size === null || (Number.isSafeInteger(file.size) && file.size >= 0))) {
+        fail(`${label}/${file.filename} has malformed exclusion evidence`);
+      }
+    }
+    const expectedDigest = sha256(JSON.stringify(receipt.files));
+    if (!HEX64.test(String(receipt.contentDigest || '')) || receipt.contentDigest !== expectedDigest) {
+      fail(`${label} contentDigest does not match its file inventory`);
+    }
+  }
+  return source;
+}
+
+export function rawUrlFor({ owner, gistId, versionSha, filename }) {
+  if (!/^[A-Za-z0-9-]{1,39}$/.test(String(owner || '')) || !HEX_GIST.test(String(gistId || ''))
+    || !HEX40.test(String(versionSha || ''))) fail('cannot construct raw URL from malformed source identity');
+  validateFilename(filename, `gist ${gistId}`);
+  const encodedFile = filename.split('/').map(encodeURIComponent).join('/');
+  return `https://gist.githubusercontent.com/${owner}/${gistId}/raw/${versionSha}/${encodedFile}`;
+}
+
+export function paragraphChunks(text, size = 3200) {
+  if (typeof text !== 'string') fail('passage content must be text');
+  if (!Number.isSafeInteger(size) || size < 1) fail('chunk size must be a positive integer');
+  const out = [];
+  let buffer = '';
+  for (const paragraph of text.split(/\n\n+/)) {
+    if (buffer && buffer.length + paragraph.length + 2 > size) {
+      out.push(buffer);
+      buffer = '';
+    }
+    buffer = buffer ? `${buffer}\n\n${paragraph}` : paragraph;
+  }
+  if (buffer.trim()) out.push(buffer);
+  return out;
+}
+
+export function provenanceBanner({ owner, gistId, filename, updatedAt }) {
+  return `SOURCE: GitHub gist by @${owner} — "${filename.replace(/\s+/g, ' ').trim().slice(0, 160)}"\n`
+    + `GIST STATUS: rUv's own notes / release announcement — may describe PROPOSED or UNRELEASED work.\n`
+    + `Treat as intent, not as confirmed shipped behavior: verify against repo source before asserting.\n`
+    + `updated: ${updatedAt.slice(0, 10)} · https://gist.github.com/${owner}/${gistId}\n\n`;
+}
+
+async function mapBounded(items, concurrency, operation) {
+  const results = new Array(items.length);
+  let next = 0;
+  async function worker() {
+    while (next < items.length) {
+      const index = next++;
+      results[index] = await operation(items[index]);
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, worker));
+  return results;
+}
+
+export async function reconstructGists(source, { fetchFn = globalThis.fetch, concurrency = 6 } = {}) {
+  validateSourceReceipts(source);
+  if (typeof fetchFn !== 'function') fail('fetch implementation is unavailable');
+  if (!Number.isSafeInteger(concurrency) || concurrency < 1 || concurrency > 32) {
+    fail('concurrency must be an integer from 1 through 32');
+  }
+
+  const jobs = [];
+  for (const [gistId, receipt] of Object.entries(source.gists)) {
+    for (const file of receipt.files) {
+      if (file.included) jobs.push({ gistId, receipt, file });
+    }
+  }
+  const bodies = await mapBounded(jobs, concurrency, async ({ gistId, receipt, file }) => {
+    const url = rawUrlFor({ owner: source.owner, gistId, versionSha: receipt.versionSha, filename: file.filename });
+    const response = await fetchFn(url, {
+      headers: { accept: 'text/plain', 'user-agent': 'ruvnet-brain-gist-receipt-rebuild' },
+    });
+    if (!response?.ok) fail(`${gistId}/${file.filename} raw fetch failed: HTTP ${response?.status ?? 'unknown'}`);
+    const bytes = Buffer.from(await response.arrayBuffer());
+    if (bytes.length !== file.bytes) fail(`${gistId}/${file.filename} byte count ${bytes.length} differs from receipt ${file.bytes}`);
+    const digest = sha256(bytes);
+    if (digest !== file.sha256) fail(`${gistId}/${file.filename} sha256 ${digest} differs from receipt ${file.sha256}`);
+    let body;
+    try {
+      body = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+    } catch {
+      fail(`${gistId}/${file.filename} is not valid UTF-8 text`);
+    }
+    return body;
+  });
+
+  const passages = [];
+  const entries = {};
+  let bodyIndex = 0;
+  let id = 0;
+  for (const [gistId, receipt] of Object.entries(source.gists)) {
+    for (const file of receipt.files) {
+      if (!file.included) continue;
+      const body = bodies[bodyIndex++];
+      const chunks = paragraphChunks(body);
+      const title = file.filename.replace(/\s+/g, ' ').trim().slice(0, 180) || file.filename;
+      const banner = provenanceBanner({ owner: source.owner, gistId, filename: file.filename, updatedAt: receipt.updatedAt });
+      for (const [chunkIndex, chunk] of chunks.entries()) {
+        const passageId = String(id++);
+        const passagePath = `${gistId.slice(0, 8)}/${file.filename}${chunks.length > 1 ? `#${chunkIndex}` : ''}`;
+        const text = banner + chunk;
+        passages.push({ id: passageId, text, path: passagePath, title });
+        entries[passageId] = { path: passagePath, kind: 'doc', title, chunk: chunkIndex, preview: text.slice(0, 200) };
+      }
+    }
+  }
+  const passageBody = passages.map(jsonLine).join('\n') + '\n';
+  const meta = {
+    model: NAME,
+    dimensions: 0,
+    metric: 'cosine',
+    name: NAME,
+    generated: source.generated,
+    repo: `gists/${source.owner}`,
+    note: "rUv's public gists — announcements and thinking, PROPOSED unless confirmed in repo source.",
+    entries,
+  };
+  return {
+    passages,
+    passageBody,
+    meta,
+    sources: { ...source, schemaVersion: 2, passagesSha256: sha256(passageBody), gists: source.gists },
+  };
+}
+
+export function writeReconstruction(result, { outDir }) {
+  const output = path.resolve(outDir || '');
+  if (!result?.passageBody || !result.meta || !result.sources) fail('complete reconstruction result is required');
+  fs.mkdirSync(output, { recursive: true });
+  const files = {
+    passagesFile: path.join(output, `${NAME}.passages.jsonl`),
+    metaFile: path.join(output, `${NAME}.meta.json`),
+    sourcesFile: path.join(output, `${NAME}.sources.json`),
+  };
+  const contents = new Map([
+    [files.passagesFile, result.passageBody],
+    [files.metaFile, `${JSON.stringify(result.meta, null, 2)}\n`],
+    [files.sourcesFile, `${JSON.stringify(result.sources, null, 2)}\n`],
+  ]);
+  const staged = [];
+  try {
+    for (const [file, content] of contents) {
+      const temporary = `${file}.tmp-${process.pid}-${crypto.randomBytes(6).toString('hex')}`;
+      fs.writeFileSync(temporary, content, { flag: 'wx' });
+      staged.push([temporary, file]);
+    }
+    for (const [temporary, file] of staged) fs.renameSync(temporary, file);
+  } finally {
+    for (const [temporary] of staged) fs.rmSync(temporary, { force: true });
+  }
+  return files;
+}
+
+function option(argv, name, fallback) {
+  const index = argv.indexOf(name);
+  return index >= 0 && argv[index + 1] && !argv[index + 1].startsWith('--') ? argv[index + 1] : fallback;
+}
+
+export async function main(argv = process.argv.slice(2)) {
+  const allowed = new Set(['--sources', '--out-dir', '--concurrency']);
+  for (let index = 0; index < argv.length; index += 2) {
+    if (!allowed.has(argv[index]) || !argv[index + 1] || argv[index + 1].startsWith('--')) fail(`unknown or incomplete option ${argv[index] || '(missing)'}`);
+  }
+  const sourcesFile = path.resolve(option(argv, '--sources', path.join(ROOT, 'kb', `${NAME}.sources.json`)));
+  const outDir = path.resolve(option(argv, '--out-dir', path.dirname(sourcesFile)));
+  const concurrency = Number(option(argv, '--concurrency', '6'));
+  let source;
+  try {
+    source = JSON.parse(fs.readFileSync(sourcesFile, 'utf8'));
+  } catch (error) {
+    fail(`cannot read source receipts ${sourcesFile}: ${error.message}`);
+  }
+  const result = await reconstructGists(source, { concurrency });
+  const written = writeReconstruction(result, { outDir });
+  process.stdout.write(`${JSON.stringify({ ok: true, passages: result.passages.length, passagesSha256: result.sources.passagesSha256, ...written }, null, 2)}\n`);
+  return 0;
+}
+
+if (path.resolve(process.argv[1] || '') === fileURLToPath(import.meta.url)) {
+  main().then((code) => { process.exitCode = code; }).catch((error) => {
+    console.error(error.message);
+    process.exitCode = 1;
+  });
+}

package/scripts/release-transaction.mjs

@@ -55,10 +55,36 @@ export const ALLOWED_TRANSITIONS = Object.freeze({
   aborted: [],
 });
 
+/**
+ * THE DIGEST SERIALISER MUST AGREE WITH THE ONE THAT WRITES THE FILE.
+ *
+ * It did not, and it silently corrupted the terminal receipt of EVERY successful release. Measured
+ * 2026-08-20 on v4.0.36 and v4.0.90-dev — both `channels-converged` receipts, both digest=BAD, both
+ * with the same missing key:
+ *
+ *     canonicalJson({a: undefined})  ->  {"a":undefined}      key KEPT (and not even valid JSON)
+ *     JSON.stringify({a: undefined}) ->  {}                   key DROPPED
+ *
+ * The converge observation carries optional fields — `hosts.verifier.error`, `claudeOnly`,
+ * `codexOnly`, `dual` — and on a clean run `verified.error` is `undefined`. So the digest was
+ * computed over `…"error":undefined…` while the bytes written omitted `error` entirely: a digest
+ * over a shape that can never be read back. `runReleaseTransaction` appends a receipt, reads it
+ * back and verifies it, so the publish then died with `release receipt digest mismatch` AFTER npm
+ * and GitHub had both been promoted — the release shipped and the rail reported failure.
+ *
+ * Proven by reconstruction: restoring `observation.hosts.verifier.error = undefined` on the stored
+ * receipt makes `digestReceipt` reproduce the stored digest exactly.
+ *
+ * Arrays have the same asymmetry (`JSON.stringify([undefined])` is `[null]`), so both are matched
+ * here. This does not change the digest of any receipt that never held an undefined value, which is
+ * every receipt that currently verifies.
+ */
 export const canonicalJson = (value) => {
-  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(',')}]`;
+  if (Array.isArray(value)) return `[${value.map((item) => (item === undefined ? 'null' : canonicalJson(item))).join(',')}]`;
   if (value && typeof value === 'object') {
-    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(',')}}`;
+    return `{${Object.keys(value).sort()
+      .filter((key) => value[key] !== undefined)
+      .map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(',')}}`;
   }
   return JSON.stringify(value);
 };
@@ -86,6 +112,8 @@ export const transactionIdFor = (identity) => crypto.createHash('sha256').update
   bundleSha256: identity.bundleSha256,
   bundleSignatureSha256: identity.bundleSignatureSha256 || null,
   bundleDigestSha256: identity.bundleDigestSha256 || null,
+  ...(identity.corpusSeedSha256 ? { corpusSeedSha256: identity.corpusSeedSha256 } : {}),
+  ...(identity.generationLedgerSha256 ? { generationLedgerSha256: identity.generationLedgerSha256 } : {}),
 })).digest('hex');
 
 export function signReceipt(receipt, privateKey) {

package/scripts/release.mjs

@@ -37,6 +37,7 @@ import { verifyPayload } from './release-payload.mjs';
 
 const ROOT = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
 const PUBLISH = process.argv.includes('--publish');
+const CORPUS_SEED = process.argv.includes('--corpus-seed');
 let protectedCandidate = null;
 let sealedPackageArtifact = null;
 let publicationReceiptPath = null;
@@ -56,6 +57,147 @@ function runOrDie(label, cmd, args, opts = {}) {
   }
 }
 
+const cliArg = (argv, name) => {
+  const index = argv.indexOf(name);
+  return index >= 0 ? argv[index + 1] : undefined;
+};
+const isHex = (value, length) => new RegExp(`^[a-f0-9]{${length}}$`).test(String(value || ''));
+const sha256File = (file) => {
+  const hash = crypto.createHash('sha256');
+  const fd = fs.openSync(file, 'r');
+  const buffer = Buffer.allocUnsafe(1024 * 1024);
+  try {
+    let bytes;
+    while ((bytes = fs.readSync(fd, buffer, 0, buffer.length, null)) > 0) hash.update(buffer.subarray(0, bytes));
+  } finally {
+    fs.closeSync(fd);
+  }
+  return hash.digest('hex');
+};
+const exactFileIdentity = (value) => value && typeof value.file === 'string'
+  && isHex(value.sha256, 64) && Number.isSafeInteger(value.bytes) && value.bytes >= 0;
+
+function corpusFailure(message) {
+  throw new Error(`[corpus-seed] ${message}`);
+}
+
+export function runProtectedCorpusSeed({
+  argv = process.argv.slice(2),
+  env = process.env,
+  root = ROOT,
+  run = (command, args, options) => spawnSync(command, args, { encoding: 'utf8', ...options }),
+} = {}) {
+  if (env.GITHUB_ACTIONS !== 'true' || env.GITHUB_WORKFLOW !== 'protected-release'
+    || env.GITHUB_REPOSITORY !== 'stuinfla/ruvnet-brain') {
+    corpusFailure('publication is allowed only inside the protected-release GitHub workflow for stuinfla/ruvnet-brain');
+  }
+
+  const tag = cliArg(argv, '--corpus-tag');
+  const bundleFile = cliArg(argv, '--corpus-bundle');
+  const receiptFile = cliArg(argv, '--corpus-receipt');
+  const target = cliArg(argv, '--target');
+  const repo = cliArg(argv, '--repo') || env.GITHUB_REPOSITORY;
+  const digestMatch = String(tag || '').match(/^corpus-sha256-([a-f0-9]{64})$/);
+  if (!digestMatch) corpusFailure('corpus tag must be corpus-sha256- followed by 64 lowercase hex characters');
+  if (repo !== env.GITHUB_REPOSITORY || repo !== 'stuinfla/ruvnet-brain') corpusFailure('repository does not match the protected workflow');
+
+  for (const [label, file] of [['bundle', bundleFile], ['receipt', receiptFile]]) {
+    if (!file || !path.isAbsolute(file)) corpusFailure(`${label} must be an absolute regular file`);
+    try {
+      const stat = fs.lstatSync(file);
+      if (!stat.isFile() || stat.isSymbolicLink()) corpusFailure(`${label} must be an absolute regular file`);
+    } catch (error) {
+      if (String(error.message).startsWith('[corpus-seed]')) throw error;
+      corpusFailure(`${label} must be an absolute regular file (${error.message})`);
+    }
+  }
+
+  const headResult = run('git', ['rev-parse', 'HEAD'], {
+    cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  if (headResult.error || headResult.status !== 0) corpusFailure('cannot resolve release HEAD');
+  const head = String(headResult.stdout || '').trim();
+
+  let receipt;
+  try {
+    receipt = JSON.parse(fs.readFileSync(receiptFile, 'utf8'));
+  } catch (error) {
+    corpusFailure(`corpus receipt is unreadable/corrupt (${error.message})`);
+  }
+  if (!isHex(target, 40) || target !== head || target !== env.GITHUB_SHA || target !== receipt.builderSourceSha) {
+    corpusFailure('target must exactly equal HEAD, GITHUB_SHA, and the corpus receipt builderSourceSha');
+  }
+
+  const boundaryIdentities = [receipt.privateFence, receipt.eligibilityPolicy, receipt.generationLedger];
+  const storeBindingsValid = Number.isSafeInteger(receipt.storeCount) && receipt.storeCount > 0
+    && Array.isArray(receipt.stores) && receipt.stores.length === receipt.storeCount
+    && receipt.stores.every((store) => typeof store?.name === 'string' && store.name.length > 0
+      && /^[a-f0-9]{7,64}$/.test(String(store.sourceCommit || ''))
+      && typeof store.builtUtc === 'string' && Number.isFinite(Date.parse(store.builtUtc))
+      && typeof store.model === 'string' && store.model.length > 0
+      && Number.isSafeInteger(store.dimensions) && store.dimensions > 0
+      && Array.isArray(store.files) && store.files.length > 0 && store.files.every(exactFileIdentity));
+  const emptyFailureArrays = ['duplicateRvfDigests', 'unreceiptedRvfFiles', 'missingSidecars']
+    .every((key) => Array.isArray(receipt[key]) && receipt[key].length === 0);
+  const privateExclusionsValid = Array.isArray(receipt.excludedPrivateStores)
+    && receipt.excludedPrivateStores.every((name) => typeof name === 'string' && name.length > 0);
+  const generatorFile = path.join(root, 'scripts/corpus-candidate.mjs');
+  const generatorValid = fs.existsSync(generatorFile)
+    && receipt.generator?.corpusCandidateSha256 === sha256File(generatorFile);
+  if (receipt.schemaVersion !== 1 || receipt.kind !== 'ruvnet-brain-corpus-candidate'
+    || !receipt.createdAt || !receipt.coverageGeneration || !storeBindingsValid || !emptyFailureArrays
+    || !privateExclusionsValid || !boundaryIdentities.every(exactFileIdentity) || !exactFileIdentity(receipt.archive)
+    || !generatorValid
+    || receipt.archive.file !== path.basename(bundleFile)) {
+    corpusFailure('corpus receipt bindings are incomplete or invalid');
+  }
+
+  const archiveSha256 = sha256File(bundleFile);
+  if (archiveSha256 !== receipt.archive.sha256 || fs.statSync(bundleFile).size !== receipt.archive.bytes) {
+    corpusFailure('archive bytes do not match the corpus receipt');
+  }
+  if (digestMatch[1] !== archiveSha256) corpusFailure('corpus tag digest does not match the receipt and archive');
+
+  const viewArgs = ['release', 'view', tag, '--json', 'tagName', '--repo', repo];
+  const view = run('gh', viewArgs, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+  if (!view.error && view.status === 0) corpusFailure(`release ${tag} already exists; refusing to overwrite immutable corpus seed`);
+  const viewError = String(view.error?.message || view.stderr || view.stdout || '');
+  if (!/(release not found|no release found)/i.test(viewError)) corpusFailure(`cannot prove ${tag} is absent (${viewError.trim() || `gh exited ${view.status}`})`);
+
+  const notes = [
+    'Content-addressed RuvNet Brain corpus seed.',
+    `Archive SHA-256: ${archiveSha256}`,
+    `Receipt SHA-256: ${sha256File(receiptFile)}`,
+    `Stores: ${receipt.storeCount}`,
+    `Coverage generation: ${receipt.coverageGeneration}`,
+    'This published prerelease is immutable and must never be replaced.',
+  ].join('\n');
+  const createArgs = [
+    'release', 'create', tag,
+    '--prerelease', '--latest=false',
+    '--target', target,
+    '--repo', repo,
+    '--title', `Immutable corpus seed ${archiveSha256.slice(0, 16)}`,
+    '--notes', notes,
+    bundleFile, receiptFile,
+  ];
+  const create = run('gh', createArgs, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+  if (create.error || create.status !== 0) {
+    corpusFailure(`protected corpus publication failed (${String(create.error?.message || create.stderr || create.stdout || '').trim()})`);
+  }
+  return { tag, target, repository: repo, archiveSha256, receiptSha256: sha256File(receiptFile) };
+}
+
+if (CORPUS_SEED) {
+  try {
+    const result = runProtectedCorpusSeed();
+    console.log(JSON.stringify({ ok: true, mode: 'corpus-seed', ...result }, null, 2));
+  } catch (error) {
+    console.error(error.message);
+    process.exitCode = 1;
+  }
+} else {
+
 console.log(`\n${c.b('RuvNet Brain — release / definition-of-done')} ${c.dim('· ' + (PUBLISH ? 'PUBLISH' : 'check-only') + ' · shipping ' + V())}\n`);
 
 // The local CLI remains useful as a read-only preflight, but publication authority lives only in
@@ -195,6 +337,8 @@ if (PUBLISH) {
     bundleSignaturePath: path.join(payloadRoot, 'ruvnet-brain.zip.sig'),
     bundleDigestPath: path.join(payloadRoot, 'ruvnet-brain.zip.sha256'),
     packagePath: byRole.get('npm'),
+    corpusSeedPath: byRole.get('corpus-seed'),
+    generationLedgerPath: byRole.get('generation-ledger'),
   };
   for (const asset of Object.values(assets)) {
     if (!fs.existsSync(asset)) {
@@ -224,6 +368,8 @@ if (PUBLISH) {
     bundleSha256,
     bundleSignatureSha256: crypto.createHash('sha256').update(fs.readFileSync(assets.bundleSignaturePath)).digest('hex'),
     bundleDigestSha256: crypto.createHash('sha256').update(fs.readFileSync(assets.bundleDigestPath)).digest('hex'),
+    corpusSeedSha256: crypto.createHash('sha256').update(fs.readFileSync(assets.corpusSeedPath)).digest('hex'),
+    generationLedgerSha256: crypto.createHash('sha256').update(fs.readFileSync(assets.generationLedgerPath)).digest('hex'),
   };
   const privatePem = process.env.RUVNET_SIGNING_KEY;
   if (!privatePem) throw new Error('RUVNET_SIGNING_KEY is required for signed transaction receipts');
@@ -254,3 +400,4 @@ if (PUBLISH) {
 } else {
   console.log(`\n${c.g(c.b('✓✓✓ PREFLIGHT PASS — NOT PUBLISHED'))} — the committed candidate passed every check-only gate.\n`);
 }
+}

package/scripts/repo-count-detector.mjs

@@ -0,0 +1,62 @@
+// repo-count-detector.mjs — THE ONE detector for corpus-size claims in public surfaces.
+//
+// Extracted from tests/unit/repo-count.test.mjs on 2026-08-10 so the WRITER (sync-census.mjs)
+// and the GATE (repo-count.test.mjs) consult the same code. They had drifted by construction:
+// the gate found every phrasing, while the writer enumerated a handful by hand and missed
+// "71 of rUv's repos", "71 RuvNet building-block repos", "71 built today", and the
+// HTML-entity variant. A checker and a fixer that disagree guarantee recurring red builds.
+
+export const MIN_CORPUS_MAGNITUDE = 20;
+
+// Deliberate, documented exceptions: the literal is correct AS WRITTEN because it describes a
+// PAST state (a "before" baseline in a receipts table), not a current claim — not stale data.
+// Anything else that disagrees with ALLOWED fails. Keyed `${file}::${matched text}` so a typo'd
+// exemption can't silently swallow an unrelated real regression.
+export const EXEMPT = new Set([
+  'README.md::24 repos', // v1 (pre-2.0) baseline column in the "what 2.0 proved" before/after table
+  'README.md::24→69 verified repos', // same v1-baseline row, "24→<current>" delta phrasing
+  // 2026-08-06: the corpus grew 69 → 71 (tonight's rebuild). The CURRENT claims were updated to 71
+  // in README.md and SKILL.md, but these two are HISTORICAL — they describe what release 2.0
+  // proved, inside a collapsed "Earlier — what 2.0 proved" section and its before/after table.
+  // Rewriting them to 71 would be the easy way to make this gate green and would falsify the record:
+  // 2.0 shipped with 69, not 71. A gate that pressures you into editing history is worse than the
+  // stale number it caught, so historical mentions are exempted by name and current ones are not.
+  'README.md::69 verified repos', // "what 2.0 proved" summary line — a claim about 2.0, not today
+  'README.md::69 repos', // the 2.0 column of the same v1→v2.0 before/after table
+]);
+
+/** @param {string} src @returns {{text: string, n: number}[]} */
+export function findRepoCountLiterals(src) {
+  const found = [];
+  // Covers "repo(s)" and the spelled-out "repositor(y|ies)" (SKILL.md line 8's own phrasing:
+  // "32 RuvNet (rUv / Reuven Cohen) repositories" — real prose puts several filler words/
+  // parentheticals between the number and the noun, so this can't be a fixed word count).
+  const REPO_WORD = '(?:repos?|repositor(?:y|ies))';
+  // Digit NOT immediately followed by "+": an open lower-bound like "20+ repos" is a true,
+  // deliberately-vague qualifier, not a precise count claim — exempt from matching at all rather
+  // than needing a per-mention exemption. Filler between the digit and the repo-word is capped at
+  // 50 chars and may not cross a sentence end / table-cell boundary (".", "|", newline), so this
+  // can't accidentally bridge two unrelated numbers separated by prose.
+  // `(?<!\d\.)` — never treat a SEMVER COMPONENT as a repo count. Real false positive: the primer's
+  // header line "…v3.4.21-dev · Built: 2026-07-20 · Covers: 69/192 repos" made the detector read the
+  // patch number `21` (the `-` after it is a word boundary) and then walk 40-odd filler chars to
+  // "repos", reporting a stale count on a line whose actual claim — 69/192 — was correct. The
+  // published number was right and the gate cried wolf, which is how a gate loses its authority.
+  // Two guards, both added after REAL false positives on the primer's own header line
+  // "…<version> · Built: <date> · Covers: 69/192 repos", whose actual claim (69/192) is correct:
+  //   (?<!\d\.)  — a SEMVER COMPONENT is never a repo count. The patch number was being read as
+  //                one, because the `-` before a prerelease suffix is a word boundary.
+  //   `·` in the filler exclusion — a middle dot separates INDEPENDENT facts. Without it the walk
+  //                crossed from the build DATE into the count and reported `2026` as a repo count
+  //                (found by this file's own detector tests, after the semver fix unmasked it).
+  const reSpaced = new RegExp(`(?<!\\d\\.)\\b(\\d{1,4})(?!\\+)\\b(?:(?![.|·\\n])[\\s\\S]){0,50}?\\b${REPO_WORD}\\b`, 'gi');
+  const reHyphen = new RegExp(`(?<!\\d\\.)\\b(\\d{1,4})(?!\\+)-repos?\\b`, 'gi');
+  for (const re of [reSpaced, reHyphen]) {
+    for (const m of src.matchAll(re)) {
+      const n = Number(m[1]);
+      if (n >= MIN_CORPUS_MAGNITUDE) found.push({ text: m[0], n });
+    }
+  }
+  return found;
+}
+

package/scripts/restore-local-ingests.mjs

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+/**
+ * restore-local-ingests.mjs — replay every ingest a bundle apply silently removed.
+ *
+ * WHAT HAPPENED, overnight 2026-08-13 → 08-14. A scheduled bundle apply extracted an Aug-8 bundle
+ * over the live brain cache. The outcome for each piece of the previous evening's work was decided
+ * entirely by whether it had been committed:
+ *
+ *   SURVIVED  capability-cards.md — 5 hand-written cards, committed and pushed that night. The live
+ *             brain was restored from the repo copy in one command.
+ *   DIED      helix, rvQR, RuCelium, wifi-veil — ingested and VERIFIED ROUTING hours earlier, gone
+ *             without a trace. Their cards became orphans pointing at stores that no longer existed,
+ *             which is worse than absence: the router offers an answer whose source is missing.
+ *
+ * The owner, correctly and for the second time: "you can't ever let work go overnight — you must
+ * always push latest changes or things get overwritten."
+ *
+ * A `.rvf` is a 32MB gitignored build artifact and CANNOT be committed. So the rule's second half
+ * applies: when the artifact cannot be pushed, commit the RECIPE. `ingest-repo.mjs` now records each
+ * ingest into `kb/local-ingests.json`, and this replays anything the cache is missing.
+ *
+ * The wipe was not on either adversarial audit's list, because both read code and this only shows
+ * up if you watch the machine overnight. A defect that needs a night to appear needs a ledger to be
+ * seen at all.
+ *
+ * MEASURED 2026-08-19, Dream Cycle memory-durability night: this script cannot tell "the store root
+ * was wiped" from "the store root never existed on this host" — a fresh checkout, a CI runner, or
+ * this very nightly agent's own ephemeral container all read exactly one recorded ingest away from
+ * every other, i.e. IDENTICALLY to a real overnight wipe, because `missingIngests()` only diffs the
+ * ledger against `storesAt(root)`, and `storesAt()` silently returns `[]` on ENOENT (kb/store-root.mjs).
+ * `restore-local-ingests.mjs` had zero test coverage before tonight, and the repo's own dream-cycle
+ * operating notes told this very automation to read ANY non-zero exit as "the nightly bundle wiped
+ * local work" — so a routine fresh-checkout run would have logged a false wipe every single night.
+ *
+ * The fix follows the pattern this repo already uses correctly in `nightly-watchdog.mjs`
+ * (MISSING / NEVER-RAN / STALE, three states never collapsed into one alarm) and the general
+ * pattern for reconciling a durable recipe against a rebuildable cache (npm's `.package-lock.json`
+ * witness co-located with `node_modules`, Dynamo-style tombstones): check whether the root was ever
+ * initialized BEFORE treating its contents as evidence of loss.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { storeRoot, storesAt } from '../kb/store-root.mjs';
+
+const ROOT = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const LEDGER = path.join(ROOT, 'kb', 'local-ingests.json');
+
+export const OK = 'OK';
+export const NEVER_MATERIALIZED = 'NEVER-MATERIALIZED';
+export const WIPED = 'WIPED';
+
+/** Which recorded ingests are absent from the store root retrieval actually reads. */
+export function missingIngests({ ledgerFile = LEDGER, root = storeRoot() } = {}) {
+  let recorded = [];
+  try { recorded = JSON.parse(fs.readFileSync(ledgerFile, 'utf8')).ingests ?? []; } catch { return []; }
+  const present = new Set(storesAt(root));
+  return recorded.filter((e) => !present.has(e.store ?? e.name.toLowerCase()));
+}
+
+/**
+ * Classify a diff between the recipe ledger and the live store root into three states, never one:
+ *   OK                 every recorded ingest is present.
+ *   NEVER-MATERIALIZED root does not exist on this host at all — nothing was ever ingested here.
+ *                       Not evidence of loss: a fresh checkout, CI runner, or this agent's own
+ *                       ephemeral container all look like this on a routine first run.
+ *   WIPED               root exists (so this host DID ingest before) but recorded entries are gone —
+ *                       the actual signal `restore-local-ingests.mjs` exists to catch.
+ */
+export function classify({ ledgerFile = LEDGER, root = storeRoot() } = {}) {
+  const missing = missingIngests({ ledgerFile, root });
+  if (!missing.length) return { state: OK, missing };
+  if (!fs.existsSync(root)) return { state: NEVER_MATERIALIZED, missing };
+  return { state: WIPED, missing };
+}
+
+const isMain = (() => {
+  try { return process.argv[1] && fs.realpathSync(process.argv[1]) === fileURLToPath(import.meta.url); }
+  catch { return false; }
+})();
+
+if (isMain) {
+  const apply = process.argv.includes('--apply');
+  const { state, missing: gone } = classify();
+  if (state === OK) {
+    console.log(`[restore] every recorded local ingest is present in ${storeRoot()}`);
+    process.exit(0);
+  }
+  // NAMED, never counted. "4 stores missing" is the truncation that reads as completeness.
+  if (state === NEVER_MATERIALIZED) {
+    console.log(`\n[restore] ${storeRoot()} does not exist on this host — ${gone.length} recorded `
+      + `ingest(s) were never materialized here. This is NOT evidence of a wipe (fresh checkout, CI `
+      + `runner, or an ephemeral agent container all look like this):`);
+  } else {
+    console.log(`\n[restore] ${gone.length} recorded ingest(s) are NOT in ${storeRoot()}:`);
+  }
+  for (const e of gone) console.log(`    ${e.name.padEnd(16)} ingested ${String(e.at).slice(0, 10)}`);
+  if (!apply) {
+    console.log('\n  read-only. Re-run with --apply to re-ingest them.\n');
+    // NEVER-MATERIALIZED exits 2 (informational: nothing to restore FROM, just re-ingest) so a
+    // caller checking the exit code cannot mistake "never synced here" for "the nightly bundle
+    // wiped local work" — WIPED keeps exit 1, the real alarm.
+    process.exit(state === NEVER_MATERIALIZED ? 2 : 1);
+  }
+  let failed = 0;
+  for (const e of gone) {
+    console.log(`\n[restore] re-ingesting ${e.name}`);
+    try {
+      execFileSync(process.execPath, [path.join(ROOT, 'scripts', 'ingest-repo.mjs'), '--name', e.name],
+        { cwd: ROOT, stdio: 'inherit', env: process.env });
+    } catch { failed += 1; console.log(`[restore] ${e.name} FAILED — left recorded so the next run retries it`); }
+  }
+  console.log(`\n[restore] ${gone.length - failed}/${gone.length} restored.\n`);
+  process.exit(failed ? 1 : 0);
+}