control-arm 0.1.0 → 1.2.0

package/action.yml

@@ -1,95 +0,0 @@
-# A composite action, not a Docker one: the tool is plain Node with no dependencies, so a
-# container would add a minute of build time to a check that otherwise takes seconds.
-name: 'control-arm'
-description: 'Prove the tests in this PR fail without it'
-inputs:
-  base:
-    description: >-
-      Branch this PR targets. The comparison uses the MERGE BASE with it, never its tip.
-      Defaults to `main`; set it explicitly if your project integrates somewhere else
-      (`develop`, `trunk`, a release branch).
-    required: false
-    default: 'main'
-  comment:
-    description: 'Post the result as a PR comment. Needs pull-requests:write and GH_TOKEN.'
-    required: false
-    default: 'true'
-  fail-on-blind:
-    description: >-
-      Fail the check when NO case in the PR discriminates. Default false: a PR can
-      legitimately ship only regression guards, and a gate that fires on those gets
-      switched off within a week.
-    required: false
-    default: 'false'
-  timeout-ms:
-    required: false
-    default: '180000'
-outputs:
-  verdict:
-    description: 'CAUGHT | BLIND | INCONCLUSIVE | FLAKY | SKIPPED'
-    value: ${{ steps.run.outputs.verdict }}
-runs:
-  using: composite
-  steps:
-    - id: run
-      shell: bash
-      env:
-        CA_BASE: ${{ inputs.base }}
-        CA_TIMEOUT: ${{ inputs.timeout-ms }}
-      run: |
-        set -uo pipefail
-        # The merge base needs both histories. A shallow checkout has neither.
-        git -C "$GITHUB_WORKSPACE" fetch --no-tags --depth=200 origin "$CA_BASE" 2>/dev/null || true
-        TIP="$(git -C "$GITHUB_WORKSPACE" rev-parse HEAD)"
-
-        OUT=$(node "${{ github.action_path }}/bin/ca.mjs" verify "$TIP" \
-                --against "origin/$CA_BASE" \
-                --repo "$GITHUB_WORKSPACE" \
-                --timeout "$CA_TIMEOUT" 2>&1) || true
-        echo "$OUT"
-
-        # `|| true` is load-bearing. GitHub runs bash steps with `set -e` by default, and
-        # `set -uo pipefail` above does not unset it. A grep that finds nothing exits 1,
-        # pipefail propagates it, and the step dies BEFORE the :-INCONCLUSIVE fallback can
-        # run. That is exactly what happens on a PR the tool declines — a workflow-only
-        # change with no test — so the one case designed to be a non-event failed the check.
-        VERDICT=$(printf '%s' "$OUT" | grep -oE 'VERDICT +[A-Z]+' | awk '{print $2}' | head -1 || true)
-        VERDICT="${VERDICT:-INCONCLUSIVE}"
-        echo "verdict=$VERDICT" >> "$GITHUB_OUTPUT"
-
-        # `--pr-comment` returns EMPTY for a commit the tool declined to judge, and the
-        # comment step skips on an empty file. The decision is the tool's, not a shell's:
-        # scraping stdout for a VERDICT line a declined run never prints is what put
-        # "SKIPPED · no case fails without the change" onto a PR that simply has no tests.
-        MD=$(node "${{ github.action_path }}/bin/ca.mjs" verify "$TIP" \
-               --against "origin/$CA_BASE" --pr-comment \
-               --repo "$GITHUB_WORKSPACE" --timeout "$CA_TIMEOUT" 2>/dev/null) || true
-        printf '%s' "$MD" > "$RUNNER_TEMP/ca-comment.md"
-        [ -s "$RUNNER_TEMP/ca-comment.md" ] || echo "declined — nothing to post: $(printf '%s' "$OUT" | tail -1)"
-
-    - shell: bash
-      if: inputs.comment == 'true' && github.event_name == 'pull_request'
-      env:
-        GITHUB_TOKEN: ${{ github.token }}
-      run: |
-        # node, not `gh`. The CLI is not installed on every runner — a self-hosted
-        # bare-metal box failed here with `gh: command not found` after every other step
-        # had passed, so the tool ran, reached the right verdict, and could not say so.
-        node "${{ github.action_path }}/scripts/gh-api.mjs" upsert-pr-comment \
-          "${{ github.repository }}" \
-          "${{ github.event.pull_request.number }}" \
-          "$RUNNER_TEMP/ca-comment.md" \
-          '### `control-arm`'
-
-    - shell: bash
-      if: inputs.fail-on-blind == 'true' && steps.run.outputs.verdict == 'BLIND'
-      run: |
-        echo "::error::No test in this PR fails without the change."
-        exit 1
-
-# Required by the GitHub Marketplace listing. `rewind` is not decoration: it is
-# literally what this does — wind the code back to before the fix, then run the
-# new test against it.
-branding:
-  icon: 'rewind'
-  color: 'orange'

