ruvnet-brain 4.3.36 → 4.3.38

package/scripts/corpus-watchdog.mjs

@@ -15,6 +15,10 @@
 //            (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
+//            (e) the generation customers actually receive (releases/latest) is older than 36h —
+//                the server-side half of "nobody's Brain is ever more than 48h old"
+//            (f) the most recent customer canary refused its candidate (canary-rejected): a night
+//                that built and staged a corpus no clean customer install could apply
 //   WARNING  a superseded or degraded night, a stand-down tonight, an unknown outcome, a long run
 //   GREEN    none of the above
 //
@@ -38,6 +42,7 @@ 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';
+import { parseCorpusGeneration } from './corpus-promotion.mjs';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 export const RED = 'RED';
@@ -50,12 +55,14 @@ 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;
+/** A customer Brain must never be >48h old; the promoted generation pages at 36h so a same-day fix lands first. */
+export const PROMOTED_AGE_LIMIT_MS = 36 * 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 DECLARED_OUTCOMES = new Set(['published', 'no-change', 'superseded', 'degraded', 'canary-rejected', 'failed']);
 const GOOD_NIGHT = new Set(['published', 'no-change']);
 
 const ms = (iso) => {
@@ -75,11 +82,17 @@ 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]));
+  // The customer canary refusing its candidate is its own outcome: red, and nothing reached customers.
+  if ((recorded?.canary ?? byName.get('customer-canary')) === 'failure') return 'canary-rejected';
+  if (run.conclusion !== 'success') return 'failed';
   const noChange = recorded?.no_change ?? byName.get('corpus-no-change-round');
-  const publish = recorded?.publish ?? byName.get('protected-corpus-publisher');
+  // Since the customer canary, `published` means PROMOTED: the promote job, not the (staging) publisher.
+  // Runs recorded before the canary existed carry no promote job; their publisher moved latest itself.
+  const publish = recorded
+    ? (Object.hasOwn(recorded, 'promote') ? recorded.promote : recorded.publish)
+    : (byName.has('promote-canaried-corpus') ? byName.get('promote-canaried-corpus') : byName.get('protected-corpus-publisher'));
   if (noChange === 'success') return 'no-change';
   if (publish === 'success') return 'published';
   return 'unknown';
