flagrm 0.2.1 → 0.4.0

package/dist/core/run-cache.js

@@ -0,0 +1,137 @@
+/**
+ * Build and test runs a passing full verify saves, so the next baseline or
+ * verify on the same tree with the same commands reuses them instead of
+ * running them again: in a sequential removal, the next flag's baseline
+ * starts on the commit the previous flag's verify passed on.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import fg from "fast-glob";
+import { flagDir, matchingFiles, runChecks } from "./baseline.js";
+import { changeFilter } from "./change-filter.js";
+import { configSnapshot, projectCommands } from "./config-snapshot.js";
+import { treeFingerprint } from "./git.js";
+import { packageVersion } from "./package.js";
+import { JSON_SCHEMA_VERSION, RUN_CHECK_ID } from "./types.js";
+import { readJson } from "./util.js";
+/** `.flagrm/<flag>/verify/runs.json`. */
+export function runsPath(root, flag) {
+    return path.join(flagDir(root, flag), "verify", "runs.json");
+}
+/**
+ * The tree the commands will run on: its fingerprint before they run, without
+ * flagrm's setup files and the test result files the runs themselves rewrite.
+ * Commands are compared on their own, so leaving out the config file is safe.
+ * Unlike the Stop hook's fingerprint, `exclude`d paths count: a build or test
+ * may read them (a lockfile, generated sources), so a change there must rerun.
+ */
+export function runsKey(root, projects) {
+    const ignore = changeFilter();
+    const patterns = projects.flatMap(({ adapter, ctx }) => projectCommands(adapter, ctx).testResults ?? []);
+    const results = matchingFiles(root, patterns);
+    return treeFingerprint(root, (rel) => ignore(rel) || results.has(rel));
+}
+/** The (project, check) pairs a run of `only` would run: those with a command. */
+export function plannedRuns(projects, only) {
+    return projects.flatMap(({ adapter, ctx }) => {
+        const commands = projectCommands(adapter, ctx);
+        return only.filter((check) => commands[check]).map((check) => ({ project: ctx.name, check }));
+    });
+}
+/**
+ * Save a passing full verify's runs; never a set with a setup problem, which would come back on every rerun,
+ * nor runs that were themselves reused: the set they came from keeps its own flag and time.
+ * The logs are copied next to `runs.json`, so a later verify overwriting its own logs leaves the saved set whole.
+ */
+export function saveRuns(root, flag, projects, key, runs, createdAt = new Date().toISOString()) {
+    if (runs.some((r) => r.failure || r.reused))
+        return;
+    const file = runsPath(root, flag);
+    const logDir = path.join(path.dirname(file), "saved");
+    fs.mkdirSync(logDir, { recursive: true });
+    const kept = runs.map(({ reused: _reused, ...run }) => {
+        if (!run.log)
+            return run;
+        const log = path.join(logDir, `${run.project}.${run.check}.log`);
+        fs.copyFileSync(run.log, log);
+        return { ...run, log };
+    });
+    const saved = {
+        schemaVersion: JSON_SCHEMA_VERSION,
+        flagrmVersion: packageVersion(),
+        flag,
+        createdAt,
+        key,
+        commands: configSnapshot(projects).projects,
+        runs: kept,
+    };
+    fs.writeFileSync(file, `${JSON.stringify(saved, null, 2)}\n`, "utf8");
+}
+/** Forget every saved set, of any flag, for this tree: a fresh run on it failed, so they may hide a flaky test or a changed machine. */
+export function dropRuns(root, key) {
+    for (const file of fg.sync(".flagrm/*/verify/runs.json", { cwd: root, absolute: true, dot: true })) {
+        if (readJson(file)?.key === key)
+            fs.rmSync(file, { force: true });
+    }
+}
+/** The newest saved set, of any flag, for this tree and these commands that has every `needed` run and its log. */
+export function findRuns(root, projects, key, needed) {
+    if (needed.length === 0)
+        return undefined;
+    const commands = JSON.stringify(configSnapshot(projects).projects);
+    const version = packageVersion();
+    let best;
+    for (const file of fg.sync(".flagrm/*/verify/runs.json", { cwd: root, absolute: true, dot: true })) {
+        const saved = readJson(file);
+        if (!saved || !Array.isArray(saved.runs) || typeof saved.createdAt !== "string")
+            continue;
+        if (saved.key !== key || saved.schemaVersion !== JSON_SCHEMA_VERSION)
+            continue;
+        if (saved.flagrmVersion !== version || JSON.stringify(saved.commands) !== commands)
+            continue;
+        const runs = needed.map((n) => saved.runs.find((r) => r.project === n.project && r.check === n.check));
+        if (runs.some((r) => !r || (r.log !== undefined && !fs.existsSync(r.log))))
+            continue;
+        if (!best || saved.createdAt > best.saved.createdAt)
+            best = { saved, runs: runs };
+    }
+    return best;
+}
+/** The found runs as this flag's own: logs copied into `logDir` under their usual names, marked `reused`. */
+export function reuseRuns(found, logDir) {
+    fs.mkdirSync(logDir, { recursive: true });
+    const reused = { flag: found.saved.flag, createdAt: found.saved.createdAt };
+    return found.runs.map((run) => {
+        if (!run.log)
+            return { ...run, reused };
+        const log = path.join(logDir, `${run.project}.${run.check}.log`);
+        if (path.resolve(run.log) !== path.resolve(log))
+            fs.copyFileSync(run.log, log);
+        return { ...run, log, reused };
+    });
+}
+/** A baseline's build, test and lint runs: reused from a passing verify on the same tree and commands, else run. */
+export async function baselineRuns(root, flag, projects, reuse = true) {
+    const logDir = flagDir(root, flag);
+    const key = reuse ? runsKey(root, projects) : undefined;
+    const found = key ? findRuns(root, projects, key, plannedRuns(projects, ["build", "test", "lint"])) : undefined;
+    return found ? reuseRuns(found, logDir) : runChecks(projects, logDir);
+}
+/** One line saying which runs were reused and from where, or undefined when none were. `at`: when they were reused. */
+export function reusedNote(runs, at) {
+    const reused = runs.find((r) => r.reused)?.reused;
+    if (!reused)
+        return undefined;
+    const checks = [...new Set(runs.filter((r) => r.reused).map((r) => RUN_CHECK_ID[r.check]))];
+    const what = checks.length > 1 ? `${checks.slice(0, -1).join(", ")} and ${checks.at(-1)}` : checks[0];
+    return `${what} reused from ${reused.flag}'s verify (same tree and commands, ${age(Date.parse(at) - Date.parse(reused.createdAt))} ago; --no-reuse to run them)`;
+}
+function age(ms) {
+    const min = Math.round(ms / 60_000);
+    if (min < 1)
+        return "under a minute";
+    if (min < 60)
+        return `${min} min`;
+    const hours = Math.round(min / 60);
+    return hours < 48 ? `${hours} h` : `${Math.round(hours / 24)} days`;
+}