package/fixtures/build.mjs

@@ -1,178 +0,0 @@
-/**
- * Fixture repos with KNOWN answers — this tool's own control arm.
- *
- * The tool's whole claim is "a test that cannot fail is decoration". A tool that asserts
- * that about other people's tests, while its own suite only checks that it doesn't crash,
- * is the same defect one level up. So: tiny git repos where the right verdict is known by
- * construction, and `test/fixtures.test.mjs` asserts the tool returns it.
- *
- * If `ca` cannot tell 02-blind-direction from 01-caught-value, it does not ship.
- *
- * THE BUG THEY ALL SHARE. `priority()` maps a label to a number. The broken version joins
- * its words with `\s*`, which matches whitespace and nothing else, so it reads
- * "HIGH PRIORITY" but not "HIGH-PRIORITY" — one separator, a different answer. The fixed
- * version accepts any run of real separators.
- *
- * Deliberately a boring, universal domain: every issue tracker has priority labels, and
- * the fixtures should not require knowing anybody's product to read. Only the TEST differs
- * between fixtures; the bug is identical in all of them, so a verdict can only come from
- * the test's quality.
- */
-
-import { execFileSync } from 'node:child_process';
-import { mkdirSync, writeFileSync, rmSync } from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), '.build');
-
-const BROKEN = `export function priority(label) {
-    const s = String(label).toLowerCase();
-    if (/high\\s*priority/.test(s)) return 1;   // \\s* matches whitespace and nothing else
-    if (/low\\s*priority/.test(s)) return 3;
-    return 2;
-}
-export const SLA_HOURS = { 1: 4, 2: 24, 3: 72 };
-`;
-const FIXED = BROKEN
-    .replace('/high\\s*priority/', '/high[-_\\s.]*priority/')
-    .replace('/low\\s*priority/', '/low[-_\\s.]*priority/');
-
-const FIXTURES = {
-    '01-caught-value': {
-        expect: 'CAUGHT',
-        why: 'asserts the exact priority for the hyphenated spelling',
-        test: `import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { priority, SLA_HOURS } from '../src/priority.mjs';
-test('a hyphenated HIGH-PRIORITY label is priority 1, four-hour SLA', () => {
-    assert.equal(priority('HIGH-PRIORITY'), 1);
-    assert.equal(SLA_HOURS[priority('HIGH-PRIORITY')], 4);
-});`,
-    },
-    '02-blind-direction': {
-        expect: 'BLIND',
-        why: 'asserts a DIRECTION (>0) that the wrong answer also satisfies',
-        test: `import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { priority, SLA_HOURS } from '../src/priority.mjs';
-test('hyphenated labels are handled', () => {
-    const p = priority('HIGH-PRIORITY');
-    assert.ok(p, 'a priority comes back');
-    assert.ok(SLA_HOURS[p] > 0, 'it has an SLA');
-    assert.notEqual(p, undefined);
-});`,
-    },
-    '03-blind-sourcetext': {
-        expect: 'BLIND',
-        why: 'greps the source instead of executing it',
-        test: `import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-test('the separator class is tolerant', () => {
-    const src = readFileSync(new URL('../src/priority.mjs', import.meta.url), 'utf8');
-    assert.ok(src.includes('priority'), 'the rule mentions priority');
-    assert.ok(/high/.test(src));
-});`,
-    },
-    '04-blind-overmock': {
-        expect: 'BLIND',
-        why: 'mocks the unit under test, so the real function never runs',
-        test: `import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { SLA_HOURS } from '../src/priority.mjs';
-const priority = () => 1;   // "stubbed for speed"
-test('a hyphenated HIGH-PRIORITY label is priority 1', () => {
-    assert.equal(priority('HIGH-PRIORITY'), 1);
-    assert.equal(SLA_HOURS[1], 4);
-});`,
-    },
-    '05-inconclusive-newexport': {
-        expect: 'INCONCLUSIVE',
-        why: 'imports a symbol the fix added — cannot even load at the parent',
-        fixedExtra: `export const SEPARATORS = /[-_\\s.]*/;\n`,
-        test: `import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { SEPARATORS } from '../src/priority.mjs';
-test('the separator class is shared', () => {
-    assert.equal(SEPARATORS.source, '[-_\\\\s.]*');
-});`,
-    },
-    '06-inconclusive-armA-red': {
-        expect: 'INCONCLUSIVE',
-        why: 'the case is not green on the fix either — the commit does not stand up',
-        test: `import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { priority } from '../src/priority.mjs';
-test('a hyphenated HIGH-PRIORITY label is priority 1', () => {
-    assert.equal(priority('HIGH-PRIORITY'), 99);
-});`,
-    },
-    '07-caught-mixed': {
-        expect: 'CAUGHT',
-        why: 'one discriminating case plus two regression guards green on both arms',
-        test: `import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { priority } from '../src/priority.mjs';
-test('DISCRIMINATES: the hyphenated spelling is priority 1', () => {
-    assert.equal(priority('HIGH-PRIORITY'), 1);
-});
-test('GUARD: the spaced spelling is still priority 1', () => {
-    assert.equal(priority('HIGH PRIORITY'), 1);
-});
-test('GUARD: an unlabelled ticket is still the default priority 2', () => {
-    assert.equal(priority('needs triage'), 2);
-});`,
-    },
-    '09-caught-slash-in-name': {
-        expect: 'CAUGHT',
-        why: 'the discriminating case has a SLASH in its name — it used to be silently dropped',
-        test: `import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { priority } from '../src/priority.mjs';
-test('label parsing / separator handling', () => {
-    assert.equal(priority('HIGH-PRIORITY'), 1);
-});`,
-    },
-    '08-skipped-notest': {
-        expect: 'SKIPPED',
-        why: 'the fix shipped no test at all',
-        test: null,
-    },
-};
-
-function sh(cwd, args) { execFileSync('git', args, { cwd, stdio: 'pipe' }); }
-
-export function buildFixtures() {
-    rmSync(ROOT, { recursive: true, force: true });
-    mkdirSync(ROOT, { recursive: true });
-    const built = {};
-
-    for (const [name, spec] of Object.entries(FIXTURES)) {
-        const dir = path.join(ROOT, name);
-        mkdirSync(path.join(dir, 'src'), { recursive: true });
-        mkdirSync(path.join(dir, 'tests'), { recursive: true });
-        sh(dir, ['init', '-q']);
-        sh(dir, ['config', 'user.email', 'ca@fixture']);
-        sh(dir, ['config', 'user.name', 'ca fixture']);
-        writeFileSync(path.join(dir, 'package.json'), JSON.stringify({ name, type: 'module', private: true }, null, 2));
-
-        // --- parent: the bug, and whatever tests existed before (none) ---
-        writeFileSync(path.join(dir, 'src/priority.mjs'), BROKEN);
-        sh(dir, ['add', '-A']); sh(dir, ['commit', '-qm', 'feat: priority labels']);
-
-        // --- fix: source repaired, test added ---
-        writeFileSync(path.join(dir, 'src/priority.mjs'), FIXED + (spec.fixedExtra || ''));
-        if (spec.test) writeFileSync(path.join(dir, 'tests/priority.test.mjs'), spec.test + '\n');
-        sh(dir, ['add', '-A']); sh(dir, ['commit', '-qm', 'fix: a hyphen made a HIGH-PRIORITY ticket read as normal']);
-
-        built[name] = { dir, sha: execFileSync('git', ['-C', dir, 'rev-parse', 'HEAD']).toString().trim(), ...spec };
-    }
-    return built;
-}
-
-if (import.meta.url === `file://${process.argv[1]}`) {
-    const b = buildFixtures();
-    for (const [n, f] of Object.entries(b)) console.log(`  ${f.expect.padEnd(13)} ${n.padEnd(26)} ${f.why}`);
-    console.log(`\n  ${Object.keys(b).length} fixtures in ${ROOT}\n`);
-}

