@e2edev/e2e 0.5.0 → 0.6.0

package/dist/report/list.js

@@ -1,85 +1,100 @@
-/** Human-readable list reporter (spec 06-cli.md). */
+/**
+ * Human-readable list reporter, styled after vitest's
+ * default reporter: one block per test file and target, a `Failed Tests`
+ * section with code frames, and a padded summary. On a TTY a live window
+ * below the log shows the running files, their tests, and the counters.
+ */
 import path from 'node:path';
 import picocolors from 'picocolors';
 import { sanitizeText, truncateUtf8 } from '../internal/errors.js';
+import { packageVersion } from '../internal/package-version.js';
 import { collapseText } from '../internal/text.js';
 import { codeFrame, userFrame } from './code-frame.js';
-import { LiveStatus } from './live-status.js';
-const MAX_FIELD_BYTES = 8192;
+import { addUsage, aiSegment, bounded, ellipsize, emptyCounters, emptyUsage, fileOutcome, formatClock, formatTime, formatTokens, padTitle, rule, stateString, statusBucket, stepsUsage, sumUsage, tally, terminalColumns, terminalRows, } from './format.js';
+import { LiveWindow } from './live-window.js';
 /** Step labels stay one glanceable line; the report holds the full text. */
 const MAX_STEP_LABEL_BYTES = 72;
-function bounded(text) {
-    return truncateUtf8(sanitizeText(text), MAX_FIELD_BYTES);
-}
+const F_POINTER = '❯';
+const F_CHECK = '✓';
+const F_CROSS = '×';
+const F_DOWN = '↓';
+const F_RIGHT = '→';
+const F_DOWN_RIGHT = '↳';
+const F_TREE_MIDDLE = '├──';
+const F_TREE_END = '└──';
+/** Indentation under a badge line, matching vitest's banner padding. */
+const BADGE_PADDING = '      ';
+/**
+ * Badge backgrounds, assigned to targets in declaration order. Bright variants
+ * because GitHub Actions renders plain yellow as dark brown, which swallows the
+ * black label.
+ */
+const BADGE_COLORS = ['bgYellowBright', 'bgCyanBright', 'bgGreenBright', 'bgMagentaBright'];
+/**
+ * Rows the live window spends outside the running tests and the summary: its
+ * blank lines, the `… more running` marker, and a margin above the prompt.
+ */
+const WINDOW_CHROME_ROWS = 6;
+/** Rows one running test takes before its calls: the test line and its current step. */
+const WINDOW_ROWS_PER_TEST = 2;
+/** Indentation of the `→ first error line` under a failed test in a file block. */
+const ERROR_GLANCE_INDENT = 7;
 /** One-line, quoted step label bounded for the live view. */
 function stepLabel(label) {
     const flat = collapseText(label);
     const shown = truncateUtf8(flat, MAX_STEP_LABEL_BYTES);
     return `"${shown}${shown === flat ? '' : '…'}"`;
 }
