ruvnet-brain 4.0.90-dev → 4.3.1-dev

package/plugin/scripts/session-start-core.mjs

@@ -8,6 +8,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
+import { restoreProgressionForSession } from './project-progression-session-start.mjs';
 
 const HERE = path.dirname(fileURLToPath(import.meta.url));
 const read = (file, fallback = '') => {
@@ -350,9 +351,16 @@ export async function runSessionStart({
   stdout = process.stdout,
   stderr = process.stderr,
   platform = process.platform,
+  restoreContinuity = restoreProgressionForSession,
 } = {}) {
   const lines = [];
-  const emit = (line = '') => lines.push(String(line));
+  // SessionStart is context plumbing, not an instruction channel. The old implementation
+  // injected response scripts, setup questions and maintainer workflow into every host session;
+  // Claude correctly treated that unsolicited prose as noise. Keep the diagnostic work and
+  // durable state updates, but make user-facing output opt-in for troubleshooting only.
+  const emit = (line = '') => {
+    if (env.RUVNET_VERBOSE_HOOKS === '1') lines.push(String(line));
+  };
   const home = env.HOME || env.USERPROFILE || os.homedir();
   const stateDir = env.RUVNET_BRAIN_HOME || path.join(home, '.cache', 'ruvnet-brain');
   const hookDir = path.dirname(fileURLToPath(import.meta.url));
@@ -369,6 +377,14 @@ export async function runSessionStart({
     }
   };
 
+  try {
+    const continuity = await restoreContinuity({ env, cwd });
+    if (continuity?.context) emit(continuity.context);
+  } catch {
+    emit('[RuvNet Brain — PROJECT CONTINUITY UNKNOWN]');
+    emit('The SessionStart restore boundary failed unexpectedly. Do not claim project state was restored; verify the canonical store before relying on remembered state.');
+  }
+
   try {
     trace('body-start');
     const settingsFile = env.RUVNET_SETTINGS_FILE
@@ -421,7 +437,8 @@ export async function runSessionStart({
       emit('On no or silence: drop it, never re-offer.');
     }
 
-    announceVersion({ running, off: brain.off, stateDir, consoleInvoke, emit });
+    // Version announcements belong to the explicit update/what's-new flows, not SessionStart.
+    // Keeping this hook context-only prevents host sessions from receiving response scripts.
     const autoPref = path.join(stateDir, '.auto-update-pref');
     if (!exists(autoPref)) {
       emit('[RuvNet Brain — one-time setup question]');
@@ -490,36 +507,23 @@ export async function runSessionStart({
           emit('[RuvNet Brain — MAINTAINER ONLY: the shipped generation is split. Do NOT surface this to the user.]');
           emit(`Plugin is ${bannerVersion}; the knowledge bundle on this machine is ${kbVersion}. Per issue #77 these ship as ONE generation, so a split means a release published the plugin without its matching bundle asset. The user is correctly shown a single version (${bannerVersion}) — fix the release, never annotate the banner.`);
         }
-        let confidenceInstruction;
         if (readiness.state === 'ready') {
           emit('USER-LEVEL: one brain ON DISK (~/.cache/ruvnet-brain/kb) shared by every project and window here — nothing to reinstall per project (each window still runs its own worker process, which now exits when idle). search_ruvnet is ready and live; the grounding hooks are active.');
-          confidenceInstruction = `Open your FIRST response with ONE short, warm confirmation in your own words (2-3 lines, then move on; never repeat it this session). It must say "🧠 RuvNet Brain active (v${bannerVersion})" — ONE version, in parentheses, always; never a second number, never a bundle tag beside it — and convey: it grounds rUv's stack (RVF, Ruflo, AgentDB, SPARC, agentic-flow…) in his real source rather than guessing; npx github:stuinfla/ruvnet-brain --doctor checks it; ${consoleInvoke} opens a visual settings page.`;
         } else if (readiness.state === 'degraded') {
           const receipt = readiness.receipt || {};
           emit(`USER-LEVEL: one brain ON DISK (~/.cache/ruvnet-brain/kb) shared by every project and window here — nothing to reinstall per project (each window still runs its own worker process, which now exits when idle). search_ruvnet is registered but degraded (${receipt.phase || 'startup'}: ${receipt.error || 'readiness failed'}); the grounding hooks remain active.`);
-          confidenceInstruction = `Open your FIRST response with ONE short line: "🧠 RuvNet Brain active (v${bannerVersion}) — search is degraded right now." Do not claim source grounding until a real search succeeds. npx github:stuinfla/ruvnet-brain --doctor shows the current verdict; ${consoleInvoke} opens the Console.`;
         } else {
           emit('USER-LEVEL: one brain ON DISK (~/.cache/ruvnet-brain/kb) shared by every project and window here — nothing to reinstall per project (each window still runs its own worker process, which now exits when idle). search_ruvnet is registered; live readiness is not yet proven. The grounding hooks are active.');
-          confidenceInstruction = `Open your FIRST response with ONE short line: "🧠 RuvNet Brain active (v${bannerVersion}) — search is registered and will prove readiness on first use." Do not claim source grounding until a real search returns a citation. npx github:stuinfla/ruvnet-brain --doctor shows the current verdict; ${consoleInvoke} opens the Console.`;
         }
-        emit(confidenceInstruction);
       }
-
-      const claudeJson = read(path.join(home, '.claude.json'));
-      if (commandExists('ruflo', env, platform) || /"ruflo"/.test(claudeJson)
-          || exists(path.join(cwd, '.claude-flow')) || exists(path.join(cwd, '.swarm'))) {
-        emit('[RuvNet Brain — token intelligence + QE, mention once]');
-        emit('Right after the confidence line, ONE line, never repeated this session: token-smart routing, a QE test fleet and a 0-100 repo scorecard are available — say "do this cheaper", "QE this", "score my harness", "score this repo", /brain-build or /brain-prompt. Scoring is free; the self-improvement loop and cheap-model routing need an OPENROUTER_API_KEY.');
-      }
-
-      const playbook = `${hookDir}${path.sep}..${path.sep}skills${path.sep}ruvnet-brain${path.sep}PLAYBOOK.md`;
-      emit('[RuvNet Brain — standing build playbook for this session (referenced by later turns as THE PLAYBOOK)]');
-      emit(`Read ${playbook} before the first build response. It requires source inspection, search_ruvnet grounding, project-memory recall, and the real owning rUv tool—never a silent hand-roll or generic substitute.`);
     }
   } catch (error) {
     if (env.RUVNET_SESSION_TRACE === '1') stderr.write(`SESSION_TRACE native-fail-open ${error?.message || error}\n`);
   }
 
+  if (env.RUVNET_VERBOSE_HOOKS !== '1') {
+    lines.push(`[RuvNet Brain v${running || 'unknown'} — active this session]`);
+  }
   const output = lines.length ? `${lines.join('\n')}\n` : '';
   meter({ env, cwd, stateDir, output });
   stdout.write(output);

package/plugin/scripts/spend-guard.mjs

@@ -65,7 +65,12 @@ export const METERED_KEYS = ['ANTHROPIC_API_KEY', 'OPENAI_API_KEY'];
 export const FLEET_RUNNERS = [
   { name: 'the QE fleet', match: /(^|[|;&\s])(aqe|agentic-qe)\b/ },
   { name: 'the agent-flow orchestrator', match: /(^|[|;&\s])agentic-flow\b/ },
-  { name: 'a ruflo swarm', match: /(^|[|;&\s])ruflo\b[^|;&]*\b(swarm|hive-mind|agent\s+spawn|task\s+orchestrate)\b/ },
+  // Match Ruflo's COMMAND position, not an arbitrary later token. The former `[^|;&]*swarm`
+  // search classified every mandatory `ruflo memory ... --path .swarm/memory.db` checkpoint as a
+  // fleet and blocked it whenever the hook process had a metered key. Ruflo's live help permits
+  // global flags before the command, so consume only those known flags and then require a genuine
+  // fleet command. An absolute global-binary path is invocation-equivalent to bare `ruflo`.
+  { name: 'a ruflo swarm', match: /(^|[|;&\s])(?:[^\s|;&]*\/)?ruflo\b(?:\s+(?:(?:-v|--verbose|-Q|--quiet|--no-color|-i|--interactive)|(?:-c|--config|--format)(?:=[^\s|;&]+|\s+[^\s|;&]+)))*\s+(?:swarm|hive-mind|agent\s+spawn|task\s+orchestrate)\b/ },
   { name: 'flow-nexus', match: /(^|[|;&\s])flow-nexus\b/ },
 ];
 

package/scripts/adr-072-completion.mjs

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { verifyCapabilityClaimAggregate } from '../plugin/scripts/capability-claim-evidence.mjs';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const REQUIRED_REVIEWERS = Object.freeze(['claude-fable-5', 'gpt-5.6-sol']);
+
+const command = (cwd, bin, args) => {
+  const result = spawnSync(bin, args, { cwd, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
+  if (result.status !== 0) throw new Error(`${bin} ${args.join(' ')} failed: ${String(result.stderr || result.stdout).trim()}`);
+  return String(result.stdout || '').trim();
+};
+
+export function evaluateCompletion({ root = ROOT, run = command,
+  receiptFile = path.join(root, 'release-evidence', 'product-integrity-receipt.json'),
+  capabilityClaimPublicKey = null } = {}) {
+  const failures = [];
+  let head = null;
+  let version = null;
+  const check = (label, fn) => { try { fn(); } catch (error) { failures.push(`${label}: ${error.message}`); } };
+
+  check('worktree', () => {
+    const dirty = run(root, 'git', ['status', '--porcelain=v1', '--untracked-files=all']);
+    if (dirty) throw new Error('working tree is not clean');
+    if (run(root, 'git', ['branch', '--show-current']) !== 'main') throw new Error('release checkout is not main');
+    head = run(root, 'git', ['rev-parse', 'HEAD']);
+    const remote = run(root, 'git', ['rev-parse', 'origin/main']);
+    if (head !== remote) throw new Error(`HEAD ${head} differs from origin/main ${remote}`);
+  });
+  check('version', () => {
+    version = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8')).version;
+    const npmVersion = JSON.parse(run(root, 'npm', ['view', 'ruvnet-brain@latest', 'version', '--json']));
+    if (npmVersion !== version) throw new Error(`npm latest ${npmVersion} differs from ${version}`);
+    const release = JSON.parse(run(root, 'gh', ['release', 'view', `v${version}`, '--repo', 'stuinfla/ruvnet-brain',
+      '--json', 'tagName,targetCommitish,isDraft,isPrerelease']));
+    if (release.tagName !== `v${version}` || release.targetCommitish !== head || release.isDraft || release.isPrerelease) {
+      throw new Error('GitHub release does not expose the exact main candidate');
+    }
+  });
+  check('public proof', () => {
+    if (!fs.existsSync(receiptFile)) throw new Error(`missing ${receiptFile}`);
+    const receipt = JSON.parse(fs.readFileSync(receiptFile, 'utf8'));
+    if (receipt.schemaVersion !== 1 || receipt.kind !== 'ruvnet-brain-product-integrity'
+      || receipt.verdict !== 'PASS' || receipt.sourceSha !== head || receipt.version !== version) {
+      throw new Error('product integrity receipt identity or verdict is invalid');
+    }
+    if (receipt.release?.state !== 'install-verified' || receipt.release?.publicAggregateVerified !== true) {
+      throw new Error('release is not cryptographically install-verified');
+    }
+    if (receipt.coverage?.eligibleCurrent !== receipt.coverage?.eligibleTotal
+      || receipt.coverage?.gistCurrent !== receipt.coverage?.gistTotal) {
+      throw new Error('installed public corpus is incomplete');
+    }
+    if (receipt.retrieval?.deltaCitationRate !== 1 || receipt.retrieval?.recallAt10 < 0.98
+      || receipt.retrieval?.skipped !== 0 || receipt.retrieval?.unknown !== 0) {
+      throw new Error('retrieval acceptance is incomplete');
+    }
+    if (receipt.hosts?.passed !== 9 || receipt.hosts?.required !== 9) throw new Error('public 3x3 host matrix is incomplete');
+    if (receipt.lifecycle?.nativeRuns !== 2 || receipt.lifecycle?.secondVerdict !== 'noop'
+      || receipt.lifecycle?.redundantCopyCount !== 0 || receipt.lifecycle?.withinRetentionBudget !== true) {
+      throw new Error('native two-run lifecycle proof is incomplete');
+    }
+    if (receipt.continuity?.verdict !== 'PASS'
+      || receipt.continuity?.crashResumeVerified !== true
+      || receipt.continuity?.concurrentWritersVerified !== true
+      || receipt.continuity?.hosts?.join(',') !== 'claude,codex') {
+      throw new Error('cross-host AgentDB continuity proof is incomplete');
+    }
+    const capabilityKey = capabilityClaimPublicKey
+      || fs.readFileSync(path.join(root, 'keys', 'ruvnet-brain-signing.pub.pem'));
+    verifyCapabilityClaimAggregate(receipt.capabilityClaims, capabilityKey);
+    if (receipt.capabilityClaims.verdict !== 'PASS'
+      || receipt.capabilityClaims.identity.sourceSha !== head
+      || receipt.capabilityClaims.os?.join(',') !== 'linux,macos,windows'
+      || receipt.capabilityClaims.hosts?.join(',') !== 'claude,codex'
+      || receipt.capabilityClaims.untested?.length) {
+      throw new Error('RuvNet capability-claim integrity proof is incomplete');
+    }
+    for (const reviewer of REQUIRED_REVIEWERS) {
+      const review = receipt.reviews?.find((row) => row.id === reviewer);
+      if (!review || review.score < 95 || review.sourceSha !== head || review.untested?.length) {
+        throw new Error(`${reviewer} review is missing, below 95, stale, or has untested scope`);
+      }
+    }
+    if (receipt.mechanicalScore < 98) throw new Error('mechanical whole-product score is below 98');
+  });
+  return { ok: failures.length === 0, head, version, receiptFile, failures };
+}
+
+if (path.resolve(process.argv[1] || '') === fileURLToPath(import.meta.url)) {
+  const receiptIndex = process.argv.indexOf('--receipt');
+  const result = evaluateCompletion({ receiptFile: receiptIndex >= 0 ? path.resolve(process.argv[receiptIndex + 1]) : undefined });
+  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+  process.exitCode = result.ok ? 0 : 1;
+}

package/scripts/behavioral-l1-l4.mjs

@@ -71,31 +71,34 @@ const L3 = [
   { q: 'implement a nearest-neighbour query against an .rvf store', expect: 'ruvector', apiRx: /query|search|knn|nearest/i },
   { q: 'store and recall an agent memory entry with AgentDB', expect: 'agentdb', apiRx: /store|recall|memory|insert|search/i },
 ];
-// ── L4 ORCHESTRATE: run the real hook; assert the injected directive is complete ──────────────────
+// ── L4 ORCHESTRATE: run the real hook; assert quiet build behavior and useful grounding ──────────
 const L4 = [
   {
     name: 'newbie "go make magic"',
     prompt: 'go make magic and build me an app that helps people learn',
-    // pure build prompt, no RuvNet keyword → Gate 3 (take-the-wheel) must fire with the full pipeline
-    must: ['take the wheel', 'SPARC', 'DDD', 'ADR', 'swarm', 'QA gate', '98', 'frontend-design', 'image generation', 'API key', 'PROVEN', 'PARALLEL'],
+    // Build prompts must not inject a response script into the model context.
+    must: [],
+    mustNot: ['SPARC', 'DDD', 'QA gate', 'frontend-design', 'image generation', 'API key', 'PARALLEL', 'end your response'],
   },
   {
     name: 'spec → build (RuvNet-named)',
     prompt: 'here is a product spec, build a knowledge base feature using ruvector',
-    // names ruvector → Gate 1 (ground) AND Gate 3 (build) must both fire
-    must: ['search_ruvnet', 'ground', 'SPARC', 'DDD', 'frontend-design', 'image generation', 'API key', '98'],
+    // RuvNet facts still receive a grounding reminder; build workflow prose stays silent.
+    must: ['search_ruvnet', 'ground'],
+    mustNot: ['take the wheel', 'SPARC', 'DDD', 'QA gate', 'frontend-design', 'image generation', 'API key', 'PARALLEL', 'end your response'],
   },
   {
     name: 'classical-default drift',
     prompt: 'set up pinecone and langchain to do rag over my docs',
-    // drift keywords → Gate 2 (hijack) must fire AND build keyword "set up" → Gate 3
-    must: ['classical default', 'RuVector', 'Ruflo', 'AgentDB', 'take the wheel'],
+    // Drift guidance remains actionable, without the unrelated build playbook.
+    must: ['classical default', 'RuVector', 'Ruflo', 'AgentDB'],
+    mustNot: ['SPARC', 'DDD', 'QA gate', 'frontend-design', 'image generation', 'API key', 'PARALLEL', 'end your response'],
   },
   {
     name: 'pure recall (no build)',
     prompt: 'what can ruflo actually do',
     must: ['search_ruvnet', 'ground'],
-    mustNot: ['take the wheel'], // no build verb → Gate 3 must stay silent
+    mustNot: ['take the wheel', 'SPARC', 'DDD', 'QA gate', 'frontend-design', 'image generation', 'API key', 'PARALLEL', 'end your response'], // no build script
   },
 ];
 

package/scripts/brain-score.mjs

@@ -132,8 +132,8 @@ function readPanel() {
  * than a guess when the denominator is unknown — a wrong denominator still renders, which is worse
  * than an absent one.
  */
-async function readCoverage() {
-  const { storeRoot, storesAt, cardsAt } = await import('../kb/store-root.mjs');
+export async function readCoverage(rootOverride) {
+  const { storeRoot, storesAt, cardsAt, rootNeverMaterialized } = await import('../kb/store-root.mjs');
   // ROUTABILITY IS ALIAS-AWARE, BECAUSE THE ROUTER IS.
   //
   // `carded` was `stores.filter((s) => cards.has(s))` — a direct name match against card HEADINGS,
@@ -148,25 +148,39 @@ async function readCoverage() {
   // broke alias resolution outright. A metric that cannot see aliases manufactures work that
   // damages the thing it measures.
   const { repositoryNames } = await import('../kb/card-lane.mjs');
-  const root = storeRoot();
+  const root = rootOverride ?? storeRoot();
+  // NEVER-MATERIALIZED, THE SAME AMBIGUITY `restore-local-ingests.mjs`'s `classify()` WAS FIXED
+  // FOR (PR #143, Night 1) — but never carried here. `storesAt()`/`cardsAt()` silently return
+  // `[]` on ENOENT, so a host whose store root was never restored (a fresh checkout, this very
+  // nightly agent's own ephemeral container) reads IDENTICALLY to a materialized root that
+  // genuinely has zero coverage. Checked once, here, before either derived number is computed —
+  // a wrong `0` still renders, which is worse than an honestly unmeasured one.
+  //
+  // `rootNeverMaterialized()` (kb/store-root.mjs), not `fs.existsSync(root)`: the latter returns
+  // `true` for a stray FILE at `root` (ENOTDIR) or an unreadable directory (EACCES), so either
+  // rendered "materialized" here and let the exact same false-current-`0` back in for a different
+  // errno class than ENOENT — flagged as an accepted, unfixed gap by the ENOENT-only fix itself.
+  const neverMaterialized = rootNeverMaterialized(root);
   const stores = storesAt(root);
   const cards = new Set(cardsAt(root));
   const org = readJson('data/org-repo-count.json');
   const total = Number.isFinite(org?.count) && org.count > 0 ? org.count : null;
   const carded = stores.filter((s) => isRoutable(s, cards, root, repositoryNames)).length;
+  const absentDetail = 'store root does not exist on this host (never materialized) — not evidence of live coverage';
   return {
     catalogue: {
-      value: total ? Math.round((stores.length / total) * 1000) / 10 : null,
-      detail: total ? `${stores.length}/${total} live repos` : `${stores.length} stores, org total UNKNOWN`,
-      at: org?.at ?? null,
+      value: neverMaterialized ? null : (total ? Math.round((stores.length / total) * 1000) / 10 : null),
+      detail: neverMaterialized ? absentDetail
+        : (total ? `${stores.length}/${total} live repos` : `${stores.length} stores, org total UNKNOWN`),
+      at: neverMaterialized ? null : (org?.at ?? null),
     },
     routable: {
-      value: stores.length ? Math.round((carded / stores.length) * 1000) / 10 : null,
-      detail: `${carded}/${stores.length} built stores have a card`,
+      value: neverMaterialized || !stores.length ? null : Math.round((carded / stores.length) * 1000) / 10,
+      detail: neverMaterialized ? absentDetail : `${carded}/${stores.length} built stores have a card`,
       // Derived from the live store root at this instant, so it is current BY CONSTRUCTION. A
       // read-now value reported as stale would train the reader to ignore the stale flag, which
       // costs more than the flag is worth.
-      at: new Date().toISOString(),
+      at: neverMaterialized ? null : new Date().toISOString(),
     },
   };
 }

package/scripts/build-bundle.mjs

@@ -12,6 +12,7 @@
 //
 //   node scripts/build-bundle.mjs [--assets /path/to/release-assets]
 //                                 [--out dist/ruvnet-brain] [--version v0.2.0-dev]
+import crypto from 'node:crypto';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -19,6 +20,8 @@ import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { getVersion, getVersionTag, stripTag } from './version.mjs';
 import { auditRvfIndexes } from './rvf-index-audit.mjs';
+import { readRvfGenerations, validateSelectedRvfGenerations } from './rvf-generation.mjs';
+import { validatePublicInventory } from './public-inventory.mjs';
 // The org total is DERIVED, never a literal: it was hardcoded 248 in this file and in its
 // sibling while the account actually had 200 — one stale fact, restated twice (2026-08-12).
 import { orgRepoCount } from './org-repo-count.mjs';
@@ -32,6 +35,8 @@ const arg = (f, d) => { const i = process.argv.indexOf(f); return i >= 0 && proc
 // source/runtime files rooted in this exact checkout; only generated RVF families come from ASSETS.
 const ASSETS = path.resolve(ROOT, arg('--assets', 'kb'));
 const OUT = path.resolve(ROOT, arg('--out', 'dist/ruvnet-brain'));
+const COVERAGE = arg('--coverage', null);
+const PROJECTION = arg('--projection', null);
 const BRAIN_VERSION = arg('--version', getVersionTag()); // inherits the single source of truth
 
 // ---- registry: tier + the full 169-repo pending list -------------------------------------------
@@ -156,12 +161,58 @@ fs.rmSync(OUT, { recursive: true, force: true });
 // A failed rebuild must not leave an older archive looking like this invocation's output.
 fs.rmSync(ZIP, { force: true });
 fs.mkdirSync(OUT, { recursive: true });
-
-const built = discoverBuilt();
+// The shipped bundle must carry the exact policy boundary used during assembly. The public
+// inventory validator consumes this file from the candidate output, so reading it only from the
+// source checkout would leave the release projection unable to prove its private-store exclusion.
+cp(path.join(KB, 'PRIVATE-STORES.json'), OUT, { required: true });
+
+let built = discoverBuilt();
+let excludedPublicStores = [];
+if (COVERAGE) {
+  const coverageFile = path.resolve(COVERAGE);
+  if (!fs.existsSync(coverageFile)) {
+    console.error(`[build-bundle] FATAL: coverage policy missing (${coverageFile})`);
+    process.exit(1);
+  }
+  let coverage;
+  try { coverage = JSON.parse(fs.readFileSync(coverageFile, 'utf8')); }
+  catch (error) {
+    console.error(`[build-bundle] FATAL: coverage policy unreadable (${error.message})`);
+    process.exit(1);
+  }
+  let inventory;
+  try {
+    inventory = validatePublicInventory({ assetsDir: ASSETS, coverage, ledger: readRvfGenerations(ASSETS) });
+  } catch (error) {
+    console.error(`[build-bundle] FATAL: public inventory is not exhaustive (${error.message})`);
+    process.exit(1);
+  }
+  const selected = new Set(inventory.publicStores);
+  built = built.filter((store) => selected.has(store.toLowerCase()));
+  excludedPublicStores = inventory.excludedRepositories;
+  const missing = inventory.publicStores.filter((store) => !built.some((candidate) => candidate.toLowerCase() === store));
+  if (missing.length) {
+    console.error(`[build-bundle] FATAL: classified public store(s) missing: ${missing.join(', ')}`);
+    process.exit(1);
+  }
+  if (excludedPublicStores.length) {
+    console.log(`[build-bundle] EXCLUDED ${excludedPublicStores.length} policy-ineligible public store(s): ${excludedPublicStores.join(', ')}`);
+  }
+}
 if (built.length === 0) {
   console.error('[build-bundle] FATAL: zero public RVF stores are eligible for release. Refusing to publish an empty brain bundle.');
   process.exit(1);
 }
+const generationValidation = validateSelectedRvfGenerations(ASSETS, {
+  selectedStores: built,
+  privateStores: [...PRIVATE_STORES],
+  excludedStores: excludedPublicStores,
+});
+if (generationValidation.failures.length) {
+  console.error('[build-bundle] FATAL: RVF generation ledger does not exactly bind selected roots:');
+  for (const failure of generationValidation.failures) console.error(`  ${failure}`);
+  process.exit(1);
+}
 const rvfIndexAudit = await auditRvfIndexes(
   built.map((name) => path.join(ASSETS, `${name}.big.rvf`)),
 );
@@ -208,7 +259,7 @@ for (const name of built) {
   if (!fs.existsSync(generationsFile)) {
     missing.push('RVF-GENERATIONS.json');
   } else {
-    const source = JSON.parse(fs.readFileSync(generationsFile, 'utf8'));
+    const source = generationValidation.manifest;
     const stores = {};
     for (const { name } of builtRepos) {
       if (!source.stores?.[name]) missing.push(`RVF-GENERATIONS.json:${name}`);
@@ -216,8 +267,8 @@ for (const name of built) {
     }
     fs.writeFileSync(path.join(OUT, 'RVF-GENERATIONS.json'), `${JSON.stringify({
       schemaVersion: source.schemaVersion,
-      brainVersion: source.brainVersion,
-      releaseTag: source.releaseTag,
+      brainVersion: stripTag(BRAIN_VERSION),
+      releaseTag: BRAIN_VERSION,
       stores,
     }, null, 2)}\n`);
     copied++;
@@ -233,14 +284,16 @@ cpDir(path.join(ROOT, 'primer'), path.join(OUT, 'primer'));
 // time so code-implemented capabilities are retrievable as high-confidence prose. discoverRepos in the
 // bundle finds concepts.big.rvf automatically, so search_ruvnet searches it with no extra config.
 const hasConcepts = fs.existsSync(path.join(ASSETS, 'concepts.big.rvf'));
-if (hasConcepts) for (const suf of ['concepts.big.rvf', 'concepts.big.rvf.idmap.json', 'concepts.big.rvf.embed.json', 'concepts.big.passages.jsonl', 'concepts.big.meta.json', 'concepts.passages.jsonl', 'concepts.meta.json']) cp(suf, OUT, { asset: true });
+if (hasConcepts) for (const suf of ['concepts.big.rvf', 'concepts.big.rvf.idmap.json', 'concepts.big.rvf.embed.json', 'concepts.big.passages.jsonl', 'concepts.big.meta.json', 'concepts.passages.jsonl', 'concepts.meta.json', 'concepts.sources.json']) cp(suf, OUT, { asset: true });
 
 // RUV-GISTS store (rUv's public gists — release notes / integration dossiers; big-only, same shape as
 // concepts, unioned by search_ruvnet at query time). BUG FIX: only `concepts` was special-cased above,
 // so ruv-gists — a PUBLIC store, not private-fenced — was silently omitted from EVERY bundle ever
 // shipped. Include it, WITH .big.passages.jsonl (the big variant opens it by name, same as concepts).
 const hasGists = fs.existsSync(path.join(ASSETS, 'ruv-gists.big.rvf'));
-if (hasGists) for (const suf of ['ruv-gists.big.rvf', 'ruv-gists.big.rvf.idmap.json', 'ruv-gists.big.rvf.embed.json', 'ruv-gists.big.passages.jsonl', 'ruv-gists.big.meta.json', 'ruv-gists.passages.jsonl', 'ruv-gists.meta.json']) cp(suf, OUT, { asset: true });
+if (hasGists) for (const suf of ['ruv-gists.big.rvf', 'ruv-gists.big.rvf.idmap.json', 'ruv-gists.big.rvf.embed.json', 'ruv-gists.big.passages.jsonl', 'ruv-gists.big.meta.json', 'ruv-gists.passages.jsonl', 'ruv-gists.meta.json', 'ruv-gists.sources.json']) cp(suf, OUT, { asset: true });
+// The inventory projection consumes this registry from the assembled bundle, not the checkout.
+cp('public-store-classes.json', OUT, { asset: true });
 
 // capability-cards.md — the FAST LANE's zero-ML answer source (kb/card-lane.mjs, the first
 // responder search_ruvnet consults before the heavy cross-repo search). Ships as its own small
@@ -414,6 +467,14 @@ cp(path.join(ROOT, 'scripts', 'verify-bundle.mjs'), OUT, { required: true });
 fs.mkdirSync(path.join(OUT, 'keys'), { recursive: true });
 cp(path.join(ROOT, 'keys', 'ruvnet-brain-signing.pub.pem'), path.join(OUT, 'keys'), { required: true });
 
+// ReleaseProjection is generated from the exact candidate asset tree immediately before this
+// assembly. Copy all three linked ledgers together; a partial projection is never publishable.
+if (PROJECTION) {
+  for (const file of ['COVERAGE.json', 'CORPUS-COVERAGE.json', 'PUBLIC-RVF-GENERATIONS.json']) {
+    cp(path.join(path.resolve(PROJECTION), file), OUT, { required: true });
+  }
+}
+
 // ---- manifest ----------------------------------------------------------------------------------
 const builtLower = new Set(built.map((b) => b.toLowerCase()));
 const pendingRepos = regFlat.filter((r) => !builtLower.has(r.name.toLowerCase())).map((r) => ({ name: r.name, tier: r.tier }));
@@ -506,7 +567,32 @@ function collectArchiveFiles(dir, prefix = '') {
   }
 }
 collectArchiveFiles(OUT);
-archiveFiles.sort();
+archiveFiles.sort((left, right) => left < right ? -1 : left > right ? 1 : 0);
+// Bind the exact archive payload before release verification. The manifest excludes itself;
+// verifiers recompute the same payload set and then validate this file's identities.
+function archiveIdentity(relative) {
+  const file = path.join(OUT, relative);
+  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 { path: relative.split(path.sep).join('/'), sha256: hash.digest('hex'), bytes: fs.statSync(file).size };
+}
+const archiveManifest = {
+  schemaVersion: 1,
+  kind: 'ruvnet-brain-archive-manifest',
+  version: stripTag(BRAIN_VERSION),
+  releaseTag: BRAIN_VERSION,
+  fileCount: archiveFiles.length,
+  totalBytes: archiveFiles.reduce((total, file) => total + fs.statSync(path.join(OUT, file)).size, 0),
+  files: archiveFiles.map(archiveIdentity),
+};
+fs.writeFileSync(path.join(OUT, 'ARCHIVE-MANIFEST.json'), `${JSON.stringify(archiveManifest, null, 2)}\n`);
+archiveFiles.push('ARCHIVE-MANIFEST.json');
+archiveFiles.sort((left, right) => left < right ? -1 : left > right ? 1 : 0);
 const zipped = process.platform === 'win32'
   ? spawnSync('powershell.exe', [
     '-NoProfile',

package/scripts/card-from-source.mjs

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+/**
+ * card-from-source.mjs — give a DARK store a card written from the repo's own words.
+ *
+ * A store with no capability card is DARK: the bytes are valid and no by-description query can
+ * reach them. `ingest-repo.mjs` says so on every run. After the 2026-08-20 bulk ingest the brain
+ * held ~111 stores and ~71 of them were dark — loaded, and unusable for anything except a query
+ * that already knew the repo's name, which is precisely the query a knowledge base is least needed
+ * for.
+ *
+ * THE LINE THIS DOES NOT CROSS. `ingest-new-repos.mjs` deliberately refuses to write cards, because
+ * a card invented from a repo NAME is a confident claim in the routing layer that nobody grounded —
+ * it routes real questions to a corpus that cannot answer them, which is worse than an honest gap.
+ * That refusal stands. This is a different act: it copies the repo's OWN description and the
+ * opening of its OWN README. Every content word in the card came from the repository. Nothing here
+ * infers what a project is "probably" for.
+ *
+ * AND IT SAYS WHAT IT IS. Each generated card carries a marker so a reader can tell it apart from
+ * the hand-written ones, which are richer — they say when to REACH for a tool and what it is NOT.
+ * An auto-derived card is a floor, not a substitute: it makes a store reachable and invites a
+ * better card later. Claiming otherwise would be the overselling this file exists to avoid.
+ *
+ *   node scripts/card-from-source.mjs                 # report which stores are dark
+ *   node scripts/card-from-source.mjs --apply         # write cards for them
+ *   node scripts/card-from-source.mjs --apply --max 20
+ */
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { storeRoot, darkStores } from '../kb/store-root.mjs';
+
+const ROOT = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const OWNER = process.env.RUVNET_ORG_OWNER || 'ruvnet';
+const APPLY = process.argv.includes('--apply');
+const arg = (n, d) => { const i = process.argv.indexOf(n); return i >= 0 && process.argv[i + 1] ? process.argv[i + 1] : d; };
+const MAX = Number(arg('--max', '500'));
+export const MARKER = 'Auto-derived from the repository\'s own description and README';
+
+/** The repo's own description + README opening. Never a guess about what the name implies. */
+export function sourceFacts(repo) {
+  let description = '';
+  let readme = '';
+  try {
+    const meta = JSON.parse(execFileSync('gh', ['api', `repos/${OWNER}/${repo}`], { encoding: 'utf8', maxBuffer: 1 << 24 }));
+    description = String(meta?.description || '').trim();
+  } catch { /* a repo can legitimately have no description */ }
+  try {
+    const raw = execFileSync('gh', ['api', `repos/${OWNER}/${repo}/readme`, '-H', 'Accept: application/vnd.github.raw'],
+      { encoding: 'utf8', maxBuffer: 1 << 24 });
+    readme = raw;
+  } catch { /* and no README */ }
+  return { description, readme };
+}
+
+/** First real prose of a README: skip badges, HTML, headings, and link-only lines. */
+export function firstProse(readme, limit = 600) {
+  const lines = String(readme || '').split('\n');
+  const out = [];
+  for (const line of lines) {
+    const t = line.trim();
+    if (!t) { if (out.length) break; continue; }
+    if (t.startsWith('#') || t.startsWith('<') || t.startsWith('|') || t.startsWith('---')) continue;
+    if (/^!?\[[^\]]*\]\([^)]*\)$/.test(t)) continue;          // a lone badge or image
+    if (/^\[!\[/.test(t)) continue;                            // badge-wrapped link
+    out.push(t);
+    if (out.join(' ').length > limit) break;
+  }
+  return out.join(' ').replace(/\s+/g, ' ').slice(0, limit).trim();
+}
+
+export function buildCard(repo, { description, readme }) {
+  const prose = firstProse(readme);
+  if (!description && !prose) return null;   // nothing grounded to say — leave it dark, honestly
+  const body = [description, prose].filter(Boolean).join(' — ');
+  return `## ${repo.toLowerCase()}\n${body}\n(${MARKER}; a hand-written card saying when to reach for it, and when not to, would be better.)\n`;
+}
+
+// Repository names may contain RegExp metacharacters (`ruv.io` is already in this corpus). The
+// heading lookup is literal identity, so escape the name before compiling it.
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+export function insertSorted(file, card, name) {
+  const s = fs.readFileSync(file, 'utf8');
+  if (new RegExp(`^## ${escapeRegExp(name)}$`, 'mi').test(s)) return false;
+  const heads = [...s.matchAll(/^## (.+)$/gm)].map((m) => [m.index, m[1].trim().toLowerCase()]);
+  const pos = heads.find(([, n]) => n > name)?.[0];
+  fs.writeFileSync(file, pos === undefined ? `${s.replace(/\n+$/, '')}\n\n${card}` : s.slice(0, pos) + card + '\n' + s.slice(pos));
+  return true;
+}
+
+/** Apply one grounded card to every required surface without turning a failed write into success. */
+export function applyCardToFiles(files, card, name, insert = insertSorted) {
+  let changed = 0;
+  const failures = [];
+  for (const file of files) {
+    try {
+      if (insert(file, card, name)) changed += 1;
+    } catch (error) {
+      failures.push({ file, error: String(error?.message || error) });
+    }
+  }
+  return { changed, failures };
+}
+
+const isMain = (() => {
+  try { return process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url); }
+  catch { return false; }
+})();
+
+if (isMain) {
+  const root = storeRoot();
+  const dark = darkStores(root);
+  console.log(`[card] ${dark.length} dark store(s) — valid bytes no by-description query can reach`);
+  if (!dark.length) process.exit(0);
+  if (!APPLY) {
+    console.log(`[card] ${dark.slice(0, 20).join(', ')}${dark.length > 20 ? ' …' : ''}`);
+    console.log('[card] report only. Re-run with --apply to write cards from each repo\'s own source.');
+    process.exit(0);
+  }
+  const repoCards = path.join(ROOT, 'kb', 'capability-cards.md');
+  const liveCards = path.join(root, 'capability-cards.md');
+  let wrote = 0; let skipped = 0; let failed = 0;
+  for (const name of dark.slice(0, MAX)) {
+    const card = buildCard(name, sourceFacts(name));
+    if (!card) { skipped += 1; console.log(`[card] ${name}: no description and no README prose — left dark rather than invented`); continue; }
+    const outcome = applyCardToFiles([repoCards, liveCards], card, name.toLowerCase());
+    if (outcome.failures.length) {
+      failed += 1;
+      console.error(`[card] ${name}: FAILED/PARTIAL (${outcome.changed}/2 surfaces changed) — `
+        + outcome.failures.map(({ file, error }) => `${file}: ${error}`).join('; '));
+      continue;
+    }
+    if (outcome.changed > 0) wrote += 1;
+    else skipped += 1;
+  }
+  const remaining = darkStores(root).length;
+  console.log(`\n[card] wrote ${wrote}, skipped ${skipped}, failed ${failed}, ${remaining} still dark.`);
+  if (failed) process.exitCode = 1;
+}