package/scripts/gh-api.mjs

@@ -1,90 +0,0 @@
-#!/usr/bin/env node
-/**
- * The few GitHub API calls these workflows need, over plain fetch.
- *
- * WHY NOT THE `gh` CLI. It is not installed on every runner. Measured: a self-hosted
- * bare-metal runner failed with `gh: command not found` (exit 127) after every other step
- * had passed — the tool ran, reached the right verdict, and then could not say so.
- * GitHub-hosted runners ship `gh`; a self-hosted one ships whatever was installed on it,
- * and a workflow that assumes otherwise works until it lands on the wrong machine.
- *
- * Node is already a hard requirement here — the tool is written in it — so this adds no
- * dependency at all. Usage:
- *
- *   gh-api.mjs upsert-pr-comment <repo> <pr> <body-file> <marker>
- *   gh-api.mjs upsert-issue      <repo> <title> <body-file> <search> [label]
- *
- * Reads GITHUB_TOKEN / GH_TOKEN from the environment. Prints what it did, and exits
- * non-zero only when the API refuses — never merely because there was nothing to do.
- */
-
-const TOKEN = process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
-const API = process.env.GITHUB_API_URL || 'https://api.github.com';
-
-async function gh(path, init = {}) {
-    const res = await fetch(`${API}${path}`, {
-        ...init,
-        headers: {
-            authorization: `Bearer ${TOKEN}`,
-            accept: 'application/vnd.github+json',
-            'content-type': 'application/json',
-            'x-github-api-version': '2022-11-28',
-            ...(init.headers || {}),
-        },
-    });
-    if (!res.ok) {
-        const text = await res.text();
-        throw new Error(`${init.method || 'GET'} ${path} → ${res.status} ${text.slice(0, 300)}`);
-    }
-    return res.status === 204 ? null : res.json();
-}
-
-const [cmd, ...args] = process.argv.slice(2);
-const read = async (f) => (await import('node:fs/promises')).readFile(f, 'utf8');
-
-try {
-    if (!TOKEN) throw new Error('no GITHUB_TOKEN / GH_TOKEN in the environment');
-
-    if (cmd === 'upsert-pr-comment') {
-        const [repo, pr, bodyFile, marker] = args;
-        const body = await read(bodyFile);
-        if (!body.trim()) { console.log('nothing to post'); process.exit(0); }
-        // ONE COMMENT PER PR, edited in place. A new comment per push turns a useful signal
-        // into noise by the third revision, and the marker is how we find ours again.
-        const comments = await gh(`/repos/${repo}/issues/${pr}/comments?per_page=100`);
-        const mine = comments.find(c => (c.body || '').startsWith(marker));
-        if (mine) {
-            await gh(`/repos/${repo}/issues/comments/${mine.id}`, { method: 'PATCH', body: JSON.stringify({ body }) });
-            console.log(`updated comment ${mine.id}`);
-        } else {
-            const made = await gh(`/repos/${repo}/issues/${pr}/comments`, { method: 'POST', body: JSON.stringify({ body }) });
-            console.log(`posted comment ${made.id}`);
-        }
-    } else if (cmd === 'upsert-issue') {
-        const [repo, title, bodyFile, search, label] = args;
-        const body = await read(bodyFile);
-        if (label) {
-            // Create the label if absent. `labels` on an issue with an unknown label is
-            // rejected outright, so this cannot be left to chance — but a failure here is
-            // a warning, not a reason to drop the finding on the floor.
-            try {
-                await gh(`/repos/${repo}/labels`, { method: 'POST', body: JSON.stringify({ name: label, color: '0E8A16', description: 'Test-gap findings from control-arm' }) });
-            } catch (e) { if (!/already_exists|422/.test(e.message)) console.log(`::warning::could not create label ${label}: ${e.message}`); }
-        }
-        const found = await gh(`/search/issues?q=${encodeURIComponent(`repo:${repo} is:issue is:open ${search}`)}`);
-        const hit = found.items?.[0];
-        if (hit) {
-            await gh(`/repos/${repo}/issues/${hit.number}`, { method: 'PATCH', body: JSON.stringify({ title, body }) });
-            console.log(`refreshed issue #${hit.number}`);
-        } else {
-            const made = await gh(`/repos/${repo}/issues`, { method: 'POST', body: JSON.stringify({ title, body, ...(label ? { labels: [label] } : {}) }) });
-            console.log(`filed issue #${made.number}`);
-        }
-    } else {
-        console.error('usage: gh-api.mjs upsert-pr-comment|upsert-issue ...');
-        process.exit(2);
-    }
-} catch (e) {
-    console.error(`::error::${e.message}`);
-    process.exit(1);
-}