@@ -110,7 +123,8 @@ export function deferralSince(generations) {
 
 /**
  * The pure verdict. `input`:
- *   corpusReleases  [{ tag, publishedAt }]                           non-draft corpus-sha256-* releases
+ *   corpusReleases  [{ tag, publishedAt }]                           PROMOTED (non-draft, non-prerelease) corpus-sha256-* releases
+ *   latestRelease   { tag, publishedAt, generation } | null           what releases/latest serves customers right now
  *   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
@@ -153,6 +167,7 @@ export function judgeCorpusHealth(input, now) {
   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 === 'canary-rejected') add(RED, 'tonight', `${ref}: the customer canary refused the candidate; it stays an unpromoted prerelease`);
     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`);
@@ -198,6 +213,24 @@ export function judgeCorpusHealth(input, now) {
     if (degraded.length) add(WARNING, 'degraded', `${deferral.newestTag} is degraded: ${deferral.degraded.carried.length} carried, ${deferral.degraded.missing.length} missing`);
   }
 
+  // (e) the generation customers receive. Its own generation stamp when it carries one (the corpus
+  // build time), else its publish time. Missing or unreadable is RED: absence of evidence is failure.
+  const latest = input?.latestRelease;
+  const latestAge = latest ? age(latest.generation || latest.publishedAt) : null;
+  if (latestAge === null) {
+    add(RED, 'promoted-age', `releases/latest could not be dated (${latest ? latest.tag : 'no latest release observed'})`);
+  } else if (latestAge > PROMOTED_AGE_LIMIT_MS) {
+    add(RED, 'promoted-age', `customers receive ${latest.tag}, ${hours(latestAge)} old (limit 36h; a customer Brain must never pass 48h)`);
+  } else add(GREEN, 'promoted-age', `customers receive ${latest.tag}, ${hours(latestAge)} old`);
+
+  // (f) the most recent customer canary verdict among the observed runs.
+  const lastCanary = runs.filter((run) => run.outcome === 'published' || run.outcome === 'canary-rejected')
+    .sort((a, b) => ms(b.createdAt) - ms(a.createdAt))[0];
+  if (!lastCanary) add(INFO, 'canary', 'no customer canary verdict among the observed corpus runs');
+  else if (lastCanary.outcome === 'canary-rejected') {
+    add(RED, 'canary', `the last customer canary (run ${lastCanary.id}) refused its candidate: a clean install could not apply it`);
+  } else add(GREEN, 'canary', `the last customer canary (run ${lastCanary.id}) applied its candidate and it was promoted`);
+
   const verdict = findings.some((f) => f.level === RED) ? RED : findings.some((f) => f.level === WARNING) ? WARNING : GREEN;
   return { verdict, findings, lastGoodNight };
 }
@@ -277,7 +310,8 @@ export async function gatherCorpusHealthInput({ repo, now, gh = defaultGh, root
     .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))
+  // PROMOTED only: a staged candidate (and a bootstrap seed) is a prerelease no customer receives.
+  const corpusReleases = releases.filter((row) => !row.isDraft && !row.isPrerelease && 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);
@@ -300,7 +334,12 @@ export async function gatherCorpusHealthInput({ repo, now, gh = defaultGh, root
       // 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 };
+  let latestRelease = null;
+  try {
+    const latest = JSON.parse(gh(['api', `repos/${repo}/releases/latest`]));
+    latestRelease = { tag: latest.tag_name, publishedAt: latest.published_at, generation: parseCorpusGeneration(latest.body)?.value || null };
+  } catch { latestRelease = null; } // judged RED as "could not be dated"
+  return { corpusReleases, corpusRuns, dispatcherRuns, codeRelease, deferral, latestRelease };
 }
 
 export function renderReport(result, now) {

package/scripts/derive-passage-content-map.mjs

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+// Derive data/retrieval-passage-content-digests.json from a corpus archive built with ordinal passage
+// ids. See scripts/retrieval-passage-identity.mjs for why the map exists.
+//
+//   node scripts/derive-passage-content-map.mjs --zip <old-format ruvnet-brain.zip> \
+//        --source-tag v4.3.36 [--fixture data/retrieval-query-evidence.json] [--out <file>]
+//
+// For every expected passage the frozen fixture pins (primary + alternatives), find the ONE row in the
+// archive's store whose path matches and whose digest equals the pin, and record that row's id-less
+// content digest. A pin that is not found exactly once is listed as `unresolved` (never guessed): it
+// keeps exact-digest matching only. The output is deterministic, so re-running proves the committed map.
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { digest } from './coverage-integrity.mjs';
+import { CONTENT_MAP_FILE, CONTENT_MAP_KIND, passageContentDigest } from './retrieval-passage-identity.mjs';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const sha256File = (file) => crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+
+/** Every pin in the fixture: [{ store, path, pinned }]. */
+export function fixturePins(fixture) {
+  const pins = [];
+  for (const [store, row] of Object.entries(fixture.queries || {})) {
+    const sources = [{ path: row.expected.path, passageSha256: row.expected.passageSha256 }, ...(row.expected.alternatives || [])];
+    for (const source of sources) pins.push({ store, path: source.path, pinned: source.passageSha256 });
+  }
+  return pins;
+}
+
+export function deriveContentMap({ fixture, fixtureSha256, readRows, sourceTag, archiveSha256 }) {
+  const entries = {};
+  const unresolved = [];
+  for (const { store, path: expectedPath, pinned } of fixturePins(fixture)) {
+    const rows = readRows(store);
+    const found = (rows || []).filter((row) => row.path === expectedPath && digest(row) === pinned);
+    if (found.length === 1) entries[pinned] = passageContentDigest(found[0]);
+    else unresolved.push({ store, path: expectedPath, pinned, reason: rows ? `${found.length} matching rows` : 'store absent from archive' });
+  }
+  const sorted = Object.fromEntries(Object.entries(entries).sort(([a], [b]) => a.localeCompare(b)));
+  return { schemaVersion: 1, kind: CONTENT_MAP_KIND, fixtureSha256,
+    derivedFrom: { tag: sourceTag, archiveSha256 },
+    entries: sorted,
+    unresolved: unresolved.sort((a, b) => a.store.localeCompare(b.store) || a.path.localeCompare(b.path)) };
+}
+
+function zipRows(zipFile, store) {
+  const result = spawnSync('unzip', ['-p', zipFile, `${store}.passages.jsonl`], { maxBuffer: 1 << 30 });
+  if (result.status !== 0) return null;
+  // Split on \n only: rows may contain U+2028/U+2029, which are not JSONL separators.
+  return result.stdout.toString('utf8').split('\n').filter((line) => line.trim()).map((line) => JSON.parse(line));
+}
+
+function main(argv) {
+  const arg = (name, fallback = null) => { const i = argv.indexOf(name); return i >= 0 ? argv[i + 1] : fallback; };
+  const zip = arg('--zip');
+  const sourceTag = arg('--source-tag');
+  if (!zip || !sourceTag) { console.error('usage: derive-passage-content-map.mjs --zip <archive> --source-tag <tag> [--fixture f] [--out f]'); process.exit(2); }
+  const fixtureFile = path.resolve(arg('--fixture', path.join(ROOT, 'data', 'retrieval-query-evidence.json')));
+  const out = path.resolve(arg('--out', CONTENT_MAP_FILE));
+  const cache = new Map();
+  const readRows = (store) => { if (!cache.has(store)) cache.set(store, zipRows(zip, store)); return cache.get(store); };
+  const map = deriveContentMap({ fixture: JSON.parse(fs.readFileSync(fixtureFile, 'utf8')), fixtureSha256: sha256File(fixtureFile),
+    readRows, sourceTag, archiveSha256: sha256File(zip) });
+  fs.writeFileSync(out, `${JSON.stringify(map, null, 2)}\n`);
+  console.log(JSON.stringify({ out, resolved: Object.keys(map.entries).length, unresolved: map.unresolved.length }));
+}
+
+if (process.argv[1] && fs.realpathSync(process.argv[1]) === fileURLToPath(import.meta.url)) main(process.argv.slice(2));

package/scripts/duplicate-gate-replay.mjs

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+/**
+ * duplicate-gate-replay.mjs — replay plugin/scripts/duplicate-gate.mjs over real history, read-only.
+ *
+ * For each code file ADDED by the last N commits (git log --diff-filter=A), score it exactly as the
+ * gate would have at that moment: against the tree at the commit's first parent. Uses the gate's own
+ * extract/prepare/rank/exemption — the replay is the gate, pointed at the past, never a second copy.
+ * Features are cached per blob sha, so N commits cost one extraction per distinct blob.
+ *
+ *   node scripts/duplicate-gate-replay.mjs [--commits 300] [--threshold 0.5] [--seed <sha>]... [--json out.json]
+ */
+import fs from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { extract, prepare, rank, exemption, isTest, isRelocation, strengthOf, SCOPE, THRESHOLD, MIN_COPIED_LINES } from '../plugin/scripts/duplicate-gate.mjs';
+
+const argv = process.argv.slice(2);
+const opt = (k, d) => { const i = argv.indexOf(k); return i >= 0 ? argv[i + 1] : d; };
+const N = Number(opt('--commits', 300));
+const threshold = Number(opt('--threshold', THRESHOLD));
+const minCopied = Number(opt('--min-copied', MIN_COPIED_LINES));
+const seeds = argv.flatMap((a, i) => (a === '--seed' ? [argv[i + 1]] : []));
+const CODE = /\.(mjs|cjs|js|ts|mts|sh|py)$/;
+const FIXTURE = /(^|\/)(__)?fixtures?(__)?\/|node_modules\//;
+
+const git = (args, input) => {
+  const r = spawnSync('git', args, { encoding: 'utf8', maxBuffer: 1 << 30, input });
+  if (r.status !== 0) throw new Error(`git ${args.join(' ')}: ${r.stderr}`);
+  return r.stdout;
+};
+
+/** Read many objects in one `git cat-file --batch` call; texts in input order ('' when missing). */
+function blobs(specs) {
+  if (!specs.length) return [];
+  const r = spawnSync('git', ['cat-file', '--batch'], { input: `${specs.join('\n')}\n`, maxBuffer: 1 << 30 });
+  const buf = r.stdout; const out = []; let pos = 0;
+  while (pos < buf.length) {
+    const nl = buf.indexOf(10, pos);
+    const head = buf.slice(pos, nl).toString().split(' ');
+    if (head.length < 3 || head[1] === 'missing') { out.push(''); pos = nl + 1; continue; }
+    const n = Number(head[2]); out.push(buf.slice(nl + 1, nl + 1 + n).toString('utf8')); pos = nl + 1 + n + 1;
+  }
+  return out;
+}
+
+const commits = [];
+let cur = null;
+for (const line of git(['log', '--diff-filter=A', '--name-only', '--format=COMMIT %H %P', `-${N}`]).split('\n')) {
+  if (line.startsWith('COMMIT ')) { const [, sha, parent] = line.split(' '); cur = { sha, parent, added: [] }; commits.push(cur); } else if (line.trim() && cur) cur.added.push(line.trim());
+}
+for (const s of seeds) {
+  const [sha, parent] = git(['log', '-1', '--format=%H %P', s]).trim().split(' ');
+  const added = git(['show', '--diff-filter=A', '--name-only', '--format=', sha]).split('\n').filter(Boolean);
+  commits.push({ sha, parent, added, seed: true });
+}
+
+const featureCache = new Map(); // `${blob sha}:${path}` -> features (the stem makes them path-dependent)
+const rows = []; const timings = [];
+for (const c of commits) {
+  const targets = c.added.filter((p) => SCOPE.some((d) => p.startsWith(d)) && CODE.test(p));
+  if (!targets.length || !c.parent) continue;
+  const t0 = Date.now();
+  const tree = git(['ls-tree', '-r', c.parent]).split('\n').filter(Boolean).map((l) => {
+    const [meta, p] = l.split('\t'); const [, type, sha] = meta.split(' '); return { p, sha, type };
+  }).filter((x) => x.type === 'blob' && CODE.test(x.p) && !FIXTURE.test(x.p));
+  const missing = tree.filter((x) => !featureCache.has(`${x.sha}:${x.p}`));
+  const texts = blobs(missing.map((x) => x.sha));
+  missing.forEach((x, i) => { if (texts[i].length <= 400_000) featureCache.set(`${x.sha}:${x.p}`, extract(x.p, texts[i])); });
+  const entries = tree.filter((x) => featureCache.has(`${x.sha}:${x.p}`)).map((x) => ({ path: x.p, f: featureCache.get(`${x.sha}:${x.p}`) }));
+  const model = prepare(entries);
+  const stems = new Set([...tree.map((x) => x.p), ...c.added].filter((p) => !isTest(p)).map((p) => p.split('/').pop().replace(/\.[^.]+$/, '')));
+  const newTexts = blobs(targets.map((p) => `${c.sha}:${p}`));
+  for (const [i, p] of targets.entries()) {
+    const text = newTexts[i];
+    const ex = exemption(p, text, stems);
+    if (ex) { rows.push({ commit: c.sha.slice(0, 8), file: p, skip: ex, seed: !!c.seed }); continue; }
+    const t1 = Date.now();
+    const ranked = rank(model, extract(p, text), { self: p, testsOnly: isTest(p), limit: 10 }).filter((m) => !isRelocation(p, m.path));
+    timings.push(Date.now() - t1);
+    // Re-derive strength at the replay's own knobs so thresholds can be swept without editing the gate.
+    const knobs = { threshold, minCopied };
+    const top = ranked.sort((a, b) => strengthOf(b, knobs) - strengthOf(a, knobs));
+    const strength = top[0] ? strengthOf(top[0], knobs) : 0;
+    rows.push({ commit: c.sha.slice(0, 8), file: p, seed: !!c.seed, score: top[0]?.score ?? 0, strength, copied: top[0]?.copied.length ?? 0, block: strength >= 1 && !isTest(p), shadow: strength >= 1 && isTest(p),
+      top: top.map((m) => ({ path: m.path, score: +m.score.toFixed(3), copied: m.copied.length, copyShare: +m.copyShare.toFixed(3), parts: Object.fromEntries(Object.entries(m.parts).map(([k, v]) => [k, +v.toFixed(2)])), exports: m.sharedExports.slice(0, 4), lits: m.sharedLits })) });
+  }
+  timings.push(-(Date.now() - t0));
+}
+
+const judged = rows.filter((r) => !r.skip);
+const blocks = judged.filter((r) => r.block);
+const rankMs = timings.filter((t) => t >= 0).sort((a, b) => a - b);
+console.log(`commits=${commits.length} candidates=${rows.length} judged=${judged.length} skipped=${rows.length - judged.length} `
+  + `blocks=${blocks.length} (${(100 * blocks.length / (judged.length || 1)).toFixed(1)}%) threshold=${threshold} `
+  + `rank p50=${rankMs[Math.floor(rankMs.length / 2)] ?? 0}ms max=${rankMs.at(-1) ?? 0}ms`);
+console.log(`shadow would-blocks (tests, never refused): ${judged.filter((r) => r.shadow).length}`);
+for (const r of blocks) console.log(`BLOCK strength=${r.strength.toFixed(2)} score=${r.score.toFixed(3)} copied=${r.copied} ${r.commit} ${r.file} -> ${r.top.slice(0, 3).map((m) => `${m.path}@${m.score}/${m.copied}`).join(' | ')}`);
+const out = opt('--json', '');
+if (out) fs.writeFileSync(out, JSON.stringify({ threshold, rows }, null, 1));

package/scripts/grounding-turn-replay.mjs

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+/**
+ * grounding-turn-replay.mjs — measure grounding-turn-gate.mjs's assertion gate (ADR-0030 #1) and its
+ * shadow gates (#2 architecture options, #3 relayed numbers) against REAL Claude Code transcripts,
+ * read-only. Same turn model and walkers as scripts/completion-claim-replay.mjs (imported, not
+ * copied); same pure functions the hooks call (grounding-turn-mark.mjs armFor at the prompt,
+ * grounding-turn-evidence.mjs at Stop).
+ *
+ *   node scripts/grounding-turn-replay.mjs [--root ~/.claude/projects] [--limit 60] [--out blocks.jsonl]
+ *        [--grep <regex over the final answer>]
+ *
+ * STOP POINTS, not turns: every `stop_hook_summary` record in a turn is one real Stop event, judged on
+ * the transcript up to that point with the last assistant text before it as `last_assistant_message`
+ * — exactly what the hook saw. A turn with no recorded Stop is judged once at its end. As at runtime,
+ * only the FIRST stop of an episode may block (stop_hook_active silences the continued stop).
+ * `--at <file>:<line>` replays one Stop point (the incident check). `--subagents` also replays
+ * subagent transcripts (<session>/subagents/*.jsonl, their sidechain flag cleared) — NOT a runtime
+ * surface (the gate is registered on Stop, not SubagentStop); it only widens the labelling sample.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { transcripts, turnsOf, finalText } from './completion-claim-replay.mjs';
+import { armFor } from '../plugin/scripts/grounding-turn-mark.mjs';
+import {
+  architectureShadow, auditAssertions, loadVocabulary, relayShadow, searchedThisTurn, turnSources,
+} from '../plugin/scripts/grounding-turn-evidence.mjs';
+
+const argv = process.argv.slice(2);
+const opt = (flag, fallback) => { const i = argv.indexOf(flag); return i >= 0 && argv[i + 1] ? argv[i + 1] : fallback; };
+const root = path.resolve(opt('--root', path.join(os.homedir(), '.claude', 'projects')));
+const limit = Number(opt('--limit', '60'));
+const out = opt('--out', null);
+const grep = opt('--grep', null);
+const at = opt('--at', null);
+const withSubagents = argv.includes('--subagents');
+// --unarmed: judge EVERY stop point as if armed (subjects from the prompt, or none) — measures the
+// Stop-side evaluator alone, i.e. what prompt-time arming saves. Not the runtime behaviour.
+const unarmed = argv.includes('--unarmed');
+function subagentFiles() {
+  const files = [];
+  for (const project of fs.readdirSync(root)) {
+    let sessions = [];
+    try { sessions = fs.readdirSync(path.join(root, project)); } catch { continue; }
+    for (const session of sessions) {
+      const dir = path.join(root, project, session, 'subagents');
+      try { for (const f of fs.readdirSync(dir)) if (f.endsWith('.jsonl') && fs.statSync(path.join(dir, f)).size > 20_000) files.push(path.join(dir, f)); } catch { /* none */ }
+    }
+  }
+  return files;
+}
+
+const parse = (l) => { try { return JSON.parse(l); } catch { return null; } };
+const assistantText = (o) => (o?.type === 'assistant' && !o.isSidechain && Array.isArray(o.message?.content)
+  ? o.message.content.filter((c) => c?.type === 'text').map((c) => c.text).join('\n').trim() : '');
+/** [lines-up-to-stop, last assistant text] for each Stop in a turn (the first per episode only). */
+function stopPoints(turnLines) {
+  const points = [];
+  let last = '';
+  let episodeOpen = true;
+  turnLines.forEach((l, i) => {
+    const o = parse(l);
+    const t = assistantText(o);
+    if (t) last = t;
+    if (o?.type === 'system' && o.subtype === 'stop_hook_summary') {
+      if (episodeOpen && last) points.push([turnLines.slice(0, i + 1), last]);
+      episodeOpen = false; // later stops in this turn are continuations (stop_hook_active)
+    }
+  });
+  if (!points.length) { const m = finalText(turnLines); if (m) points.push([turnLines, m]); }
+  return points;
+}
+
+const vocab = loadVocabulary();
+if (at) {
+  const [file, line] = [at.slice(0, at.lastIndexOf(':')), Number(at.slice(at.lastIndexOf(':') + 1))];
+  const lines = fs.readFileSync(file, 'utf8').split('\n').slice(0, line);
+  const message = assistantText(parse(lines[lines.length - 1])) || finalText(lines);
+  const turn = turnSources(lines);
+  const arm = armFor({ hook_event_name: 'UserPromptSubmit', session_id: 'replay', prompt: turn.prompt }, vocab);
+  const audit = arm?.assert ? auditAssertions({ message, subjects: arm.subjects, vocab, sources: turn.sources }) : null;
+  console.log(JSON.stringify({ at, arm, verdict: audit?.findings.length ? 'BLOCK' : 'PASS', findings: audit?.findings,
+    sources: turn.sources.map((x) => `${x.order} ${x.kind} ${x.strength} ${String(x.ref).slice(0, 60)}`) }, null, 2));
+  process.exit(0);
+}
+const r = { root, transcripts: 0, turns: 0, armed: 0, armedGate1: 0, blocked: 0, gate1WouldFire: 0,
+  shadowArchitecture: 0, shadowRelay: 0, claims: 0, ms: [] };
+const samples = [];
+for (const file of [...transcripts(root, limit), ...(withSubagents ? subagentFiles() : [])]) {
+  r.transcripts += 1;
+  const sub = file.includes(`${path.sep}subagents${path.sep}`);
+  const lines = fs.readFileSync(file, 'utf8').split('\n').filter(Boolean)
+    .map((l) => (sub ? l.replace('"isSidechain":true', '"isSidechain":false') : l));
+  for (const [turnLines, message] of turnsOf(lines).flatMap(stopPoints)) {
+    r.turns += 1;
+    const t0 = performance.now();
+    const turn = turnSources(turnLines);
+    const arm = unarmed ? { gate1: false, assert: true, architecture: false, subjects: [] }
+      : armFor({ hook_event_name: 'UserPromptSubmit', session_id: 'replay', prompt: turn.prompt }, vocab);
+    if (!arm) { r.ms.push(performance.now() - t0); continue; }
+    if (arm.gate1) { r.armedGate1 += 1; if (!searchedThisTurn(turn.sources)) r.gate1WouldFire += 1; }
+    let audit = { claims: [], findings: [] };
+    if (arm.assert) {
+      r.armed += 1;
+      audit = auditAssertions({ message, subjects: arm.subjects, vocab, sources: turn.sources });
+      r.claims += audit.claims.length;
+      if (audit.findings.length) r.blocked += 1;
+      if (architectureShadow({ architecture: arm.architecture, message })) r.shadowArchitecture += 1;
+      if (relayShadow({ message, sources: turn.sources })) r.shadowRelay += 1;
+    }
+    r.ms.push(performance.now() - t0);
+    const hit = grep && new RegExp(grep, 'i').test(message);
+    if (audit.findings.length || hit || (argv.includes('--all-claims') && audit.claims.length)) {
+      samples.push({ file: path.basename(file), subagent: sub, grep: !!hit, verdict: audit.findings.length ? 'BLOCK' : 'PASS',
+        prompt: turn.prompt.slice(0, 300), subjects: arm.subjects,
+        findings: audit.findings.map((f) => ({ claim: f.text.slice(0, 300), subject: f.subject, reason: f.reason, read: f.read })),
+        passed: audit.claims.filter((c) => !audit.findings.some((f) => f.text === c.text)).map((c) => ({ claim: c.text.slice(0, 300), subject: c.subject })),
+        sources: turn.sources.length });
+    }
+  }
+}
+const ms = r.ms.sort((a, b) => a - b);
+console.log(JSON.stringify({ ...r, ms: undefined,
+  armRate: +(r.armed / (r.turns || 1)).toFixed(3), blockRate: +(r.blocked / (r.turns || 1)).toFixed(4),
+  blockRateOfArmed: +(r.blocked / (r.armed || 1)).toFixed(3),
+  gate1FireRate: +(r.gate1WouldFire / (r.turns || 1)).toFixed(4),
+  shadowArchitectureRate: +(r.shadowArchitecture / (r.turns || 1)).toFixed(4), shadowRelayRate: +(r.shadowRelay / (r.turns || 1)).toFixed(4),
+  auditP50Ms: +(ms[Math.floor(ms.length / 2)] || 0).toFixed(2), auditP99Ms: +(ms[Math.floor(ms.length * 0.99)] || 0).toFixed(2),
+  unit: 'turns = first Stop point per turn (stop_hook_summary), else turn end', subagents: withSubagents, unarmed }, null, 2));
+if (out) fs.writeFileSync(out, samples.map((s) => JSON.stringify(s)).join('\n') + '\n');
+if (grep) for (const s of samples.filter((x) => x.grep)) console.log(JSON.stringify(s).slice(0, 1500));

