ruvnet-brain 4.3.9 → 4.3.11

package/scripts/stack-sync.mjs

@@ -186,13 +186,15 @@ export function listInstalledPlugins(pluginsDir = PLUGINS_DIR) {
     // not equality" discipline as the rest of this file. Fall back to the manifest's own version field
     // if the on-disk plugin.json is unreadable, so a present plugin is NEVER reported "not installed".
     let installed = null;
+    const instances = [];
     for (const rec of Array.isArray(records) ? records : []) {
       const v = (rec && rec.installPath ? pluginVersion(rec.installPath) : null)
         || (rec && rec.version && rec.version !== 'unknown' ? rec.version : null);
+      instances.push({ scope: rec?.scope || 'unknown', installPath: rec?.installPath || null, version: v, readable: Boolean(rec?.installPath && pluginVersion(rec.installPath)) });
       if (!v) continue;
       if (installed === null || cmpVersion(v, installed) > 0) installed = v;
     }
-    out.push({ name, installed, source: 'plugin', marketplace });
+    out.push({ name, installed, source: 'plugin', marketplace, instances });
   }
   return out;
 }
@@ -209,15 +211,8 @@ function listInstalled({ lib = GLOBAL_LIB, pluginsDir = PLUGINS_DIR } = {}) {
     }
   };
   scan(lib);
-  // Merge in plugin-sourced tools (ISSUE #22). Dedup by name: a tool present BOTH globally and as a
-  // plugin appears once, and the global-npm copy wins — it is the one classify() can compare against
-  // npm dist-tags. A plugin-only tool is added, so it can never be reported "not installed".
-  const seen = new Set(out.map((r) => r.name));
-  for (const p of listInstalledPlugins(pluginsDir)) {
-    if (seen.has(p.name)) continue;
-    seen.add(p.name);
-    out.push(p);
-  }
+  // Preserve both distribution sources; one must not hide the other.
+  out.push(...listInstalledPlugins(pluginsDir));
   return out.sort((a, b) => a.name.localeCompare(b.name));
 }
 