package/dist/core/scope-files.js

@@ -0,0 +1,14 @@
+/**
+ * A file-scoped name (a local, parameter or field) is also used in the files
+ * that share its file's scope, such as an Angular component's template. The
+ * adapter whose project contains the file says which (`Adapter.scopeFiles`).
+ */
+import path from "node:path";
+import { relativePath } from "./util.js";
+/** `rel` (relative to the config `root`) followed by the files sharing its scope, relative too, each once. */
+export function withScopeFiles(projects, root, rel) {
+    const file = path.resolve(root, rel);
+    const owner = projects.find(({ ctx }) => !path.relative(ctx.root, file).startsWith(".."));
+    const more = owner?.adapter.scopeFiles?.(owner.ctx, file) ?? [];
+    return [...new Set([rel, ...more.map((f) => relativePath(root, f))])];
+}

package/dist/core/scope.js

@@ -121,6 +121,10 @@ export function writeScope(setups, projects, root, configFile) {
                 // The resolved commands: the configured ones, or the adapter's defaults when none are.
                 build: commands.build && pointAt(commands.build, rel),
                 test: commands.test && pointAt(commands.test, rel),
+                // Written out, the test command is no longer the default, so its default results location must be too.
+                testResults: commands.testResults && commands.defaults.includes("testResults")
+                    ? `./${relativePath(root, commands.testResults)}`
+                    : undefined,
             });
         }
     }
