ruvnet-brain 4.3.35 → 4.3.36

package/scripts/corpus-store-failure.mjs

@@ -0,0 +1,82 @@
+// ADR-0091 D5 — per-store failure isolation for corpus reconciliation.
+//
+// One store failing to refresh must not abort the whole generation. This module owns the three
+// pure decisions that make that safe, so the reconciler, the rehearsal and the tests share them:
+//
+//   1. WHICH failures are retried. Only transient ones (clone, fetch, runner I/O), exactly once, in a
+//      fresh worker directory. A corpus-qa failure is never retried: the round-trip sample is
+//      deterministic (FNV-1a, corpus-qa.mjs), so a retry re-embeds the whole store to reproduce it.
+//      The class comes from WHERE the worker failed and from forge-refresh's exit status, never
+//      from log text.
+//   2. HOW MANY stores may be carried or missing before the failure is systemic and the generation
+//      must fail loudly: carried + missing <= max(3, 5% of eligible).
+//   3. WHETHER a degraded generation may be published at all. Installed clients judge every bundle
+//      with their INSTALLED validator, and every validator shipped before this change rejects any
+//      non-CURRENT eligible row. ADR-0091 D10 therefore gates degraded publication behind a
+//      transition release plus a 14-day soak; until D10 records that transition, a degraded
+//      generation is built and sealed but never published.
+
+/** kb/forge-refresh.mjs exits with this status when corpus-qa rejected its candidate. */
+export const CORPUS_QA_FAILED_EXIT = 3;
+
+export const FAILURE_CLASS = Object.freeze({
+  TRANSIENT: 'transient',
+  QA: 'qa',
+  BUILD: 'build',
+  INTEGRITY: 'integrity',
+});
+
+/** A worker failure carrying its structured class. `detail` is for logs only, never for shipped rows. */
+export class StoreWorkerError extends Error {
+  constructor({ store, stage, failureClass, detail = '' }) {
+    super(`[corpus-reconcile] ${store}: ${stage} failed (${failureClass})${detail ? ` (${detail})` : ''}`);
+    this.name = 'StoreWorkerError';
+    this.store = store;
+    this.stage = stage;
+    this.failureClass = failureClass;
+  }
+}
+
+export function isRetryable(error) {
+  return error instanceof StoreWorkerError && error.failureClass === FAILURE_CLASS.TRANSIENT;
+}
+
+/**
+ * The shipped, machine-readable reason. Stage and class only: stderr can quote runner paths, and a
+ * coverage row travels to every user.
+ */
+export function failureReason(error) {
+  if (error instanceof StoreWorkerError) return `${error.failureClass}: ${error.stage} failed`;
+  return `${FAILURE_CLASS.INTEGRITY}: worker failed`;
+}
+
+/** Fixed rule: the failure is systemic above max(3, 5% of eligible). */
+export function degradedBound(eligibleCount) {
+  if (!Number.isSafeInteger(eligibleCount) || eligibleCount < 0) throw new Error('eligible count must be a non-negative integer');
+  return Math.max(3, Math.floor(eligibleCount * 0.05));
+}
+
+/**
+ * ADR-0091 D10 owns this value. It stays null until the transition release N (the first release
+ * shipping the tolerant validator while its own coverage is all-CURRENT) has become releases/latest;
+ * D10 then records { version, latestSince } here. Null means no transition: never publish degraded.
+ */
+export const VALIDATOR_TRANSITION = null;
+export const TRANSITION_SOAK_DAYS = 14;
+
+export function degradedPublication({ transition = VALIDATOR_TRANSITION, now = new Date() } = {}) {
+  if (!transition) {
+    return { allowed: false,
+      reason: 'no tolerant-validator transition release is recorded (ADR-0091 D10); installed clients would reject a non-CURRENT row' };
+  }
+  const since = Date.parse(transition.latestSince);
+  if (typeof transition.version !== 'string' || !transition.version || !Number.isFinite(since)) {
+    return { allowed: false, reason: 'the recorded validator transition is malformed' };
+  }
+  const soakEnds = since + TRANSITION_SOAK_DAYS * 24 * 60 * 60 * 1000;
+  if (now.getTime() < soakEnds) {
+    return { allowed: false,
+      reason: `validator transition ${transition.version} soaks until ${new Date(soakEnds).toISOString()} (ADR-0091 D10)` };
+  }
+  return { allowed: true, reason: `validator transition ${transition.version} has soaked ${TRANSITION_SOAK_DAYS} days` };
+}

package/scripts/corpus-watchdog.mjs

