control-arm 0.1.0 → 1.0.0

package/README.md

@@ -46,7 +46,7 @@ Node 18+. No other dependencies.
 
 ```bash
 # Can this repo be measured at all?
-ca probe
+ca doctor
 
 # Judge one commit — a fix, with the test that shipped alongside it
 ca verify <sha>
@@ -62,6 +62,12 @@ ca verify HEAD --against origin/main
 name: control-arm
 on: pull_request
 
+# `comment: true` posts with the default GITHUB_TOKEN, which is read-only in most
+# repos. Without this block the run succeeds and the comment silently never appears.
+permissions:
+  contents: read
+  pull-requests: write
+
 jobs:
   verify:
     runs-on: ubuntu-latest

package/package.json

@@ -1,9 +1,32 @@
 {
   "name": "control-arm",
-  "version": "0.1.0",
+  "version": "1.0.0",
   "description": "Does a test actually fail on the code it was written to catch?",
   "type": "module",
   "bin": { "ca": "./bin/ca.mjs" },
+  "files": [
+    "bin",
+    "src",
+    "README.md",
+    "DESIGN.md",
+    "LICENSE"
+  ],
+  "engines": { "node": ">=18" },
+  "keywords": [
+    "testing",
+    "test-quality",
+    "mutation-testing",
+    "regression-testing",
+    "continuous-integration",
+    "github-actions",
+    "code-quality"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mekanhan/control-arm.git"
+  },
+  "homepage": "https://github.com/mekanhan/control-arm#readme",
+  "bugs": { "url": "https://github.com/mekanhan/control-arm/issues" },
   "scripts": {
     "test": "node --test test/*.test.mjs",
     "fixtures": "node fixtures/build.mjs"

package/.github/workflows/ci.yml

@@ -1,82 +0,0 @@
-# The tool that asks whether your tests can fail, running its own.
-#
-# It shipped for a day without this. That is the defect it exists to find, one level up:
-# a suite that is never executed by anything but its author's terminal is not a gate, and
-# "46/46 green" meant "green on one laptop, when I remembered".
-#
-# GitHub-hosted runners on purpose: control-arm has no dependencies and must work on a
-# stock box. Pinning it to a self-hosted fleet would hide exactly the assumptions —
-# a preinstalled binary, a warm cache, a particular git version — that break for the
-# first stranger who clones it.
-name: CI
-
-on:
-  push:
-    branches: [master, main]
-  pull_request:
-  workflow_dispatch:
-
-concurrency:
-  group: ci-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  test:
-    name: node ${{ matrix.node }}
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        # 20 is the oldest LTS with a stable node:test reporter API, which the TAP parser
-        # depends on. 24 is what it is developed against. A break in either is worth knowing.
-        node: ['20', '22', '24']
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          # FULL HISTORY, not the default shallow clone. The dogfood step verifies the tool
-          # against one of its OWN past commits, and `git show 1845c1d3` on a depth-1
-          # checkout fails with "unknown revision". Caught by this workflow's first run,
-          # which is the argument for having it.
-          fetch-depth: 0
-      - uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.node }}
-
-      - name: Unit + fixtures
-        run: node --test --test-concurrency=1 test/*.test.mjs
-
-      # DOGFOOD. The fixtures prove the verdicts on repos built to have known answers.
-      # This proves the whole two-arm machinery works on a REAL history with real commits,
-      # worktrees and module resolution — which is where every bug so far has come from.
-      - name: Judge its own history
-        run: |
-          set -euo pipefail
-          git config --global user.email ci@control-arm
-          git config --global user.name ci
-
-          OUT=$(node bin/ca.mjs verify 1845c1d3 --repo "$GITHUB_WORKSPACE" --timeout 120000)
-          echo "$OUT"
-
-          # That commit added the rule "a SKIPPED case blocks BLIND", with a test written
-          # for it. If the tool cannot still see that test discriminate, the tool is broken
-          # — regardless of what its unit suite says.
-          # Match the VERDICT WORD, not the whole line. This grep was 'VERDICT  CAUGHT'
-          # and broke the moment a glyph was added between them — a cosmetic change that
-          # failed a correctness gate, which trains people to edit the gate rather than
-          # believe it. Anchor on what the check is actually about.
-          echo "$OUT" | grep -qE '^ *VERDICT .*\bCAUGHT\b' \
-            || { echo "::error::control-arm no longer judges its own fix correctly"; exit 1; }
-          # And it must be the STRONG claim: 1845c1d3 is a repair, so a "weak evidence"
-          # qualifier here would mean the new-code heuristic has started misfiring on fixes.
-          echo "$OUT" | grep -q 'weak evidence' \
-            && { echo "::error::a repair was labelled new code — the kind heuristic is wrong"; exit 1; }
-          echo "$OUT" | grep -q 'module identity verified' \
-            || { echo "::error::module identity was not proven — a verdict here is not trustworthy"; exit 1; }
-
-      - name: Determinism
-        run: |
-          set -euo pipefail
-          A=$(node bin/ca.mjs verify 1845c1d3 --repo "$GITHUB_WORKSPACE" --work /tmp/d1 --timeout 120000 | tail -14)
-          B=$(node bin/ca.mjs verify 1845c1d3 --repo "$GITHUB_WORKSPACE" --work /tmp/d2 --timeout 120000 | tail -14)
-          [ "$A" = "$B" ] || { echo "::error::two runs disagreed — the tool is not deterministic"; exit 1; }
-          echo "two independent runs are byte-identical"

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');
-});

package/test/fixtures.test.mjs

@@ -1,41 +0,0 @@
-/**
- * The tool's control arm. Eight repos where the right answer is known by construction.
- *
- * A green run here is the only reason to believe a verdict this tool prints about
- * anybody else's code. It is also the thing that would catch the failure mode that
- * matters most — a FALSE BLIND — because 01 and 07 must never come back BLIND.
- */
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import path from 'node:path';
-import { buildFixtures } from '../fixtures/build.mjs';
-import { verifyCommit } from '../src/verify.mjs';
-import { removeWorktrees } from '../src/worktree.mjs';
-
-const fixtures = buildFixtures();
-
-for (const [name, f] of Object.entries(fixtures)) {
-    test(`${name} -> ${f.expect}  (${f.why})`, async () => {
-        const workDir = path.join(f.dir, '.ca-work');
-        try {
-            const r = await verifyCommit({ repo: f.dir, workDir, sha: f.sha, runs: 1, timeoutMs: 30_000 });
-            assert.equal(r.verdict, f.expect,
-                `expected ${f.expect}, got ${r.verdict}\n` +
-                r.cases.map(c => `    ${c.verdict}  ${c.name}  — ${c.reason}`).join('\n') +
-                (r.note ? `\n    note: ${r.note}` : ''));
-        } finally {
-            await removeWorktrees(f.dir, workDir);
-        }
-    });
-}
-
-test('a FALSE BLIND is the failure that matters: no discriminating fixture may read BLIND', async () => {
-    for (const name of ['01-caught-value', '07-caught-mixed']) {
-        const f = fixtures[name];
-        const workDir = path.join(f.dir, '.ca-work-fb');
-        try {
-            const r = await verifyCommit({ repo: f.dir, workDir, sha: f.sha, runs: 1, timeoutMs: 30_000 });
-            assert.notEqual(r.verdict, 'BLIND', `${name} was accused of being blind — this is the output that destroys trust in the tool`);
-        } finally { await removeWorktrees(f.dir, workDir); }
-    }
-});

package/test/runner-json.test.mjs

@@ -1,69 +0,0 @@
-/**
- * The vitest/jest adapter, at the level where it can actually be wrong.
- *
- * WHAT THIS DOES AND DOES NOT COVER — stated because the gap matters.
- *
- * The node:test path has 9 end-to-end fixtures: real git repos, both arms, known verdict.
- * These two runners do NOT, because a fixture would have to `npm install` vitest or jest
- * per repo — slow, network-dependent, and version-drifting. The full two-arm path for
- * each is verified on ONE real commit apiece — a vitest component commit and a jest
- * React Native commit — which is a smoke test, not a control arm.
- *
- * So this file covers the part that is BOTH untested end-to-end AND most likely to be
- * wrong: the text-matching in `classifyMessages`. node:test hands over `ERR_ASSERTION`;
- * these two give formatted strings, so the adapter has to read prose. Every string below
- * is a real shape emitted by vitest or jest, not an invented one.
- */
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { classifyMessages } from '../src/runner-json.mjs';
-
-const isDisagreement = m => classifyMessages(m).code === 'ERR_ASSERTION';
-const isCannotRun = m => classifyMessages(m).code === 'ERR_TEST_FAILURE';
-const isUnknown = m => classifyMessages(m).code === null;
-
-test('vitest/chai disagreement is read as an assertion', () => {
-    assert.ok(isDisagreement(["AssertionError: expected 'Urgent' to deeply equal 'Normal'"]));
-    assert.ok(isDisagreement(['AssertionError: expected 40 to be 65 // Object.is equality']));
-});
-
-test('jest/expect disagreement is read as an assertion', () => {
-    assert.ok(isDisagreement(['expect(received).toBe(expected) // Object.is equality\n\nExpected: "Normal"\nReceived: "Urgent"']));
-    assert.ok(isDisagreement(['Error: expect(received).toEqual(expected)\n\n- Expected\n+ Received']));
-});
-
-test('a module that could not load is NOT an assertion', () => {
-    assert.ok(isCannotRun(["Error: Cannot find module '../src/newHelper' from 'lib/__tests__/x.test.tsx'"]));
-    assert.ok(isCannotRun(["SyntaxError: The requested module './bucket.js' does not provide an export named 'SEP'"]));
-    assert.ok(isCannotRun(['Error: Failed to resolve import "./notYet" from "lib/x.test.tsx". Does the file exist?']));
-    assert.ok(isCannotRun(['TypeError [ERR_UNKNOWN_FILE_EXTENSION]: Unknown file extension ".tsx"']));
-});
-
-test('CANNOT-RUN WINS when both shapes appear — the ordering that matters', () => {
-    // A failed module load frequently ALSO prints an expect() frame from the stack. If
-    // the disagreement patterns were checked first, this would read CAUGHT, and a commit
-    // whose test never ran would be credited with catching its bug.
-    const both = ['SyntaxError: does not provide an export named \'SEP\'\n  at expect(received).toBe(expected)\n  expected \'a\' to be \'b\''];
-    assert.ok(isCannotRun(both), 'a load failure that also prints an expect() frame must not read as a disagreement');
-    assert.notEqual(classifyMessages(both).code, 'ERR_ASSERTION');
-});
-
-test('an UNRECOGNISED message is unknown — never guessed into an assertion', () => {
-    // This is the design: an unrecognised shape costs COVERAGE (it reads INCONCLUSIVE),
-    // it cannot manufacture a finding. A drifting regex must fail safe, not fail loud.
-    assert.ok(isUnknown(['Something entirely unexpected happened in a custom matcher']));
-    assert.ok(isUnknown([]));
-    assert.ok(isUnknown(['']));
-    assert.notEqual(classifyMessages(['whatever']).code, 'ERR_ASSERTION');
-});
-
-test('CONTROL ARM: a naive "any failure is a disagreement" classifier gets these wrong', () => {
-    // TEST-001 — run the broken implementation and assert it still reproduces the bug.
-    const naive = msgs => (msgs && msgs.length ? 'ERR_ASSERTION' : null);
-    const loadFail = ["Error: Cannot find module '../src/newHelper'"];
-    assert.equal(naive(loadFail), 'ERR_ASSERTION');              // the naive one says CAUGHT
-    assert.equal(classifyMessages(loadFail).code, 'ERR_TEST_FAILURE');  // ours says it never ran
-    const weird = ['custom matcher blew up'];
-    assert.equal(naive(weird), 'ERR_ASSERTION');
-    assert.equal(classifyMessages(weird).code, null);
-});

package/test/select-runner.test.mjs

@@ -1,78 +0,0 @@
-/**
- * Runner selection, over synthetic trees.
- *
- * Picking the WRONG runner is a silent failure: vitest run from the repo root finds no
- * config and reports "No test files found", which reads INCONCLUSIVE — a whole surface
- * disappears without ever saying why. So the walk-up has to be pinned.
- */
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { selectRunner } from '../src/select-runner.mjs';
-
-function tree(spec) {
-    const root = mkdtempSync(path.join(tmpdir(), 'ca-sel-'));
-    for (const [rel, content] of Object.entries(spec)) {
-        const p = path.join(root, rel);
-        mkdirSync(path.dirname(p), { recursive: true });
-        writeFileSync(p, content);
-    }
-    return root;
-}
-
-test('a vitest config in the workspace wins, and names that workspace as cwd', async () => {
-    const root = tree({
-        'package.json': '{"workspaces":["apps/*"]}',
-        'apps/web/vitest.config.ts': 'export default {}',
-        'apps/web/lib/__tests__/x.test.tsx': '',
-    });
-    try {
-        const r = await selectRunner(root, 'apps/web/lib/__tests__/x.test.tsx');
-        assert.equal(r.flavour, 'vitest');
-        assert.equal(r.pkgDir, 'apps/web', 'must run FROM apps/web — vitest resolves config relative to cwd');
-    } finally { rmSync(root, { recursive: true, force: true }); }
-});
-
-test('a jest config in the workspace wins', async () => {
-    const root = tree({ 'package.json': '{}', 'apps/mobile/jest.config.js': '', 'apps/mobile/__tests__/y.test.ts': '' });
-    try {
-        const r = await selectRunner(root, 'apps/mobile/__tests__/y.test.ts');
-        assert.equal(r.flavour, 'jest');
-        assert.equal(r.pkgDir, 'apps/mobile');
-    } finally { rmSync(root, { recursive: true, force: true }); }
-});
-
-test('root tests fall to node:test when nothing else claims them', async () => {
-    const root = tree({ 'package.json': '{"scripts":{"test":"node --test tests/*.test.js"}}', 'tests/a.test.js': '' });
-    try {
-        const r = await selectRunner(root, 'tests/a.test.js');
-        assert.equal(r.flavour, 'node');
-        assert.equal(r.pkgDir, '');
-    } finally { rmSync(root, { recursive: true, force: true }); }
-});
-
-test('a repo that declares NOTHING falls through to node:test, not to a guess', async () => {
-    // The safe default: node:test either works, or reports a load failure, which reads
-    // INCONCLUSIVE. Guessing vitest here would produce "No test files found" — the same
-    // silent disappearance this test exists to prevent.
-    const root = tree({ 'tests/a.test.js': '' });
-    try {
-        assert.equal((await selectRunner(root, 'tests/a.test.js')).flavour, 'node');
-    } finally { rmSync(root, { recursive: true, force: true }); }
-});
-
-test('a workspace config beats a root test script — the nearest owner wins', async () => {
-    // The root script often delegates (`npm run test --workspaces`), while the config
-    // that actually governs the file sits in the package. Nearest wins, walking up.
-    const root = tree({
-        'package.json': '{"scripts":{"test":"node --test"}}',
-        'apps/web/vitest.config.ts': '',
-        'apps/web/x.test.tsx': '',
-    });
-    try {
-        const r = await selectRunner(root, 'apps/web/x.test.tsx');
-        assert.equal(r.flavour, 'vitest');
-    } finally { rmSync(root, { recursive: true, force: true }); }
-});

package/test/verdict.test.mjs

@@ -1,113 +0,0 @@
-/**
- * The decision logic, exhaustively, with no git and no subprocesses.
- *
- * Every case here is a shape observed in a real run, not an invented one.
- */
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { classify, reduceRuns, rollUp, isDisagreement, CAUGHT, BLIND, NON_DISCRIMINATING, INCONCLUSIVE, FLAKY, SKIPPED } from '../src/verdict.mjs';
-
-const pass = { status: 'pass' };
-const assertFail = { status: 'fail', code: 'ERR_ASSERTION', errorName: 'AssertionError', message: "expected 1, got 2" };
-const errFail = { status: 'fail', code: 'ERR_TEST_FAILURE', errorName: 'SyntaxError', message: "does not provide an export named 'TITLE_SEPARATOR'" };
-
-test('CAUGHT: green on the fix, assertion-red on the parent', () => {
-    assert.equal(classify({ armA: pass, armB: assertFail }).verdict, CAUGHT);
-});
-
-test('NON-DISCRIMINATING: green on the fix AND green on the parent', () => {
-    assert.equal(classify({ armA: pass, armB: pass }).verdict, NON_DISCRIMINATING);
-});
-
-test('a case green on both arms is never called BLIND — a regression guard is indistinguishable', () => {
-    // Observed in practice: 3 of one commit's 4 cases were deliberate regression guards.
-    assert.notEqual(classify({ armA: pass, armB: pass }).verdict, BLIND);
-});
-
-test('a non-assertion failure on the parent is INCONCLUSIVE, never CAUGHT — the test never ran', () => {
-    const r = classify({ armA: pass, armB: errFail });
-    assert.equal(r.verdict, INCONCLUSIVE);
-    assert.match(r.reason, /never ran/);
-});
-
-test('exit code alone would have gotten that wrong', () => {
-    // Both of these are "the process exited non-zero". Only one is a verdict.
-    assert.equal(classify({ armA: pass, armB: assertFail }).verdict, CAUGHT);
-    assert.equal(classify({ armA: pass, armB: errFail }).verdict, INCONCLUSIVE);
-});
-
-test('unproven module identity withholds the verdict even when arm B passed', () => {
-    // THE false-BLIND guard. Arm B green + identity unproven is precisely the symlink
-    // trap that made this tool report a false BLIND before it had an identity gate.
-    const r = classify({ armA: pass, armB: pass, identity: { proven: false, reason: 'resolved OUTSIDE the worktree' } });
-    assert.equal(r.verdict, INCONCLUSIVE);
-    assert.notEqual(r.verdict, BLIND);
-});
-
-test('a case that is red on the fix is INCONCLUSIVE — the commit does not stand up', () => {
-    assert.equal(classify({ armA: assertFail, armB: assertFail }).verdict, INCONCLUSIVE);
-});
-
-test('a case missing from the parent run is INCONCLUSIVE, not BLIND', () => {
-    assert.equal(classify({ armA: pass, armB: null }).verdict, INCONCLUSIVE);
-});
-
-test('isDisagreement is narrow: an unknown error name is not guessed into CAUGHT', () => {
-    assert.equal(isDisagreement({ status: 'fail', errorName: 'WeirdCustomError' }), false);
-    assert.equal(isDisagreement({ status: 'fail', errorName: 'JestAssertionError' }), true);
-});
-
-test('FLAKY: runs that disagree between CAUGHT and BLIND', () => {
-    const r = reduceRuns([{ verdict: CAUGHT }, { verdict: NON_DISCRIMINATING }, { verdict: CAUGHT }]);
-    assert.equal(r.verdict, FLAKY);
-});
-
-test('an INCONCLUSIVE run does not erase a decided one, but is disclosed', () => {
-    const r = reduceRuns([{ verdict: CAUGHT, reason: 'assertion' }, { verdict: INCONCLUSIVE, reason: 'timeout' }, { verdict: CAUGHT, reason: 'assertion' }]);
-    assert.equal(r.verdict, CAUGHT);
-    assert.match(r.reason, /1 of 3 runs inconclusive/);
-});
-
-test('rollUp: one discriminating case carries the commit, guards and all', () => {
-    assert.equal(rollUp([{ verdict: NON_DISCRIMINATING }, { verdict: NON_DISCRIMINATING }, { verdict: CAUGHT }]), CAUGHT);
-});
-
-test('rollUp: a SKIPPED case blocks BLIND — it might have been the discriminating one', () => {
-    // Observed: all four tests written FOR a bug were { skip: SKIP } on a host with no
-    // TEST_DATABASE_URL, while older cases in the same file ran and did not discriminate.
-    // Calling that blind judges the commit on the tests NOT written for it.
-    assert.equal(rollUp([{ verdict: NON_DISCRIMINATING }, { verdict: SKIPPED }]), INCONCLUSIVE);
-    assert.equal(rollUp([{ verdict: NON_DISCRIMINATING }, { verdict: NON_DISCRIMINATING }, { verdict: SKIPPED }]), INCONCLUSIVE);
-});
-
-test('rollUp: BLIND only when every case ran and NOT ONE discriminated', () => {
-    assert.equal(rollUp([{ verdict: NON_DISCRIMINATING }, { verdict: NON_DISCRIMINATING }]), BLIND);
-    // one case could not be judged -> the commit cannot be called blind
-    assert.equal(rollUp([{ verdict: NON_DISCRIMINATING }, { verdict: INCONCLUSIVE }]), INCONCLUSIVE);
-});
-
-test('CONTROL ARM: a verdict engine that only read exit codes fails these', () => {
-    // TEST-001 — the old, naive implementation, executed here, asserted to still be wrong.
-    const naive = ({ armB }) => (armB && armB.status === 'fail' ? CAUGHT : BLIND);
-    assert.equal(naive({ armB: errFail }), CAUGHT);                       // it says CAUGHT...
-    assert.equal(classify({ armA: pass, armB: errFail }).verdict, INCONCLUSIVE);  // ...we say no
-    assert.equal(naive({ armB: pass }), BLIND);   // and calls every regression guard blind                            // and it cannot see
-    assert.equal(classify({ armA: pass, armB: pass, identity: { proven: false, reason: 'x' } }).verdict, INCONCLUSIVE);
-});
-
-test('a CAUGHT on new code is still CAUGHT — the verdict does not lie, the CLAIM narrows', async () => {
-    // Issue #3. On a feature the base lacks the code entirely, so essentially any test
-    // touching it fails there — `expected 0 to be greater than 0` is a real AssertionError
-    // that says nothing about whether the test is well aimed. Reclassifying it would be
-    // dishonest (it IS a disagreement); counting it as evidence would be worse.
-    const { commitKind } = await import('../src/verify.mjs');
-
-    assert.equal(commitKind('feat(web): add seoTitle', false).newCode, true,
-        'a feature is new code whatever its diff looks like');
-    assert.equal(commitKind('fix(core): a hyphen decided a title', false).newCode, false,
-        'a fix that changes lines is a repair, and its CAUGHT is strong evidence');
-    assert.equal(commitKind('fix(api): add a missing export', true).newCode, true,
-        'a fix whose source diff only ADDS may still be reading something that was absent');
-    assert.equal(commitKind('no conventional prefix at all', false).kind, 'unknown',
-        'an unrecognised subject must not be guessed into fix or feature');
-});