verifika 0.0.1 → 0.0.3

package/dist/main.js

@@ -3,28 +3,32 @@ import path from "node:path";
 import { parseArgs } from "node:util";
 import { findConfigFile, loadConfig } from "./config.js";
 import { ExitCode, VerifikaError } from "./errors.js";
-import { initConfig } from "./init.js";
+import { addVerifyScripts, initConfig, VERIFY_SCRIPTS } from "./init.js";
 import { showLogs } from "./logs.js";
+import { pagerAvailable, pagerCommand } from "./pager.js";
 import { plan } from "./planner.js";
 import { killAllNow } from "./process.js";
 import { agentReporter } from "./reporters/agent.js";
+import { detectCi } from "./ci.js";
 import { colors, humanReporter, plain } from "./reporters/human.js";
 import { jsonReporter } from "./reporters/json.js";
+import { liveReporter } from "./reporters/live.js";
 import { planJson, renderPlan } from "./reporters/plan.js";
 import { quietReporter } from "./reporters/quiet.js";
 import { OUTPUT_MODES } from "./reporters/reporter.js";
 import { runVerification } from "./runner.js";
+import { estimateSkipped } from "./runs.js";
 const COMMANDS = ["run", "plan", "logs", "init", "help"];
 const DEFAULT_PREVIEW_LINES = 10;
-export const HELP = `verifika - run the checks your changes need, with minimal output
+export const HELP = `vfk - run the checks your changes need, with minimal output
+(vfk is short for verifika; the two commands are identical)
 
 Usage:
-  verifika [run] [options]        Verify (selective locally, full in CI)
-  verifika plan [options]         Show which checks would run and why
-  verifika logs [check...]        Show logs from the latest run
-  verifika init [--force]         Create verifika.config.json from package.json scripts
-
-vfk is a shorthand for verifika: vfk plan, vfk --all, ...
+  vfk [run] [options]             Verify (selective locally, full in CI)
+  vfk plan [options]              Show which checks would run and why
+  vfk logs [check...]             Show logs from the latest run
+  vfk init [--force]              Create verifika.config.json from package.json scripts
+                                  and add "verify"/"verify:ci" scripts if absent
 
 Selection (run, plan):
       --all                       Run every check
@@ -39,11 +43,15 @@ Execution (run):
       --fail-fast                 Stop everything after the first failure
       --no-fail-fast              Run every selected check even after a failure
       --preview <lines>           Failure preview lines per check (default ${DEFAULT_PREVIEW_LINES}, 0 = off)
+      --no-live                   Print progress line by line instead of a live
+                                  status block (or set VERIFIKA_LIVE=0)
 
 Logs:
       --failed                    Print logs of every failed check
       --tail <lines>              Print only the last lines of each log
       --run <id>                  Read a specific run instead of the latest
+      --no-pager                  Print logs directly instead of through $PAGER
+                                  (paging only happens on a terminal)
 
 Output:
       --mode <mode>               human | agent | json | quiet