@@ -0,0 +1,334 @@
+#!/usr/bin/env node
+// scripts/corpus-watchdog.mjs — is the customer corpus ACTUALLY being refreshed every night?
+//
+// THE FAILURE THIS EXISTS TO END (2026-09-28/29, measured on live run history). The nightly
+// dispatcher `corpus-nightly-dispatch.yml` stood down in ~13 seconds and finished GREEN, night after
+// night, because repository variable CORPUS_NIGHTLY was unset. A green run is not a refreshed corpus:
+// nothing was dispatched, nothing was published, and ntfy-alerts only pages on red. Before that, nine
+// corpus-mode protected-release failures in a row never paged at all (a GITHUB_TOKEN dispatch cannot
+// fire workflow_run). Silence was read as health — the exact failure config/scheduled-jobs.json names:
+// ABSENCE OF EVIDENCE IS FAILURE.
+//
+// So this watchdog does not ask "did a workflow go green?". It asks for EVIDENCE OF AN OUTCOME:
+//   RED      (a) no night ended `published` or `no-change` in the last 48h (catches silent stand-downs)
+//            (b) the newest corpus run of the last 24h failed (or was cancelled / timed out)
+//            (c) the newest vX.Y.Z code release has no VERIFIED public-verification aggregate 24h after
+//                publish, or carries one that does not verify (the nightly cannot arm without it)
+//            (d) any store has been deferred (carried STALE or MISSING) for more than 7 days
+//   WARNING  a superseded or degraded night, a stand-down tonight, an unknown outcome, a long run
+//   GREEN    none of the above
+//
+// Exit code is the contract (same as scripts/github-health-watch.mjs): 0 = GREEN or WARNING,
+// 1 = RED or the evidence could not be gathered. corpus-watchdog.yml runs on a genuine `schedule:`,
+// so its red conclusion fires ntfy-alerts.yml's workflow_run listener — no secret needed here.
+//
+// READ-ONLY. Every gh call below is a list/view/download. It never dispatches, edits, or publishes.
+// Every `--json` field used is one gh 2.101.0 lists for that subcommand (the redesign that created
+// this file exists because release.mjs asked `gh release view` for `isLatest`, which only
+// `gh release list` has); tests/unit/corpus-watchdog.test.mjs pins the lists.
+//
+//   node scripts/corpus-watchdog.mjs [--repo owner/name] [--json] [--now ISO]
+
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { CODE_TAG_PATTERN, isCorpusReleaseTag } from './release-channel-kind.mjs';
+import { AGGREGATE_ASSET, SIGNING_PUBLIC_KEY_FILE } from './approved-runtime.mjs';
+import { COVERAGE_ASSET, COVERAGE_RECEIPT_ASSET, verifyCoverageSidecar } from './corpus-coverage-sidecar.mjs';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+export const RED = 'RED';
+export const WARNING = 'WARNING';
+export const GREEN = 'GREEN';
+export const INFO = 'INFO';
+const HOUR = 3_600_000;
+export const FRESHNESS_WINDOW_MS = 48 * HOUR;
+export const TONIGHT_WINDOW_MS = 24 * HOUR;
+export const AGGREGATE_GRACE_MS = 24 * HOUR;
+export const DEFERRAL_LIMIT_MS = 7 * 24 * HOUR;
+export const LONG_RUN_MS = 8 * HOUR;
+/** protected-release.yml's run-name for a corpus run: `protected-release corpus <dispatch id>`. */
+export const CORPUS_RUN_TITLE = /^protected-release corpus (\S+)$/;
+/** The dispatch id corpus-nightly-dispatch.yml passes: `corpus-<its run id>-<its attempt>`. */
+const DISPATCH_ID = /^corpus-(\d+)-(\d+)$/;
+/** Terminal outcomes a corpus-release-outcome.json may declare in an `outcome` field (design D2). */
+const DECLARED_OUTCOMES = new Set(['published', 'no-change', 'superseded', 'degraded', 'failed']);
+const GOOD_NIGHT = new Set(['published', 'no-change']);
+
+const ms = (iso) => {
+  const t = Date.parse(String(iso ?? ''));
+  return Number.isFinite(t) ? t : null;
+};
+const hours = (delta) => `${(delta / HOUR).toFixed(1)}h`;
+
+/**
+ * What ONE protected-release corpus run proved. Preference order: an explicit `outcome` in the run's
+ * corpus-release-outcome.json, then that record's per-job results, then the run's own job list.
+ * A non-success run conclusion is `failed` unless the record says otherwise (a typed superseded exit
+ * is a warning, not red). A success that shows neither a publish nor a no-change round is `unknown`
+ * — never counted as a good night.
+ */
+export function classifyCorpusRun(run) {
+  if (run?.status !== 'completed') return 'in-progress';
+  const declared = String(run.outcomeRecord?.outcome ?? '').replace('no_change', 'no-change');
+  if (DECLARED_OUTCOMES.has(declared)) return declared;
+  if (run.conclusion !== 'success') return 'failed';
+  const recorded = run.outcomeRecord?.jobs;
+  const byName = new Map((run.jobs || []).map((job) => [job.name, job.conclusion]));
+  const noChange = recorded?.no_change ?? byName.get('corpus-no-change-round');
+  const publish = recorded?.publish ?? byName.get('protected-corpus-publisher');
+  if (noChange === 'success') return 'no-change';
+  if (publish === 'success') return 'published';
+  return 'unknown';
+}
+
+/**
+ * How long each store in the NEWEST generation has been deferred: walk generations newest-first while
+ * the store stays carried/missing; it has been deferred since the oldest generation in that unbroken
+ * run. A generation whose coverage is unknown (published before the D6.2 sidecar, or not fetched)
+ * ends the walk with `lowerBound: true` — the true deferral is at least that long.
+ * `generations`: [{ tag, publishedAt, degraded: { carried, missing } | null }], newest first.
+ */
+export function deferralSince(generations) {
+  const [newest, ...older] = generations || [];
+  if (!newest?.degraded) return [];
+  const stores = [...new Set([...(newest.degraded.carried || []), ...(newest.degraded.missing || [])])].sort();
+  return stores.map((store) => {
+    let since = newest.publishedAt;
+    let lowerBound = true; // until a generation proves the store was NOT deferred, history ran out first
+    for (const generation of older) {
+      if (!generation.degraded) break;
+      if (![...(generation.degraded.carried || []), ...(generation.degraded.missing || [])].includes(store)) { lowerBound = false; break; }
+      since = generation.publishedAt;
+    }
+    return { store, since, lowerBound };
+  });
+}
+
+/**
+ * The pure verdict. `input`:
+ *   corpusReleases  [{ tag, publishedAt }]                           non-draft corpus-sha256-* releases
+ *   corpusRuns      [{ id, title, status, conclusion, createdAt, updatedAt, outcome }]  protected-release corpus runs
+ *   dispatcherRuns  [{ id, attempt, status, conclusion, createdAt }]  corpus-nightly-dispatch runs
+ *   codeRelease     { tag, publishedAt, aggregate: { state: verified|missing|invalid, reason } } | null
+ *   deferral        { observable, reason, newestTag, degraded: {carried, missing}, stores: [{store, since, lowerBound}] }
+ */
+export function judgeCorpusHealth(input, now) {
+  const at = now instanceof Date ? now.getTime() : Number(now);
+  if (!Number.isFinite(at)) throw new Error('judgeCorpusHealth needs a valid `now`');
+  const findings = [];
+  const add = (level, check, detail) => findings.push({ level, check, detail });
+  const age = (iso) => { const t = ms(iso); return t === null || t > at ? null : at - t; };
+  const runs = (input?.corpusRuns || []).map((run) => ({ ...run, outcome: run.outcome ?? classifyCorpusRun(run) }));
+  const dispatchers = input?.dispatcherRuns || [];
+
+  // Dispatcher runs that finished without creating a corpus run: stand-downs (the silent failure).
+  const dispatchedIds = new Set(runs.map((run) => CORPUS_RUN_TITLE.exec(String(run.title || ''))?.[1]).filter(Boolean));
+  const standDowns = dispatchers.filter((d) => d.status === 'completed' && d.conclusion === 'success'
+    && !dispatchedIds.has(`corpus-${d.id}-${d.attempt ?? 1}`));
+
+  // (a) a good night inside the freshness window. Inclusive: exactly 48h old still counts.
+  const evidence = [
+    ...(input?.corpusReleases || []).map((release) => ({ kind: 'published', at: release.publishedAt, ref: release.tag })),
+    ...runs.filter((run) => GOOD_NIGHT.has(run.outcome)).map((run) => ({ kind: run.outcome, at: run.updatedAt, ref: `run ${run.id}` })),
+  ].filter((item) => age(item.at) !== null).sort((a, b) => ms(b.at) - ms(a.at));
+  const lastGoodNight = evidence[0] || null;
+  if (!lastGoodNight || age(lastGoodNight.at) > FRESHNESS_WINDOW_MS) {
+    const recentStandDowns = standDowns.filter((d) => (age(d.createdAt) ?? Infinity) <= FRESHNESS_WINDOW_MS).length;
+    add(RED, 'freshness', `no night ended published or no-change in the last 48h `
+      + `(last: ${lastGoodNight ? `${lastGoodNight.kind} ${lastGoodNight.ref} ${hours(age(lastGoodNight.at))} ago` : 'never observed'}; `
+      + `${recentStandDowns} dispatcher stand-down(s) in the window — a green dispatcher that dispatched nothing is not a refreshed corpus)`);
+  } else {
+    add(GREEN, 'freshness', `${lastGoodNight.kind} ${lastGoodNight.ref} ${hours(age(lastGoodNight.at))} ago`);
+  }
+
+  // (b) tonight: the newest corpus run created in the last 24h.
+  const tonight = runs.filter((run) => (age(run.createdAt) ?? Infinity) <= TONIGHT_WINDOW_MS)
+    .sort((a, b) => ms(b.createdAt) - ms(a.createdAt))[0];
+  const lastDispatcher = dispatchers.filter((d) => (age(d.createdAt) ?? Infinity) <= TONIGHT_WINDOW_MS)
+    .sort((a, b) => ms(b.createdAt) - ms(a.createdAt))[0];
+  if (tonight) {
+    const ref = `corpus run ${tonight.id} (${tonight.title})`;
+    if (tonight.outcome === 'failed') add(RED, 'tonight', `${ref} failed (conclusion ${tonight.conclusion})`);
+    else if (tonight.outcome === 'superseded') add(WARNING, 'tonight', `${ref} was superseded by a newer code release before publish`);
+    else if (tonight.outcome === 'degraded') add(WARNING, 'tonight', `${ref} published a degraded generation`);
+    else if (tonight.outcome === 'unknown') add(WARNING, 'tonight', `${ref} succeeded but shows neither a publish nor a no-change round`);
+    else if (tonight.outcome === 'in-progress') {
+      add((age(tonight.createdAt) ?? 0) > LONG_RUN_MS ? WARNING : INFO, 'tonight', `${ref} still running after ${hours(age(tonight.createdAt) ?? 0)}`);
+    } else add(GREEN, 'tonight', `${ref} ended ${tonight.outcome}`);
+  } else if (!lastDispatcher) {
+    add(WARNING, 'tonight', 'no corpus-nightly-dispatch run in the last 24h (schedule dropped or disabled?)');
+  } else if (lastDispatcher.status === 'completed' && lastDispatcher.conclusion !== 'success') {
+    add(RED, 'tonight', `corpus-nightly-dispatch run ${lastDispatcher.id} concluded ${lastDispatcher.conclusion}`);
+  } else if (standDowns.includes(lastDispatcher)) {
+    add(WARNING, 'tonight', `corpus-nightly-dispatch run ${lastDispatcher.id} stood down: nothing was dispatched `
+      + '(CORPUS_NIGHTLY off, or no install-verified runtime yet)');
+  } else {
+    add(GREEN, 'tonight', `corpus-nightly-dispatch run ${lastDispatcher.id} is ${lastDispatcher.status}`);
+  }
+
+  // (c) the newest code release must reach a verified aggregate within 24h of publish.
+  const code = input?.codeRelease;
+  if (!code) add(RED, 'code-aggregate', 'no published vX.Y.Z code release was found');
+  else if (code.aggregate?.state === 'verified') add(GREEN, 'code-aggregate', `${code.tag} carries a verified PASS aggregate`);
+  else if (code.aggregate?.state === 'invalid') add(RED, 'code-aggregate', `${code.tag} carries an aggregate that does not verify `
+    + `under this checkout's verifier (the one approved-runtime --resolve runs, so the nightly will refuse it too): ${code.aggregate.reason}`);
+  else {
+    const since = age(code.publishedAt);
+    if (since === null || since >= AGGREGATE_GRACE_MS) {
+      add(RED, 'code-aggregate', `${code.tag} was published ${since === null ? 'at an unknown time' : `${hours(since)} ago`} `
+        + 'and still has no public-verification aggregate — the nightly cannot arm');
+    } else add(INFO, 'code-aggregate', `${code.tag} is ${hours(since)} old; aggregate pending (grace 24h)`);
+  }
+
+  // (d) deferred stores. Only observable from a generation that carries the D6.2 coverage sidecar.
+  const deferral = input?.deferral;
+  if (!deferral?.observable) {
+    add(INFO, 'deferral', `not observable: ${deferral?.reason || 'no coverage evidence gathered'}`);
+  } else {
+    const overdue = (deferral.stores || []).filter((row) => (age(row.since) ?? 0) > DEFERRAL_LIMIT_MS);
+    if (overdue.length) {
+      add(RED, 'deferral', `${overdue.length} store(s) deferred more than 7 days: ${overdue.slice(0, 10)
+        .map((row) => `${row.store} (${row.lowerBound ? '≥' : ''}${hours(age(row.since))})`).join(', ')}`);
+    } else add(GREEN, 'deferral', `${(deferral.stores || []).length} deferred store(s), none older than 7 days`);
+    const degraded = [...(deferral.degraded?.carried || []), ...(deferral.degraded?.missing || [])];
+    if (degraded.length) add(WARNING, 'degraded', `${deferral.newestTag} is degraded: ${deferral.degraded.carried.length} carried, ${deferral.degraded.missing.length} missing`);
+  }
+
+  const verdict = findings.some((f) => f.level === RED) ? RED : findings.some((f) => f.level === WARNING) ? WARNING : GREEN;
+  return { verdict, findings, lastGoodNight };
+}
+
+// ── Gathering (read-only gh). Everything above is pure; everything below talks to GitHub. ──────────
+
+function defaultGh(args) {
+  const result = spawnSync(process.env.RUVNET_GH_COMMAND || 'gh', args, { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024, timeout: 5 * 60_000 });
+  if (result.error || result.status !== 0) {
+    throw new Error(`gh ${args.slice(0, 3).join(' ')} failed: ${String(result.error?.message || result.stderr || `exit ${result.status}`).trim().slice(0, 300)}`);
+  }
+  return result.stdout;
+}
+
+const semver = (tag) => CODE_TAG_PATTERN.test(tag) ? tag.slice(1).split('.').map(Number) : null;
+/** Same selection as scripts/approved-runtime.mjs --resolve: newest by semver, no drafts, no prereleases. */
+function newestCodeRelease(rows) {
+  return rows.filter((row) => !row.isDraft && !row.isPrerelease && semver(row.tagName))
+    .sort((a, b) => { const x = semver(a.tagName); const y = semver(b.tagName); return y[0] - x[0] || y[1] - x[1] || y[2] - x[2]; })[0] || null;
+}
+
+function assetNames(gh, repo, tag) {
+  return new Set((JSON.parse(gh(['release', 'view', tag, '--repo', repo, '--json', 'assets'])).assets || []).map((asset) => asset.name));
+}
+function download(gh, repo, tag, name, dir) {
+  gh(['release', 'download', tag, '--repo', repo, '--pattern', name, '--dir', dir, '--clobber']);
+  return fs.readFileSync(path.join(dir, name));
+}
+
+async function aggregateState({ gh, repo, tag, root, scratch }) {
+  if (!assetNames(gh, repo, tag).has(AGGREGATE_ASSET)) return { state: 'missing' };
+  try {
+    const aggregate = JSON.parse(download(gh, repo, tag, AGGREGATE_ASSET, scratch).toString('utf8'));
+    const { verifyPublicVerificationAggregate } = await import('./public-verification-aggregate.mjs');
+    verifyPublicVerificationAggregate(aggregate, crypto.createPublicKey(fs.readFileSync(path.join(root, SIGNING_PUBLIC_KEY_FILE), 'utf8')));
+    if (aggregate.identity?.tag !== tag) throw new Error(`aggregate describes ${aggregate.identity?.tag}, not ${tag}`);
+    return { state: 'verified' };
+  } catch (error) {
+    return { state: 'invalid', reason: error.message.slice(0, 200) };
+  }
+}
+
+function generationCoverage({ gh, repo, tag, scratch }) {
+  const names = assetNames(gh, repo, tag);
+  if (!names.has(COVERAGE_ASSET) || !names.has(COVERAGE_RECEIPT_ASSET)) return null;
+  const dir = fs.mkdtempSync(path.join(scratch, 'coverage-'));
+  const { degraded } = verifyCoverageSidecar({
+    sidecar: JSON.parse(download(gh, repo, tag, COVERAGE_RECEIPT_ASSET, dir).toString('utf8')),
+    coverageBytes: download(gh, repo, tag, COVERAGE_ASSET, dir),
+    generationTag: tag,
+    archiveSha256: tag.slice('corpus-sha256-'.length),
+  });
+  return degraded;
+}
+
+function corpusRunEvidence({ gh, repo, run, scratch }) {
+  if (run.status !== 'completed') return {};
+  const dir = fs.mkdtempSync(path.join(scratch, 'outcome-'));
+  try {
+    gh(['run', 'download', String(run.databaseId), '--repo', repo, '--name', `corpus-release-outcome-${run.databaseId}-${run.attempt ?? 1}`, '--dir', dir]);
+    return { outcomeRecord: JSON.parse(fs.readFileSync(path.join(dir, 'corpus-release-outcome.json'), 'utf8')) };
+  } catch {
+    // Runs that never reached corpus-terminal-outcome have no record; their job list still says what happened.
+    return { jobs: JSON.parse(gh(['run', 'view', String(run.databaseId), '--repo', repo, '--json', 'jobs'])).jobs || [] };
+  }
+}
+
+export async function gatherCorpusHealthInput({ repo, now, gh = defaultGh, root = ROOT, scratch = fs.mkdtempSync(path.join(os.tmpdir(), 'corpus-watchdog-')) }) {
+  const at = now.getTime();
+  const recent = (iso) => (ms(iso) ?? 0) >= at - 3 * 24 * HOUR;
+  const dispatcherRuns = JSON.parse(gh(['run', 'list', '--repo', repo, '--workflow', 'corpus-nightly-dispatch.yml', '--limit', '30',
+    '--json', 'databaseId,attempt,event,status,conclusion,createdAt,updatedAt']))
+    .map((run) => ({ id: run.databaseId, attempt: run.attempt, event: run.event, status: run.status, conclusion: run.conclusion, createdAt: run.createdAt }));
+  const corpusRuns = JSON.parse(gh(['run', 'list', '--repo', repo, '--workflow', 'protected-release.yml', '--limit', '60',
+    '--json', 'databaseId,attempt,displayTitle,status,conclusion,createdAt,updatedAt']))
+    .filter((run) => CORPUS_RUN_TITLE.test(String(run.displayTitle || '')) && recent(run.createdAt))
+    .map((run) => ({ id: run.databaseId, title: run.displayTitle, status: run.status, conclusion: run.conclusion,
+      createdAt: run.createdAt, updatedAt: run.updatedAt, ...corpusRunEvidence({ gh, repo, run, scratch }) }));
+  const releases = JSON.parse(gh(['release', 'list', '--repo', repo, '--limit', '100', '--json', 'tagName,publishedAt,isDraft,isPrerelease']));
+  const corpusReleases = releases.filter((row) => !row.isDraft && isCorpusReleaseTag(row.tagName))
+    .map((row) => ({ tag: row.tagName, publishedAt: row.publishedAt }))
+    .sort((a, b) => (ms(b.publishedAt) ?? 0) - (ms(a.publishedAt) ?? 0));
+  const newestCode = newestCodeRelease(releases);
+  const codeRelease = newestCode && { tag: newestCode.tagName, publishedAt: newestCode.publishedAt,
+    aggregate: await aggregateState({ gh, repo, tag: newestCode.tagName, root, scratch }) };
+
+  // Deferral: newest generation's verified coverage, then older ones only while it can still matter.
+  let deferral = { observable: false, reason: 'no corpus release is published' };
+  if (corpusReleases.length) {
+    const generations = [];
+    for (const release of corpusReleases.slice(0, 15)) {
+      const degraded = generationCoverage({ gh, repo, tag: release.tag, scratch });
+      generations.push({ ...release, degraded });
+      const pending = generations[0].degraded && [...generations[0].degraded.carried, ...generations[0].degraded.missing];
+      if (!degraded || !pending?.length || (ms(release.publishedAt) ?? 0) < at - DEFERRAL_LIMIT_MS - 24 * HOUR) break;
+    }
+    deferral = generations[0].degraded
+      ? { observable: true, newestTag: generations[0].tag, degraded: generations[0].degraded, stores: deferralSince(generations) }
+      // Generations published before ADR-0091 D6.2 carry no CORPUS-COVERAGE.json / coverage-receipt.json,
+      // so which stores were carried, and since when, is simply not recorded anywhere a reader can verify.
+      : { observable: false, reason: `${generations[0].tag} predates the D6.2 coverage sidecar (${COVERAGE_ASSET} + ${COVERAGE_RECEIPT_ASSET})` };
+  }
+  return { corpusReleases, corpusRuns, dispatcherRuns, codeRelease, deferral };
+}
+
+export function renderReport(result, now) {
+  const lines = [`corpus-watchdog ${result.verdict} at ${now.toISOString()}`];
+  for (const f of result.findings) lines.push(`  [${f.level}] ${f.check}: ${f.detail}`);
+  return `${lines.join('\n')}\n`;
+}
+
+async function main(argv = process.argv.slice(2)) {
+  const opt = (name) => { const i = argv.indexOf(name); return i >= 0 ? argv[i + 1] : undefined; };
+  const repo = opt('--repo') || process.env.GITHUB_REPOSITORY || 'stuinfla/ruvnet-brain';
+  const now = opt('--now') ? new Date(opt('--now')) : new Date();
+  if (!/^[^/\s]+\/[^/\s]+$/.test(repo) || !Number.isFinite(now.getTime())) {
+    process.stderr.write('usage: corpus-watchdog.mjs [--repo owner/name] [--json] [--now ISO]\n');
+    return 2;
+  }
+  let result;
+  try {
+    result = judgeCorpusHealth(await gatherCorpusHealthInput({ repo, now }), now);
+  } catch (error) {
+    // Could not observe = could not prove health. Absence of evidence is failure.
+    process.stderr.write(`corpus-watchdog RED: evidence could not be gathered: ${error.message}\n`);
+    return 1;
+  }
+  process.stdout.write(argv.includes('--json') ? `${JSON.stringify(result, null, 2)}\n` : renderReport(result, now));
+  return result.verdict === RED ? 1 : 0;
+}
+
+if (process.argv[1] && pathToFileURL(path.resolve(process.argv[1])).href === import.meta.url) {
+  main().then((code) => { process.exitCode = code; });
+}