@@ -172,7 +176,9 @@ function excludeFromGit(root, file) {
 }
 /** Set the build and test commands of `projects:` entries in place, keeping the file's comments and layout. */
 function updateConfig(configFile, root, updates) {
-    const paste = updates.map((u) => `${u.project}: build: ${u.build}; test: ${u.test}`).join("; ");
+    const paste = updates
+        .map((u) => `${u.project}: build: ${u.build}; test: ${u.test}${u.testResults ? `; testResults: ${u.testResults}` : ""}`)
+        .join("; ");
     if (!configFile || configFile.endsWith(".json")) {
         return {
             path: configFile ? relativePath(root, configFile) : "flagrm.config.yaml",
@@ -196,8 +202,11 @@ function updateConfig(configFile, root, updates) {
             doc.setIn(["projects", index, "build"], u.build);
         if (u.test)
             doc.setIn(["projects", index, "test"], u.test);
+        if (u.testResults)
+            doc.setIn(["projects", index, "testResults"], u.testResults);
     }
-    const next = doc.toString();
+    // lineWidth 0: never fold a long command over two lines.
+    const next = doc.toString({ lineWidth: 0 });
     if (next !== text)
         fs.writeFileSync(configFile, next, "utf8");
     const note = missing.length

package/dist/core/test-runner.js

@@ -0,0 +1,136 @@
+/**
+ * Which JavaScript test runner a project uses, read from `angular.json`'s
+ * test builder, config files and `package.json`, so the Angular adapter can
+ * default to a test command that writes machine-readable results, and
+ * doctor can say how to get them. Reads only; anything unreadable is `unknown`.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import fg from "fast-glob";
+import { readJson, relativePath } from "./util.js";
+/** The test target of the first `angular.json` project that has one. */
+function angularTestTarget(root) {
+    const json = readJson(path.join(root, "angular.json"));
+    for (const project of Object.values(json?.projects ?? {})) {
+        const test = (project?.architect ?? project?.targets)?.test;
+        if (test?.builder)
+            return test;
+    }
+    return undefined;
+}
+function dependencies(root) {
+    const pkg = readJson(path.join(root, "package.json"));
+    return new Set([...Object.keys(pkg?.dependencies ?? {}), ...Object.keys(pkg?.devDependencies ?? {})]);
+}
+const hasFile = (root, pattern) => fg.sync(pattern, { cwd: root, deep: 1 }).length > 0;
+function karma(root, options) {
+    const conf = path.resolve(root, typeof options.karmaConfig === "string" ? options.karmaConfig : "karma.conf.js");
+    let text;
+    try {
+        text = fs.readFileSync(conf, "utf8");
+    }
+    catch {
+        return { kind: "karma" };
+    }
+    const outputDir = /junitReporter\s*:\s*\{[^}]*?\boutputDir\s*:\s*(['"`])([^'"`]+)\1/.exec(text)?.[2];
+    // Without a `plugins` key Karma loads every installed karma-* package.
+    const loaded = text.includes("karma-junit-reporter") ||
+        (!/\bplugins\s*:/.test(text) && dependencies(root).has("karma-junit-reporter"));
+    return loaded && outputDir
+        ? { kind: "karma", junit: { outputDir: path.resolve(path.dirname(conf), outputDir) } }
+        : { kind: "karma" };
+}
+export function detectTestRunner(root) {
+    const target = angularTestTarget(root);
+    const builder = target?.builder ?? "";
+    const options = target?.options ?? {};
+    if (builder === "@angular/build:unit-test")
+        return options.runner === "karma" ? karma(root, options) : { kind: "vitest-ng" };
+    if (builder.endsWith(":karma"))
+        return karma(root, options);
+    if (builder.startsWith("@angular-builders/jest"))
+        return { kind: "jest", viaNg: true };
+    if (hasFile(root, "jest.config.{js,ts,mjs,cjs,json}"))
+        return { kind: "jest", viaNg: false };
+    if (hasFile(root, "vitest.config.{js,ts,mjs,cjs,mts}"))
+        return { kind: "vitest" };
+    const deps = dependencies(root);
+    if (deps.has("jest"))
+        return { kind: "jest", viaNg: false };
+    if (deps.has("vitest"))
+        return { kind: "vitest" };
+    if (hasFile(root, "karma.conf.{js,cjs,ts}"))
+        return karma(root, {});
+    return { kind: "unknown" };
+}
+/** The flags that make each runner write results to `file` (quoted, relative to the project). */
+function resultFlags(runner, file) {
+    switch (runner.kind) {
+        case "vitest-ng":
+            // The unit-test builder's --output-file applies to the first reporter only.
+            return `--reporters=junit --output-file="${file("junit.xml")}"`;
+        case "jest":
+            return runner.viaNg ? undefined : `--json --outputFile="${file("jest.json")}"`;
+        case "vitest":
+            return `--reporter=default --reporter=junit --outputFile.junit="${file("junit.xml")}"`;
+        default:
+            return undefined;
+    }
+}
+const RESULT_FILE = {
+    "vitest-ng": "junit.xml",
+    jest: "jest.json",
+    vitest: "junit.xml",
+};
+/**
+ * A test command for the runner that writes results into `resultsDir`, and
+ * where to read them. Undefined when the runner can't without a setup change
+ * (Karma without a JUnit reporter, Jest through an Angular builder, unknown).
+ */
+export function runnerTestCommands(runner, projectRoot, resultsDir) {
+    if (runner.kind === "karma") {
+        return runner.junit
+            ? {
+                test: "npx ng test --watch=false --reporters=progress --reporters=junit",
+                testResults: path.join(runner.junit.outputDir, "**", "*.xml"),
+            }
+            : undefined;
+    }
+    const flags = resultFlags(runner, (name) => relativePath(projectRoot, path.join(resultsDir, name)));
+    const name = RESULT_FILE[runner.kind];
+    if (!flags || !name)
+        return undefined;
+    const base = runner.kind === "vitest-ng"
+        ? "npx ng test --watch=false"
+        : runner.kind === "jest"
+            ? "npx jest --ci"
+            : "npx vitest run";
+    return { test: `${base} ${flags}`, testResults: path.join(resultsDir, name) };
+}
+/**
+ * How to get test results for a project whose test command has none: one
+ * line for doctor and init. `dirFromProject` is a results directory relative
+ * to the project (for the command), `dirFromConfig` the same relative to the
+ * config file (for `testResults`). `adapterDefault`: the adapter's default
+ * test command writes results for this runner (Angular), so removing `test` is a fix too.
+ * `configRoot`: the config file's directory, for a results directory karma.conf.js names.
+ */
+export function testResultsHint(runner, dirFromProject, dirFromConfig, adapterDefault, configRoot) {
+    const flags = resultFlags(runner, (name) => `${dirFromProject}/${name}`);
+    const name = RESULT_FILE[runner.kind];
+    const fallback = adapterDefault ? " (or remove `test` to use the adapter default)" : "";
+    if (flags && name) {
+        return `add \`${flags}\` to the test command and set testResults: ${dirFromConfig}/${name}${fallback}`;
+    }
+    if (runner.kind === "karma" && runner.junit) {
+        const results = `./${relativePath(configRoot, runner.junit.outputDir)}/**/*.xml`;
+        return `add \`--reporters=progress --reporters=junit\` to the test command and set testResults: ${results}${fallback}`;
+    }
+    if (runner.kind === "karma") {
+        return "npm i -D karma-junit-reporter, add require('karma-junit-reporter') to plugins and junitReporter: { outputDir: 'test-results' } to karma.conf.js; the angular adapter's default test command then writes JUnit";
+    }
+    if (runner.kind === "jest") {
+        return `add \`--json --outputFile="${dirFromProject}/jest.json"\` to the test command if @angular-builders/jest passes them on, and set testResults: ${dirFromConfig}/jest.json`;
+    }
+    return "make the test runner write JUnit XML, TRX or Jest JSON and point testResults at the file";
+}

package/dist/core/types.js

@@ -18,11 +18,16 @@
  *   counts and at most 20 short failed test names (`failedTests`), no
  *   `config`. `baseline.json` itself is unchanged, so version 6 files are
  *   still read.
+ * - 8: `lint` runs (`check: "lint"`) and the `lint` and `coverage` checks;
+ *   `baseline.json` gains the config's `lint` commands and `git.dirtyHashes`.
+ *   Both are optional, so version 6 and 7 files are still read.
  */
-export const JSON_SCHEMA_VERSION = 7;
-/** `baseline.json` versions this flagrm reads: 7 only added optional fields to 6. */
-export const READABLE_BASELINE_VERSIONS = [6, 7];
+export const JSON_SCHEMA_VERSION = 8;
+/** `baseline.json` versions this flagrm reads: 7 and 8 only added optional fields to 6. */
+export const READABLE_BASELINE_VERSIONS = [6, 7, 8];
 // ---------------------------------------------------------------------------
 // verify
 // ---------------------------------------------------------------------------
-export const CHECK_IDS = ["leftovers", "dead-code", "build", "tests"];
+export const CHECK_IDS = ["leftovers", "dead-code", "build", "tests", "lint", "coverage"];
+/** The check that judges each kind of command run. */
+export const RUN_CHECK_ID = { build: "build", test: "tests", lint: "lint" };

package/dist/core/verify/commands.js

@@ -4,15 +4,21 @@
  * tests of the OFF path is part of removing a flag, losing any other test is not.
  * A changed test file none of whose tests ran is a warning too: the test
  * command doesn't cover it, so verify didn't check the edit.
+ *
+ * The `lint` check: a failing lint command fails. One that already failed at
+ * the baseline (lint debt) only warns, unless its log has error lines the
+ * baseline's didn't.
  */
 import fs from "node:fs";
 import path from "node:path";
-import { errorExcerpt, templateCheckGap } from "../baseline.js";
+import { errorExcerpt, logLines, looksLikeError, templateCheckGap } from "../baseline.js";
+import { projectCommands } from "../config-snapshot.js";
 import { escapeRegExp, isTestPath } from "../scan.js";
+import { RUN_CHECK_ID, } from "../types.js";
 import { relativePath } from "../util.js";
 import { checkResult, configFindings, plural, skippedResult } from "./context.js";
-import { classifyRemovedTests } from "./removed-tests.js";
-import { diffTestNames, shortTestNames, splitFailures } from "./test-results.js";
+import { classifyRemovedTests, declaredTestDiff } from "./removed-tests.js";
+import { diffTestNames, hasTestNames, shortTestNames, splitFailures } from "./test-results.js";
 function failedRunFindings(run) {
     const findings = [
         {
@@ -34,8 +40,9 @@ function setupFinding(run) {
     return { severity: "info", message: `setup problem: ${run.failure?.message}`, project: run.project };
 }
 /** No command to run: skipped, unless the baseline had one, which is worth a warning. */
-function noCommandResult(v, id) {
-    const summary = `no ${id === "build" ? "build" : "test"} command configured`;
+function noCommandResult(v, kind) {
+    const id = RUN_CHECK_ID[kind];
+    const summary = `no ${kind} command configured`;
     const findings = configFindings(v, id);
     return findings.length ? checkResult(id, summary, findings) : skippedResult(id, summary);
 }
@@ -62,15 +69,104 @@ export function buildCheck(v) {
         : `${runs.map((r) => r.project).join(", ")} built successfully`;
     return checkResult("build", summary, findings);
 }
+export function lintCheck(v) {
+    const runs = v.runs.filter((r) => r.check === "lint");
+    if (runs.length === 0)
+        return noCommandResult(v, "lint");
+    const findings = [];
+    let failed = 0;
+    let known = 0;
+    for (const run of runs) {
+        if (run.exitCode === 0)
+            continue;
+        const before = v.baseline.checks?.find((c) => c.project === run.project && c.check === "lint");
+        // A setup problem, or a run cut short, is no lint debt: it fails even when the baseline failed too.
+        if (run.failure || run.interrupted || !before || before.exitCode === 0 || before.failure || before.interrupted) {
+            failed++;
+            findings.push(...failedRunFindings(run));
+            if (!before) {
+                findings.push({
+                    severity: "info",
+                    message: "the baseline has no lint run to compare with (lint configured after it, or baseline --no-checks), so every lint error fails: show the user",
+                    project: run.project,
+                });
+            }
+            continue;
+        }
+        const debt = knownLintFindings(before, run);
+        if (debt.some((f) => f.severity === "fail"))
+            failed++;
+        else
+            known++;
+        findings.push(...debt);
+    }
+    findings.push(...configFindings(v, "lint"));
+    const summary = failed
+        ? `${plural(failed, "lint run")} failed`
+        : known
+            ? `${plural(known, "lint run fails", "lint runs fail")} as at the baseline`
+            : `${runs.map((r) => r.project).join(", ")} linted cleanly`;
+    return checkResult("lint", summary, findings);
+}
+/**
+ * A lint run that failed at the baseline too: compared line by line with the
+ * baseline's log. Numbers are masked first, so an old error whose line moved
+ * (`40:5` → `30:5`) or a changed problem count isn't new. Lines are counted,
+ * not just compared: ESLint prints an error without its file, so a second
+ * identical one is still new. A new line that looks like an error fails; other
+ * new lines only warn. At most 20 are listed, errors first.
+ */
+function knownLintFindings(before, run) {
+    const was = logLines(before.log);
+    if (!was) {
+        return [
+            {
+                severity: "warn",
+                message: `lint already failed at the baseline; its log wasn't found, so new errors can't be told (log: ${run.log})`,
+                project: run.project,
+                file: run.log,
+            },
+        ];
+    }
+    const mask = (line) => line.replace(/\d+/g, "#");
+    const seen = new Map();
+    for (const line of was)
+        seen.set(mask(line), (seen.get(mask(line)) ?? 0) + 1);
+    const added = (logLines(run.log) ?? []).filter((line) => {
+        const left = seen.get(mask(line)) ?? 0;
+        seen.set(mask(line), left - 1);
+        return left <= 0;
+    });
+    const errors = added.filter(looksLikeError);
+    const listed = [...errors, ...added.filter((line) => !looksLikeError(line))].slice(0, 20);
+    const head = errors.length
+        ? {
+            severity: "fail",
+            message: `lint already failed at the baseline, but ${plural(errors.length, "error line is", "error lines are")} new: fix ${errors.length === 1 ? "it" : "them"} (log: ${run.log})`,
+            project: run.project,
+            file: run.log,
+        }
+        : {
+            severity: "warn",
+            message: `lint already failed at the baseline: ${added.length ? `${plural(added.length, "new line")} in the log, none an error` : "no new lines in the log"} (log: ${run.log})`,
+            project: run.project,
+            file: run.log,
+        };
+    return [
+        head,
+        ...listed.map((line) => ({ severity: "info", message: `new: ${line}`, project: run.project })),
+    ];
+}
 export function compareTests(v) {
     const out = [];
     for (const run of v.runs.filter((r) => r.check === "test")) {
         const before = v.baseline.checks?.find((c) => c.project === run.project && c.check === "test")?.results;
         const after = run.results;
+        const counted = (r) => (r && (r.total > 0 || hasTestNames(r)) ? r.total : undefined);
         const comparison = {
             project: run.project,
-            before: before?.total,
-            after: after?.total,
+            before: counted(before),
+            after: counted(after),
             removed: [],
             added: [],
             deleted: [],
@@ -87,16 +183,40 @@ export function compareTests(v) {
             comparison.newFailures = shortTestNames(failures.new);
             comparison.knownFailures = shortTestNames(failures.known);
         }
-        if (before && after) {
+        const projectRoot = v.projects.find(({ ctx }) => ctx.name === run.project)?.ctx.root;
+        const removedCtx = {
+            root: v.root,
+            sha: v.baseline.git.sha,
+            changedFiles: projectRoot
+                ? (v.changedFiles ?? []).filter((rel) => !path.relative(projectRoot, path.join(v.root, rel)).startsWith(".."))
+                : v.changedFiles,
+            names: v.baseline.names,
+            testConfigChanged: v.originalConfigChanges.some((c) => c.check === "tests" && c.project === run.project),
+        };
+        if (hasTestNames(before) && hasTestNames(after)) {
             const { removed, added } = diffTestNames(before.names, after.names);
             Object.assign(comparison, { removed, added });
-            Object.assign(comparison, classifyRemovedTests(removed, added, after.names, {
-                root: v.root,
-                sha: v.baseline.git.sha,
-                changedFiles: v.changedFiles,
-                names: v.baseline.names,
-                testConfigChanged: v.configChanges.some((c) => c.check === "tests" && c.project === run.project),
-            }));
+            Object.assign(comparison, classifyRemovedTests(removed, added, after.names, removedCtx));
+        }
+        else {
+            // No names from result files on both sides: the test files' declarations show what the diff deleted or renamed.
+            const declared = declaredTestDiff(removedCtx);
+            const { renamed } = classifyRemovedTests(declared.removed, declared.added, declared.now, removedCtx, declared.files);
+            const from = new Set(renamed.map((r) => r.from));
+            Object.assign(comparison, {
+                removed: declared.removed,
+                added: declared.added,
+                renamed,
+                deleted: declared.removed.filter((name) => !from.has(name)),
+            });
+            if (comparison.before !== undefined && comparison.after !== undefined) {
+                const gap = comparison.before - comparison.after - comparison.deleted.length + (declared.added.length - renamed.length);
+                if (gap > 0) {
+                    comparison.missing = gap;
+                    if (declared.rows)
+                        comparison.missingMayBeRows = true;
+                }
+            }
         }
         out.push(comparison);
     }
@@ -105,31 +225,41 @@ export function compareTests(v) {
 /**
  * For a test run that exited non-zero: its failed tests split into the ones
  * that already failed at the baseline and new ones. Undefined when that can't
- * be told (no result files now or at the baseline, or none of them failed, so
+ * be told (no results now or at the baseline, from different sources, or none of them failed, so
  * the command broke some other way).
  */
 function splitBaselineFailures(v, run) {
     const before = v.baseline.checks?.find((c) => c.project === run.project && c.check === "test")?.results;
     if (!before || !run.results?.failed)
         return undefined;
+    // Counts without all their names (a log may not name every failing test) can't be split.
+    if (run.results.failedNames.length < run.results.failed || before.failedNames.length < before.failed)
+        return undefined;
+    // Names from a log and from result files aren't spelled alike, so they can't be matched.
+    if ((before.source ?? "files") !== (run.results.source ?? "files"))
+        return undefined;
     return splitFailures(before.failedNames, run.results.failedNames);
 }
 /**
  * A failed test run fails the check, unless every failed test already failed
- * at the baseline: those are known failures, and only warn.
+ * at the baseline: those are known failures, and only warn, or are only
+ * listed once the user accepted them (`baseline --accept failures`).
  */
-function failedTestFindings(run, failures) {
+function failedTestFindings(run, failures, accepted = false) {
     const list = (names, prefix) => shortTestNames(names)
         .slice(0, 20)
         .map((name) => ({ severity: "info", message: `${prefix}: ${name}`, project: run.project }));
     if (!failures) {
-        return [...failedRunFindings(run).slice(0, 1), ...list(run.results?.failedNames ?? [], "failed")];
+        const names = run.results?.failedNames ?? [];
+        const [head, ...excerpt] = failedRunFindings(run);
+        // Without failing test names, the log's error lines are all there is to go on; the caller adds a setup problem.
+        return [head, ...(names.length || run.failure ? [] : excerpt), ...list(names, "failed")];
     }
     if (failures.new.length === 0) {
         return [
             {
-                severity: "warn",
-                message: `${plural(failures.known.length, "test fails", "tests fail")}, as at the baseline (known failures; log: ${run.log})`,
+                severity: accepted ? "info" : "warn",
+                message: `${plural(failures.known.length, "test fails", "tests fail")}, as at the baseline (known failures${accepted ? ", accepted" : ""}; log: ${run.log})`,
                 project: run.project,
                 file: run.log,
             },
@@ -158,7 +288,7 @@ function failedTestFindings(run, failures) {
 export function testsCheck(v, comparisons) {
     const runs = v.runs.filter((r) => r.check === "test");
     if (runs.length === 0)
-        return noCommandResult(v, "tests");
+        return noCommandResult(v, "test");
     const findings = configFindings(v, "tests");
     let failed = 0;
     let known = 0;
@@ -168,21 +298,22 @@ export function testsCheck(v, comparisons) {
             if (failures?.new.length !== 0)
                 failed++;
             known += failures?.known.length ?? 0;
-            findings.push(...failedTestFindings(run, failures));
+            findings.push(...failedTestFindings(run, failures, v.baseline.acceptedFailures));
             if (run.failure)
                 findings.push(setupFinding(run));
         }
-        const ctx = v.projects.find(({ ctx }) => ctx.name === run.project)?.ctx;
-        const project = ctx?.project;
+        const entry = v.projects.find(({ ctx }) => ctx.name === run.project);
+        const ctx = entry?.ctx;
+        const testResults = entry && projectCommands(entry.adapter, entry.ctx).testResults;
         const comparison = comparisons.find((c) => c.project === run.project);
-        if (project?.testResults && !run.results) {
+        if (testResults && !hasTestNames(run.results)) {
             findings.push({
                 severity: "warn",
-                message: `no test results found at ${project.testResults}, so the test count was not compared`,
+                message: `no test results found at ${testResults}, so tests were not compared by name${run.results ? " (failing tests and counts read from the log)" : ""}`,
                 project: run.project,
             });
         }
-        else if (run.results && comparison?.before === undefined) {
+        else if (hasTestNames(run.results) && comparison?.before === undefined) {
             findings.push({
                 severity: "info",
                 message: "the baseline has no test results to compare with (run `flagrm baseline` before the removal)",
@@ -200,7 +331,16 @@ export function testsCheck(v, comparisons) {
                 findings.push({ severity: "info", message: `no longer runs: ${name}`, project: run.project });
             }
         }
-        if (run.results && ctx) {
+        const missing = comparison?.missing ?? 0;
+        if (missing > 0 && comparison) {
+            const configChanged = v.originalConfigChanges.some((c) => c.check === "tests" && c.project === run.project);
+            findings.push({
+                severity: configChanged || comparison.missingMayBeRows ? "info" : "warn",
+                message: `${plural(missing, "more test stopped running", "more tests stopped running")} than the diff deletes (${comparison.before} → ${comparison.after}, ${comparison.deleted.length} deleted): account for ${missing === 1 ? "it" : "them"} in the PR${comparison.missingMayBeRows ? " (data rows and .each cases count separately, so this may be them)" : ""}`,
+                project: run.project,
+            });
+        }
+        if (hasTestNames(run.results) && ctx) {
             for (const file of changedTestFiles(v, ctx.root)) {
                 if (testFileRan(file, ctx.root, run.results.names))
                     continue;
@@ -223,6 +363,7 @@ export function testsCheck(v, comparisons) {
             c.renamed.length && `${c.renamed.length} renamed`,
             c.excludedByConfig.length && `${c.excludedByConfig.length} excluded by config`,
             c.unexplained.length && `${c.unexplained.length} unexplained`,
+            c.missing && `${c.missing} unaccounted for`,
         ].filter(Boolean);
         return `${c.project} ${c.before} → ${c.after}${why.length ? `: ${why.join(", ")}` : ""}`;
     });