package/scripts/nightly-watchdog.mjs

@@ -38,7 +38,7 @@ import path from 'node:path';
 import os from 'node:os';
 import { spawnSync, execFileSync } from 'node:child_process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import { NIGHTLY_LABEL, schedulerStatus } from '../plugin/scripts/nightly-scheduler.mjs';
+import { NIGHTLY_LABEL, schedulerStatus, updateOwnedByAgenticKit } from '../plugin/scripts/nightly-scheduler.mjs';
 import { oldestIncompleteProgress } from '../kb/shard-progress.mjs';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
@@ -230,9 +230,9 @@ export function productSchedulerVerdict(status) {
 /** ONE update owner per machine (CONTRIBUTING.md § The knowledge corpus). agentic-kit removes the
  *  Brain's own scheduler by design and updates through `ak sync`, which the registry watches as
  *  com.stuartkerr.ak-sync — so on such a machine the Brain scheduler is not expected to exist. */
+// One reader of agentic-kit ownership, shared with SessionStart's knowledge-currency line.
 export function brainUpdateOwnedByAgenticKit(home = os.homedir()) {
-  try { return JSON.parse(fs.readFileSync(path.join(home, '.config', 'agentic-kit', 'kit.json'), 'utf8')).ruvnetBrain === true; }
-  catch { return false; }
+  return updateOwnedByAgenticKit(home);
 }
 
 const loadState = () => { try { return JSON.parse(fs.readFileSync(STATE, 'utf8')); } catch { return {}; } };

package/scripts/public-verification-inputs.mjs

@@ -11,6 +11,7 @@ import { extractZip } from '../kb/zip-extract.mjs';
 import { canonicalJson, digest, validateCoverageLedger, validateCoverageLink } from './coverage-integrity.mjs';
 import { validatePublicInventory } from './public-inventory.mjs';
 import { verifySeedBaseline } from './corpus-candidate.mjs';
+import { loadFixture, readRecallReport } from './oracle/repo-recall.mjs';
 import {
   buildRetrievalCanaryPlan,
   validateRetrievalQueryEvidence,
@@ -430,9 +431,27 @@ function writeExactOutputs(outDir, outputs) {
   return root;
 }
 
+/**
+ * The stores a corpus generation's OWN repo-recall measurement retrieved (exact file within top-k). The
+ * report is bound to the exact baseline archive (sha256 + bytes) and to the frozen fixture the canary
+ * samples from, and is re-derived through the same reader the corpus pipeline uses — a report for another
+ * archive or another fixture is refused, never silently accepted.
+ */
+export function measuredHitStores({ recallFile, baselineArchive, oracleFile }) {
+  const stat = fs.statSync(baselineArchive);
+  // A report that claims retired questions must be verified against the coverage it names; the
+  // generation's sealed coverage sits beside its report in the seed directory when it exists.
+  const siblingCoverage = path.join(path.dirname(path.resolve(recallFile)), 'CORPUS-COVERAGE.json');
+  const { report } = readRecallReport({ reportFile: recallFile,
+    archive: { sha256: sha256File(baselineArchive), bytes: stat.size },
+    expectedFixtureSha256: loadFixture(oracleFile).fixtureSha256,
+    coverageBytes: fs.existsSync(siblingCoverage) ? fs.readFileSync(siblingCoverage) : null });
+  return new Set(report.rows.filter((row) => Number.isInteger(row.exactFileRank)).map((row) => String(row.store).toLowerCase()));
+}
+
 export async function createPublicVerificationInputs({ baselineBundle, candidateBundle,
   candidatePackage, oracleFile, repo = process.cwd(), outDir = 'release-evidence', baselineMode = 'verified',
-  baselineReceipt = null } = {}) {
+  baselineReceipt = null, baselineRecall = null } = {}) {
   const baselineArchive = trustedFile(baselineBundle, 'baseline archive');
   const candidateArchive = trustedFile(candidateBundle, 'candidate archive');
   const packageFile = trustedFile(candidatePackage, 'candidate package');
@@ -513,9 +532,11 @@ export async function createPublicVerificationInputs({ baselineBundle, candidate
   verifyQueryOracleSource(queryEvidence, candidateResult.candidate.sourceSha, {
     cwd: path.resolve(repo), allowSquashedSource: true,
   });
+    const knownHitStores = baselineRecall
+      ? measuredHitStores({ recallFile: baselineRecall, baselineArchive, oracleFile: oraclePath }) : null;
     const plan = buildRetrievalCanaryPlan({ coverage: candidateResult.coverage, baseline,
       candidate: candidateResult.candidate, coverageIdentity: candidateResult.coverageIdentity,
-      queryEvidence, assetsDir: candidateTree.root, allowNoDelta: true });
+      queryEvidence, assetsDir: candidateTree.root, allowNoDelta: true, knownHitStores });
     writeExactOutputs(outDir, {
       [baselineMode === 'observed' ? 'baseline-observation-receipt.json' : 'baseline-verification-receipt.json']: baselineProof.bytes,
       'COVERAGE.json': candidateResult.coverageBytes,
@@ -574,6 +595,7 @@ export async function main(argv = process.argv.slice(2)) {
     outDir: arg(argv, '--out-dir') || 'release-evidence',
     baselineMode: argv.includes('--receipted-baseline') ? 'receipted' : argv.includes('--observed-baseline') ? 'observed' : 'verified',
     baselineReceipt: arg(argv, '--baseline-receipt'),
+    baselineRecall: arg(argv, '--baseline-recall'),
   });
   console.log(JSON.stringify({ ok: true, sourceSha: result.candidate.sourceSha,
     coverageGeneration: result.coverage.releaseCoverageGeneration, cases: result.plan.cases.length }));

package/scripts/release-transaction-provider.mjs

@@ -60,13 +60,36 @@ const tagSha = (tag, root) => {
 // Assets now stream to a temp file and are hashed incrementally, so peak memory is one 1MB chunk
 // instead of the whole bundle and there is no ceiling to outgrow. Small assets (receipts) still
 // come back as bytes, because callers parse them as JSON.
-const assetToFile = (asset, destination) => {
-  const result = spawnSync('gh', ['api', asset.url, '-H', 'Accept: application/octet-stream'], {
-    stdio: ['ignore', fs.openSync(destination, 'w'), 'pipe'], timeout: ASSET_DOWNLOAD_TIMEOUT_MS,
-  });
-  if (result.error || result.signal || result.status !== 0) {
-    throw new Error(`cannot download transaction asset ${asset.name}: ${result.error?.message || result.signal || `exit ${result.status}`}`);
+//
+// 2026-09-29: ONE FLAKY DOWNLOAD MUST NOT ABORT A RELEASE. discover() reads the receipts of every
+// published release (411 assets, serially, ~3 minutes); a single transient `gh api` failure among
+// them killed the 4.3.36 publish with only "exit 1" -- the stderr that said why was discarded, and
+// re-fetching the same asset a minute later worked. A download is now retried with backoff, and the
+// final error carries the real cause. A genuinely missing/corrupt asset still fails, just not on
+// the first hiccup; the digest checks downstream are unchanged.
+export const ASSET_DOWNLOAD_ATTEMPTS = 4;
+const sleepSync = (ms) => { Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms); };
+export const downloadAsset = (asset, destination, {
+  spawn = spawnSync, wait = sleepSync, attempts = ASSET_DOWNLOAD_ATTEMPTS, baseDelayMs = 2000,
+} = {}) => {
+  let cause = '';
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    const fd = fs.openSync(destination, 'w'); // 'w' truncates any partial bytes from the previous attempt
+    let result;
+    try {
+      result = spawn('gh', ['api', asset.url, '-H', 'Accept: application/octet-stream'], {
+        stdio: ['ignore', fd, 'pipe'], timeout: ASSET_DOWNLOAD_TIMEOUT_MS,
+      });
+    } finally { fs.closeSync(fd); }
+    if (!result.error && !result.signal && result.status === 0) return destination;
+    const stderr = String(result.stderr || '').trim().slice(0, 300);
+    cause = `${result.error?.message || result.signal || `exit ${result.status}`}${stderr ? ` (${stderr})` : ''}`;
+    if (attempt < attempts) wait(baseDelayMs * 2 ** (attempt - 1));
   }
+  throw new Error(`cannot download transaction asset ${asset.name} after ${attempts} attempts: ${cause}`);
+};
+const assetToFile = (asset, destination) => {
+  downloadAsset(asset, destination);
   return destination;
 };
 const withTempAsset = (asset, fn) => {