package/scripts/fixture-denominator.mjs

@@ -0,0 +1,72 @@
+// scripts/fixture-denominator.mjs — ADR-0091 D6.4 (and the one retirement function D7.7 requires).
+//
+// The retrieval fixture is FROZEN (182 human questions, one per repository, digest-bound). Live
+// coverage is not: 194+ eligible repositories and growing. The release canary used to demand that
+// the two sets be EQUAL, which a living corpus can never satisfy. The reconciled decision:
+//
+//   available  = eligible repository rows that ship a store (CURRENT, or STALE with a verified carry)
+//   retired    = fixture repositories with NO row at all in a complete coverage observation (D7.2)
+//   questioned = fixture ∩ available            -- every one is asked its frozen question
+//   blocking   = fixture − available − retired  -- the release refuses (e.g. MISSING, INELIGIBLE)
+//   unfixturedEligible = available − fixture    -- RECORDED, never blocking; the fixture stays frozen
+//
+// Retirement only ever REMOVES a question from the denominator; it never adds a passing answer. The
+// signal is "absent from a sealed, complete enumeration" -- it cannot tell deleted from privatized
+// from renamed, which is acceptable for exactly that reason (ADR-0091 D7.2).
+
+import { eligibleRepositoryStanding } from '../plugin/scripts/coverage-integrity.mjs';
+
+const lower = (value) => String(value || '').toLowerCase();
+// localeCompare, exactly as scripts/retrieval-canary.mjs orders and set-checks these lists. Default
+// code-unit sort disagrees on real store names ('chatgpt-…' vs 'chatgpt_…'), which the canary's
+// checkedSet rejects as 'eligible denominator set is invalid'.
+const ordered = (values) => [...new Set(values)].sort((a, b) => a.localeCompare(b));
+
+/** True only for a repository enumeration the coverage itself proves complete and terminal. */
+export function repositoryEnumerationComplete(coverage) {
+  const repositories = (coverage?.rows || []).filter((row) => row?.kind === 'repository');
+  const enumeration = coverage?.enumerationReceipt;
+  return enumeration?.terminal === true && enumeration?.duplicateKeys === 0
+    && enumeration?.repositories?.expected === repositories.length;
+}
+
+/** D7.2: fixture stores with no repository row at all, under a complete enumeration; else none. */
+export function retiredFixtureStores({ coverage, fixtureStores }) {
+  if (!repositoryEnumerationComplete(coverage)) return [];
+  const present = new Set();
+  for (const row of (coverage.rows || []).filter((entry) => entry?.kind === 'repository')) {
+    present.add(lower(row.name));
+    if (row.artifact?.store) present.add(lower(row.artifact.store));
+  }
+  return ordered(fixtureStores.map(lower).filter((store) => !present.has(store)));
+}
+
+export function fixtureDenominator({ coverage, fixtureStores }) {
+  const fixture = ordered((fixtureStores || []).map(lower));
+  if (!fixture.length || fixture.some((store) => !store)) throw new Error('fixture store set is empty or malformed');
+  const eligible = (coverage?.rows || []).filter((row) => row?.kind === 'repository' && row.disposition === 'eligible');
+  const available = new Map();
+  for (const row of eligible) {
+    if (eligibleRepositoryStanding(row) !== 'shipped') continue;
+    const store = lower(row.artifact?.store);
+    if (!store) throw new Error(`eligible repository row ${row.key} names no store`);
+    if (available.has(store)) throw new Error(`eligible repository store ${store} is duplicated`);
+    available.set(store, row);
+  }
+  const retired = new Set(retiredFixtureStores({ coverage, fixtureStores: fixture }));
+  const questioned = fixture.filter((store) => available.has(store));
+  const blocking = fixture.filter((store) => !available.has(store) && !retired.has(store)).map((store) => {
+    const row = (coverage?.rows || []).find((entry) => entry?.kind === 'repository'
+      && (lower(entry.artifact?.store) === store || lower(entry.name) === store));
+    return { store, status: row?.status ?? null, disposition: row?.disposition ?? null };
+  });
+  const fixtureSet = new Set(fixture);
+  return {
+    fixture,
+    questioned,
+    questionedRows: questioned.map((store) => available.get(store)),
+    retired: [...retired],
+    blocking,
+    unfixturedEligible: ordered([...available.keys()].filter((store) => !fixtureSet.has(store))),
+  };
+}