-/** Human duration: milliseconds under a second, one decimal above. */
-function formatDuration(ms) {
-    return ms < 1_000 ? `${ms}ms` : `${(ms / 1_000).toFixed(1)}s`;
-}
-/** Compact token count: plain under a thousand, `12.4k`, then `4.2M`. */
-function formatTokens(count) {
-    if (count < 1_000)
-        return `${count}`;
-    if (count < 1_000_000)
-        return `${(count / 1_000).toFixed(1)}k`;
-    return `${(count / 1_000_000).toFixed(1)}M`;
-}
-/** USD with enough precision for sub-cent model calls. */
-function formatCost(costUsd) {
-    return `$${costUsd.toFixed(costUsd < 0.1 ? 4 : 2)}`;
-}
-/** Accumulates the model usage of one step list into a running total. */
-function addStepsUsage(usage, steps) {
-    for (const step of steps) {
-        if (step.model === undefined)
-            continue;
-        usage.calls += step.model.calls;
-        usage.tokens += step.model.inputTokens + step.model.outputTokens;
-        if (step.model.estimatedCostUsd !== undefined) {
-            usage.costUsd = (usage.costUsd ?? 0) + step.model.estimatedCostUsd;
-        }
-    }
-}
 /**
- * Sums model usage across every step of every attempt of one result. Serial
- * members carry no attempts of their own; their usage arrives once per group
- * through the `serial-group` event.
- */
-function aiUsage(result) {
-    const usage = { calls: 0, tokens: 0, costUsd: undefined };
-    for (const attempt of result.attempts)
-        addStepsUsage(usage, attempt.steps);
-    return usage;
-}
-/** One dim `ai …` segment, or undefined when the test used no model. */
-function aiSegment(usage) {
-    if (usage.calls === 0)
-        return undefined;
-    const cost = usage.costUsd === undefined ? '' : ` · ${formatCost(usage.costUsd)}`;
-    return `ai ${formatTokens(usage.tokens)} tokens${cost}`;
-}
-/**
- * Live tail for one step event. Model and backend calls are the ones worth a
+ * Live tail for one step event. Model and engine calls are the ones worth a
  * glance (`tool:` prefixes come from executor tool accounting); polls and
  * policy decisions stay quiet.
  */
 function eventTail(event) {
     if (event.kind === 'model') {
         const tokens = event.count !== undefined && event.count > 0 ? ` · ${formatTokens(event.count)} tokens` : '';
-        return `model turn ${formatDuration(event.durationMs)}${tokens}`;
+        return `model turn ${formatTime(event.durationMs)}${tokens}`;
     }
-    if (event.kind === 'backend') {
-        const name = sanitizeText(event.name ?? 'backend').replace(/^tool:/, '');
-        const failed = event.status === 'passed' ? '' : ' ✗';
-        return `${truncateUtf8(name, 40)} ${formatDuration(event.durationMs)}${failed}`;
+    if (event.kind === 'engine') {
+        const name = sanitizeText(event.name ?? 'engine').replace(/^tool:/, '');
+        const failed = event.status === 'passed' ? '' : ` ${F_CROSS}`;
+        return `${truncateUtf8(name, 40)} ${formatTime(event.durationMs)}${failed}`;
     }
     return undefined;
 }
+/** The identity of one test-target pair across `test-started`, `step`, and `test-finished`. */
+function pairKey(testId, target) {
+    return `${testId}@${target}`;
+}
+/** Details of an ordinary result: summed over its attempts, the error from the last. */
+function attemptDetails(attempts) {
+    return {
+        durationMs: attempts.reduce((total, attempt) => total + attempt.durationMs, 0),
+        usage: stepsUsage(attempts.map((attempt) => attempt.steps)),
+        error: attempts[attempts.length - 1]?.error,
+    };
+}
+/**
+ * Details of one serial member, read from its group: member results carry no
+ * attempts of their own. Duration and usage sum over every group attempt the
+ * member ran in. The error is the member's own from the last attempt; a member
+ * that attempt never ran (skipped, or absent after a launch failure) inherits
+ * the attempt's error, since that is what stopped it.
+ */
+function serialMemberDetails(group, testId) {
+    const runs = group.attempts.map((attempt) => ({
+        attempt,
+        member: attempt.members.find((member) => member.testId === testId),
+    }));
+    const last = runs[runs.length - 1];
+    const own = last?.member;
+    const neverRan = own === undefined || own.status === 'skipped';
+    return {
+        durationMs: runs.reduce((total, run) => total + (run.member?.durationMs ?? 0), 0),
+        usage: stepsUsage(runs.map((run) => run.member?.steps ?? [])),
+        error: own?.error ?? (neverRan ? last?.attempt.error : undefined),
+    };
+}
 const DEFAULT_OUTPUT = {
     write: (line) => process.stdout.write(`${line}\n`),
     raw: (text) => process.stdout.write(text),
@@ -91,31 +106,35 @@ const DEFAULT_OUTPUT = {
  */
 export class ListReporter {
     output;
-    passed = 0;
-    failed = 0;
-    flaky = 0;
-    skipped = 0;
-    projectRoot;
-    status;
-    /** Base live-status text of each running pair, keyed `${testId}@${target}`. */
-    liveBase = new Map();
-    /** Current step line of each running pair, rendered under its header. */
-    liveStep = new Map();
-    /** Rolling window of the running step's latest model and backend calls. */
-    liveEvents = new Map();
-    /** Pairs whose permanent header line has been written. */
-    headerPrinted = new Set();
-    /** Run-wide model usage, summed from every reported result. */
-    runAi = { calls: 0, tokens: 0, costUsd: undefined };
-    /** Colors follow live rendering: non-interactive sinks get plain text. */
     pc;
+    window;
+    separator;
+    projectRoot;
+    /** Selected targets in declaration order; decides each badge's color. */
+    targets = [];
+    /** When the run began: the summary's `Start at` and the origin of `Duration`. */
+    startedAt = new Date();
+    /** File groups keyed `${target}\u0000${file}`, in first-seen order. */
+    groups = new Map();
+    /** Pairs executing right now, keyed by `pairKey`, in start order. */
+    running = new Map();
+    failures = [];
+    /**
+     * Serial groups whose members' results are still to come, by group id. The
+     * runner emits a group before its member results, and a member's details
+     * live only in the group.
+     */
+    pendingSerial = new Map();
     /** Run-level errors, printed once at the end; the stream carries them as they happen. */
     errors = [];
+    /** Run-wide model usage, summed from every reported result and serial group. */
+    runUsage = emptyUsage();
     constructor(output = DEFAULT_OUTPUT, options = {}) {
         this.output = output;
         const live = (options.live ?? process.stdout.isTTY === true) && output.raw !== undefined;
-        this.status = new LiveStatus(live ? output.raw?.bind(output) : undefined);
-        this.pc = picocolors.createColors(live);
+        this.pc = picocolors.createColors(options.colors ?? (live || picocolors.isColorSupported));
+        this.separator = this.pc.dim(' > ');
+        this.window = new LiveWindow(live ? output.raw?.bind(output) : undefined, () => this.renderWindow());
     }
     /**
      * The reporter as an event sink: one dispatch per fact. Bound, so it can be
@@ -127,10 +146,10 @@ export class ListReporter {
                 this.runStarted(event);
                 break;
             case 'plan':
-                this.status.plan(event.total);
+                this.plan(event);
                 break;
             case 'notice':
-                this.writeAboveStatus(`${this.pc.dim('ℹ')} ${event.message}`);
+                this.print(`${this.pc.dim('ℹ')} ${bounded(event.message)}`);
                 break;
             case 'test-started':
                 this.testStarted(event);
@@ -155,233 +174,459 @@ export class ListReporter {
                 break;
         }
     };
+    /** Writes one permanent line without disturbing the live window. */
+    print(line) {
+        this.window.erase();
+        this.output.write(line);
+        this.window.redraw();
+    }
+    /** A target's colored badge, `|web|` when colors are off (vitest's convention). */
+    badge(target) {
+        const name = bounded(target);
+        if (!this.pc.isColorSupported)
+            return `|${name}|`;
+        const index = Math.max(0, this.targets.indexOf(target));
+        const color = BADGE_COLORS[index % BADGE_COLORS.length];
+        return this.pc.black(this.pc[color](` ${name} `));
+    }
+    /** A path relative to the project root when inside it, else as given. */
+    displayPath(target) {
+        const inside = this.projectRoot !== undefined && target.startsWith(`${this.projectRoot}${path.sep}`);
+        return bounded(inside ? path.relative(this.projectRoot, target) : target);
+    }
+    group(file, target) {
+        const key = `${target}\u0000${file}`;
+        let group = this.groups.get(key);
+        if (group === undefined) {
+            group = { file, target, planned: undefined, lines: [], streamed: false, printed: false };
+            this.groups.set(key, group);
+        }
+        return group;
+    }
+    runStarted(event) {
+        const { pc } = this;
+        this.projectRoot = event.projectRoot;
+        this.targets = event.targets;
+        this.startedAt = new Date();
+        const version = packageVersion(import.meta.url, '../../package.json', '0.0.0');
+        this.output.write('');
+        this.output.write(`${pc.bold(pc.black(pc.bgCyan(' RUN ')))} ${pc.cyan(`e2e v${version}`)} ${pc.gray(event.projectRoot)}`);
+        const details = [`run ${event.runId}`, `targets: ${event.targets.join(', ')}`];
+        if (event.ci)
+            details.push('CI');
+        this.output.write(BADGE_PADDING + pc.dim(details.join(' · ')));
+        this.output.write('');
+        this.window.start();
+    }
+    plan(event) {
+        for (const planned of event.files) {
+            this.group(planned.file, planned.target).planned = planned.tests;
+        }
+        this.window.redraw();
+    }
     /** Acknowledged immediately, so a bounded teardown is not mistaken for a hang. */
     runInterrupted(event) {
-        this.writeAboveStatus(this.pc.yellow(event.mode === 'graceful'
+        this.print(this.pc.yellow(event.mode === 'graceful'
             ? 'interrupted: stopping the running test and tearing down (interrupt again to force)'
             : 'interrupted again: tearing every worker down now'));
     }
-    runStarted(event) {
-        this.projectRoot = event.projectRoot;
-        this.output.write(this.pc.dim(`e2e run ${event.runId} (targets: ${event.targets.join(', ')})${event.ci ? ' [CI]' : ''}`));
-    }
-    /** A worker began one test-target pair: show it in the live status block. */
+    /**
+     * A worker began one test-target pair: show it in the live window. A serial
+     * member replaces the previous member of its group, which has finished
+     * executing even though its result only arrives with the whole group.
+     */
     testStarted(event) {
-        const key = `${event.testId}@${event.target}`;
-        const base = `${bounded(event.title)} ${this.pc.dim(`[${event.target}]`)}`;
-        this.liveBase.set(key, base);
-        this.status.start(key, base);
-        // A second concurrent pair ends permanent streaming: entries the stream
-        // had hidden come back as block rows.
-        if (this.liveBase.size > 1) {
-            for (const [other, otherBase] of this.liveBase)
-                this.redrawLive(other, otherBase);
+        if (event.serialId !== undefined) {
+            for (const [key, test] of this.running) {
+                if (test.serialId === event.serialId && test.group.target === event.target) {
+                    this.running.delete(key);
+                }
+            }
         }
+        this.running.set(pairKey(event.testId, event.target), {
+            group: this.group(event.file, event.target),
+            serialId: event.serialId,
+            title: bounded(event.title),
+            startedMs: Date.now(),
+            step: undefined,
+            events: [],
+            streaming: false,
+        });
+        this.window.redraw();
     }
     /**
-     * Streams step progress of a running pair. With a single test running, the
-     * whole story prints permanently and chronologically: a test header, one
-     * line per step, one line per model or backend call, and a step summary -
-     * the scrollback of a run reads without `--debug`. With parallel tests the
-     * stream would interleave, so each pair instead shows its current step and
-     * latest calls transiently in the live block.
+     * Streams step progress of a running pair. With a single test running, its
+     * agent steps print permanently and chronologically under a header naming
+     * the file and test - the scrollback of a long agentic run reads without
+     * `--debug`. Deterministic steps are fast and many, so they only ever show
+     * in the live window. With parallel tests the stream would interleave, so
+     * each pair instead shows its current step and latest calls transiently in
+     * the live window, and finished agent steps print with the test they
+     * belong to.
      */
     step(event) {
-        const key = `${event.testId}@${event.target}`;
-        const base = this.liveBase.get(key);
-        if (base === undefined)
+        const { pc } = this;
+        const running = this.running.get(pairKey(event.testId, event.target));
+        if (running === undefined)
             return;
         const { progress } = event;
         switch (progress.phase) {
             case 'start': {
-                this.liveStep.set(key, `${progress.api} ${stepLabel(progress.label)}`);
-                this.liveEvents.delete(key);
-                if (this.liveBase.size === 1)
-                    this.ensureHeader(key, base);
-                this.redrawLive(key, base);
+                running.step = `${progress.api} ${stepLabel(progress.label)}`;
+                running.events = [];
+                if (progress.kind === 'agent' && this.running.size === 1 && !running.streaming) {
+                    running.streaming = true;
+                    const { group } = running;
+                    group.streamed = true;
+                    this.print(` ${pc.yellow(F_POINTER)} ${this.badge(group.target)} ${pc.dim(bounded(group.file))}${this.separator}${running.title}`);
+                }
+                this.window.redraw();
                 break;
             }
             case 'event': {
                 const tail = eventTail(progress.event);
-                if (!this.liveStep.has(key) || tail === undefined)
+                if (running.step === undefined || tail === undefined)
                     break;
-                const recent = this.liveEvents.get(key) ?? [];
-                recent.push(tail);
-                this.liveEvents.set(key, recent);
-                this.redrawLive(key, base);
+                running.events.push(tail);
+                this.window.redraw();
                 break;
             }
             case 'end': {
-                this.liveStep.delete(key);
-                this.liveEvents.delete(key);
-                this.redrawLive(key, base);
-                if (progress.kind !== 'agent')
+                running.step = undefined;
+                running.events = [];
+                if (progress.kind !== 'agent') {
+                    this.window.redraw();
                     break;
-                const glyph = progress.status === 'passed' ? this.pc.green('✓') : this.pc.red('✗');
+                }
+                const glyph = progress.status === 'passed' ? pc.green(F_CHECK) : pc.red(F_CROSS);
                 const calls = progress.modelCalls > 0
                     ? ` · ${progress.modelCalls} model call${progress.modelCalls === 1 ? '' : 's'}`
                     : '';
                 const outcome = progress.status === 'passed' ? '' : ` ${progress.status}`;
-                this.writeAboveStatus(`  ${glyph} ${this.pc.dim(progress.api)} ${stepLabel(progress.label)} ` +
-                    this.pc.dim(`${formatDuration(progress.durationMs)}${calls}${outcome}`));
+                const context = running.streaming ? '' : `${pc.dim(running.title)}${this.separator}`;
+                this.print(`   ${glyph} ${context}${pc.dim(progress.api)} ${stepLabel(progress.label)} ` +
+                    pc.dim(`${formatTime(progress.durationMs)}${calls}${outcome}`));
                 break;
             }
         }
     }
-    /**
-     * Adds one serial group's model usage to the run totals. Member result
-     * records intentionally carry no attempts, so the group record is the one
-     * place their steps exist; summing here counts each member exactly once.
-     */
+    /** Holds a serial group until each of its members' results has read its details. */
     serialGroup(group) {
-        for (const attempt of group.attempts) {
-            for (const member of attempt.members) {
-                addStepsUsage(this.runAi, member.steps);
-            }
-        }
-    }
-    /** Writes one permanent line without disturbing the live block. */
-    writeAboveStatus(line) {
-        this.status.erase();
-        this.output.write(line);
-        this.status.redraw();
+        this.pendingSerial.set(group.id, { group, remaining: group.memberTestIds.length });
     }
     /**
-     * Prints the permanent test header once, before its first step line, so
-     * collapsed step summaries read under the test they belong to.
+     * The details behind one result. A serial member's come from its group; a
+     * group that never arrived (a stream out of contract) leaves them empty
+     * rather than failing the run.
      */
-    ensureHeader(key, base) {
-        if (this.headerPrinted.has(key))
-            return;
-        this.headerPrinted.add(key);
-        this.writeAboveStatus(`${this.pc.dim('▸')} ${base}`);
+    detailsOf(result) {
+        if (result.serialGroupId === undefined)
+            return attemptDetails(result.attempts);
+        const pending = this.pendingSerial.get(result.serialGroupId);
+        if (pending === undefined)
+            return attemptDetails([]);
+        pending.remaining -= 1;
+        if (pending.remaining <= 0)
+            this.pendingSerial.delete(result.serialGroupId);
+        return serialMemberDetails(pending.group, result.test.id);
     }
-    /**
-     * Repaints one live entry: only the active step expands, showing its latest
-     * calls under the spinner line; between steps the entry collapses to the
-     * counter (its header is already permanent) or, before any step ran, the
-     * test title. With parallel pairs the title stays as block context.
-     */
-    redrawLive(key, base) {
-        const solo = this.liveBase.size === 1 && this.headerPrinted.has(key);
-        const step = this.liveStep.get(key);
-        if (step === undefined) {
-            this.status.start(key, solo ? undefined : base);
+    testFinished(result) {
+        // Unselected pairs are report-only: they never print and the plan never
+        // counted them.
+        if (!result.selected)
             return;
+        this.running.delete(pairKey(result.test.id, result.target.name));
+        const group = this.group(result.test.file, result.target.name);
+        const { durationMs, usage, error } = this.detailsOf(result);
+        addUsage(this.runUsage, usage);
+        const title = bounded(result.test.titlePath.join(' > '));
+        group.lines.push({
+            title,
+            declarationIndex: result.test.declarationIndex,
+            status: result.status,
+            durationMs,
+            usage,
+            firstErrorLine: error === undefined ? undefined : bounded(error.message).split('\n')[0],
+            skipReason: result.skip === undefined ? undefined : bounded(result.skip.reason),
+        });
+        if (statusBucket(result.status) === 'failed') {
+            this.failures.push({ group, title, status: result.status, error });
         }
-        const head = solo ? this.pc.dim(step) : `${base}\n    ${this.pc.dim(`▸ ${step}`)}`;
-        const indent = solo ? '      ' : '        ';
-        const lines = [head];
-        // Every call of the active step stays visible until the step collapses.
-        // The block must still fit the screen: repainting more rows than the
-        // terminal has breaks the cursor-up erase, so the oldest calls fold into
-        // one counter line when height runs out.
-        const events = this.liveEvents.get(key) ?? [];
-        const maxEvents = Math.max(4, (process.stdout.rows ?? 40) - 8);
-        const overflow = events.length - maxEvents;
-        const shown = overflow > 0 ? events.slice(overflow) : events;
-        if (overflow > 0) {
-            lines.push(`${indent}${this.pc.dim(`… ${overflow} earlier call${overflow === 1 ? '' : 's'}`)}`);
-        }
-        for (const tail of shown) {
-            lines.push(`${indent}${this.pc.dim(tail)}`);
+        if (group.planned !== undefined && group.lines.length >= group.planned)
+            this.printGroup(group);
+        this.window.redraw();
+    }
+    /** Counters over every reported result; the total is the plan's once it has arrived. */
+    testCounters() {
+        const counters = tally([...this.groups.values()].flatMap((group) => group.lines));
+        counters.total = 0;
+        for (const group of this.groups.values())
+            counters.total += group.planned ?? group.lines.length;
+        return counters;
+    }
+    /** Counters over test files; a file lands in an outcome once its block has printed. */
+    fileCounters() {
+        const counters = emptyCounters();
+        for (const group of this.groups.values()) {
+            counters.total += 1;
+            if (group.printed)
+                counters[fileOutcome(tally(group.lines))] += 1;
         }
-        this.status.start(key, lines.join('\n'));
+        return counters;
     }
-    testFinished(result) {
-        if (!result.selected && result.status === 'skipped') {
-            this.status.skip();
+    /**
+     * Prints one file's block: the file line with its counts, then - when the
+     * file failed, had a flaky pass, streamed its steps, or is the run's only
+     * file - one line per test, as vitest lists tests for a failed module.
+     */
+    printGroup(group) {
+        if (group.printed)
             return;
+        group.printed = true;
+        const { pc } = this;
+        const counts = tally(group.lines);
+        const outcome = fileOutcome(counts);
+        const symbol = outcome === 'failed'
+            ? pc.red(F_POINTER)
+            : outcome === 'skipped'
+                ? pc.dim(pc.gray(F_DOWN))
+                : pc.green(F_CHECK);
+        const state = [
+            pc.dim(`${counts.total} test${counts.total === 1 ? '' : 's'}`),
+            counts.failed > 0 ? pc.red(`${counts.failed} failed`) : undefined,
+            counts.flaky > 0 ? pc.yellow(`${counts.flaky} flaky`) : undefined,
+            counts.skipped > 0 ? pc.yellow(`${counts.skipped} skipped`) : undefined,
+        ]
+            .filter((part) => part !== undefined)
+            .join(pc.dim(' | '));
+        const durationMs = group.lines.reduce((total, line) => total + line.durationMs, 0);
+        const ai = aiSegment(sumUsage(group.lines));
+        const parts = [
+            ` ${symbol} ${this.badge(group.target)} ${bounded(group.file)}`,
+            `${pc.dim('(')}${state}${pc.dim(')')}`,
+        ];
+        // A file whose tests all skipped never ran; `0ms` would only invite a question.
+        if (durationMs > 0)
+            parts.push(pc.dim(formatTime(durationMs)));
+        if (ai !== undefined)
+            parts.push(pc.dim(ai));
+        this.print(parts.join(' '));
+        const verbose = counts.failed > 0 ||
+            counts.flaky > 0 ||
+            group.streamed ||
+            this.groups.size === 1;
+        if (!verbose)
+            return;
+        const ordered = group.lines.toSorted((a, b) => a.declarationIndex - b.declarationIndex);
+        for (const line of ordered) {
+            for (const rendered of this.testLine(line))
+                this.print(rendered);
         }
-        this.status.erase();
-        const key = `${result.test.id}@${result.target.name}`;
-        this.status.finish(key);
-        this.liveBase.delete(key);
-        this.liveStep.delete(key);
-        this.liveEvents.delete(key);
-        this.headerPrinted.delete(key);
-        const title = bounded(result.test.titlePath.join(' \u203a '));
-        const target = result.target.name;
-        const duration = result.attempts.reduce((total, attempt) => total + attempt.durationMs, 0);
-        const usage = aiUsage(result);
-        this.runAi.calls += usage.calls;
-        this.runAi.tokens += usage.tokens;
-        if (usage.costUsd !== undefined)
-            this.runAi.costUsd = (this.runAi.costUsd ?? 0) + usage.costUsd;
-        const ai = aiSegment(usage);
-        const aiSuffix = ai === undefined ? '' : ` \u00b7 ${ai}`;
-        switch (result.status) {
+    }
+    /** One test row under its file line, plus the first error line for a failure. */
+    testLine(line) {
+        const { pc } = this;
+        const duration = pc.dim(formatTime(line.durationMs));
+        const segment = aiSegment(line.usage);
+        const ai = segment === undefined ? '' : ` ${pc.dim(segment)}`;
+        switch (line.status) {
             case 'passed':
-                this.passed += 1;
-                this.output.write(`${this.pc.green('\u2713')} ${title} ${this.pc.dim(`[${target}] ${formatDuration(duration)}${aiSuffix}`)}`);
-                break;
+                return [`   ${pc.green(F_CHECK)} ${line.title} ${duration}${ai}`];
             case 'flaky':
-                this.flaky += 1;
-                this.output.write(`${this.pc.yellow('\u2713')} ${title} ${this.pc.yellow('(flaky)')} ${this.pc.dim(`[${target}] ${formatDuration(duration)}${aiSuffix}`)}`);
-                break;
-            case 'skipped':
-                this.skipped += 1;
-                this.output.write(`${this.pc.cyan('-')} ${title} ${this.pc.dim(`[${target}] skipped: ${bounded(result.skip?.reason ?? '')}`)}`);
-                break;
+                return [`   ${pc.yellow(F_CHECK)} ${line.title} ${pc.yellow('(flaky)')} ${duration}${ai}`];
+            case 'skipped': {
+                // `test.skip` without a message records the bare word; repeating it adds nothing.
+                const reason = line.skipReason === undefined || line.skipReason === 'skipped'
+                    ? ''
+                    : pc.dim(pc.gray(` [${line.skipReason}]`));
+                return [`   ${pc.dim(pc.gray(F_DOWN))} ${line.title}${reason}`];
+            }
             default: {
-                this.failed += 1;
-                this.output.write(`${this.pc.red('\u2717')} ${title} ${this.pc.dim(`[${target}] ${result.status} ${formatDuration(duration)}${aiSuffix}`)}`);
-                const error = result.attempts[result.attempts.length - 1]?.error;
-                if (error !== undefined) {
-                    for (const line of bounded(error.message).split('\n')) {
-                        this.output.write(`    ${this.pc.red(line)}`);
-                    }
-                    this.writeFailureLocation(error.stack);
+                const status = line.status === 'failed' ? '' : pc.red(` (${line.status})`);
+                const rows = [`   ${pc.red(`${F_CROSS} ${line.title}`)}${status} ${duration}${ai}`];
+                if (line.firstErrorLine !== undefined) {
+                    // A glance line; the `Failed Tests` section carries the whole message.
+                    const glance = ellipsize(line.firstErrorLine, terminalColumns() - ERROR_GLANCE_INDENT);
+                    rows.push(`     ${pc.red(`${F_RIGHT} ${glance}`)}`);
                 }
+                return rows;
+            }
+        }
+    }
+    /**
+     * vitest's padded summary, shared by the live window and the final report:
+     * files, tests, model usage, run errors, start time, and elapsed time.
+     */
+    summaryRows() {
+        const { pc } = this;
+        const files = this.fileCounters();
+        const tests = this.testCounters();
+        const rows = [
+            padTitle(pc, 'Test Files') + (files.total === 0 ? pc.dim('no test files') : stateString(pc, files)),
+            padTitle(pc, 'Tests') + (tests.total === 0 ? pc.dim('no tests executed') : stateString(pc, tests)),
+        ];
+        const ai = aiSegment(this.runUsage);
+        if (ai !== undefined)
+            rows.push(padTitle(pc, 'AI') + `${ai} · ${this.runUsage.calls} model calls`);
+        if (this.errors.length > 0) {
+            const count = this.errors.length;
+            rows.push(padTitle(pc, 'Errors') + pc.bold(pc.red(`${count} error${count === 1 ? '' : 's'}`)));
+        }
+        rows.push(padTitle(pc, 'Start at') + formatClock(this.startedAt));
+        rows.push(padTitle(pc, 'Duration') + formatTime(Date.now() - this.startedAt.getTime()));
+        return rows;
+    }
+    /**
+     * The live window: running files and tests, then the summary. The block
+     * must fit the screen, because repainting more rows than the terminal has
+     * breaks the cursor-up erase: rows left after the summary go to the running
+     * tests, each test's calls share what remains once every test has its own
+     * line, and tests that still do not fit fold into one `more running` marker.
+     */
+    renderWindow() {
+        const { pc } = this;
+        const now = Date.now();
+        const active = new Map();
+        for (const test of this.running.values()) {
+            const tests = active.get(test.group);
+            if (tests === undefined)
+                active.set(test.group, [test]);
+            else
+                tests.push(test);
+        }
+        const summary = this.summaryRows();
+        let budget = terminalRows() - summary.length - WINDOW_CHROME_ROWS;
+        const spare = budget - active.size - this.running.size * WINDOW_ROWS_PER_TEST;
+        const maxEvents = Math.max(0, Math.floor(spare / Math.max(1, this.running.size)));
+        const lines = [''];
+        let hidden = 0;
+        for (const [group, tests] of active) {
+            if (budget < 2) {
+                hidden += tests.length;
+                continue;
             }
+            const progress = pc.dim(` ${group.lines.length}/${group.planned ?? '?'}`);
+            lines.push(`${pc.bold(pc.yellow(` ${F_POINTER} `))}${this.badge(group.target)} ${bounded(group.file)}${progress}`);
+            budget -= 1;
+            tests.forEach((test, index) => {
+                if (budget < 1) {
+                    hidden += 1;
+                    return;
+                }
+                const glyph = index === tests.length - 1 ? F_TREE_END : F_TREE_MIDDLE;
+                const elapsed = pc.bold(pc.yellow(formatTime(Math.max(0, now - test.startedMs))));
+                lines.push(`${pc.bold(pc.yellow(`   ${glyph} `))}${test.title} ${elapsed}`);
+                budget -= 1;
+                if (test.step === undefined)
+                    return;
+                const detail = [`       ${pc.dim(`${F_DOWN_RIGHT} ${test.step}`)}`];
+                const overflow = test.events.length - maxEvents;
+                if (overflow > 0) {
+                    detail.push(`         ${pc.dim(`… ${overflow} earlier call${overflow === 1 ? '' : 's'}`)}`);
+                }
+                for (const tail of overflow > 0 ? test.events.slice(overflow) : test.events) {
+                    detail.push(`         ${pc.dim(tail)}`);
+                }
+                const shown = detail.slice(0, budget);
+                lines.push(...shown);
+                budget -= shown.length;
+            });
         }
-        this.status.redraw();
+        if (hidden > 0)
+            lines.push(pc.dim(`   … ${hidden} more running`));
+        if (active.size > 0)
+            lines.push('');
+        lines.push(...summary, '');
+        return lines;
     }
-    /** Names the user's failing line and renders a small code frame around it. */
-    writeFailureLocation(stack) {
-        if (this.projectRoot === undefined)
+    /** vitest's `Failed Tests` section: a banner, then each failure with its code frame. */
+    printFailures() {
+        const { pc } = this;
+        if (this.failures.length === 0)
             return;
+        this.print('');
+        this.print(this.errorBanner(`Failed Tests ${this.failures.length}`));
+        this.print('');
+        this.failures.forEach(({ group, title, status, error }, index) => {
+            this.print(`${pc.bold(pc.bgRed(' FAIL '))} ${this.badge(group.target)} ${bounded(group.file)}${this.separator}${title}`);
+            if (error === undefined) {
+                this.print(pc.red(`${pc.bold(status)}: no error was recorded`));
+            }
+            else {
+                const [first = '', ...rest] = bounded(error.message).split('\n');
+                this.print(pc.red(`${pc.bold(bounded(error.code))}: ${first}`));
+                for (const line of rest)
+                    this.print(pc.red(line));
+                this.printFailureLocation(error.stack);
+            }
+            const marker = `[${index + 1}/${this.failures.length}]`;
+            const { before, after } = rule(marker, 'right');
+            this.print('');
+            this.print(pc.red(pc.dim(`${before}${marker}${after}`)));
+            this.print('');
+        });
+    }
+    /** A full-width red rule with a centered `FAIL`-style label. */
+    errorBanner(message) {
+        const { pc } = this;
+        const label = pc.bold(pc.bgRed(` ${message} `));
+        const { before, after } = rule(label, 'center');
+        return `${pc.red(before)}${label}${pc.red(after)}`;
+    }
+    /** Names the user's failing line and renders a code frame around it. */
+    printFailureLocation(stack) {
+        const { pc } = this;
         const frame = userFrame(stack, this.projectRoot);
         if (frame === undefined)
             return;
-        const relative = path.relative(this.projectRoot, frame.file);
-        this.output.write('');
-        this.output.write(`    ${this.pc.dim('at')} ${this.pc.cyan(`${bounded(relative)}:${frame.line}:${frame.column}`)}`);
-        for (const line of codeFrame(frame))
-            this.output.write(`    ${line}`);
+        this.print(pc.cyan(` ${pc.dim(F_POINTER)} ${bounded(this.displayPath(frame.file))}:${pc.dim(`${frame.line}:${frame.column}`)}`));
+        for (const line of codeFrame(frame, pc))
+            this.print(`    ${line}`);
     }
-    runFinished(event) {
-        this.status.stop();
-        // Run-level errors never arrive as results: they abort before, between, or
-        // after test execution. Without this the console shows only a bare exit
-        // code and the reason lives solely in report.json.
+    /**
+     * Run-level errors never arrive as results: they abort before, between, or
+     * after test execution. Without this the console shows only a bare exit
+     * code and the reason lives solely in report.json.
+     */
+    printErrors() {
+        const { pc } = this;
+        if (this.errors.length === 0)
+            return;
+        this.print('');
+        this.print(this.errorBanner(`Run Errors ${this.errors.length}`));
+        this.print('');
         for (const error of this.errors) {
-            this.output.write('');
-            const phase = error.phase === undefined ? '' : ` ${this.pc.dim(`(${error.phase})`)}`;
-            this.output.write(`${this.pc.red(`\u2717 ${error.category} error`)} ${this.pc.dim(error.code)}${phase}`);
-            for (const line of bounded(error.message).split('\n')) {
-                this.output.write(`    ${this.pc.red(line)}`);
-            }
+            const phase = error.phase === undefined ? '' : pc.dim(` (${bounded(error.phase)})`);
+            this.print(`${pc.bold(pc.bgRed(' ERROR '))} ${bounded(error.category)} error ${pc.dim(bounded(error.code))}${phase}`);
+            for (const line of bounded(error.message).split('\n'))
+                this.print(pc.red(line));
+            this.print('');
         }
-        const parts = [
-            this.passed > 0 ? this.pc.green(`${this.passed} passed`) : undefined,
-            this.failed > 0 ? this.pc.red(`${this.failed} failed`) : undefined,
-            this.flaky > 0 ? this.pc.yellow(`${this.flaky} flaky`) : undefined,
-            this.skipped > 0 ? this.pc.cyan(`${this.skipped} skipped`) : undefined,
-        ].filter((part) => part !== undefined);
-        this.output.write('');
-        this.output.write(parts.length > 0 ? parts.join(this.pc.dim(' \u00b7 ')) : this.pc.dim('no tests executed'));
-        const ai = aiSegment(this.runAi);
-        if (ai !== undefined) {
-            this.output.write(this.pc.dim(`${ai} \u00b7 ${this.runAi.calls} model calls`));
+    }
+    runFinished(event) {
+        const { pc } = this;
+        this.window.stop();
+        // An interrupted or crashed run leaves files without their full result
+        // set; print what they have so nothing that ran goes unreported.
+        for (const group of this.groups.values()) {
+            if (!group.printed && group.lines.length > 0)
+                this.printGroup(group);
         }
-        this.output.write(this.pc.dim(`report: ${event.reportPath ?? '(not written)'}`));
+        this.printFailures();
+        this.printErrors();
+        this.print('');
+        for (const row of this.summaryRows())
+            this.print(row);
+        this.print(padTitle(pc, 'Report') +
+            (event.reportPath === undefined ? pc.dim('(not written)') : this.displayPath(event.reportPath)));
         if (event.junitPath !== undefined) {
-            this.output.write(this.pc.dim(`junit: ${event.junitPath}`));
+            this.print(padTitle(pc, 'JUnit') + this.displayPath(event.junitPath));
         }
         if (event.aiTracePath !== undefined) {
-            this.output.write(this.pc.dim(`ai trace: ${event.aiTracePath} · open with: npx unbox-ai ${event.aiTracePath}`));
+            const shown = this.displayPath(event.aiTracePath);
+            this.print(padTitle(pc, 'AI trace') + `${shown} ${pc.dim(`(open with: npx unbox-ai ${shown})`)}`);
         }
+        this.print('');
     }
 }
 //# sourceMappingURL=list.js.map