package/scripts-analyze.mjs

@@ -1,86 +0,0 @@
-/**
- * Segment the audit CSV by which runner the test file belongs to.
- *
- * `ca` ships one runner (node:test). A monorepo's fix commits touch vitest and jest test
- * files too, and those come back INCONCLUSIVE for a reason that says nothing about the
- * test — the tool simply cannot execute it. Reporting one blended ratio over both would
- * be the same defect the tool exists to catch: a number fitted to a population it does
- * not describe.
- */
-import { readFileSync } from 'node:fs';
-
-const rows = [];
-const raw = readFileSync(process.argv[2], 'utf8').split('\n').filter(Boolean);
-const hdr = raw.shift().split(',');
-for (const line of raw) {
-    // naive CSV with quoted fields
-    const f = []; let cur = '', q = false;
-    for (let i = 0; i < line.length; i++) {
-        const c = line[i];
-        if (q) { if (c === '"' && line[i + 1] === '"') { cur += '"'; i++; } else if (c === '"') q = false; else cur += c; }
-        else if (c === '"') q = true;
-        else if (c === ',') { f.push(cur); cur = ''; }
-        else cur += c;
-    }
-    f.push(cur);
-    rows.push(Object.fromEntries(hdr.map((h, i) => [h, f[i]])));
-}
-
-const runnerOf = (file) => {
-    if (!file) return 'none';
-    if (file.startsWith('tests/')) return 'node:test (supported)';
-    if (file.startsWith('apps/web/')) return 'vitest (unsupported)';
-    if (file.startsWith('apps/mobile/')) return 'jest (unsupported)';
-    if (file.startsWith('apps/e2e/')) return 'playwright (unsupported)';
-    if (file.startsWith('packages/')) return 'node:test (supported)';
-    return 'other';
-};
-
-const commits = new Map();
-for (const r of rows) {
-    if (!commits.has(r.sha)) commits.set(r.sha, { sha: r.sha, date: r.date, subject: r.subject, verdict: r.commit_verdict, cases: [] });
-    commits.get(r.sha).cases.push(r);
-}
-
-// A commit belongs to the runner of its test files; mixed commits are called out.
-const seg = new Map();
-for (const c of commits.values()) {
-    const rs = [...new Set(c.cases.map(x => runnerOf(x.file)).filter(x => x !== 'none'))];
-    const key = rs.length === 0 ? 'no test file' : rs.length === 1 ? rs[0] : 'mixed';
-    if (!seg.has(key)) seg.set(key, []);
-    seg.get(key).push(c);
-}
-
-const V = ['CAUGHT', 'BLIND', 'FLAKY', 'INCONCLUSIVE', 'SKIPPED'];
-console.log('\n  COMMITS BY RUNNER SEGMENT\n');
-console.log('  ' + 'segment'.padEnd(26) + V.map(v => v.slice(0, 6).padStart(7)).join('') + '    n');
-for (const [k, list] of [...seg].sort((a, b) => b[1].length - a[1].length)) {
-    const t = V.map(v => String(list.filter(c => c.verdict === v).length).padStart(7)).join('');
-    console.log('  ' + k.padEnd(26) + t + String(list.length).padStart(5));
-}
-
-const supported = seg.get('node:test (supported)') || [];
-const dec = supported.filter(c => c.verdict === 'CAUGHT' || c.verdict === 'BLIND');
-console.log(`\n  SUPPORTED SEGMENT ONLY (node:test)\n`);
-console.log(`    ${supported.length} commits · ${dec.length} the instrument could answer`);
-if (dec.length) {
-    const caught = dec.filter(c => c.verdict === 'CAUGHT').length;
-    console.log(`    CAUGHT ${caught}/${dec.length} = ${(caught / dec.length * 100).toFixed(1)}%   BLIND ${dec.length - caught}/${dec.length} = ${((dec.length - caught) / dec.length * 100).toFixed(1)}%`);
-}
-const blind = supported.filter(c => c.verdict === 'BLIND');
-if (blind.length) {
-    console.log(`\n  BLIND COMMITS IN THE SUPPORTED SEGMENT (hand-audit these)\n`);
-    for (const c of blind) console.log(`    ${c.sha.slice(0, 8)}  ${c.date}  ${c.subject.slice(0, 90)}`);
-}
-const why = new Map();
-for (const c of supported.filter(c => c.verdict === 'INCONCLUSIVE')) {
-    for (const cs of c.cases.filter(x => x.case_verdict === 'INCONCLUSIVE')) {
-        const k = cs.reason.replace(/'[^']*'/g, "'…'").replace(/\d+/g, 'N').slice(0, 88);
-        why.set(k, (why.get(k) || 0) + 1);
-    }
-}
-if (why.size) {
-    console.log(`\n  WHY INCONCLUSIVE, supported segment only\n`);
-    for (const [k, v] of [...why].sort((a, b) => b[1] - a[1]).slice(0, 14)) console.log(`    ${String(v).padStart(4)}  ${k}`);
-}
-console.log('');