package/scripts/knowledge-input-digest.mjs

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+// scripts/knowledge-input-digest.mjs — "has anything the corpus is built FROM changed since the seed?"
+//
+// WHY (2026-09-29 nightly redesign). The old no-change test compared the NEW archive's digest with
+// the seed archive's digest. It could never match: a rebuilt archive carries fresh builtUtc stamps,
+// a fresh selection receipt and fresh aggregate receipts even when not one input moved, so every
+// quiet night paid the full ~3 hours and minted a new generation anyway. The decision now happens
+// BEFORE anything is built, over the inputs themselves, computed the same way for the seed (from the
+// sealed evidence it carries) and for tonight (from the sealed observation and this checkout):
+//
+//   sourceObservationSha256  the sealed observation digest. Included on purpose (the conservative
+//                            clause of the design): the aggregate builders consume more of the
+//                            observation than head SHAs -- concepts.sources.json binds
+//                            observationSha256 and the ruv-gists ledger row uses it as sourceCommit,
+//                            and coverage rows ship each repository's description/homepage for routing.
+//   repositories             every eligible repository store -> the commit tonight wants (upstream.sha)
+//                            versus the commit the seed actually contains (artifact.sourceCommit),
+//                            so a store the seed carried at old bytes can never read as unchanged.
+//   gists                    every gist -> wanted version versus ingested version, same rule.
+//   publicInputs             the byte identities of the fenced public prose (primers, topics, L2,
+//                            capability cards, aliases) and the topic-ownership map.
+//   embedding                the model:dimensions the runtime embeds with / the seed was embedded with.
+//
+// Every uncertainty resolves toward BUILDING: a seed without the evidence (the pre-contract bootstrap)
+// yields null, and null is never "unchanged".
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { canonicalJson, digest as sha256Of } from './coverage-integrity.mjs';
+import { materializePublicInputs, SELECTION_FILE } from './public-inputs.mjs';
+import { parseBuildFingerprint } from './corpus-next-seed.mjs';
+
+export const KNOWLEDGE_INPUT_KIND = 'ruvnet-brain-knowledge-input';
+const DEFAULT_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const HEX64 = /^[0-9a-f]{64}$/;
+const COMMIT = /^[0-9a-f]{7,64}$/;
+
+function fail(message) {
+  throw new Error(`[knowledge-input-digest] ${message}`);
+}
+
+const lower = (value) => (value === null || value === undefined ? null : String(value).toLowerCase());
+
+/** Canonical form: every list sorted, every commit lowercased, nothing else admitted. */
+export function normalize(components) {
+  const c = components || {};
+  if (!HEX64.test(String(c.sourceObservationSha256 || ''))) fail('sourceObservationSha256 must be 64 lowercase hex');
+  if (![c.repositories, c.gists, c.publicInputs?.files, c.embedding].every(Array.isArray)) {
+    fail('repositories, gists, publicInputs.files and embedding must be arrays');
+  }
+  const repositories = c.repositories.map((row) => ({ store: lower(row?.store), sha: lower(row?.sha) }))
+    .sort((a, b) => String(a.store).localeCompare(String(b.store)));
+  if (repositories.some((row) => !row.store)) fail('a repository component has no store');
+  if (new Set(repositories.map((row) => row.store)).size !== repositories.length) fail('duplicate repository store');
+  const gists = c.gists.map((row) => ({ id: String(row?.id || ''), sha: lower(row?.sha) }))
+    .sort((a, b) => a.id.localeCompare(b.id));
+  if (gists.some((row) => !row.id)) fail('a gist component has no id');
+  const files = c.publicInputs.files.map((row) => ({ path: String(row?.path || ''), sha256: lower(row?.sha256), bytes: row?.bytes }))
+    .sort((a, b) => a.path.localeCompare(b.path));
+  if (files.some((row) => !row.path || !HEX64.test(String(row.sha256)) || !Number.isSafeInteger(row.bytes))) {
+    fail('a public input file row is malformed');
+  }
+  const ownership = Object.fromEntries(Object.entries(c.publicInputs.ownership || {})
+    .map(([slug, repo]) => [String(slug), String(repo)]).sort(([a], [b]) => a.localeCompare(b)));
+  const embedding = [...new Set(c.embedding.map(String))].sort();
+  if (!embedding.length) fail('no embedding model recorded');
+  return {
+    schemaVersion: 1, kind: KNOWLEDGE_INPUT_KIND, sourceObservationSha256: c.sourceObservationSha256,
+    repositories, gists, publicInputs: { files, ownership }, embedding,
+  };
+}
+
+/** One sha256 over the canonical components. Ordering of the inputs never matters. */
+export function digest(components) {
+  return sha256Of(canonicalJson(normalize(components)));
+}
+
+const eligibleRepositories = (coverage) => (coverage?.rows || [])
+  .filter((row) => row?.kind === 'repository' && row?.disposition === 'eligible');
+const gistRows = (coverage) => (coverage?.rows || []).filter((row) => row?.kind === 'gist');
+const gistId = (row) => String(row?.key || '').replace(/^gist:/, '');
+
+function readJsonIfPresent(file) {
+  if (!fs.existsSync(file)) return null;
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return null; }
+}
+
+/**
+ * The seed's knowledge inputs, read ONLY from evidence the sealed seed carries (its extracted assets):
+ * CORPUS-COVERAGE.json, PUBLIC-INPUT-SELECTION.json and RVF-GENERATIONS.json. null when any is absent
+ * or unreadable -- the caller must then build.
+ */
+export function fromSeed(assetsDir) {
+  const assets = path.resolve(assetsDir || '');
+  const coverage = readJsonIfPresent(path.join(assets, 'CORPUS-COVERAGE.json'));
+  const selection = readJsonIfPresent(path.join(assets, SELECTION_FILE));
+  const ledger = readJsonIfPresent(path.join(assets, 'RVF-GENERATIONS.json'));
+  if (coverage?.kind !== 'ruvnet-brain-corpus-coverage' || !Array.isArray(coverage.rows)
+    || !HEX64.test(String(coverage.sourceObservationSha256 || ''))) return null;
+  if (!Array.isArray(selection?.files) || !ledger?.stores || typeof ledger.stores !== 'object') return null;
+  const embedding = Object.values(ledger.stores)
+    .filter((store) => store?.model && Number.isSafeInteger(store?.dimensions))
+    .map((store) => `${store.model}:${store.dimensions}`);
+  if (!embedding.length) return null;
+  return {
+    sourceObservationSha256: coverage.sourceObservationSha256,
+    // What the seed CONTAINS: a carried (STALE) or MISSING store reads as its old/absent commit.
+    repositories: eligibleRepositories(coverage).map((row) => ({ store: row.artifact?.store, sha: row.artifact?.sourceCommit ?? null })),
+    gists: gistRows(coverage).map((row) => ({ id: gistId(row), sha: row.artifact?.sourceCommit ?? null })),
+    publicInputs: { files: selection.files, ownership: selection.ownership || {} },
+    embedding,
+  };
+}
+
+/** The runtime's embedding profile, read from THAT runtime's own forge fingerprint. */
+export async function runtimeEmbedding(root = DEFAULT_ROOT) {
+  const forge = await import(pathToFileURL(path.join(path.resolve(root), 'kb', 'forge-corpus.mjs')).href);
+  const { model, dimensions } = parseBuildFingerprint(forge.FORGE_BUILD_FINGERPRINT);
+  return [`${model}:${dimensions}`];
+}
+
+/**
+ * Tonight's knowledge inputs: the coverage measured from the sealed observation (what every source
+ * WANTS to be), plus the public prose this checkout would select, materialized into a throwaway
+ * directory by the one canonical selector -- never re-implemented here.
+ */
+export async function fromCoverage(coverage, root = DEFAULT_ROOT, {
+  materialize = materializePublicInputs, embedding = null } = {}) {
+  if (coverage?.kind !== 'ruvnet-brain-corpus-coverage' || !Array.isArray(coverage.rows)) {
+    fail('tonight requires a measured ruvnet-brain-corpus-coverage object');
+  }
+  const scratch = fs.mkdtempSync(path.join(os.tmpdir(), 'knowledge-input-'));
+  let publicInputs;
+  try {
+    const selected = materialize({ builderRoot: path.resolve(root), outDir: path.join(scratch, 'public') });
+    publicInputs = { files: selected.selectionReceipt.files, ownership: selected.selectionReceipt.ownership || {} };
+  } finally {
+    fs.rmSync(scratch, { recursive: true, force: true });
+  }
+  return {
+    sourceObservationSha256: coverage.sourceObservationSha256,
+    repositories: eligibleRepositories(coverage).map((row) => {
+      if (!COMMIT.test(lower(row.upstream?.sha) || '')) fail(`${row.artifact?.store || row.key} has no upstream sha`);
+      return { store: row.artifact?.store, sha: row.upstream.sha };
+    }),
+    gists: gistRows(coverage).map((row) => ({ id: gistId(row), sha: row.upstream?.sha ?? null })),
+    publicInputs,
+    embedding: embedding || await runtimeEmbedding(root),
+  };
+}
+
+/** { unchanged, seedSha256, tonightSha256 }. A seed without evidence is never unchanged. */
+export function compareKnowledgeInputs({ seed, tonight }) {
+  const tonightSha256 = digest(tonight);
+  if (!seed) return { unchanged: false, seedSha256: null, tonightSha256, reason: 'the seed carries no knowledge-input evidence' };
+  const seedSha256 = digest(seed);
+  return {
+    unchanged: seedSha256 === tonightSha256, seedSha256, tonightSha256,
+    reason: seedSha256 === tonightSha256 ? 'every knowledge input equals the seed' : 'at least one knowledge input differs from the seed',
+  };
+}