verifika 0.0.2 → 0.0.3

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
@@ -14,15 +14,12 @@ export function renderAgent(result) {
     ];
     if (summary.selected === 0)
         lines.push("Nothing to verify for these changes. Full run: vfk --all");
-    let previewed = 0;
+    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)

package/dist/reporters/human.js

@@ -1,4 +1,5 @@
-import { describeProblem, duration, isFailureStatus, logsHint, MAX_PREVIEWED_FAILURES, problems, selectionLabel, } from "./reporter.js";
+import { formatSeconds } from "../format.js";
+import { describeProblem, duration, isFailureStatus, logsHint, previewDecider, problems, selectionLabel, STOPPING_MESSAGE, } from "./reporter.js";
 const wrap = (open, close) => (text) => `\u001b[${open}m${text}\u001b[${close}m`;
 export const colors = {
     green: wrap(32, 39),
@@ -25,20 +26,13 @@ const HEARTBEAT_MS = 30_000;
 export function humanReporter(output, style, options = {}) {
     const running = new Map();
     let heartbeat;
+    let width = 0;
     return {
-        onStart({ selection, selected }) {
-            const skipped = selection.checks.length - selected.length;
-            output.out(`${style.bold("verifika")} ${selectionLabel(selection, skipped)}\n`);
-            if (selected.length === 0) {
-                output.out(style.dim("Nothing to verify for these changes. Full run: vfk --all\n"));
+        onStart(info) {
+            output.out(renderStart(info, style, options.skipEstimate));
+            width = nameWidth(info.selected);
+            if (info.selected.length === 0)
                 return;
-            }
-            if (skipped > 0) {
-                const names = selection.checks
-                    .filter((check) => !check.selected)
-                    .map((check) => check.name);
-                output.out(style.dim(`skipped: ${names.join(", ")}\n`));
-            }
             if (options.heartbeat) {
                 heartbeat = setInterval(() => {
                     if (running.size === 0)
@@ -58,33 +52,75 @@ export function humanReporter(output, style, options = {}) {
         },
         onCheckEnd(check) {
             running.delete(check.name);
-            const detail = check.status === "passed" ? "" : ` ${describeProblem(check)}`;
-            output.out(`${symbol(check.status, style)} ${check.name} ${style.dim(duration(check.durationMs))}${detail}\n`);
+            output.out(renderCheckEnd(check, style, width));
         },
         onFinish(result) {
             if (heartbeat)
                 clearInterval(heartbeat);
             output.out(renderSummary(result, style));
         },
+        onInterrupt() {
+            output.err(style.yellow(STOPPING_MESSAGE));
+        },
     };
 }
+export function nameWidth(names) {
+    return Math.max(0, ...names.map((name) => name.length));
+}
+/**
+ * The run header (`verifika · <selection> · <n> checks · <j> parallel`), then
+ * the skipped checks with the time skipping them saved.
+ */
+export function renderStart({ selection, selected, concurrency }, style, estimate) {
+    const header = [style.bold("verifika"), selectionLabel(selection, 0)];
+    header.push(`${selected.length} check${selected.length === 1 ? "" : "s"}`);
+    if (selected.length > 0)
+        header.push(`${concurrency} parallel`);
+    let text = `${header.join(" · ")}\n`;
+    const skipped = selection.checks.filter((check) => !check.selected).map((check) => check.name);
+    if (skipped.length > 0) {
+        text += style.dim(`${skipped.length} skipped${savedNote(skipped.length, estimate)}: ${skipped.join(", ")}\n`);
+    }
+    if (selected.length === 0) {
+        text += style.dim("Nothing to verify for these changes. Full run: vfk --all\n");
+    }
+    return text;
+}
+/** ` (~40s saved)`, ` (≥40s saved)` when some durations are unknown, or nothing when none are known. */
+function savedNote(skipped, estimate) {
+    if (!estimate || estimate.unknown >= skipped)
+        return "";
+    return ` (${estimate.unknown > 0 ? "≥" : "~"}${formatSeconds(estimate.knownMs)} saved)`;
+}
+/** The permanent line printed when a check finishes; durations line up in a column. */
+export function renderCheckEnd(check, style, width = 0) {
+    const time = style.dim(duration(check.durationMs).padStart(5));
+    const detail = check.status === "passed" ? "" : `  ${describeProblem(check)}`;
+    return `${symbol(check.status, style)} ${check.name.padEnd(width)} ${time}${detail}\n`;
+}
 export function renderSummary(result, style) {
     const { summary } = result;
     const lines = [];
     const failing = problems(result);
-    let previewed = 0;
+    const decide = previewDecider(result);
+    const width = nameWidth(failing.map((check) => check.name));
     if (failing.length > 0)
         lines.push("");
     for (const check of failing) {
+        const name = check.name.padEnd(width);
+        if (check.status === "blocked") {
+            lines.push(style.dim(`${symbol(check.status, plain)} ${name}  ${blockedReason(check, result)}`));
+            continue;
+        }
         if (!isFailureStatus(check.status)) {
-            lines.push(`${symbol(check.status, style)} ${check.name}: ${describeProblem(check)}`);
+            lines.push(`${symbol(check.status, style)} ${name}  ${describeProblem(check)}`);
             continue;
         }
-        lines.push(`${symbol(check.status, style)} ${style.bold(check.name)}: ${describeProblem(check)}`);
-        if (check.preview.length > 0 && previewed < MAX_PREVIEWED_FAILURES) {
-            previewed++;
+        const preview = decide(check);
+        const rerun = `rerun: vfk -c ${check.name}`;
+        lines.push(`${symbol(check.status, style)} ${style.bold(name)}  ${check.command} → ${describeProblem(check)}${style.dim(` · ${rerun}${preview.note}`)}`);
+        if (preview.show)
             lines.push(...check.preview.map((line) => style.dim(`    ${line}`)));
-        }
     }
     const time = duration(result.durationMs);
     if (result.status === "passed") {
@@ -99,6 +135,18 @@ export function renderSummary(result, style) {
         lines.push(style.dim(`Logs: ${hint}`));
     return `${lines.join("\n")}\n`;
 }
+/** `not run: build failed`, naming what happened to the dependency that blocked the check. */
+function blockedReason(check, result) {
+    const dependency = result.checks.find((other) => other.name === check.blockedBy);
+    if (!dependency)
+        return `not run: ${check.reason}`;
+    const outcome = dependency.status === "timed_out"
+        ? "timed out"
+        : isFailureStatus(dependency.status)
+            ? "failed"
+            : "did not run";
+    return `not run: ${dependency.name} ${outcome}`;
+}
 export function symbol(status, style) {
     switch (status) {
         case "passed":
@@ -109,6 +157,8 @@ export function symbol(status, style) {
             return style.red("✗");
         case "skipped":
             return style.dim("–");
+        case "blocked":
+            return style.dim("○");
         default:
             return style.yellow("!");
     }

package/dist/reporters/live.js

@@ -0,0 +1,209 @@
+import { formatSeconds } from "../format.js";
+import { nameWidth, renderCheckEnd, renderStart, renderSummary, } from "./human.js";
+import { STOPPING_MESSAGE } from "./reporter.js";
+/** Redraw interval: about 10 frames a second, which also throttles output-driven updates. */
+const FRAME_MS = 100;
+const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const CSI = "\u001b[";
+const HIDE_CURSOR = `${CSI}?25l`;
+const SHOW_CURSOR = `${CSI}?25h`;
+// Autowrap stays off while the block is drawn, so an overlong line (wide characters
+// the width estimate missed) is clipped by the terminal instead of wrapping and
+// breaking the cursor-up count of the next redraw.
+const NO_WRAP = `${CSI}?7l`;
+const WRAP = `${CSI}?7h`;
+/**
+ * The redrawn part of the live display: a progress header, one line per running
+ * check (spinner, elapsed time, latest output) and the checks still waiting.
+ * Lines fit the width; the block never exceeds the height minus one row, so the
+ * cursor can always move back to its top.
+ */
+export function renderBlock(state, view, style) {
+    const max = Math.max(1, view.width - 1);
+    const elapsed = formatSeconds(view.now - state.startedAt);
+    const header = `[${state.finished.size}/${state.selected.length}] ${elapsed}${state.stopping ? " · stopping…" : ""}`;
+    const namePad = nameWidth(state.selected);
+    const frame = SPINNER[Math.floor(view.now / FRAME_MS) % SPINNER.length];
+    const running = state.selected
+        .filter((name) => state.running.has(name))
+        .map((name) => {
+        const { since, line } = state.running.get(name);
+        const time = formatSeconds(view.now - since).padStart(5);
+        const prefix = `${frame} ${name.padEnd(namePad)}  ${time}`;
+        if (prefix.length + 2 >= max)
+            return fit(prefix, max);
+        const shown = fit(line, max - prefix.length - 2);
+        return `${frame} ${name.padEnd(namePad)}  ${style.dim(time)}${shown ? `  ${style.dim(shown)}` : ""}`;
+    });
+    const groups = waitingGroups(state);
+    const waiting = groups.map(({ names, why }) => style.dim(fit(`  ${names.join(", ")}  ${why}`, max)));
+    // Keep the header, then as many running checks as fit, then waiting groups;
+    // collapse whatever does not fit into a count.
+    const room = Math.max(1, view.height - 1) - 1;
+    let shownRunning = running.length;
+    let shownWaiting = waiting.length;
+    const total = () => shownRunning +
+        (shownRunning < running.length ? 1 : 0) +
+        shownWaiting +
+        (shownWaiting < waiting.length ? 1 : 0);
+    while (total() > room && (shownWaiting > 0 || shownRunning > 0)) {
+        if (shownWaiting > 0)
+            shownWaiting--;
+        else
+            shownRunning--;
+    }
+    const lines = [style.bold(fit(header, max)), ...running.slice(0, shownRunning)];
+    if (shownRunning < running.length)
+        lines.push(style.dim(fit(`  +${running.length - shownRunning} more running`, max)));
+    lines.push(...waiting.slice(0, shownWaiting));
+    if (shownWaiting < waiting.length) {
+        const hidden = groups
+            .slice(shownWaiting)
+            .reduce((count, group) => count + group.names.length, 0);
+        lines.push(style.dim(fit(`  +${hidden} more waiting`, max)));
+    }
+    return lines.slice(0, Math.max(1, view.height - 1));
+}
+/** Checks not yet started, grouped by what they wait for, e.g. `test, pack  waiting on build`. */
+function waitingGroups(state) {
+    const selected = new Set(state.selected);
+    // A check whose dependency failed (directly or down a chain) will never start.
+    const blocked = new Set();
+    for (let changed = true; changed;) {
+        changed = false;
+        for (const name of state.selected) {
+            if (blocked.has(name) || state.finished.has(name) || state.running.has(name))
+                continue;
+            const deps = state.dependsOn[name] ?? [];
+            if (deps.some((dep) => state.finished.get(dep) === false || blocked.has(dep))) {
+                blocked.add(name);
+                changed = true;
+            }
+        }
+    }
+    const groups = new Map();
+    for (const name of state.selected) {
+        if (state.running.has(name) || state.finished.has(name) || blocked.has(name))
+            continue;
+        const unmet = (state.dependsOn[name] ?? []).filter((dep) => selected.has(dep) && state.finished.get(dep) !== true);
+        const why = state.stopping
+            ? "will not start"
+            : unmet.length > 0
+                ? `waiting on ${unmet.join(", ")}`
+                : "queued";
+        groups.set(why, [...(groups.get(why) ?? []), name]);
+    }
+    return [...groups].map(([why, names]) => ({ names, why }));
+}
+/** Truncates to `width` characters (code points), marking the cut with an ellipsis. */
+export function fit(text, width) {
+    const chars = Array.from(text);
+    if (chars.length <= width)
+        return text;
+    return width <= 0 ? "" : `${chars.slice(0, width - 1).join("")}…`;
+}
+/**
+ * Human output with a live status block. Finished checks print permanently above
+ * the block exactly as the line reporter prints them, so scrollback reads like
+ * line mode; the block below is redrawn in place (cursor up, erase down) and
+ * removed when the run ends. The cursor is hidden while live and restored on
+ * finish, on dispose (errors) and on process exit.
+ */
+export function liveReporter(terminal, style, options = {}) {
+    let state = null;
+    let drawn = 0;
+    let stopTicker;
+    let unregisterExit;
+    let width = 0;
+    const clear = () => (drawn > 0 ? `\r${CSI}${drawn}A${CSI}J` : "");
+    const draw = (above = "") => {
+        if (!state)
+            return;
+        const lines = renderBlock(state, { width: terminal.columns(), height: terminal.rows(), now: terminal.now() }, style);
+        terminal.write(`${clear()}${above}${NO_WRAP}${lines.map((line) => `${line}\n`).join("")}${WRAP}`);
+        drawn = lines.length;
+    };
+    const release = (after = "") => {
+        if (!state) {
+            if (after)
+                terminal.write(after);
+            return;
+        }
+        stopTicker?.();
+        unregisterExit?.();
+        terminal.write(`${clear()}${SHOW_CURSOR}${after}`);
+        state = null;
+        drawn = 0;
+    };
+    return {
+        onStart(info) {
+            terminal.write(renderStart(info, style, options.skipEstimate));
+            width = nameWidth(info.selected);
+            if (info.selected.length === 0)
+                return;
+            state = {
+                selected: info.selected,
+                dependsOn: info.dependsOn,
+                running: new Map(),
+                finished: new Map(),
+                startedAt: terminal.now(),
+                stopping: false,
+            };
+            terminal.write(HIDE_CURSOR);
+            unregisterExit = terminal.onExit(() => terminal.write(`${SHOW_CURSOR}${WRAP}`));
+            stopTicker = terminal.every(FRAME_MS, () => draw());
+            draw();
+        },
+        onCheckStart(name) {
+            state?.running.set(name, { since: terminal.now(), line: "" });
+            draw();
+        },
+        onCheckOutput(name, line) {
+            // Picked up by the next frame; output alone never triggers a redraw.
+            const entry = state?.running.get(name);
+            if (entry)
+                entry.line = line;
+        },
+        onCheckEnd(check) {
+            state?.running.delete(check.name);
+            state?.finished.set(check.name, check.status === "passed");
+            draw(renderCheckEnd(check, style, width));
+        },
+        onFinish(result) {
+            release(renderSummary(result, style));
+        },
+        onInterrupt() {
+            // Clear the block first so the message lands above it, not inside it (or on top of
+            // the ^C the terminal echoed below it); the redrawn block then says it is stopping.
+            if (state) {
+                state.stopping = true;
+                terminal.write(clear());
+                drawn = 0;
+            }
+            terminal.writeError(style.yellow(STOPPING_MESSAGE));
+            draw();
+        },
+        dispose() {
+            release();
+        },
+    };
+}
+/** The real terminal behind stdout. */
+export function systemTerminal(write, writeError, stream) {
+    return {
+        write,
+        writeError,
+        columns: () => stream.columns || 80,
+        rows: () => stream.rows || 24,
+        now: () => performance.now(),
+        every(ms, frame) {
+            const timer = setInterval(frame, ms);
+            timer.unref();
+            return () => clearInterval(timer);
+        },
+        onExit(restore) {
+            process.once("exit", restore);
+            return () => process.off("exit", restore);
+        },
+    };
+}

package/dist/reporters/plan.js

@@ -1,3 +1,4 @@
+import { plain } from "./human.js";
 import { selectionLabel } from "./reporter.js";
 const STATUS_LETTER = {
     added: "A",
@@ -7,7 +8,7 @@ const STATUS_LETTER = {
     changed: "~",
 };
 /** Text rendering of a plan. `maxFiles` bounds the changed-file list. */
-export function renderPlan(selection, maxFiles) {
+export function renderPlan(selection, maxFiles, style = plain) {
     const skipped = selection.checks.filter((check) => !check.selected).length;
     const lines = [`Plan: ${selectionLabel(selection, skipped)}`];
     const files = selection.changes?.files;
@@ -21,7 +22,8 @@ export function renderPlan(selection, maxFiles) {
     lines.push("Checks:");
     const width = Math.max(...selection.checks.map((check) => check.name.length));
     for (const check of selection.checks) {
-        lines.push(`  ${check.selected ? "run " : "skip"}  ${check.name.padEnd(width)}  ${check.reason}`);
+        const row = `${check.name.padEnd(width)}  ${check.reason}`;
+        lines.push(check.selected ? `  ${style.green("run ")}  ${row}` : style.dim(`  skip  ${row}`));
     }
     return `${lines.join("\n")}\n`;
 }

package/dist/reporters/reporter.js

@@ -1,5 +1,7 @@
 import { formatSeconds } from "../format.js";
 export const OUTPUT_MODES = ["human", "agent", "json", "quiet"];
+/** Printed to stderr in human mode on the first interrupt. */
+export const STOPPING_MESSAGE = "stopping… (Ctrl-C again to force)\n";
 /** Previews are shown for at most this many failed checks, to keep output bounded. */
 export const MAX_PREVIEWED_FAILURES = 3;
 export function isFailureStatus(status) {
@@ -28,9 +30,31 @@ export function logsHint(result) {
     const withLogs = problems(result).filter((check) => isFailureStatus(check.status) && check.log);
     if (withLogs.length === 0)
         return null;
-    const command = withLogs.length === 1 ? `vfk logs ${withLogs[0]?.name}` : "vfk logs --failed";
+    return logsCommand(result, withLogs.length === 1 ? (withLogs[0]?.name ?? "") : "--failed");
+}
+/** `vfk logs <target>`, naming the run when a later run has become the latest. */
+function logsCommand(result, target) {
+    const command = `vfk logs ${target}`;
     return result.latest ? command : `${command} --run ${result.runId}`;
 }
+/**
+ * Decides which failed checks get their preview printed: at most
+ * MAX_PREVIEWED_FAILURES, in config order. The rest get a note pointing at their
+ * log, so a hidden preview never looks like one that found nothing.
+ */
+export function previewDecider(result) {
+    let previewed = 0;
+    return (check) => {
+        if (!isFailureStatus(check.status) || check.preview.length === 0) {
+            return { show: false, note: "" };
+        }
+        if (previewed < MAX_PREVIEWED_FAILURES) {
+            previewed++;
+            return { show: true, note: "" };
+        }
+        return { show: false, note: ` (preview omitted: ${logsCommand(result, check.name)})` };
+    };
+}
 export function verdict(result) {
     return result.status === "passed"
         ? "PASS"