package/scripts-recompute.mjs

@@ -1,53 +0,0 @@
-/**
- * Re-roll commit verdicts from a saved audit CSV using the CURRENT rollUp.
- *
- * Per-case verdicts are what the two arms measured; the commit verdict is a pure function
- * of them. So a change to the roll-up rule does not need the 7-minute run again — and
- * re-running would also change the sample, which is the wrong thing to do when comparing
- * a rule change.
- */
-import { readFileSync } from 'node:fs';
-import { rollUp } from './src/verdict.mjs';
-
-function parseCsv(text) {
-    const out = []; const lines = text.split('\n').filter(Boolean); const hdr = lines.shift().split(',');
-    for (const line of lines) {
-        const f = []; let cur = '', q = false;
-        for (let i = 0; i < line.length; i++) { const c = line[i];
-            if (q) { if (c === '"' && line[i+1] === '"') { cur += '"'; i++; } else if (c === '"') q = false; else cur += c; }
-            else if (c === '"') q = true; else if (c === ',') { f.push(cur); cur = ''; } else cur += c; }
-        f.push(cur); out.push(Object.fromEntries(hdr.map((h, i) => [h, f[i]])));
-    }
-    return out;
-}
-const runnerOf = f => !f ? 'none'
-    : f.startsWith('tests/') || f.startsWith('packages/') ? 'node:test'
-    : f.startsWith('apps/web/') ? 'vitest' : f.startsWith('apps/mobile/') ? 'jest'
-    : f.startsWith('apps/e2e/') ? 'playwright' : 'other';
-
-const rows = parseCsv(readFileSync(process.argv[2], 'utf8'));
-const commits = new Map();
-for (const r of rows) {
-    if (!commits.has(r.sha)) commits.set(r.sha, { ...r, cases: [] });
-    if (r.case) commits.get(r.sha).cases.push(r);
-}
-const list = [...commits.values()].map(c => {
-    const nv = c.cases.length ? rollUp(c.cases.map(x => ({ verdict: x.case_verdict }))) : c.commit_verdict;
-    const rs = [...new Set(c.cases.map(x => runnerOf(x.file)).filter(x => x !== 'none'))];
-    return { ...c, was: c.commit_verdict, now: nv, seg: rs.length === 1 ? rs[0] : rs.length ? 'mixed' : 'none' };
-});
-
-const V = ['CAUGHT', 'BLIND', 'FLAKY', 'INCONCLUSIVE', 'SKIPPED'];
-const changed = list.filter(c => c.was !== c.now);
-console.log(`\n  ${list.length} commits · ${changed.length} changed verdict under the corrected roll-up\n`);
-for (const c of changed) console.log(`    ${c.was.padEnd(13)} -> ${c.now.padEnd(13)} ${c.sha.slice(0,8)}  ${c.subject.slice(0,70)}`);
-
-const node = list.filter(c => c.seg === 'node:test' || c.seg === 'mixed');
-const dec = node.filter(c => c.now === 'CAUGHT' || c.now === 'BLIND');
-const caught = dec.filter(c => c.now === 'CAUGHT').length;
-console.log(`\n  SUPPORTED SEGMENT (node:test, incl. mixed): ${node.length} commits`);
-for (const v of V) { const n = node.filter(c => c.now === v).length; if (n) console.log(`    ${v.padEnd(14)} ${String(n).padStart(4)}  ${(n/node.length*100).toFixed(1)}%`); }
-console.log(`\n  ANSWERABLE: ${dec.length}   CAUGHT ${caught} (${(caught/dec.length*100).toFixed(1)}%)   BLIND ${dec.length-caught} (${((dec.length-caught)/dec.length*100).toFixed(1)}%)\n`);
-console.log('  BLIND after correction:\n');
-for (const c of list.filter(c => c.now === 'BLIND')) console.log(`    ${c.sha.slice(0,8)}  ${c.date}  ${c.subject.slice(0,84)}`);
-console.log('');

