@holmes-lab/holmes-kit 0.1.0

package/dist/holmes/review/test-runner.js

@@ -0,0 +1,572 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planTestRun = planTestRun;
+exports.ecosystemOf = ecosystemOf;
+exports.parseGoTestJson = parseGoTestJson;
+exports.parseExecutedCounts = parseExecutedCounts;
+exports.parseJUnitXmlCounts = parseJUnitXmlCounts;
+exports.parseCargoTest = parseCargoTest;
+exports.runCargo = runCargo;
+exports.runGradle = runGradle;
+exports.runDotnet = runDotnet;
+exports.runGo = runGo;
+exports.runTestScope = runTestScope;
+// @implements A-SPEC-102.1
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+function planTestRun(scope) {
+    if (scope.tier === 'full') {
+        return { mode: 'full', testFiles: [], reason: 'full regression — run the entire suite' };
+    }
+    if (scope.impactedTestFiles.length === 0) {
+        return { mode: 'noop', testFiles: [], reason: `${scope.tier} scope but no impacted test files — nothing to run` };
+    }
+    return {
+        mode: 'scoped',
+        testFiles: [...scope.impactedTestFiles],
+        reason: `${scope.tier} scope — run ${scope.impactedTestFiles.length} impacted test file(s)`,
+    };
+}
+/** Ecosystem of a test file, by extension/convention. `null` when no runner adapter exists for it. */
+function ecosystemOf(file) {
+    if (/\.(ts|mts|cts|tsx|jsx|js|mjs|cjs)$/i.test(file))
+        return 'jest';
+    if (/\.py$/i.test(file))
+        return 'pytest';
+    // @implements A-SPEC-137.1 — Go's test convention is a `_test.go` suffix; a plain `.go` file is
+    // scanned for symbols/edges but is not a runnable test file.
+    if (/_test\.go$/i.test(file))
+        return 'go';
+    // @implements A-SPEC-137.2 — Rust test files, matching the scanner's isTestFile convention:
+    // tests/<x>.rs (integration), <x>_test(s).rs, <x>_unittest.rs, test_<x>.rs. A plain src/x.rs may
+    // carry inline #[cfg(test)] unit tests but is a production source, not a selected test file.
+    if (/(^|\/)(tests\/[^/]*|[^/]*_(tests?|unittest)|test_[^/]*)\.rs$/i.test(file))
+        return 'rust';
+    // @implements A-SPEC-137.3 — JUnit/xUnit naming (case-sensitive `Test` so Manifest.java is not a
+    // test): Java `…Test(s|Case|Cases).java`, C# `…Test(s).cs`.
+    if (/(^|\/)[^/]*(Test|Tests|TestCase|TestCases)\.java$/.test(file))
+        return 'java';
+    if (/(^|\/)[^/]*(Test|Tests)\.cs$/.test(file))
+        return 'dotnet';
+    return null; // cpp and non-test files — counted syntactically, not yet executable here
+}
+/**
+ * @implements A-SPEC-137.1
+ * Executed-test counts per Go package from `go test -json` output. A test is EXECUTED when a NAMED
+ * test (`Test` present) reaches `Action: 'pass'` or `'fail'` — a skip does not count (matching the
+ * jest/pytest rule), and a package-level result (no `Test`) is not a test case. Non-JSON lines (go
+ * interleaves build output) are ignored. Pure; empty/garbage input yields `{}` rather than throwing.
+ */
+function parseGoTestJson(out) {
+    const counts = {};
+    for (const line of out.split('\n')) {
+        const s = line.trim();
+        if (!s.startsWith('{'))
+            continue;
+        let evt;
+        try {
+            evt = JSON.parse(s);
+        }
+        catch {
+            continue;
+        }
+        if (!evt.Test || !evt.Package)
+            continue; // package-level result is not a test case
+        if (evt.Action === 'pass' || evt.Action === 'fail') { // skip is excluded; pass/fail both executed
+            counts[evt.Package] = (counts[evt.Package] ?? 0) + 1;
+        }
+    }
+    return counts;
+}
+/**
+ * Parse jest --json output into per-file EXECUTED case counts. This is the execution-proof upgrade
+ * over the syntactic countTestCases lower bound: a case only appears here if jest actually ran it
+ * (pending/skipped assertions are excluded), so `if(false){it(…)}`, aliasing, and other syntactic
+ * fabrications cannot produce evidence. Returns {} for unparseable output (caller falls back).
+ */
+function parseExecutedCounts(stdout, cwd) {
+    const start = stdout.indexOf('{');
+    if (start < 0)
+        return {};
+    let data;
+    try {
+        data = JSON.parse(stdout.slice(start));
+    }
+    catch {
+        return {};
+    }
+    const out = {};
+    for (const tr of data?.testResults ?? []) {
+        const abs = tr.name ?? tr.testFilePath ?? '';
+        if (!abs)
+            continue;
+        const rel = abs.startsWith(cwd) ? abs.slice(cwd.length).replace(/^[/\\]/, '') : abs;
+        const ran = (tr.assertionResults ?? []).filter((a) => a.status === 'passed' || a.status === 'failed').length;
+        out[rel.split('\\').join('/')] = ran;
+    }
+    return out;
+}
+/**
+ * Parse pytest's built-in JUnit XML into per-file EXECUTED case counts — the pytest analogue of
+ * parseExecutedCounts. `--junit-xml` ships with pytest core, so this needs no plugin, and it is the
+ * only pytest output that is both machine-readable and per-file.
+ *
+ * A `<testcase>` counts as executed unless it carries `<skipped>`, matching the jest rule where
+ * pending/skipped assertions are excluded. Errors and failures DO count: they executed.
+ */
+function parseJUnitXmlCounts(xml, ext = 'py') {
+    const out = {};
+    for (const m of xml.matchAll(/<testcase\b([^>]*?)(\/>|>([\s\S]*?)<\/testcase>)/g)) {
+        const attrs = m[1] ?? '';
+        const body = m[3] ?? '';
+        // `file` (xunit1 / dotnet loggers) is used verbatim when present. Otherwise the `classname`
+        // fallback maps to a source path — but the class↔file relationship is language-specific:
+        // @implements A-SPEC-137.3
+        //   py  : the MODULE names the file, the class is a nested segment. `tests.test_calc.TestThing`
+        //         -> `tests/test_calc.py` (drop trailing Capitalized class segments).
+        //   java/cs : the CLASS names the file. `com.x.FooTest` -> `com/x/FooTest.java` (keep all).
+        let file = /\bfile="([^"]*)"/.exec(attrs)?.[1];
+        if (!file) {
+            const cls = /\bclassname="([^"]*)"/.exec(attrs)?.[1];
+            if (!cls)
+                continue;
+            const parts = cls.split('.').filter(Boolean);
+            if (ext === 'py') {
+                while (parts.length > 1 && /^[A-Z]/.test(parts[parts.length - 1]))
+                    parts.pop();
+            }
+            if (parts.length === 0)
+                continue;
+            file = `${parts.join('/')}.${ext}`;
+        }
+        if (/<skipped\b/.test(body))
+            continue;
+        const key = file.split('\\').join('/');
+        out[key] = (out[key] ?? 0) + 1;
+    }
+    return out;
+}
+/** Run the jest half of a plan. */
+function runJest(files, mode, cwd) {
+    // --runTestsByPath treats args as EXACT files (not testPathPattern REGEXes, which would over/mis-match
+    // or throw on a metachar); `--` + a leading-`./` guard so a path can never be read as a flag. NO
+    // --passWithNoTests on a scoped run (verification H5): if the resolved paths match ZERO tests
+    // (e.g. a cwd≠root mismatch), that must FAIL, not report a false "passed" — a scoped gate that ran
+    // nothing has verified nothing. `full` mode runs the whole suite.
+    const safeFiles = files.map((p) => (p.startsWith('-') ? `./${p}` : p));
+    // --json yields per-file assertion results = EXECUTION evidence (see parseExecutedCounts).
+    const args = mode === 'scoped'
+        ? ['jest', '--silent', '--json', '--runTestsByPath', '--', ...safeFiles]
+        : ['jest', '--silent', '--json'];
+    try {
+        const out = (0, node_child_process_1.execFileSync)('npx', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+        return { passed: true, tail: tailOf(out), executed: parseExecutedCounts(out, cwd) };
+    }
+    catch (e) {
+        const err = e;
+        // A failing suite still emits --json on stdout, so execution evidence survives a red run.
+        return { passed: false, tail: tailOf(`${err.stdout ?? ''}\n${err.stderr ?? err.message ?? ''}`), executed: parseExecutedCounts(err.stdout ?? '', cwd) };
+    }
+}
+/** Run the pytest half of a plan, taking execution evidence from pytest's built-in JUnit XML. */
+function runPytest(files, mode, cwd) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'holmes-pytest-'));
+    const report = path.join(dir, 'report.xml');
+    // `python3 -m pytest` rather than a bare `pytest`, so the interpreter on PATH decides which
+    // environment runs — a bare `pytest` shim can belong to a different virtualenv than the project.
+    // `--` guards a path that begins with a dash. No "exit ok on no tests collected": pytest's exit
+    // code 5 (no tests ran) must stay a failure for a scoped run, for the same reason jest gets no
+    // --passWithNoTests — a gate that executed nothing has verified nothing.
+    // `junit_family=xunit1` is requested explicitly because it is the only family that emits a `file`
+    // attribute per testcase. pytest's default since v6 is xunit2, which carries only `classname` —
+    // measured: a green 4-passed/1-skipped run yielded ZERO per-file evidence under the default, so
+    // the tier gate would have had nothing to verify against.
+    const args = ['-m', 'pytest', '-q', '-o', 'junit_family=xunit1', `--junit-xml=${report}`,
+        ...(mode === 'scoped' ? ['--', ...files] : [])];
+    const read = () => {
+        try {
+            return parseJUnitXmlCounts(fs.readFileSync(report, 'utf8'));
+        }
+        catch {
+            return {};
+        }
+    };
+    try {
+        const out = (0, node_child_process_1.execFileSync)('python3', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+        return { passed: true, tail: tailOf(out), executed: read() };
+    }
+    catch (e) {
+        const err = e;
+        // A red pytest run still writes the XML, so execution evidence survives — same property as jest.
+        return { passed: false, tail: tailOf(`${err.stdout ?? ''}\n${err.stderr ?? err.message ?? ''}`), executed: read() };
+    }
+    finally {
+        try {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+        catch { /* best effort */ }
+    }
+}
+/**
+ * @implements A-SPEC-137.2
+ * Executed-test count from `cargo test` text output. cargo prints one `test <name> ... ok|FAILED|
+ * ignored` line per test across all test binaries (unit/integration/doctest); `ok` and `FAILED` are
+ * EXECUTED, `ignored` is the skip rule. The `test result:` summary line is not itself counted (the
+ * per-test lines are the evidence). Crate-granular — cargo does not name a passing test's source
+ * file. Pure; empty input → 0.
+ */
+function parseCargoTest(out) {
+    let n = 0;
+    for (const line of out.split('\n')) {
+        if (/^test .+ \.\.\. (ok|FAILED)$/.test(line.trim()))
+            n++;
+    }
+    return n;
+}
+/**
+ * @implements A-SPEC-137.2
+ * Run the rust half of a plan. cargo runs the WHOLE crate (a crate is its smallest test unit), so
+ * scoped and full both invoke `cargo test` in the crate root; the crate total is credited to each
+ * input test file (crate-granular). A red suite still yields the count (cargo writes the test lines
+ * to stdout on failure). Absent toolchain → `unsupported`, never a pass. `opts.cargoPresent`
+ * overrides the probe for testing.
+ */
+function runCargo(files, _mode, cwd, opts) {
+    const present = opts?.cargoPresent ?? (() => {
+        try {
+            (0, node_child_process_1.execFileSync)('cargo', ['--version'], { cwd, stdio: 'ignore' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    })();
+    if (!present) {
+        return { passed: false, tail: 'cargo toolchain not found on PATH — cannot execute Rust tests', executed: {}, unsupported: files };
+    }
+    let out = '';
+    let ok = true;
+    try {
+        out = (0, node_child_process_1.execFileSync)('cargo', ['test'], { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+    }
+    catch (e) {
+        const err = e;
+        out = err.stdout ?? '';
+        ok = false;
+    }
+    const count = parseCargoTest(out);
+    const executed = {};
+    for (const f of files)
+        executed[f] = count; // crate-granular
+    // Executing nothing is not a pass, mirroring no-passWithNoTests.
+    const passed = ok && count > 0;
+    return { passed, tail: `[rust] cargo test: ${count} executed`, executed };
+}
+/** Read every JUnit XML report under a directory (recursively) and sum their counts for `ext`. */
+function readJUnitReports(dir, ext) {
+    const acc = {};
+    const walk = (d) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(d, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            const p = path.join(d, e.name);
+            if (e.isDirectory())
+                walk(p);
+            else if (e.name.endsWith('.xml')) {
+                try {
+                    const counts = parseJUnitXmlCounts(fs.readFileSync(p, 'utf8'), ext);
+                    for (const [k, v] of Object.entries(counts))
+                        acc[k] = (acc[k] ?? 0) + v;
+                }
+                catch { /* skip unreadable/non-JUnit xml */ }
+            }
+        }
+    };
+    walk(dir);
+    return acc;
+}
+/**
+ * @implements A-SPEC-137.3
+ * Run the Java half of a plan via gradle or maven, taking evidence from the JUnit XML they write.
+ * The presence probe RUNS `java -version` (a `/usr/bin/java` shim with no JDK fails — PATH is not
+ * enough). Absent → `unsupported`, never a pass. On this machine (no JDK) only the degradation is
+ * exercised; the run+read path is reviewed but unverified here (see A-SPEC-137.3).
+ */
+function runGradle(files, _mode, cwd, opts) {
+    const present = opts?.javaPresent ?? (() => {
+        try {
+            (0, node_child_process_1.execFileSync)('java', ['-version'], { cwd, stdio: 'ignore' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    })();
+    if (!present) {
+        return { passed: false, tail: 'java runtime not found (a PATH shim without a JDK does not count) — cannot execute Java tests', executed: {}, unsupported: files };
+    }
+    // Detect the build tool. gradle wrapper > gradle > maven.
+    const has = (f) => { try {
+        return fs.existsSync(path.join(cwd, f));
+    }
+    catch {
+        return false;
+    } };
+    let cmd;
+    let args;
+    let reportDir;
+    if (has('gradlew')) {
+        cmd = './gradlew';
+        args = ['test'];
+        reportDir = 'build/test-results/test';
+    }
+    else if (has('build.gradle') || has('build.gradle.kts')) {
+        cmd = 'gradle';
+        args = ['test'];
+        reportDir = 'build/test-results/test';
+    }
+    else if (has('pom.xml')) {
+        cmd = 'mvn';
+        args = ['-q', 'test'];
+        reportDir = 'target/surefire-reports';
+    }
+    else {
+        return { passed: false, tail: 'no gradle/maven build file found — cannot execute Java tests', executed: {}, unsupported: files };
+    }
+    let ok = true;
+    try {
+        (0, node_child_process_1.execFileSync)(cmd, args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+    }
+    catch {
+        ok = false;
+    } // a failing test run still wrote the JUnit XML
+    const executed = readJUnitReports(path.join(cwd, reportDir), 'java');
+    const total = Object.values(executed).reduce((a, b) => a + b, 0);
+    return { passed: ok && total > 0, tail: `[java] ${cmd} ${args.join(' ')}: ${total} executed`, executed };
+}
+/**
+ * @implements A-SPEC-137.3
+ * Run the C# half of a plan via `dotnet test` with the JUnit logger. The probe RUNS `dotnet
+ * --version`; absent → `unsupported`, never a pass. dotnet is absent on this machine, so only the
+ * degradation is exercised; the run+read path is reviewed but unverified here.
+ */
+function runDotnet(files, _mode, cwd, opts) {
+    const present = opts?.dotnetPresent ?? (() => {
+        try {
+            (0, node_child_process_1.execFileSync)('dotnet', ['--version'], { cwd, stdio: 'ignore' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    })();
+    if (!present) {
+        return { passed: false, tail: 'dotnet not found on PATH — cannot execute C# tests', executed: {}, unsupported: files };
+    }
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'holmes-dotnet-'));
+    const report = path.join(dir, 'junit.xml');
+    let ok = true;
+    try {
+        (0, node_child_process_1.execFileSync)('dotnet', ['test', '--logger', `junit;LogFilePath=${report}`], { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+    }
+    catch {
+        ok = false;
+    }
+    let executed = {};
+    try {
+        executed = parseJUnitXmlCounts(fs.readFileSync(report, 'utf8'), 'cs');
+    }
+    catch { /* no report */ }
+    try {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+    catch { /* best effort */ }
+    const total = Object.values(executed).reduce((a, b) => a + b, 0);
+    return { passed: ok && total > 0, tail: `[dotnet] dotnet test: ${total} executed`, executed };
+}
+/**
+ * @implements A-SPEC-137.1
+ * Run the go half of a plan. Evidence is PACKAGE-granular (go test names a passing test's package,
+ * not its file), so each package's non-skip count is credited to its input `_test.go` files. A red
+ * suite still yields counts (go writes JSON events to stdout on failure too). Absent toolchain →
+ * `unsupported`, never a pass. `opts.goPresent` overrides the probe for testing.
+ */
+function runGo(files, mode, cwd, opts) {
+    const present = opts?.goPresent ?? (() => {
+        try {
+            (0, node_child_process_1.execFileSync)('go', ['version'], { cwd, stdio: 'ignore' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    })();
+    if (!present) {
+        return { passed: false, tail: 'go toolchain not found on PATH — cannot execute Go tests', executed: {}, unsupported: files };
+    }
+    // Group the impacted test files by their package directory; run each package once. `full` mode
+    // runs the module (`./...`) and credits nothing per-file (package names do not map to file anchors
+    // without `go list`) — scoped is the path that produces per-file evidence.
+    const executed = {};
+    const tails = [];
+    let passed = true;
+    let anyExecuted = 0;
+    const runDir = (dirArg, creditFiles) => {
+        let out = '';
+        try {
+            out = (0, node_child_process_1.execFileSync)('go', ['test', '-json', dirArg], { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+        }
+        catch (e) {
+            const err = e;
+            out = err.stdout ?? '';
+            tails.push(err.stderr ? tailOf(err.stderr, 2) : (err.message ?? 'go test failed'));
+            passed = false;
+        }
+        const perPkg = parseGoTestJson(out);
+        const dirCount = Object.values(perPkg).reduce((a, b) => a + b, 0);
+        anyExecuted += dirCount;
+        for (const f of creditFiles)
+            executed[f] = (executed[f] ?? 0) + dirCount; // package-granular
+        tails.push(`[go] ${dirArg}: ${dirCount} executed`);
+    };
+    if (mode === 'full') {
+        runDir('./...', []);
+    }
+    else {
+        const byDir = new Map();
+        for (const f of files) {
+            const d = path.dirname(f);
+            const arg = d === '.' || d === '' ? '.' : `./${d}`;
+            if (!byDir.has(arg))
+                byDir.set(arg, []);
+            byDir.get(arg).push(f);
+        }
+        for (const [dirArg, creditFiles] of byDir)
+            runDir(dirArg, creditFiles);
+    }
+    // A run that executed NOTHING is not a pass — the same no-passWithNoTests rule jest/pytest hold.
+    if (anyExecuted === 0)
+        passed = false;
+    return { passed, tail: tails.join('\n'), executed };
+}
+/**
+ * Execute a plan (I/O). Deterministic inputs → deterministic command; the pass/fail is the suite's.
+ * A no-op plan is `skipped: true, passed: true` (nothing to run is not a failure).
+ *
+ * Test files are grouped by ecosystem and each group runs under its own adapter, so a mixed repo is
+ * covered rather than silently reduced to whichever language happens to sort first. Files whose
+ * ecosystem has no adapter are returned in `unsupported` — never dropped quietly, because a scoped
+ * gate that ran part of its scope has verified less than it reports.
+ */
+function runTestScope(scope, cwd) {
+    const plan = planTestRun(scope);
+    if (plan.mode === 'noop') {
+        return { tier: scope.tier, mode: 'noop', ranFiles: [], passed: true, skipped: true, tail: plan.reason };
+    }
+    // planTestRun deliberately empties testFiles for a `full` run (the point is to run everything), so
+    // ecosystem detection has to read the SCOPE's impacted files instead. Grouping on plan.testFiles
+    // alone made every full-tier run fall back to jest — i.e. a Python project's full regression
+    // executed the JavaScript suite and reported on it. Found by review, not by a failing test.
+    const detectFrom = plan.mode === 'full' ? scope.impactedTestFiles : plan.testFiles;
+    const groups = new Map();
+    const unsupported = [];
+    for (const f of detectFrom) {
+        const eco = ecosystemOf(f);
+        if (!eco) {
+            unsupported.push(f);
+            continue;
+        }
+        // In full mode the runners ignore the file list; the group only records which ecosystems exist.
+        groups.set(eco, plan.mode === 'full' ? [] : [...(groups.get(eco) ?? []), f]);
+    }
+    // A full run with no impacted files at all gives no signal about which ecosystems are present.
+    // Defaulting to jest keeps the historical behavior; the assumption is stated in the evidence tail
+    // rather than left implicit, because "we ran the wrong suite" and "we ran nothing" look identical
+    // to a caller that only sees passed=true.
+    let assumedJest = false;
+    if (plan.mode === 'full' && groups.size === 0) {
+        groups.set('jest', []);
+        assumedJest = true;
+    }
+    if (groups.size > 0) {
+        const runners = { jest: runJest, pytest: runPytest, go: runGo, rust: runCargo, java: runGradle, dotnet: runDotnet };
+        const ran = [];
+        let passed = true;
+        const tails = [];
+        const executedByFile = {};
+        for (const eco of [...groups.keys()].sort()) {
+            const r = runners[eco](groups.get(eco), plan.mode, cwd);
+            ran.push(eco);
+            passed = passed && r.passed;
+            tails.push(`[${eco}] ${r.tail}`);
+            Object.assign(executedByFile, r.executed);
+            // @implements A-SPEC-137.1 — an adapter whose toolchain is absent reports its files as
+            // unsupported; merge them so a scope that could not run them never reads as fully covered.
+            const adapterUnsupported = r.unsupported;
+            if (adapterUnsupported && adapterUnsupported.length)
+                unsupported.push(...adapterUnsupported);
+        }
+        if (assumedJest) {
+            tails.push('[assumption] full run with no impacted test files — defaulted to the jest suite');
+        }
+        if (unsupported.length) {
+            tails.push(`[unsupported] ${unsupported.length} test file(s) have no runner adapter: ${unsupported.slice(0, 5).join(', ')}`);
+        }
+        return {
+            tier: scope.tier, mode: plan.mode, ranFiles: plan.testFiles, passed, skipped: false,
+            tail: tails.join('\n'), executedByFile, ranWith: ran,
+            ...(unsupported.length ? { unsupported } : {}),
+        };
+    }
+    // Every file in scope belongs to an ecosystem with no adapter. Executing nothing must NOT read as
+    // a pass: there is no evidence either way, and reporting success would be the exact false comfort
+    // the no-passWithNoTests rule exists to prevent.
+    return {
+        tier: scope.tier, mode: plan.mode, ranFiles: plan.testFiles, passed: false, skipped: false,
+        tail: `no runner adapter for ${unsupported.length} test file(s): ${unsupported.slice(0, 5).join(', ')}`,
+        executedByFile: {}, unsupported, ranWith: [],
+    };
+}
+function tailOf(s, n = 6) {
+    return s.trim().split('\n').slice(-n).join('\n');
+}