@@ -258,14 +253,9 @@ export function findShadows(npxCache = NPX_CACHE, lib = GLOBAL_LIB) {
 // exits) share ONE classification, never two that can drift.
 export function classify(pkgs) {
   return pkgs.map((p) => {
-    // ISSUE #22 — a Claude Code plugin tracks ITS MARKETPLACE's update cadence, not npm semver. There
-    // is no npm dist-tag oracle for it (querying `npm view <plugin>` would compare against an unrelated
-    // package or 404), so we do not manufacture a drift signal. It is present and installed ⇒ CURRENT;
-    // a plugin is only BROKEN if we could not read any version at all. Either way it is COUNTED and is
-    // never reported "not installed". This also keeps the npm-registry "blind tool" guard scoped to
-    // real npm rows (see audit()/auditModel()).
+    // Installed records prove presence, not marketplace currency.
     if (p.source === 'plugin') {
-      return { ...p, tag: 'plugin', target: p.installed, state: p.installed ? 'CURRENT' : 'BROKEN' };
+      return { ...p, tag: 'plugin', target: null, state: p.installed ? 'INSTALLED_UNVERIFIED' : 'BROKEN', evidence: 'local install record only; marketplace revision not checked' };
     }
     const want = TAG_POLICY[p.name] || DEFAULT_TAG;
     const tags = registryTags(p.name);
@@ -293,9 +283,7 @@ function audit() {
   // inside the fix for it. Silence is not health.
   const rows = classify(pkgs);
   const unresolved = rows.filter((r) => r.state === 'UNRESOLVED');
-  // Guard scoped to npm rows (ISSUE #22): plugin rows are CURRENT by construction, so counting them
-  // here would let a fully-unreachable registry hide behind a couple of installed plugins — the exact
-  // "blind tool reports health" bug this guard exists to kill, reintroduced. Denominator = npm rows.
+  // Registry reachability is measured only against npm rows; plugins remain unverified.
   const npmRows = rows.filter((r) => r.source !== 'plugin');
   if (npmRows.length && unresolved.length === npmRows.length) {
     die(`could not reach the npm registry for ANY of ${npmRows.length} npm packages.\n` +
@@ -303,7 +291,7 @@ function audit() {
   }
 
   const shadows = findShadows();
-  return { rows, unresolved, shadows, stale: shadows.filter((s) => s.global && s.version !== s.global) };
+  return { rows, unresolved, shadows, stale: shadows.filter((s) => s.global && isBehind(s.version, s.global)) };
 }
 
 // Non-exiting audit for embedders (the Onboarding Console). Same measurement as audit(), but returns
@@ -316,32 +304,44 @@ export function auditModel() {
   const rows = classify(pkgs);
   const unresolved = rows.filter((r) => r.state === 'UNRESOLVED');
   const shadows = findShadows();
-  const stale = shadows.filter((s) => s.global && s.version !== s.global);
+  const stale = shadows.filter((s) => s.global && isBehind(s.version, s.global));
   // Same npm-scoped guard as audit() (ISSUE #22): plugin rows never count toward "registry unreachable".
   const npmRows = rows.filter((r) => r.source !== 'plugin');
   const error = npmRows.length && unresolved.length === npmRows.length
     ? `could not reach the npm registry for any of ${npmRows.length} npm packages` : null;
-  return { rows, unresolved, shadows, stale, error };
+  return { rows, unresolved, shadows, stale, error, summary: summarizeAudit({ rows, shadows }) };
+}
+
+export function summarizeAudit({ rows, shadows }) {
+  const count = (state) => rows.filter((row) => row.state === state).length;
+  const summary = { behind: count('BEHIND'), broken: count('BROKEN'),
+    unverified: count('INSTALLED_UNVERIFIED') + count('UNRESOLVED'), shadows: shadows.length,
+    stale: shadows.filter((s) => s.global && isBehind(s.version, s.global)).length };
+  summary.verdict = summary.behind || summary.broken || summary.shadows ? 'DRIFT'
+    : summary.unverified || !rows.length ? 'UNKNOWN' : 'PASS';
+  summary.exitCode = summary.verdict === 'PASS' ? 0 : summary.verdict === 'UNKNOWN' ? 4 : 1;
+  return summary;
 }
 
 function report({ rows, shadows, stale }) {
-  const w = Math.max(...rows.map((r) => r.name.length));
+  const w = Math.max(1, ...rows.map((r) => r.name.length));
   const nPlugin = rows.filter((r) => r.source === 'plugin').length;
   const nNpm = rows.length - nPlugin;
-  log(`\n  RuvNet stack — ${rows.length} packages (${nNpm} npm-global, ${nPlugin} Claude Code plugin)\n`);
+  log(`\n  RuvNet stack — ${rows.length} distribution records (${nNpm} npm-global, ${nPlugin} Claude Code plugin)\n`);
   for (const r of rows) {
-    const mark = { CURRENT: '  ok  ', BEHIND: 'BEHIND', AHEAD: ' ahead', BROKEN: 'BROKEN', UNRESOLVED: '  ??  ' }[r.state];
+    const mark = { CURRENT: '  ok  ', BEHIND: 'BEHIND', AHEAD: ' ahead', BROKEN: 'BROKEN', UNRESOLVED: '  ??  ', INSTALLED_UNVERIFIED: 'UNVERIFIED' }[r.state];
     const detail = r.state === 'BEHIND' ? `${r.installed} -> ${r.target}  (@${r.tag})`
       : r.state === 'AHEAD' ? `${r.installed}  (ahead of @${r.tag} ${r.target} — alpha track; left alone)`
       : r.state === 'BROKEN' ? `no readable version on disk; registry has ${r.target ?? '?'}`
-      : r.source === 'plugin' ? `${r.installed}  (plugin · ${r.marketplace} marketplace)`
+      : r.source === 'plugin' ? `${r.installed}  (plugin · ${r.marketplace}; marketplace currency NOT CHECKED; ${r.instances?.length || 1} scope record(s))`
       : r.installed;
     log(`  [${mark}] ${r.name.padEnd(w)}  ${detail}`);
+    if (r.instances?.length > 1) for (const instance of r.instances) log(`      ${instance.scope}: ${instance.version || 'UNREADABLE'} (${instance.readable ? 'disk' : 'record only'})`);
   }
   if (shadows.length) {
     log(`\n  npx shadow copies:`);
     for (const s of shadows) {
-      log(`    ${s.name}@${s.version}${s.global && s.version !== s.global ? `   STALE — global is ${s.global}` : ''}`);
+      log(`    ${s.name}@${s.version}${s.global && isBehind(s.version, s.global) ? `   STALE — global is ${s.global}` : ''}`);
     }
   }
   log('');
@@ -391,8 +391,9 @@ function sync({ dryRun = false } = {}) {
   const toInstall = [...behind, ...broken.filter((r) => r.target)].map((r) => `${r.name}@${r.target}`);
 
   if (!toInstall.length && !stale.length) {
-    log('  one copy of everything, all current, no shadows. Nothing to do.');
-    writeReceipt(a, [], []);
+    log(`  No npm repair selected. Audit: ${JSON.stringify(summarizeAudit(a))}`);
+    if (!dryRun) writeReceipt(a, [], []);
+    process.exitCode = summarizeAudit(a).exitCode;
     return;
   }
   if (dryRun) {
@@ -431,7 +432,10 @@ function sync({ dryRun = false } = {}) {
   }
   if (wrong.length) die(`npm reported success but THE DISK DISAGREES:\n   - ${wrong.join('\n   - ')}`);
 
-  writeReceipt(audit(), toInstall, purged);
+  const after = audit();
+  writeReceipt(after, toInstall, purged);
+  process.exitCode = summarizeAudit(after).exitCode;
+  log(`  Remaining audit: ${JSON.stringify(summarizeAudit(after))}`);
   log(`\n  synced ${toInstall.length} package(s); purged ${purged.length} shadow(s); verified against disk.`);
 }
 
@@ -440,18 +444,12 @@ if (process.argv[1] && path.resolve(process.argv[1]).endsWith('stack-sync.mjs'))
   const args = process.argv.slice(2);
   if (args.includes('--audit')) {
     const a = audit();
-    const { behind, broken, stale } = report(a);
-    // UNRESOLVED counts as drift, not as health: a package we could not measure is a package we
-    // cannot vouch for. Reporting "current" for something we never checked is the lie this tool exists to stop.
-    const unres = a.unresolved.length;
-    const bad = behind.length + broken.length + stale.length + unres;
-    if (bad) {
-      log(`  DRIFT: ${behind.length} behind, ${broken.length} broken, ${stale.length} stale shadow(s)` +
-          (unres ? `, ${unres} UNMEASURED (registry unreachable)` : '') + '.');
-      log(`  Fix:   node scripts/stack-sync.mjs --sync\n`);
-      process.exit(1); // non-zero: a watchdog must never call a drifted stack "green"
-    }
-    log('  one copy of everything, all current, no shadows.\n');
+    report(a);
+    const summary = summarizeAudit(a);
+    log(`  Audit: ${JSON.stringify(summary)}`);
+    if (summary.unverified) log('  Required: verify each plugin against its marketplace revision and each unresolved npm target against registry tags.');
+    if (summary.shadows) log('  Cached copies are present; inspect invocation paths before removing any cache. No copies removed by audit.');
+    process.exitCode = summary.exitCode;
   } else if (args.includes('--sync')) {
     sync({ dryRun: args.includes('--dry-run') });
   } else {

package/scripts/staged-host-verifier.mjs

@@ -4,8 +4,48 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { runHostMatrixAsync } from './host-install-matrix.mjs';
+import { validatePlanAgainstCoverage } from './retrieval-canary.mjs';
+import { extractZip } from '../kb/zip-extract.mjs';
+import { tarExtractionInvocation } from './publication-receipt.mjs';
 
 const sha256 = (file) => crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+
+export function readCandidateRetrieval({ manifest, planFile, coverageFile }) {
+  if (!planFile || !coverageFile) throw new Error('candidate retrieval requires sealed plan and coverage files');
+  const plan = JSON.parse(fs.readFileSync(planFile));
+  const coverageBytes = fs.readFileSync(coverageFile);
+  const coverage = JSON.parse(coverageBytes);
+  // An observed baseline defines the delta only; it never supplies candidate PASS evidence.
+  validatePlanAgainstCoverage(plan, coverage, { allowObservedBaseline: true });
+  const npm = manifest.members?.filter(({ role }) => role === 'npm') || [];
+  const bundle = manifest.members?.filter(({ role }) => role === 'bundle') || [];
+  const coverageSha256 = crypto.createHash('sha256').update(coverageBytes).digest('hex');
+  if (npm.length !== 1 || bundle.length !== 1
+    || plan.candidate.sourceSha !== manifest.candidateSha
+    || plan.candidate.packageSha256 !== npm[0].sha256 || plan.candidate.archiveSha256 !== bundle[0].sha256
+    || plan.coverage.sha256 !== coverageSha256 || plan.candidate.coverageSha256 !== coverageSha256
+    || plan.coverage.bytes !== coverageBytes.length
+    || coverage.releaseIdentity?.sourceSnapshot !== manifest.candidateSha
+    || coverage.releaseIdentity?.version !== manifest.version || coverage.releaseIdentity?.tag !== manifest.tag
+    || plan.candidate.publicLedgerSha256 !== coverage.generationLedger?.sha256
+    || plan.candidate.publicLedgerBytes !== coverage.generationLedger?.bytes
+    || plan.candidate.publicStoreCount !== coverage.generationLedger?.storeCount
+    || plan.candidate.publicInventoryPartitionSha256 !== coverage.publicInventoryPartitionSha256) {
+    throw new Error('candidate retrieval plan, coverage or artifact identity mismatch');
+  }
+  return { plan, sourceSha: manifest.candidateSha, artifactSha256: npm[0].sha256,
+    candidateArchiveSha256: bundle[0].sha256, packageBytes: npm[0].size, bundleBytes: bundle[0].size };
+}
+
+export function verifyCandidateRetrievalAssets({ retrieval, assets }) {
+  for (const [file, digest, bytes] of [[assets.packagePath, retrieval.artifactSha256, retrieval.packageBytes],
+    [assets.bundlePath, retrieval.candidateArchiveSha256, retrieval.bundleBytes]]) {
+    if (!Number.isSafeInteger(bytes) || bytes < 1 || fs.statSync(file).size !== bytes || sha256(file) !== digest) {
+      throw new Error(`candidate artifact does not match sealed retrieval input: ${file}`);
+    }
+  }
+  return true;
+}
 const locate = (name) => {
   try { return execFileSync('which', [name], { encoding: 'utf8' }).trim(); } catch { return null; }
 };
@@ -23,25 +63,32 @@ const run = (name, args, options) => {
 // tests/unit/staged-host-verifier.test.mjs pins it, but it is now an alias, not a second copy.
 export { classifyDoctor as classifyDoctorResult } from './host-install-matrix.mjs';
 
-const preparePackage = ({ packagePath, bundlePath }) => {
+const preparePackage = async ({ packagePath, bundlePath }) => {
   const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'ruvnet-staged-host-'));
-  run('tar', ['-xzf', packagePath, '-C', temp]);
-  const packageRoot = path.join(temp, 'package');
-  const bundleRoot = path.join(packageRoot, 'dist', 'ruvnet-brain');
-  fs.mkdirSync(bundleRoot, { recursive: true });
-  run('unzip', ['-q', bundlePath, '-d', bundleRoot]);
-  const nested = path.join(bundleRoot, 'ruvnet-brain');
-  if (fs.existsSync(nested)) {
-    for (const name of fs.readdirSync(nested)) fs.renameSync(path.join(nested, name), path.join(bundleRoot, name));
-    fs.rmdirSync(nested);
+  try {
+    const extraction = tarExtractionInvocation(packagePath, temp);
+    run('tar', extraction.args, { cwd: extraction.cwd });
+    const packageRoot = path.join(temp, 'package');
+    const bundleRoot = path.join(packageRoot, 'dist', 'ruvnet-brain');
+    fs.mkdirSync(bundleRoot, { recursive: true });
+    await extractZip(bundlePath, bundleRoot);
+    const nested = path.join(bundleRoot, 'ruvnet-brain');
+    if (fs.existsSync(nested)) {
+      for (const name of fs.readdirSync(nested)) fs.renameSync(path.join(nested, name), path.join(bundleRoot, name));
+      fs.rmdirSync(nested);
+    }
+    return { temp, packageRoot };
+  } catch (error) {
+    fs.rmSync(temp, { recursive: true, force: true });
+    throw error;
   }
-  return { temp, packageRoot };
 };
 
-export function stagedHostVerifier({ assets, identity }) {
+export function stagedHostVerifier({ assets, identity, retrieval }, { runMatrix = runHostMatrixAsync } = {}) {
   return {
     async verify({ source, assets: observedAssets = assets }) {
-      const prepared = preparePackage(observedAssets);
+      if (retrieval) verifyCandidateRetrievalAssets({ retrieval, assets: observedAssets });
+      const prepared = await preparePackage(observedAssets);
       try {
         // The loop, the mode names, the env and the doctor verdict all live in
         // scripts/host-install-matrix.mjs, shared with the published-side check in
@@ -50,13 +97,15 @@ export function stagedHostVerifier({ assets, identity }) {
         // install shape than the one that runs after publication — so the two halves of a release
         // were judging different things and could not be compared. Only the STAGED-vs-PUBLISHED
         // difference is real, and it is now a named variant rather than a second implementation.
-        const matrix = await runHostMatrixAsync({
+        const matrix = await runMatrix({
           packageRoot: prepared.packageRoot,
           version: identity.version,
           variant: 'staged',
           locate,
           temp: prepared.temp,
+          retrieval,
         });
+        if (retrieval) verifyCandidateRetrievalAssets({ retrieval, assets: observedAssets });
         if (matrix.verdict !== 'PASS') {
           return { verdict: 'FAIL', source, error: matrix.error, fixtures: matrix.fixtures };
         }

package/scripts/wired-check.mjs

@@ -69,6 +69,8 @@ const argv = process.argv.slice(2);
  * every entry on every run, below, so they cannot rot unseen.
  */
 const STANDALONE = [
+  ['gate', 'retired automatic-hook helper retained for explicit use and tests'],
+  ['version-bump-gate', 'retired automatic interceptor; explicit version checks own release validation'],
   ['lesson-seed', 'one-shot seeding, run deliberately by a human'],
   ['lesson-ratify', 'the human control surface — a CLI is its entire purpose'],
   ['stamp-sweep', 'ADR-056 §2 — the ONE-TIME backfill half of the stamp rule. A human runs it once '
@@ -95,6 +97,12 @@ const STANDALONE = [
     + 'RVFs to RVF-GENERATIONS.json and optionally prunes legacy sidecars; build-bundle.mjs consumes '
     + 'and validates the resulting manifest, so scheduling this destructive migration would be wrong'],
   ['release', 'the ship path, run by a human'],
+  ['corpus-seed-publish', 'privileged manual corpus publication wrapper; corpus-seed.yml explicitly '
+    + 'stops at sealed preparation with contents:read. This entry validates receipt/archive inputs '
+    + 'and delegates mutation to release.mjs protected authority. No operational caller is registered; '
+    + 'classification does not claim publication works or has occurred'],
+  ['gate', 'manual benchmark harness: rebuilds concepts and runs three routing proof batteries; '
+    + 'no workflow or scheduler invokes this expensive command'],
   ['execution-preflight', 'external orchestration boundary — invoked by the host before consequential Ruflo/Codex execution; no in-repo caller exists because the host supplies the live Brain and AgentDB receipts'],
   ['fix-workstream', 'session-supervised coordination CLI run explicitly by the integration owner or an '
     + 'isolated writing agent to start and hand off a fix lane. Scheduling it would violate its safety '
@@ -375,8 +383,11 @@ function callerFiles(repo = REPO) {
  */
 export function callerPattern(fileName) {
   const q = fileName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  // Filenames must be complete tokens: gates.mjs is not corpus-aggregates.mjs,
+  // and version.mjs.map is not a caller of version.mjs.
+  const bounded = `(?<![\\w.-])${q}(?![\\w.-])`;
     // eslint-disable-next-line no-useless-escape
-  return new RegExp(`["'\`][^"'\`\\n]*${q}|(?:node|bash|sh|exec|spawn\\w*)\\s+[^\\n]*${q}`);
+  return new RegExp(`["'\`][^"'\`\\n]*${bounded}|(?:node|bash|sh|exec|spawn\\w*)\\s+[^\\n]*${bounded}`);
 }
 
 /**
@@ -765,6 +776,16 @@ export function hookWiringAudit({
   homeSettingsFile = path.join(os.homedir(), '.claude', 'settings.json'),
   held = HOOK_HELD,
 } = {}) {
+  const retirementFiles = [
+    path.join(repo, 'plugin/hooks/hooks.json'),
+    path.join(repo, 'plugin/hooks/codex-hooks.json'),
+    path.join(repo, '.claude/settings.json'),
+    path.join(repo, '.codex/hooks.json'),
+  ];
+  const automaticHooksRetired = retirementFiles.every((file) => {
+    const doc = readJsonSafe(file);
+    return doc && doc.hooks && commandStrings(doc.hooks).length === 0;
+  });
   const table = hookShimTable(repo);
   const codexWrapper = installedCodexHookWrapper(repo);
   const reached = new Map(); // basename -> Set(reason)
@@ -818,6 +839,11 @@ export function hookWiringAudit({
     const isReached = reached.has(f);
     if (!declared && !isReached) continue; // not hook-intended at all — outside the census
     if (isReached) rows.push({ file: f, state: 'wired', sources: [...reached.get(f)] });
+    else if (automaticHooksRetired && declared) rows.push({
+      file: f,
+      state: 'retired',
+      why: 'automatic Brain hook registries are intentionally empty; body retained for audit or explicit-command reuse',
+    });
     else if (held[f]) rows.push({ file: f, state: 'held', why: held[f] });
     else rows.push({ file: f, state: 'unwired' });
   }
@@ -872,6 +898,7 @@ if (invokedDirectly) {
   const hookAudit = hookWiringAudit();
   const hookBy = (s) => hookAudit.rows.filter((r) => r.state === s);
   const hookUnwired = hookBy('unwired');
+  const hookRetired = hookBy('retired');
 
   const lessonAudit = lessonTriggerAudit();
 
@@ -915,7 +942,7 @@ if (invokedDirectly) {
     console.log(`\n  ── HOOK WIRING — plugin/scripts/*.sh|*.mjs vs plugin/hooks/{hooks,codex-hooks}.json, `
       + `.claude/settings.json, ~/.claude/settings.json ──\n`);
     console.log(`  ${hookAudit.rows.length} hook-intended script(s) in the census`);
-    console.log(`    ${hookBy('wired').length} wired · ${hookBy('held').length} held · `
+    console.log(`    ${hookBy('wired').length} wired · ${hookRetired.length} retired · ${hookBy('held').length} held · `
       + `${hookUnwired.length} UNWIRED\n`);
 
     for (const u of hookUnwired) {
@@ -928,6 +955,8 @@ if (invokedDirectly) {
 
     for (const h of hookBy('held')) console.log(`    ⏸ plugin/scripts/${h.file}\n       ${h.why}\n`);
 
+    for (const r of hookRetired) console.log(`    ○ plugin/scripts/${r.file}\n       ${r.why}\n`);
+
     for (const w of hookBy('wired')) {
       console.log(`    ✓ plugin/scripts/${w.file}\n       via ${w.sources.join('; ')}`);
     }