ruvnet-brain 4.3.28 → 4.3.30

package/scripts/release-convergence-watchdog.mjs

@@ -1,112 +0,0 @@
-#!/usr/bin/env node
-/**
- * RELEASE CONVERGENCE WATCHDOG — finishes issue #77 unattended, or does nothing at all.
- *
- * WHY THIS EXISTS. On 2026-08-06 the published surfaces named different generations (npm 4.0.12,
- * GitHub releases/latest v4.0.7). The cause was not drift: the release rail was dead three
- * independent ways, each fatal alone, and with the rail dead every release was made by hand — which
- * is how the surfaces came apart in the first place. All three are fixed. What remained was a
- * GitHub Actions MAJOR OUTAGE ("workflow runs are still failing or delayed in starting"), and the
- * publisher is an Actions workflow, so the last step could not run and the maintainer was leaving
- * for a month.
- *
- * WHAT IT WILL NOT DO. It does not publish. `scripts/self-update.mjs:56` refuses `--publish` and
- * `release-candidate-preflight.yml` owns the one-time long lanes and `protected-release.yml` is the
- * sole publication controller. This watchdog is report-only: it never dispatches either phase and
- * cannot manufacture typed candidate evidence.
- *
- * IT IS A NO-OP UNLESS EVERY PRECONDITION HOLDS. It runs from the nightly, unattended, for weeks.
- * A watchdog that acts on a partial picture is worse than no watchdog, so it refuses on anything
- * unexpected and says why. The default outcome is "nothing happened, here is the reason".
- *
- *   node scripts/release-convergence-watchdog.mjs           # report only, never acts
- *   node scripts/release-convergence-watchdog.mjs --dispatch # compatibility flag; still reports only
- */
-import { execFileSync } from 'node:child_process';
-import fs from 'node:fs';
-import path from 'node:path';
-import { latestCodeReleaseTag } from './release-channel-kind.mjs';
-
-const ROOT = path.dirname(path.dirname(new URL(import.meta.url).pathname));
-const DISPATCH = process.argv.includes('--dispatch');
-const REPO = 'stuinfla/ruvnet-brain';
-
-const log = (s) => process.stdout.write(`[release-watchdog] ${s}\n`);
-const sh = (cmd, args, opts = {}) =>
-  execFileSync(cmd, args, { cwd: ROOT, encoding: 'utf8', timeout: 120_000, ...opts }).trim();
-const tryShy = (fn, fallback = null) => { try { return fn(); } catch { return fallback; } };
-
-/** Refuse loudly and exit 0 — a watchdog that exits non-zero would page someone every night. */
-function stand_down(reason) {
-  log(`STAND DOWN: ${reason}`);
-  log('no action taken. This is the expected outcome on most nights.');
-  process.exit(0);
-}
-
-// ── 1. Is there anything to converge? ────────────────────────────────────────────────────────────
-const npmLatest = tryShy(() => sh('npm', ['view', 'ruvnet-brain', 'dist-tags.latest']));
-// ADR-086 S1: `gh release view` with no tag resolves `releases/latest`, which is a corpus
-// generation on any night a corpus round shipped. Comparing npm against a corpus digest would read
-// "never converged" forever and keep dispatching the publisher — a guard that silently disarms into
-// a loop is worse than one that breaks loudly.
-const ghLatest = tryShy(() => latestCodeReleaseTag(JSON.parse(sh('gh', ['api', `repos/${REPO}/releases?per_page=30`]))));
-if (!npmLatest || !ghLatest) stand_down(`could not read published surfaces (npm=${npmLatest} github=${ghLatest})`);
-
-const ghVersion = ghLatest.replace(/^v/, '');
-log(`npm dist-tags.latest = ${npmLatest} · GitHub latest code release = ${ghLatest}`);
-if (npmLatest === ghVersion) {
-  log(`CONVERGED — both surfaces name ${npmLatest}. Issue #77's invariant holds; nothing to do.`);
-  process.exit(0);
-}
-
-// ── 2. Can the publisher even run? ───────────────────────────────────────────────────────────────
-// The whole reason this script exists. Dispatching into a broken Actions plane burns a candidate and
-// leaves a confusing failed run behind for a maintainer who is not here to read it.
-const running = tryShy(() => sh('gh', ['run', 'list', '--repo', REPO, '--limit', '20', '--json', 'status',
-  '-q', '[.[]|select(.status=="in_progress")]|length']), '0');
-const queued = tryShy(() => sh('gh', ['run', 'list', '--repo', REPO, '--limit', '40', '--json', 'status',
-  '-q', '[.[]|select(.status=="queued")]|length']), '0');
-if (Number(running) === 0 && Number(queued) > 3) {
-  stand_down(`Actions appears stalled (${running} running, ${queued} queued) — likely still the outage. Will retry tomorrow.`);
-}
-
-// ── 3. Everything else must already be resolved. ─────────────────────────────────────────────────
-const openPrs = tryShy(() => sh('gh', ['pr', 'list', '--repo', REPO, '--state', 'open', '--json', 'number', '-q', 'length']), '?');
-if (openPrs !== '0') stand_down(`${openPrs} open PR(s) — merge them before cutting a release, so the release contains them`);
-
-const dirty = tryShy(() => sh('git', ['status', '--porcelain']), 'unknown');
-if (dirty === 'unknown' || dirty.split('\n').filter((l) => l && !l.startsWith('??')).length) {
-  stand_down('working tree is dirty — release candidates must come from a clean worktree');
-}
-
-sh('git', ['fetch', 'origin', '--quiet']);
-const head = sh('git', ['rev-parse', 'HEAD']);
-const originMain = sh('git', ['rev-parse', 'origin/main']);
-if (head !== originMain) stand_down(`local HEAD ${head.slice(0, 7)} != origin/main ${originMain.slice(0, 7)}`);
-
-// ── 4. The candidate must BE a release candidate. ────────────────────────────────────────────────
-const version = JSON.parse(fs.readFileSync(path.join(ROOT, 'plugin/.claude-plugin/plugin.json'), 'utf8')).version;
-if (/-dev$/.test(version)) {
-  // Deliberate: promoting -dev to clean means writing a release commit, and that is an authoring
-  // decision (which generation ships, with what narrative) — not something a nightly should invent.
-  stand_down(`main carries ${version}; a release needs a clean version in a release(<version>) commit. Authoring that is a human/session decision, not a watchdog's.`);
-}
-const subjects = sh('git', ['log', '-25', '--pretty=%s']).split('\n');
-if (!subjects.some((s) => /^release\s*\(/i.test(s) && s.includes(version))) {
-  stand_down(`clean version ${version} present but no release(${version}) commit in recent history`);
-}
-
-// ── 5. Exact-SHA evidence must exist and be green. ───────────────────────────────────────────────
-const runsFor = (wf) => JSON.parse(tryShy(() => sh('gh', ['run', 'list', '--repo', REPO, '--workflow', wf,
-  '--limit', '20', '--json', 'databaseId,status,conclusion,headSha']), '[]'));
-const greenAt = (wf) => runsFor(wf).find((r) => r.headSha === originMain && r.conclusion === 'success');
-
-const ci = greenAt('ci');
-if (!ci) stand_down(`no successful exact-SHA \`ci\` run at ${originMain.slice(0, 7)} yet`);
-
-log(`PRECONDITIONS VISIBLE — candidate=${originMain.slice(0, 7)} version=${version} ci=${ci.databaseId}`);
-// ── 6. Never dispatch a publisher from the watchdog. ───────────────────────────────────────────
-// Only protected-release may derive the complete typed evidence chain and cross Production.
-// This unattended observer cannot turn visible preconditions into release authority.
-log(`PRECONDITIONS ONLY — no candidate artifact inferred and no action taken for ${version} at ${originMain}`);
-log('Run release-candidate-preflight on release/** once; fast-forward that exact SHA to main; then protected-release imports release-candidate-<SHA> without a run ID.');

package/scripts/stamp-existing-rvf-generations.mjs

@@ -1,53 +0,0 @@
-#!/usr/bin/env node
-// Bind every existing canonical RVF to the current Brain release without re-embedding. Optional
-// legacy pruning is fail-closed: the canonical passages/meta and big RVF sidecars must exist first.
-
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { writeRvfGeneration } from './rvf-generation.mjs';
-
-const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const KB = path.join(ROOT, 'kb');
-const PRUNE = process.argv.includes('--prune-legacy');
-const stores = fs.readdirSync(KB)
-  .filter((file) => file.endsWith('.big.rvf'))
-  .map((file) => file.slice(0, -'.big.rvf'.length))
-  .sort();
-
-let pruned = 0;
-for (const store of stores) {
-  const embedFile = path.join(KB, `${store}.big.rvf.embed.json`);
-  const idmapFile = path.join(KB, `${store}.big.rvf.idmap.json`);
-  const passagesFile = path.join(KB, `${store}.passages.jsonl`);
-  const metaFile = path.join(KB, `${store}.meta.json`);
-  for (const required of [embedFile, idmapFile, passagesFile, metaFile]) {
-    if (!fs.existsSync(required)) throw new Error(`${store}: missing ${path.basename(required)}; refusing to stamp/prune`);
-  }
-  const embed = JSON.parse(fs.readFileSync(embedFile, 'utf8'));
-  const generation = writeRvfGeneration({
-    dir: KB,
-    store,
-    model: embed.model,
-    dimensions: embed.dimensions,
-    sourceCommit: null,
-  });
-  console.log(`[generation] ${store}: ${generation.sha256.slice(0, 16)}… ${generation.bytes} bytes`);
-
-  if (PRUNE) {
-    for (const legacy of [
-      `${store}.rvf`,
-      `${store}.rvf.idmap.json`,
-      `${store}.rvf.embed.json`,
-      `${store}.big.passages.jsonl`,
-      `${store}.big.meta.json`,
-    ]) {
-      const file = path.join(KB, legacy);
-      if (fs.existsSync(file)) {
-        fs.rmSync(file);
-        pruned++;
-      }
-    }
-  }
-}
-console.log(`[generation] stamped ${stores.length} canonical RVFs${PRUNE ? `; pruned ${pruned} legacy files` : ''}`);

package/scripts/verify-channels.mjs

@@ -1,196 +0,0 @@
-#!/usr/bin/env node
-// scripts/verify-channels.mjs — the release-channel protocol. WALK EVERY PATH A USER WALKS.
-//
-// WHY (2026-07-17, Stuart, after a real client hit a broken install): "whenever you push it, you are
-// verifying all the aspects — the explainer page, the GitHub repo, the npm, the npx — all are working
-// flawlessly. Having people find out the experience is lousy because you didn't track it is 100%
-// unacceptable." He is right. The root failure was assuming the repo state equals the user experience
-// (see AgentDB lesson: YOUR ASSUMPTIONS = FAILURE). CI green != it works; committed != shipped;
-// pushed != the npm package is current.
-//
-// This script asserts, against the LIVE endpoints (never the repo, never a guess), that every channel
-// is current AND reachable. Exit 0 = all channels good. Exit 1 = at least one is broken/stale — and
-// the word "shipped" MUST NOT be uttered until this passes.
-//
-// Usage:
-//   node scripts/verify-channels.mjs            # check all channels against the local plugin version
-//   node scripts/verify-channels.mjs --json     # machine-readable
-//
-// Checks (each hits the real thing):
-//   1. npm registry     — `ruvnet-brain` latest dist-tag == the shipping plugin version (not stale)
-//   2. self-update path — the bundle's canonicalManifestUrl actually resolves (no 404 — Jan's bug)
-//   3. release bundle   — releases/latest/download/ruvnet-brain.zip is downloadable (HTTP 200)
-//   4. release signature— the .sig asset exists next to the bundle (auto-apply needs it)
-//   5. explainer (live) — isovision.ai serves the current major.minor AND the update one-liner
-//   6. git remote       — local HEAD is pushed to origin/main (no unpushed shipped code)
-
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-import { fileURLToPath } from 'node:url';
-import { execFileSync } from 'node:child_process';
-import { describeLatestPointer, latestCodeReleaseTag } from './release-channel-kind.mjs';
-
-const ROOT = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
-const JSON_OUT = process.argv.includes('--json');
-const PRE_PUSH = process.argv.includes('--pre-push'); // git pre-push hook mode: block only on what is KNOWABLE before the push
-const REPO = 'stuinfla/ruvnet-brain';
-const NPM_PKG = 'ruvnet-brain';
-const EXPLAINER = 'https://isovision.ai/ruvnet-brain/';
-
-const c = { g: (s) => `\x1b[32m${s}\x1b[0m`, r: (s) => `\x1b[31m${s}\x1b[0m`, dim: (s) => `\x1b[2m${s}\x1b[0m`, b: (s) => `\x1b[1m${s}\x1b[0m` };
-const pluginVersion = () => JSON.parse(fs.readFileSync(path.join(ROOT, 'plugin/.claude-plugin/plugin.json'), 'utf8')).version;
-const mm = (v) => (String(v).match(/^(\d+\.\d+)/) || [, '?'])[1];
-
-async function head(url, timeout = 20000) {
-  const ctl = AbortSignal.timeout(timeout);
-  try { const r = await fetch(url, { method: 'GET', redirect: 'follow', signal: ctl, headers: { 'user-agent': 'ruvnet-brain-verify' } }); return { ok: r.ok, status: r.status, r }; }
-  catch (e) { return { ok: false, status: 0, error: e.message }; }
-}
-
-const results = [];
-const check = (name, pass, detail) => { results.push({ name, pass: !!pass, detail }); };
-
-async function run() {
-  const V = pluginVersion();
-
-  // ── PRE-PUSH MODE ──────────────────────────────────────────────────────────
-  // Runs from the git pre-push hook. It can ONLY block on things knowable BEFORE the push —
-  // i.e. what I am about to ship. npm-latest and the live explainer are DOWNSTREAM of a push
-  // (publish + Vercel deploy happen after), so blocking on them here would refuse every honest
-  // push. The two things that stranded Jan and are 100% knowable now: (a) the version surfaces
-  // disagree, (b) the self-update manifest in the SOURCE.json I'm shipping 404s. Block on those.
-  if (PRE_PUSH) {
-    // a) version single-source-of-truth
-    const sv = execFileSync(process.execPath, [path.join(ROOT, 'scripts/sync-version.mjs'), '--check'], { cwd: ROOT, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
-    check('version surfaces agree', /agree|✓/i.test(sv), sv.trim().split('\n').pop());
-    // b) the self-update manifest URL in the bundle SOURCE.json resolves (the exact 404 that broke --update)
-    let manifestUrl = null;
-    try { const sj = JSON.parse(fs.readFileSync(path.join(ROOT, 'kb/SOURCE.json'), 'utf8'));
-      const find = (o) => { if (!o || typeof o !== 'object') return null; if (o.canonicalManifestUrl) return o.canonicalManifestUrl; for (const k of Object.keys(o)) { const r = find(o[k]); if (r) return r; } return null; };
-      manifestUrl = find(sj); } catch { /* */ }
-    if (!manifestUrl) check('self-update manifest URL present', false, 'no canonicalManifestUrl in kb/SOURCE.json');
-    else { const h = await head(manifestUrl); check('self-update manifest resolves (no 404)', h.ok, `${manifestUrl} → HTTP ${h.status}${h.ok ? '' : '  ← would strand every --update user, exactly like Jan'}`); }
-
-    const failed = results.filter((r) => !r.pass);
-    console.log(`\n  ${c.b('pre-push gate')} ${c.dim('· shipping ' + V + ' · (npm/explainer are verified post-publish by `release.mjs --publish`)')}`);
-    for (const r of results) console.log(`   ${r.pass ? c.g('✓') : c.r('✗')} ${r.name}  ${c.dim(r.detail || '')}`);
-    if (failed.length) { console.log(`\n  ${c.r('✗ pre-push gate FAILED — push refused. Fix the above; do not --no-verify around it.')}\n`); process.exit(1); }
-    console.log(`\n  ${c.g('✓ version/channel checks passed — document currency runs next.')}\n`);
-    process.exit(0);
-  }
-
-  // 1) npm registry latest == shipping version. npm's read replicas lag a few seconds behind a fresh
-  // publish, so a single immediate `npm view` right after `release.mjs` publishes can still return the
-  // PRIOR version — a false STALE that fails an otherwise-perfect ship (hit exactly this 2026-07-18:
-  // publish succeeded, `+ ruvnet-brain@3.4.9-dev`, yet the immediate view read 3.4.8-dev). Retry with a
-  // short backoff so propagation lag is absorbed, while a publish that genuinely never landed still
-  // fails after the window. A gate that false-fails teaches you to distrust the gate — the worst outcome.
-  {
-    let latest = '', ok = false, lastErr = '';
-    const ATTEMPTS = 6; // up to ~6×5s = 30s of propagation tolerance
-    for (let i = 0; i < ATTEMPTS; i++) {
-      try {
-        latest = execFileSync('npm', ['view', NPM_PKG, 'dist-tags.latest'], { encoding: 'utf8', timeout: 30000 }).trim();
-        if (latest === V) { ok = true; break; }
-      } catch (e) { lastErr = e.message.split('\n')[0]; }
-      if (i < ATTEMPTS - 1) await new Promise((r) => setTimeout(r, 5000));
-    }
-    check('npm latest matches shipping version', ok,
-      ok ? `npm latest=${latest} · shipping=${V}`
-        : `npm latest=${latest || '(view failed: ' + lastErr + ')'} · shipping=${V}${latest && latest !== V ? '  ← STILL STALE after ~' + (ATTEMPTS * 5) + 's: dispatch the protected-release workflow for the exact candidate SHA' : ''}`);
-  }
-
-  // 2) the self-update manifest URL actually resolves (the 404 that stranded users)
-  let manifestUrl = null;
-  try {
-    const sj = JSON.parse(fs.readFileSync(path.join(ROOT, 'kb/SOURCE.json'), 'utf8'));
-    const find = (o) => { if (!o || typeof o !== 'object') return null; if (o.canonicalManifestUrl) return o.canonicalManifestUrl; for (const k of Object.keys(o)) { const r = find(o[k]); if (r) return r; } return null; };
-    manifestUrl = find(sj);
-  } catch { /* */ }
-  if (!manifestUrl) check('self-update manifest URL present', false, 'no canonicalManifestUrl in kb/SOURCE.json');
-  else { const h = await head(manifestUrl); check('self-update manifest resolves (no 404)', h.ok, `${manifestUrl} → HTTP ${h.status}${h.ok ? '' : '  ← the exact 404 that broke --update'}`); }
-
-  // 3) release bundle downloadable
-  const bundleUrl = `https://github.com/${REPO}/releases/latest/download/ruvnet-brain.zip`;
-  { const h = await head(bundleUrl); check('release bundle downloads', h.ok, `releases/latest/…/ruvnet-brain.zip → HTTP ${h.status}`); }
-
-  // 3b) …AND IT IS THE VERSION WE ARE SHIPPING. Reachability is not currency.
-  //
-  // MEASURED 2026-07-24, and this gate reported SHIPPED while it was false. npm was moved to
-  // 3.9.50-dev by `release.mjs --publish`; the GitHub Release stayed at v3.9.18-dev from 2026-07-23,
-  // THIRTY-TWO versions behind. Every check above passed — the manifest resolved, the bundle
-  // downloaded, the signature was present — because they all ask "does the latest release respond?"
-  // and none asked "is the latest release the one we just built?" A 32-version-old bundle answers
-  // HTTP 200 perfectly well.
-  //
-  // WHY THE GAP EXISTED AT ALL: the ship path is SPLIT and nothing said so. `release.mjs --publish`
-  // publishes to npm and contains zero `gh release` calls; GitHub Releases are cut only by
-  // `self-update.mjs`, which runs from the NIGHTLY. The nightly had been aborting since 2026-07-23 on
-  // its (correct) main-only branch guard, so releases silently froze while npm advanced. Two channels,
-  // two owners, one of them broken, and a verifier that could not tell.
-  //
-  // This is the same defect shape this repo has now fixed four times in one day: a proxy measured in
-  // place of the thing (receipt-count for "is routing running", backlog-remaining for "is promotion in
-  // force", cache-exists for "is this measurement current"). Reachability is the proxy; version is the
-  // thing. Users updating via the release bundle get whatever THIS says, not whatever npm says.
-  // ADR-086 S1: `releases/latest` is the CUSTOMER download pointer and may legitimately be a corpus
-  // generation (`corpus-sha256-<digest>`), which can never equal a semver. Asking that pointer "are
-  // you the shipping version?" therefore stopped being the right question the moment corpus
-  // promotion existed — and because release.mjs runs this script as `runOrDie` in step E, the wrong
-  // question would have failed the OWNER'S OWN preflight every time a corpus night succeeded. The
-  // code generation is a separate fact, so it gets asked separately.
-  {
-    let releases = null, tag = null, latestPointer = null, err = null;
-    try {
-      const r = await fetch(`https://api.github.com/repos/${REPO}/releases?per_page=30`, {
-        headers: { 'User-Agent': 'ruvnet-brain-verify-channels' },
-      });
-      if (r.ok) {
-        releases = await r.json();
-        tag = latestCodeReleaseTag(releases);
-        latestPointer = (Array.isArray(releases) ? releases.find((row) => row && !row.draft) : null)?.tag_name || null;
-      } else err = `HTTP ${r.status}`;
-    } catch (e) { err = String(e && e.message || e); }
-    // Tags carry a leading `v`; the version does not. Compare the bare versions.
-    const bare = (s) => String(s || '').replace(/^v/, '');
-    const pointerNote = latestPointer ? ` · ${describeLatestPointer(latestPointer)}` : '';
-    check('GitHub Release IS the shipping version', tag != null && bare(tag) === bare(V),
-      tag == null
-        ? `could not read the latest code release (${err || 'no semver-tagged release found'}) — release currency NOT verified`
-        : `code release=${tag} · shipping=${V}${pointerNote}${bare(tag) === bare(V) ? '' : '  ← STALE: the release channel is behind npm. Cut the release, or users on --update stay on ' + tag}`);
-  }
-
-  // 4) release signature present (auto-apply verifies against it)
-  { const h = await head(`${bundleUrl}.sig`); check('release signature present', h.ok, `ruvnet-brain.zip.sig → HTTP ${h.status}`); }
-
-  // 5) explainer live shows current major.minor AND the update command
-  { const h = await head(EXPLAINER);
-    if (!h.ok) check('explainer live + current', false, `${EXPLAINER} → HTTP ${h.status}`);
-    else { const html = await h.r.text().catch(() => '');
-      const bare = html.replace(/<[^>]+>/g, '').replace(/&(?:rsquo|apos|#8217|#39);/gi, "'");
-      const newIn = [...bare.matchAll(/what[’']?s new in (\d+\.\d+)/gi)].map((m) => m[1]);
-      const stale = newIn.filter((x) => x !== mm(V));
-      const hasCmd = /ruvnet-brain@latest --update --auto/.test(bare);
-      check('explainer live shows current version', stale.length === 0, stale.length ? `live still says "What's new in ${stale.join(', ')}" while ${mm(V)} ships` : `"What's new in ${mm(V)}" ✓`);
-      check('explainer live shows the update command', hasCmd, hasCmd ? 'update one-liner present' : 'the --update --auto command is MISSING from the live page');
-    }
-  }
-
-  // 6) local HEAD pushed to origin/main (no unpushed shipped code)
-  try {
-    const local = execFileSync('git', ['-C', ROOT, 'rev-parse', 'HEAD'], { encoding: 'utf8' }).trim();
-    const remote = execFileSync('git', ['-C', ROOT, 'ls-remote', 'origin', 'main'], { encoding: 'utf8' }).trim().split(/\s+/)[0];
-    check('local HEAD pushed to origin/main', local === remote, local === remote ? 'in sync' : `local ${local.slice(0, 7)} != origin ${(remote || '').slice(0, 7)} — unpushed commits`);
-  } catch (e) { check('local HEAD pushed to origin/main', false, `git check failed: ${e.message.split('\n')[0]}`); }
-
-  const failed = results.filter((r) => !r.pass);
-  if (JSON_OUT) { console.log(JSON.stringify({ version: V, ok: failed.length === 0, results }, null, 2)); process.exit(failed.length ? 1 : 0); }
-
-  console.log(`\n  ${c.b('RuvNet Brain — channel verification')} ${c.dim('· shipping ' + V)}\n`);
-  for (const r of results) console.log(`   ${r.pass ? c.g('✓') : c.r('✗')} ${r.name}\n      ${c.dim(r.detail || '')}`);
-  if (failed.length) { console.log(`\n  ${c.r('✗ ' + failed.length + ' channel(s) BROKEN or STALE — this is NOT shipped. Fix, then re-run.')}\n`); process.exit(1); }
-  console.log(`\n  ${c.g('✓ every channel is current and reachable — a user on any path gets the working, current build.')}\n`);
-  process.exit(0);
-}
-run();