package/test/assertions.test.mjs

@@ -1,130 +0,0 @@
-/**
- * Case extraction, pinned against the four shapes that actually broke it.
- *
- * Each of these was measured on a real corpus of 400 test cases, and each one alone
- * accounted for a double-digit share of "could not analyse". Together they took the
- * unresolvable pile from 64% to 1.3%. None would be caught by a suite that only fed the
- * analyser well-formed input, which is why they are here with the messy input attached.
- */
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { extractCase, analyseCase } from '../src/assertions.mjs';
-
-test('nested suites: the runner reports the CONCATENATED name, the source holds the inner one', () => {
-    const src = `
-describe('auction client', () => {
-  it('AUCWEB-001 calls GET /auction/:vin', () => { assert.equal(a, 1); });
-});`;
-    // Reported by the runner as describe-title + space + it-title.
-    const body = extractCase(src, 'auction client AUCWEB-001 calls GET /auction/:vin');
-    assert.ok(body, 'progressive reduction must find the inner title');
-    assert.match(body, /assert\.equal\(a, 1\)/);
-});
-
-test('an APOSTROPHE in the title: source holds a backslash the reported name does not', () => {
-    const src = `it('METER-038: usage on the user\\'s LOCAL today is counted', () => { assert.equal(n, 3); });`;
-    const body = extractCase(src, "METER-038: usage on the user's LOCAL today is counted");
-    assert.ok(body, "an escaped quote inside the literal must still match the unescaped reported name");
-    assert.match(body, /assert\.equal\(n, 3\)/);
-});
-
-test('JSX: a closing tag is NOT a regex literal', () => {
-    // `</div>` puts a slash after `<`. The usual "slash after a non-expression starts a
-    // regex" heuristic swallows the rest of the component, and the body is never found.
-    const src = `
-it('hero renders', () => {
-  render(<div className="x">{name}</div>);
-  expect(screen.getByText('hi')).toBeTruthy();
-});`;
-    const body = extractCase(src, 'hero renders');
-    assert.ok(body, 'a JSX body must brace-match cleanly');
-    assert.match(body, /getByText/);
-});
-
-test('braces inside strings and regexes do not unbalance the scan', () => {
-    const src = `
-it('handles braces', () => {
-  const s = '{';
-  const re = /[{}]/;
-  assert.equal(f(s, re), '}');
-});`;
-    const body = extractCase(src, 'handles braces');
-    assert.ok(body, 'a brace inside a string or a character class is not structure');
-    assert.match(body, /assert\.equal\(f\(s, re\)/);
-});
-
-test('template-literal titles: every generated case resolves to the shared body', () => {
-    const src = `
-for (const rel of PAGES) {
-  it(\`\${rel}: no internal repo paths\`, () => { expect(md).not.toMatch(BAD); });
-}`;
-    const a = extractCase(src, 'app/page.tsx: no internal repo paths');
-    const b = extractCase(src, 'app/pricing/page.tsx: no internal repo paths');
-    assert.ok(a && b, 'a parameterised title must match by pattern, not by equality');
-    assert.equal(a, b, 'all generated cases share one body — that is correct, not a bug');
-});
-
-test('a wrong body is worse than none: a short remainder is refused', () => {
-    const src = `
-it('alpha returns null', () => { assert.equal(x, null); });
-it('beta returns null',  () => { assert.equal(y, 0); });`;
-    // "returns null" alone is ambiguous between the two — reduction must not take it.
-    const body = extractCase(src, 'some suite that does not exist returns null');
-    assert.equal(body, null, 'an ambiguous short suffix must not resolve to an arbitrary case');
-});
-
-test('CONTROL ARM: naive equality-only extraction fails every one of these', () => {
-    // The implementation this replaced. Asserted to still get them wrong.
-    const naive = (src, name) => {
-        const esc = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-        return new RegExp(`\\b(?:test|it)\\s*\\(\\s*(['"\`])${esc}\\1`).test(src);
-    };
-    assert.equal(naive(`it('a b c', () => {});`, 'suite a b c'), false);   // nested
-    assert.equal(naive(`it('u\\'s v', () => {});`, "u's v"), false);        // apostrophe
-    assert.equal(naive('it(`${r}: x`, () => {});', 'p.tsx: x'), false);    // template
-});
-
-test('the analyser reports UNKNOWN rather than a clean bill when it cannot tell', () => {
-    const r = analyseCase(`it('odd', () => { somethingEntirelyUnrecognised(); });`, 'odd');
-    assert.notEqual(r.verdict, 'strong', 'an unrecognised body must never read as strong');
-});
-
-test('a short helper name must not be accused of stubbing the unit under test', () => {
-    // FOUND ON A REAL RUN. The stub check substring-matched the name against every import
-    // path, so a two-letter helper `at` matched '@acme/core' — "acme" contains "at" — and
-    // every case in that file was reported as testing a stub. A wrong explanation is worse
-    // than none: it sends the reader to look at code that is fine.
-    const src = `
-import { computeTier } from '@acme/core/tiers.js';
-const at = (arr, i) => arr[i];
-it('TIER-001: the tier changes the money', () => {
-    assert.equal(at(computeTier(x), 0), 1200);
-});`;
-    const r = analyseCase(src, 'TIER-001: the tier changes the money');
-    assert.ok(!r.findings.some(f => f.id === 'stubbed-subject'),
-        'a local helper whose name merely appears inside an import path is not a stub');
-});
-
-test('a REAL stub is still caught — the tightening must not blind the check', () => {
-    const src = `
-import { SLA_HOURS } from '../src/priority.mjs';
-const priority = () => 1;
-it('p is 1', () => { assert.equal(priority('HIGH-PRIORITY'), 1); });`;
-    const r = analyseCase(src, 'p is 1');
-    assert.ok(r.findings.some(f => f.id === 'stubbed-subject'),
-        'a stub matching the imported module basename must still be reported');
-    assert.equal(r.verdict, 'weak');
-});
-
-test('a declined commit produces NO pr comment — silence, not an accusation', async () => {
-    // It briefly posted "SKIPPED · No case in this branch fails without the change" onto a
-    // workflow-only PR. Technically true and completely misleading: that PR has no tests,
-    // so of course none discriminate. A comment reading as an accusation on a PR doing
-    // nothing wrong is worse than no comment.
-    const { prComment } = await import('../src/markdown-report.mjs');
-    const declined = { short: 'abc12345', verdict: 'SKIPPED', cases: [], note: 'no test file in the commit' };
-    assert.equal(prComment(declined), '', 'a noted (declined) result must render as empty');
-
-    const real = { short: 'abc12345', verdict: 'CAUGHT', cases: [{ verdict: 'CAUGHT', name: 'x', reason: 'y' }] };
-    assert.notEqual(prComment(real), '', 'a real verdict must still render');
-});