@@ -78,6 +86,7 @@ const OPTIONS = {
         "fail-fast": { type: "boolean" },
         "no-fail-fast": { type: "boolean" },
         preview: { type: "string" },
+        "no-live": { type: "boolean" },
     },
     plan: { ...SHARED, ...SELECTION },
     logs: {
@@ -85,6 +94,7 @@ const OPTIONS = {
         failed: { type: "boolean" },
         tail: { type: "string" },
         run: { type: "string" },
+        "no-pager": { type: "boolean" },
     },
     init: { ...SHARED, force: { type: "boolean" } },
     help: SHARED,
@@ -124,6 +134,9 @@ export async function main(argv, io) {
                 ...(values.run !== undefined ? { runId: values.run } : {}),
                 ...(values.tail !== undefined ? { tail: integerOption(values.tail, "--tail", 1) } : {}),
                 stripAnsi: !io.isTTY,
+                env: io.env,
+                // Agents in a pseudo-terminal must never get a pager waiting for a keypress.
+                ...(mode === "human" ? logsDisplay(io, values["no-pager"] === true) : {}),
             }, io);
         }
         const request = {
@@ -147,8 +160,10 @@ export async function main(argv, io) {
         if (command === "plan") {
             if (mode === "json")
                 io.out(planJson(selection, config));
-            else if (mode !== "quiet")
-                io.out(renderPlan(selection, mode === "human" ? 50 : 20));
+            else if (mode === "human")
+                io.out(renderPlan(selection, 50, humanStyle(io)));
+            else if (mode === "agent")
+                io.out(renderPlan(selection, 20));
             return ExitCode.Passed;
         }
         if (values["fail-fast"] && values["no-fail-fast"]) {
@@ -161,18 +176,31 @@ export async function main(argv, io) {
         const previewLines = values.preview !== undefined
             ? integerOption(values.preview, "--preview", 0)
             : DEFAULT_PREVIEW_LINES;
-        const result = await withInterruptHandling((signal) => runVerification({
-            config,
-            selection,
-            concurrency,
-            failFast,
-            previewLines,
-            signal,
-            reporter: reporterFor(mode, io),
-            version: version(),
-            env: io.env,
-        }));
-        return result.exitCode;
+        const skipped = selection.checks.filter((check) => !check.selected).map((check) => check.name);
+        const reporter = reporterFor(mode, io, {
+            live: values["no-live"] !== true,
+            // Only people see the estimate; other modes skip reading earlier runs.
+            ...(mode === "human" && skipped.length > 0
+                ? { skipEstimate: await estimateSkipped(config.root, skipped) }
+                : {}),
+        });
+        try {
+            const result = await withInterruptHandling(() => reporter.onInterrupt?.(), (signal) => runVerification({
+                config,
+                selection,
+                concurrency,
+                failFast,
+                previewLines,
+                signal,
+                reporter,
+                version: version(),
+                env: io.env,
+            }));
+            return result.exitCode;
+        }
+        finally {
+            reporter.dispose?.();
+        }
     }
     catch (error) {
         if (error instanceof VerifikaError) {
@@ -192,7 +220,19 @@ async function runInit(io, values) {
     const root = values.config ? path.dirname(path.resolve(io.cwd, values.config)) : io.cwd;
     const { file, checks } = await initConfig(root, Boolean(values.force));
     io.out(`Created ${path.relative(io.cwd, file) || file} with checks: ${checks.join(", ")}\n`);
-    io.out('Review the commands, add "paths" to checks that only some files affect, format the file if your repository checks formatting, then run: verifika plan\n');
+    const scripts = await addVerifyScripts(root);
+    if (scripts.added.length > 0) {
+        const added = scripts.added.map((name) => `"${name}": "${VERIFY_SCRIPTS[name]}"`);
+        io.out(`Added package.json scripts: ${added.join(", ")}\n`);
+    }
+    for (const { name, command } of scripts.kept) {
+        if (command === VERIFY_SCRIPTS[name]) {
+            io.out(`package.json already has "${name}": "${command}"\n`);
+            continue;
+        }
+        io.out(`Kept the existing "${name}" script (${command}); to use Verifika, change it to "${VERIFY_SCRIPTS[name]}" once the checks cover everything it runs\n`);
+    }
+    io.out('Review the commands, add "paths" to checks that only some files affect, format the file if your repository checks formatting, then run: vfk plan\n');
     return ExitCode.Passed;
 }
 function parse(args, command) {
@@ -208,7 +248,7 @@ function parse(args, command) {
     }
     catch (error) {
         const message = error.message.replace(/\. To specify a positional argument.*$/s, "");
-        throw new VerifikaError(message, `Run "verifika --help" for usage.`);
+        throw new VerifikaError(message, `Run "vfk --help" for usage.`);
     }
 }
 function integerOption(value, flag, min) {
@@ -241,13 +281,22 @@ function guessMode(argv, io) {
             ? "human"
             : "agent";
 }
-function reporterFor(mode, io) {
+function reporterFor(mode, io, options) {
     switch (mode) {
         case "human": {
-            const color = io.isTTY && !io.env.NO_COLOR
-                ? true
-                : Boolean(io.env.FORCE_COLOR && io.env.FORCE_COLOR !== "0");
-            return humanReporter(io, color ? colors : plain, { heartbeat: io.isTTY });
+            const style = humanStyle(io);
+            // The live block redraws in place, so it needs a real, capable terminal that
+            // nobody is logging; everywhere else the line reporter is the fallback.
+            const live = options.live &&
+                io.terminal !== undefined &&
+                io.isTTY &&
+                !detectCi(io.env).ci &&
+                io.env.TERM !== "dumb" &&
+                !isOff(io.env.VERIFIKA_LIVE);
+            const estimate = options.skipEstimate ? { skipEstimate: options.skipEstimate } : {};
+            if (live && io.terminal)
+                return liveReporter(io.terminal, style, estimate);
+            return humanReporter(io, style, { heartbeat: io.isTTY, ...estimate });
         }
         case "agent":
             return agentReporter(io);
@@ -257,6 +306,28 @@ function reporterFor(mode, io) {
             return quietReporter(io);
     }
 }
+/**
+ * On a terminal, `vfk logs` speaks to a person: local relative times, clickable
+ * log paths (not in CI, whose log viewers show escape codes), and a pager.
+ */
+function logsDisplay(io, noPager) {
+    if (!io.isTTY)
+        return {};
+    const capable = !detectCi(io.env).ci && io.env.TERM !== "dumb";
+    const pager = pagerCommand(io.env);
+    return {
+        display: { now: new Date(), hyperlinks: capable && !isOff(io.env.VERIFIKA_HYPERLINKS) },
+        ...(noPager || !pagerAvailable(pager, io.env) ? {} : { pager }),
+    };
+}
+/** Colour on a terminal unless NO_COLOR is set; FORCE_COLOR enables it elsewhere. */
+function humanStyle(io) {
+    const color = io.isTTY && !io.env.NO_COLOR ? true : Boolean(io.env.FORCE_COLOR && io.env.FORCE_COLOR !== "0");
+    return color ? colors : plain;
+}
+function isOff(value) {
+    return value !== undefined && ["0", "false", "no", "off"].includes(value.trim().toLowerCase());
+}
 function reportError(error, mode, io) {
     if (mode === "json") {
         const document = {
@@ -274,14 +345,16 @@ function reportError(error, mode, io) {
  * First SIGINT/SIGTERM/SIGHUP stops scheduling and terminates running checks
  * gracefully; a second one kills them immediately.
  */
-async function withInterruptHandling(operation) {
+async function withInterruptHandling(onFirstSignal, operation) {
     const controller = new AbortController();
     const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
     const onSignal = (signal) => {
         if (controller.signal.aborted)
             killAllNow();
-        else
+        else {
+            onFirstSignal();
             controller.abort(signal);
+        }
     };
     for (const signal of signals)
         process.on(signal, onSignal);

package/dist/pager.js

@@ -0,0 +1,92 @@
+import { spawn } from "node:child_process";
+import { accessSync, constants } from "node:fs";
+import path from "node:path";
+/** Used when `PAGER` is unset: quit if one screen, keep colours, leave output on screen. */
+export const DEFAULT_PAGER = "less -R -F -X";
+/** The pager command line from `PAGER`, or the default. */
+export function pagerCommand(env) {
+    const configured = env.PAGER?.trim();
+    return configured ? configured : DEFAULT_PAGER;
+}
+/**
+ * Whether the pager's program exists, so a missing one (e.g. `less` on Windows)
+ * falls back to plain output instead of a shell error. Checks the first word of
+ * the command (which may be quoted): a path, or a name looked up on PATH (with
+ * PATHEXT on Windows).
+ */
+export function pagerAvailable(command, env) {
+    const match = /^\s*(?:"([^"]+)"|'([^']+)'|(\S+))/.exec(command);
+    const program = match?.[1] ?? match?.[2] ?? match?.[3] ?? "";
+    if (program === "")
+        return false;
+    const isWindows = process.platform === "win32";
+    const extensions = isWindows
+        ? ["", ...(env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";").filter(Boolean)]
+        : [""];
+    const candidates = program.includes("/") || program.includes("\\")
+        ? [program]
+        : (env.PATH ?? env.Path ?? "")
+            .split(path.delimiter)
+            .filter(Boolean)
+            .map((directory) => path.join(directory, program));
+    return candidates.some((candidate) => extensions.some((extension) => {
+        try {
+            accessSync(candidate + extension, isWindows ? constants.F_OK : constants.X_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }));
+}
+/**
+ * Pipes everything `produce` writes into the pager, which takes over the
+ * terminal until the user quits it. Quitting early is not an error: further
+ * output is dropped. Ctrl-C belongs to the pager meanwhile, so Verifika ignores
+ * SIGINT until the pager exits (as git does).
+ */
+export async function withPager(command, env, produce) {
+    // Like git: colours and quit-if-one-screen for a plain `less`, unless the user configured LESS.
+    const child = spawn(command, {
+        shell: true,
+        stdio: ["pipe", "inherit", "inherit"],
+        env: { LESS: "FRX", ...env },
+    });
+    const ignoreInterrupt = () => undefined;
+    process.on("SIGINT", ignoreInterrupt);
+    const exited = new Promise((resolve) => {
+        child.once("close", () => resolve());
+        child.once("error", () => resolve());
+    });
+    let closed = false;
+    const stdin = child.stdin;
+    stdin.on("error", () => {
+        // EPIPE: the user quit the pager before reading everything.
+        closed = true;
+    });
+    child.once("close", () => {
+        closed = true;
+    });
+    try {
+        await produce((text) => {
+            if (closed)
+                return;
+            if (!stdin.write(text)) {
+                return new Promise((resolve) => {
+                    const done = () => {
+                        stdin.off("drain", done);
+                        child.off("close", done);
+                        resolve();
+                    };
+                    stdin.once("drain", done);
+                    child.once("close", done);
+                });
+            }
+        });
+    }
+    finally {
+        stdin.end();
+        await exited;
+        process.off("SIGINT", ignoreInterrupt);
+    }
+}

package/dist/planner.js

@@ -138,24 +138,37 @@ function decideByPaths(check, files) {
         matchedFiles: matched.slice(0, MAX_MATCHED_FILES),
     };
 }
-/** Adds dependencies of selected checks, then emits decisions in config order. */
+/**
+ * Adds dependencies of selected checks, recording every check that requires
+ * each one, then emits decisions in config order.
+ */
 function finalize(config, decisions, skipReason) {
     const byName = new Map(config.checks.map((check) => [check.name, check]));
+    const requiredBy = new Map();
     const pending = [...decisions.keys()];
     while (pending.length > 0) {
         const name = pending.shift();
         for (const dependency of byName.get(name)?.dependsOn ?? []) {
+            // Selected on its own merits: its own reason says why.
+            if (decisions.has(dependency) && !requiredBy.has(dependency))
+                continue;
+            requiredBy.set(dependency, (requiredBy.get(dependency) ?? new Set()).add(name));
             if (decisions.has(dependency))
                 continue;
-            decisions.set(dependency, {
-                name: dependency,
-                selected: true,
-                reason: `required by ${name}`,
-                matchedFiles: [],
-            });
+            decisions.set(dependency, { name: dependency, selected: true, reason: "", matchedFiles: [] });
             pending.push(dependency);
         }
     }
+    for (const [dependency, dependents] of requiredBy) {
+        const names = config.checks.map((check) => check.name).filter((name) => dependents.has(name));
+        decisions.set(dependency, {
+            name: dependency,
+            selected: true,
+            reason: `required by ${names.join(", ")}`,
+            matchedFiles: [],
+            requiredBy: names,
+        });
+    }
     return config.checks.map((check) => decisions.get(check.name) ?? {
         name: check.name,
         selected: false,

package/dist/preview.js

@@ -6,6 +6,8 @@ const ANSI =
 const REDRAW = /\u001b\[\d*A|\u001b\[2K/;
 /** Markers test runners and compilers print for the failure itself. Case-sensitive on purpose. */
 const DEFINITE_FAILURE = /\bFAILED\b|^\s*FAIL\b|\bAssertionError\b|^\s*Expected\b|\berror TS\d+|\[ERROR\]|^\s*[✗✖×]|\bTraceback\b|\bpanicked\b/;
+/** ESLint's stylish format: `  1:9  error  'x' is assigned a value but never used  no-unused-vars`. */
+const ESLINT_ERROR = /^\s+\d+:\d+\s+error\s/;
 /** Exception lines; passing tests that exercise error paths print these too. */
 const EXCEPTION = /\b\w*Error:/;
 /** Lines that often relate to a failure but also appear in passing output. */
@@ -16,6 +18,13 @@ const PROGRESS = /\b\d+\s*(?:of|\/)\s*\d+\b|\d+(?:\.\d+)?%/;
 const JSON_LINE = /^\s*[[{]"/;
 /** Package-manager wrapper noise that repeats the exit code without saying what failed. */
 const WRAPPER_NOISE = /^(?:npm (?:error|ERR!|warn|notice)|\s*ELIFECYCLE\b|error Command failed with exit code|info Visit https:\/\/yarnpkg)/;
+/**
+ * First line of a package-manager script banner: npm and pnpm print `> pkg@1.2.3 script`
+ * (pnpm adds the directory), yarn 1 prints `yarn run v1.22.19`. The next line repeats the command.
+ */
+const SCRIPT_BANNER = /^(?:> \S*@\S+ \S|yarn run v\d)/;
+/** The command line that follows a banner: `> eslint .` (npm, pnpm) or `$ eslint .` (yarn). */
+const BANNER_COMMAND = /^[>$] \S/;
 const MAX_LINE_CHARS = 200;
 /** Partial lines are truncated beyond this, so one giant line cannot grow memory. */
 const MAX_PENDING_CHARS = 4_096;
@@ -25,10 +34,12 @@ export function stripAnsi(text) {
 /**
  * Keeps a bounded excerpt of command output for failure previews. In order of
  * preference it returns lines that clearly mark a failure (FAIL/FAILED,
- * assertion and compiler errors) with the line after each, then exception lines
+ * assertion and compiler errors) with the line after each, and ESLint errors
+ * under their file heading; then exception lines
  * (`TypeError: ...`), then lines that merely mention errors, then the last lines
  * of output.
  *
+ * Package-manager script banners (`> pkg@1.2.3 lint` / `> eslint .`) are dropped.
  * Progress output is collapsed: terminal redraws and progress counters rewritten
  * on new lines replace the previous line. Memory use is O(limit) regardless of
  * how much the command prints.
@@ -44,9 +55,12 @@ export class OutputCapture {
     lastShape = null;
     /** Most recent unindented, non-matching line, e.g. the file name ESLint prints above its errors. */
     header = null;
-    headerShown = false;
+    /** Lists that already hold the current header, so each group shows it once. */
+    headerShownIn = new Set();
     /** Whether the next indented line continues a failure marker (e.g. the message under a FAILED test). */
     continueDefinite = false;
+    /** Whether the previous line opened a package-manager script banner. */
+    inBanner = false;
     constructor(limit) {
         this.limit = Math.max(0, limit);
     }
@@ -78,6 +92,10 @@ export class OutputCapture {
         const line = stripAnsi(content.slice(content.lastIndexOf("\r") + 1)).trimEnd();
         if (line.trim() === "" || WRAPPER_NOISE.test(line))
             return;
+        const banner = SCRIPT_BANNER.test(line) || (this.inBanner && BANNER_COMMAND.test(line));
+        this.inBanner = banner && SCRIPT_BANNER.test(line);
+        if (banner)
+            return;
         const text = line.length > MAX_LINE_CHARS ? `${line.slice(0, MAX_LINE_CHARS - 1)}…` : line;
         // Progress counters ("Executed 12 of 756", "40%") rewritten on new lines are one line;
         // a final progress line often adds a suffix ("… (16.5 secs)").
@@ -93,10 +111,16 @@ export class OutputCapture {
         const entry = { seq: this.seq, text, progressKey };
         const indented = /^\s/.test(line);
         const isJson = JSON_LINE.test(line);
-        const definite = !isJson && DEFINITE_FAILURE.test(line);
+        const eslint = ESLINT_ERROR.test(line);
+        const definite = !isJson && (eslint || DEFINITE_FAILURE.test(line));
         const exception = !isJson && !definite && EXCEPTION.test(line);
         const weak = !isJson && !definite && !exception && WEAK_FAILURE.test(line);
-        if (definite || (this.continueDefinite && indented && !/^\s*at\s/.test(line))) {
+        if (eslint) {
+            this.pushWithHeader(this.definite, entry, indented);
+            // The line after an ESLint error is the next problem, possibly a warning: not a continuation.
+            this.continueDefinite = false;
+        }
+        else if (definite || (this.continueDefinite && indented && !/^\s*at\s/.test(line))) {
             push(this.definite, entry, this.limit, false);
             this.continueDefinite = definite;
         }
@@ -109,16 +133,16 @@ export class OutputCapture {
         }
         if (!indented && !definite && !exception && !weak && !isJson) {
             this.header = entry;
-            this.headerShown = false;
+            this.headerShownIn.clear();
         }
         push(this.tail, entry, this.limit, true);
     }
     /** An indented failure usually belongs to the heading above it; keep that context once. */
     pushWithHeader(list, entry, indented) {
-        if (indented && this.header && !this.headerShown && list.length + 2 <= this.limit) {
+        if (indented && this.header && !this.headerShownIn.has(list) && list.length + 2 <= this.limit) {
             push(list, this.header, this.limit, false);
         }
-        this.headerShown = true;
+        this.headerShownIn.add(list);
         push(list, entry, this.limit, false);
     }
     replacePrevious() {
@@ -145,3 +169,38 @@ function push(list, entry, limit, rolling) {
         list.push(entry);
     }
 }
+/**
+ * Follows a stream of output and reports its latest non-empty line, including a
+ * line still being written (progress bars redraw with `\r` and may never end
+ * one). Reports only changes, ANSI-stripped. Memory is bounded like OutputCapture.
+ */
+export class LastLine {
+    report;
+    pending = "";
+    last = "";
+    constructor(report) {
+        this.report = report;
+    }
+    write(text) {
+        const buffer = this.pending + text;
+        const lines = buffer.split("\n");
+        const rest = lines.pop() ?? "";
+        this.pending = rest.length > MAX_PENDING_CHARS ? rest.slice(-MAX_PENDING_CHARS) : rest;
+        for (const candidate of [rest, ...lines.reverse()]) {
+            const content = candidate.endsWith("\r") ? candidate.slice(0, -1) : candidate;
+            // Control characters (BEL, SO/SI, backspace) would act on the terminal at every redraw.
+            const line = stripAnsi(content.slice(content.lastIndexOf("\r") + 1))
+                .replace(/\t/g, " ")
+                // eslint-disable-next-line no-control-regex
+                .replace(/[\u0000-\u001f\u007f]/g, "")
+                .trim();
+            if (line === "")
+                continue;
+            if (line !== this.last) {
+                this.last = line;
+                this.report(line);
+            }
+            return;
+        }
+    }
+}

package/dist/process.js

@@ -62,12 +62,19 @@ export async function execCheck(options) {
         };
     }
     active.add(child);
-    for (const stream of [child.stdout, child.stderr]) {
+    for (const [name, stream] of [
+        ["stdout", child.stdout],
+        ["stderr", child.stderr],
+    ]) {
         if (!stream)
             continue;
         const decoder = new StringDecoder("utf8");
         stream.pipe(log, { end: false });
-        stream.on("data", (chunk) => capture.write(stream, decoder.write(chunk)));
+        stream.on("data", (chunk) => {
+            const text = decoder.write(chunk);
+            capture.write(stream, text);
+            options.onOutput?.(name, text);
+        });
         stream.on("end", () => capture.write(stream, decoder.end() + "\n"));
     }
     let giveUp = () => undefined;

package/dist/reporters/agent.js

@@ -1,4 +1,4 @@
-import { describeProblem, duration, isFailureStatus, logsHint, MAX_PREVIEWED_FAILURES, problems, selectionLabel, verdict, } from "./reporter.js";
+import { describeProblem, duration, logsHint, previewDecider, problems, selectionLabel, verdict, } from "./reporter.js";
 /**
  * Minimal output for coding agents and other non-interactive callers: one line
  * on success; on failure, one line per problem, a bounded preview, and the
@@ -13,16 +13,13 @@ export function renderAgent(result) {
         `${verdict(result)} ${summary.passed}/${summary.selected} (${duration(result.durationMs)}) ${selectionLabel(result.selection, summary.skipped)}`,
     ];
     if (summary.selected === 0)
-        lines.push("Nothing to verify for these changes. Full run: verifika --all");
-    let previewed = 0;
+        lines.push("Nothing to verify for these changes. Full run: vfk --all");
+    const decide = previewDecider(result);
     for (const check of problems(result)) {
-        lines.push(`${check.name}: ${describeProblem(check)}`);
-        if (isFailureStatus(check.status) &&
-            check.preview.length > 0 &&
-            previewed < MAX_PREVIEWED_FAILURES) {
-            previewed++;
+        const preview = decide(check);
+        lines.push(`${check.name}: ${describeProblem(check)}${preview.note}`);
+        if (preview.show)
             lines.push(...check.preview.map((line) => `  ${line}`));
-        }
     }
     const hint = logsHint(result);
     if (hint)