e2e 0.16.0 → 0.18.0

package/dist/report/junit.js

@@ -1,6 +1,7 @@
 /** JUnit XML reporter: the report-1 document as `.e2e/junit.xml`. */
 import { sanitizeText } from '../internal/errors.js';
 import { repeatSuffix } from './format.js';
+import { toldAttempt } from './failure-text.js';
 import { outcome } from './outcome.js';
 import { fileReporter } from './write.js';
 /**
@@ -60,11 +61,9 @@ function addCounts(total, part) {
     total.skipped += part.skipped;
     total.timeMs += part.timeMs;
 }
-/** `<failure>` for a product verdict, `<error>` for anything that prevented one. */
-function verdictElement(error, status) {
-    if (error !== undefined)
-        return error.category === 'test' ? 'failure' : 'error';
-    return status === 'interrupted' ? 'error' : 'failure';
+/** `<failure>` for a product verdict, `<error>` for anything else that prevented one. */
+function verdictElement(error) {
+    return error === undefined || error.category === 'test' ? 'failure' : 'error';
 }
 function errorBody(error) {
     const phase = error.phase === undefined ? '' : ` (${error.phase})`;
@@ -93,18 +92,18 @@ function renderResult(result, groups) {
             };
         }
         case 'skipped':
+        case 'interrupted': {
+            // JUnit has no interrupted outcome; a test the run stopped reached no verdict, so it reads as skipped with why.
+            const message = result.status === 'skipped' ? (result.skip?.reason ?? 'skipped') : `interrupted: ${final.final.error?.message ?? 'the run was stopped'}`;
             return {
-                lines: [
-                    `${open}>`,
-                    `  <skipped ${attributes({ message: result.skip?.reason ?? 'skipped' })}/>`,
-                    '</testcase>',
-                ],
+                lines: [`${open}>`, `  <skipped ${attributes({ message })}/>`, '</testcase>'],
                 outcome: 'skipped',
                 durationMs: final.durationMs,
             };
+        }
         default: {
-            const element = verdictElement(final.final.error, result.status);
-            const error = final.final.error;
+            const error = toldAttempt(result, final).error;
+            const element = verdictElement(error);
             const message = error?.message ?? result.status;
             const type = error?.code ?? result.status;
             const body = error === undefined ? result.status : errorBody(error);

package/dist/report/list.d.ts

@@ -49,6 +49,7 @@ export declare class ListReporter implements Reporter {
     /** Whether a live window paints; without one, finished steps stream permanently. */
     private readonly live;
     private readonly failures;
+    private readonly skippedFailures;
     /** Every finished test's run, for the `Repeats` summary of a `--repeat-each` run. */
     private readonly runs;
     /**
@@ -119,6 +120,17 @@ export declare class ListReporter implements Reporter {
      * the test's result, or the end of the run.
      */
     private testOutput;
+    /**
+     * Text user code wrote in the runner's own process (the config's top
+     * level, a test file's while it is collected, a reporter), printed like a
+     * test's output under a `stdout | runner` heading. The runner hands it
+     * here already redacted, only while this reporter shows the run.
+     */
+    processOutput(stream: 'stdout' | 'stderr', text: string): void;
+    /** Prints what `processOutput` left unfinished: the runner hands nothing more once the run's events are all dispatched. */
+    endProcessOutput(): void;
+    /** Prints the lines `text` ends under the heading of `stream` and `source`, holding the unfinished rest. */
+    private sourcedOutput;
     /** Prints finished output lines under their heading, unless the heading is the one printed last. */
     private printOutput;
     /** Prints the unfinished output of `pair`, or of every source when undefined. */

package/dist/report/list.js

@@ -8,6 +8,7 @@
 import path from 'node:path';
 import picocolors from 'picocolors';
 import { packageVersion } from '../internal/package-version.js';
+import { failureBeforeSkip } from '../run/records.js';
 import { codeFrame, userFrame } from './code-frame.js';
 import { addCacheTally, addModelTally, addUsage, aiSegment, bounded, cacheText, durationText, fitColumns, emptyCacheTally, emptyCounters, emptyUsage, F_CHECK, F_CROSS, F_POINTER, fileOutcome, formatClock, formatTime, modelsText, padTitle, rule, stateString, statusBucket, stepsCacheTally, repeatSuffix, stepsModelTally, stepsUsage, sumUsage, tally, terminalColumns, usageText, } from './format.js';
 import { ExploreView } from './list-explore.js';
@@ -43,14 +44,16 @@ function pairKey(testId, agent, target, repeat) {
 /** Details of an ordinary result: summed over its attempts, the error from the last. */
 function attemptDetails(attempts) {
     const steps = attempts.map((attempt) => attempt.steps);
+    // A retry the run interrupted tells nothing; the failure before it is the verdict.
+    const told = attempts.findLast((attempt) => attempt.status !== 'interrupted') ?? attempts.at(-1);
     return {
         durationMs: attempts.reduce((total, attempt) => total + attempt.durationMs, 0),
         usage: stepsUsage(steps),
         models: stepsModelTally(steps),
         cache: stepsCacheTally(steps),
-        error: attempts[attempts.length - 1]?.error,
+        error: told?.error,
         videos: videoPaths(attempts),
-        ...failureOf(attempts[attempts.length - 1]),
+        ...failureOf(told),
     };
 }
 /** The failure evidence of one attempt, and the path of the screen text it points at. */
@@ -85,7 +88,7 @@ function serialMemberDetails(group, testId) {
         attempt,
         member: attempt.members.find((member) => member.testId === testId),
     }));
-    const last = runs[runs.length - 1];
+    const last = runs.findLast((run) => run.attempt.status !== 'interrupted') ?? runs.at(-1);
     const own = last?.member;
     const neverRan = own === undefined || own.status === 'skipped';
     const steps = runs.map((run) => run.member?.steps ?? []);
@@ -135,6 +138,7 @@ export class ListReporter {
     /** Whether a live window paints; without one, finished steps stream permanently. */
     live;
     failures = [];
+    skippedFailures = [];
     /** Every finished test's run, for the `Repeats` summary of a `--repeat-each` run. */
     runs = [];
     /**
@@ -268,20 +272,37 @@ export class ListReporter {
      * the test's result, or the end of the run.
      */
     testOutput(event) {
-        const { pc } = this;
-        if (event.text === '')
-            return;
         const pair = event.pair === undefined ? undefined : pairKey(event.pair.testId, event.pair.agent, event.target, event.pair.repeat);
         const running = pair === undefined ? undefined : this.pairs.get(pair);
         const source = running === undefined ? this.badge(event.target) : `${this.badge(running.group.target)} ${bounded(running.group.file)}${this.separator}${running.title}`;
-        const key = `${event.stream}\u0000${source}`;
+        this.sourcedOutput(event.stream, source, pair, event.text);
+    }
+    /**
+     * Text user code wrote in the runner's own process (the config's top
+     * level, a test file's while it is collected, a reporter), printed like a
+     * test's output under a `stdout | runner` heading. The runner hands it
+     * here already redacted, only while this reporter shows the run.
+     */
+    processOutput(stream, text) {
+        this.sourcedOutput(stream, this.pc.dim('runner'), undefined, text);
+    }
+    /** Prints what `processOutput` left unfinished: the runner hands nothing more once the run's events are all dispatched. */
+    endProcessOutput() {
+        this.flushOutput();
+    }
+    /** Prints the lines `text` ends under the heading of `stream` and `source`, holding the unfinished rest. */
+    sourcedOutput(stream, source, pair, text) {
+        const { pc } = this;
+        if (text === '')
+            return;
+        const key = `${stream}\u0000${source}`;
         let entry = this.pendingOutput.get(key);
         if (entry === undefined) {
-            const label = event.stream === 'stderr' ? pc.yellow(event.stream) : pc.dim(event.stream);
+            const label = stream === 'stderr' ? pc.yellow(stream) : pc.dim(stream);
             entry = { heading: `${label} ${pc.dim('|')} ${source}`, pair, fragment: '' };
             this.pendingOutput.set(key, entry);
         }
-        const lines = (entry.fragment + event.text).split('\n');
+        const lines = (entry.fragment + text).split('\n');
         entry.fragment = lines.pop() ?? '';
         if (entry.fragment === '')
             this.pendingOutput.delete(key);
@@ -550,15 +571,17 @@ export class ListReporter {
         const steps = this.pairs.get(key)?.steps ?? [];
         this.pairs.delete(key);
         const group = this.group(result.test.file, result.target.name);
+        // Read before `detailsOf` releases the result's serial group.
+        const skippedAfter = failureBeforeSkip(result, (id) => this.pendingSerial.get(id)?.group);
         const { durationMs, usage, models, cache, error, videos, failure, screenPath } = this.detailsOf(result);
         addUsage(this.runUsage, usage);
         addModelTally(this.runModels, models);
         addCacheTally(this.runCache, cache);
         const title = this.titledAs(result.test.titlePath.join(' > '), result.agent, result.repeat);
         if (this.explore !== undefined) {
-            // The exploration's verdict is its findings; any other error is a failure of its own.
+            // The exploration's verdict is its findings; any other error is a failure of its own, unless the run stopped it.
             this.explore.result(result.attempts.flatMap((attempt) => attempt.artifacts));
-            if (error !== undefined && !this.explore.isVerdict(error)) {
+            if (error !== undefined && result.status !== 'interrupted' && !this.explore.isVerdict(error)) {
                 this.failures.push({ group, title, status: result.status, error, videos, failure, screenPath });
             }
             this.window.redraw();
@@ -584,6 +607,9 @@ export class ListReporter {
         if (statusBucket(result.status) === 'failed') {
             this.failures.push({ group, title, status: result.status, error, videos, failure, screenPath });
         }
+        if (skippedAfter !== undefined) {
+            this.skippedFailures.push({ group, title, status: result.status, error: skippedAfter.error, videos, ...failureOf(skippedAfter) });
+        }
         if (group.planned !== undefined && group.lines.length >= group.planned)
             this.printGroup(group);
         this.window.redraw();
@@ -623,12 +649,15 @@ export class ListReporter {
         const outcome = fileOutcome(counts);
         const symbol = outcome === 'failed'
             ? pc.red(F_POINTER)
-            : outcome === 'skipped'
-                ? pc.dim(pc.gray(F_DOWN))
-                : pc.green(F_CHECK);
+            : outcome === 'interrupted'
+                ? pc.yellow(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.interrupted > 0 ? pc.yellow(`${counts.interrupted} interrupted`) : undefined,
             counts.flaky > 0 ? pc.yellow(`${counts.flaky} flaky`) : undefined,
             counts.skipped > 0 ? pc.yellow(`${counts.skipped} skipped`) : undefined,
         ]
@@ -647,6 +676,7 @@ export class ListReporter {
             parts.push(pc.dim(ai));
         this.print(parts.join(' '));
         const verbose = counts.failed > 0 ||
+            counts.interrupted > 0 ||
             counts.flaky > 0 ||
             this.groups.size === 1 ||
             (this.live && group.lines.some((line) => line.steps.length > 0));
@@ -678,6 +708,8 @@ export class ListReporter {
                     : pc.dim(pc.gray(` [${line.skipReason}]`));
                 return [`   ${pc.dim(pc.gray(F_DOWN))} ${line.title}${reason}`];
             }
+            case 'interrupted':
+                return [`   ${pc.yellow(F_CROSS)} ${line.title} ${pc.yellow('(interrupted)')} ${duration}${ai}`];
             default: {
                 const status = line.status === 'failed' ? '' : pc.red(` (${line.status})`);
                 const rows = [`   ${pc.red(`${F_CROSS} ${line.title}`)}${status} ${duration}${ai}`];
@@ -716,6 +748,9 @@ export class ListReporter {
             rows.push(padTitle(pc, 'Cache') + cache);
         if (final)
             rows.push(...this.repeatRows());
+        if (this.skippedFailures.length > 0) {
+            rows.push(padTitle(pc, 'Warnings') + pc.yellow(`${this.skippedFailures.length} skipped after failure`));
+        }
         if (this.errors.length > 0) {
             const count = this.errors.length;
             rows.push(padTitle(pc, 'Errors') + pc.bold(pc.red(`${count} error${count === 1 ? '' : 's'}`)));
@@ -736,11 +771,12 @@ export class ListReporter {
         const groups = repeatGroups(this.runs, (entry) => entry);
         if (groups.length === 0)
             return [];
-        const unstable = groups.filter((group) => group.passed < group.runs.length);
+        // A test is listed when it missed a run: a flake first, then one the run cut short.
+        const missed = groups.filter((group) => group.passed < group.runs.length).toSorted((a, b) => Number(b.unstable) - Number(a.unstable));
         const summary = repeatSummary(groups);
         return [
-            padTitle(pc, 'Repeats') + (unstable.length === 0 ? pc.green(summary) : pc.yellow(summary)),
-            ...unstable.map((group) => `${padTitle(pc, '')}${pc.yellow(F_CROSS)} ${group.label}  ${pc.dim(repeatLine(group))}`),
+            padTitle(pc, 'Repeats') + (missed.some((group) => group.unstable) ? pc.yellow(summary) : pc.green(summary)),
+            ...missed.map((group) => `${padTitle(pc, '')}${group.unstable ? pc.yellow(F_CROSS) : pc.dim(pc.gray(F_DOWN))} ${group.label}  ${pc.dim(repeatLine(group))}`),
         ];
     }
     /** A zero counter's label: the plain text, or the interrupt when that is why nothing is counted. */
@@ -808,15 +844,15 @@ export class ListReporter {
             this.print(line);
     }
     /** vitest's `Failed Tests` section: a banner, then each failure with its code frame. */
-    printFailures() {
+    printFailures(heading, failures) {
         const { pc } = this;
-        if (this.failures.length === 0)
+        if (failures.length === 0)
             return;
         this.print('');
-        this.print(this.errorBanner(`Failed Tests ${this.failures.length}`));
+        this.print(this.errorBanner(`${heading} ${failures.length}`));
         this.print('');
-        this.failures.forEach(({ group, title, status, error, videos, failure, screenPath }, index) => {
-            this.print(`${pc.bold(pc.bgRed(' FAIL '))} ${this.badge(group.target)} ${bounded(group.file)}${this.separator}${title}`);
+        failures.forEach(({ group, title, status, error, videos, failure, screenPath }, index) => {
+            this.print(`${pc.bold(pc.bgRed(status === 'skipped' ? ' SKIP ' : ' 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`));
             }
@@ -829,7 +865,7 @@ export class ListReporter {
             }
             this.printEvidence(failure, screenPath);
             this.printVideos(videos);
-            const marker = `[${index + 1}/${this.failures.length}]`;
+            const marker = `[${index + 1}/${failures.length}]`;
             const { before, after } = rule(marker, 'right');
             this.print('');
             this.print(pc.red(pc.dim(`${before}${marker}${after}`)));
@@ -925,7 +961,8 @@ export class ListReporter {
                 this.printGroup(group);
         }
         this.printExplore();
-        this.printFailures();
+        this.printFailures('Failed Tests', this.failures);
+        this.printFailures('Skipped After Failure', this.skippedFailures);
         this.printErrors();
         this.print('');
         for (const row of this.summaryRows(true))

package/dist/report/markdown.d.ts

@@ -50,7 +50,7 @@ export declare function renderMarkdownReport(report: Report1Document, options?:
  * `summary.md` beside `report.json`, with evidence listed as paths from the
  * project root, for a reader with the checkout in front of it: a pull
  * request description, a coding agent's handoff, a wiki page. Every test
- * that did not pass gets a page of its own under `failures/`, with the
+ * that failed or was flaky gets a page of its own under `failures/`, with the
  * screen at failure inline; the run page links each block to its page. The
  * directory is the reporter's: what an earlier run left there is removed
  * first, so a stale page never describes a failure this run did not have.

package/dist/report/markdown.js

@@ -45,11 +45,11 @@ const MAX_GOAL_CHARS = 400;
 const TRUNCATED_NOTE = '_Truncated to fit a pull request comment; the full report is in `report.json`._';
 /** Screenshots first, then the recording, then the trace; the compiler fails when a kind is missing here. */
 const KIND_RANK = { screenshot: 0, video: 1, trace: 2, download: 3, log: 4 };
-const ICON = { failed: '🔴', flaky: '⚠️', skipped: '⏭️', passed: '🟢' };
+const ICON = { failed: '🔴', interrupted: '⏹️', flaky: '⚠️', skipped: '⏭️', passed: '🟢' };
 /** Worst first: the order failures are listed, files are sorted, and a file's glyph is chosen in. */
-const WORST_FIRST = ['failed', 'flaky', 'skipped', 'passed'];
-/** The order counts read in: `1 failed, 1 flaky, 3 passed, 1 skipped`. */
-const COUNT_ORDER = ['failed', 'flaky', 'passed', 'skipped'];
+const WORST_FIRST = ['failed', 'interrupted', 'flaky', 'skipped', 'passed'];
+/** The order counts read in: `1 failed, 2 interrupted, 1 flaky, 3 passed, 1 skipped`. */
+const COUNT_ORDER = ['failed', 'interrupted', 'flaky', 'passed', 'skipped'];
 function worstBucket(results) {
     const present = new Set(results.map((result) => statusBucket(result.status)));
     return WORST_FIRST.find((key) => present.has(key)) ?? 'passed';
@@ -65,9 +65,25 @@ function pageName(options) {
     const title = options.title?.trim() ?? '';
     return title === '' ? 'e2e' : `e2e ${cell(title, MAX_ID_CHARS)}`;
 }
+/**
+ * The headline's glyph: red for a failed run or any failed test, the
+ * interrupted glyph for a run or a listed test the run stopped, else green.
+ * A `--last-failed` rerun that passed can still list a test the first pass
+ * never finished, and the page must not read as all green.
+ */
+function runIcon(run, results) {
+    if (run.status !== 'passed' && run.status !== 'interrupted')
+        return ICON.failed;
+    const worst = worstBucket(results);
+    if (worst === 'failed')
+        return ICON.failed;
+    if (worst === 'interrupted' || run.status === 'interrupted')
+        return ICON.interrupted;
+    return ICON.passed;
+}
 function headline(run, results, options) {
     const summary = countText(tally(results)) || (run.errors.length > 0 ? 'no tests ran' : 'no tests selected');
-    return `### ${run.status === 'passed' ? ICON.passed : ICON.failed} ${pageName(options)}: ${summary}`;
+    return `### ${runIcon(run, results)} ${pageName(options)}: ${summary}`;
 }
 /** The model calls an agent step made; the step's metrics are the source of truth. */
 function modelCalls(step) {
@@ -236,6 +252,12 @@ function flakyFold(entries, manyTargets, options) {
     const summary = `${ICON.flaky} ${plural(entries.length, 'flaky test')} passed on a retry`;
     return [['<details>', `<summary>${summary}</summary>`, '', shown.join('\n\n'), '</details>'].join('\n')];
 }
+/** A test that missed a run: flaky when a run failed, else interrupted when the run stopped one, else skipped. */
+function missIcon(group) {
+    if (group.unstable)
+        return ICON.flaky;
+    return group.runs.some((run) => run.status === 'interrupted') ? ICON.interrupted : ICON.skipped;
+}
 /**
  * A `--repeat-each` run's tally: how many tests passed every run, then each
  * test that did not, with the runs that failed. Empty for a run that
@@ -254,10 +276,11 @@ function repeatsSection(entries, manyTargets) {
     }));
     if (groups.length === 0)
         return [];
-    const unstable = groups.filter((group) => group.passed < group.runs.length);
+    // A test is listed when it missed a run: a flake first, then one the run cut short.
+    const missed = groups.filter((group) => group.passed < group.runs.length).toSorted((a, b) => Number(b.unstable) - Number(a.unstable));
     return [
         `**Repeats:** ${repeatSummary(groups)}`,
-        ...(unstable.length === 0 ? [] : ['', ...unstable.map((group) => `- ${ICON.flaky} ${group.label}: ${cell(repeatLine(group))}`)]),
+        ...(missed.length === 0 ? [] : ['', ...missed.map((group) => `- ${missIcon(group)} ${group.label}: ${cell(repeatLine(group))}`)]),
     ];
 }
 /** Results grouped by file and target, the worst file first, then by path. */
@@ -353,12 +376,12 @@ function footer(run, targets, options) {
     return [`<sub>${parts.join(' · ')}</sub>`];
 }
 // --- the exploration record ---
-function exploreHeadline(run, explore, options) {
+function exploreHeadline(run, results, explore, options) {
     const issues = explore.findings.filter((finding) => finding.kind === 'issue').length;
     const warnings = explore.findings.length - issues;
     const counts = [...(issues > 0 ? [plural(issues, 'issue')] : []), ...(warnings > 0 ? [plural(warnings, 'warning')] : [])];
     const summary = counts.length > 0 ? counts.join(', ') : run.status === 'blocked' ? 'explored nothing' : run.status === 'passed' ? 'no findings' : 'did not finish';
-    return `### ${run.status === 'passed' ? ICON.passed : ICON.failed} ${pageName(options)} explore: ${summary}`;
+    return `### ${runIcon(run, results)} ${pageName(options)} explore: ${summary}`;
 }
 /** `3 of 8 steps · 2 passed · 1 failed · the agent covered the goal`. */
 function exploreSteps(explore) {
@@ -448,7 +471,7 @@ export function renderMarkdownReport(report, options = {}) {
         failures.push([`and ${failed.length - failures.length} more failed`]);
     const flaky = flakyFold(notPassed.filter(({ result }) => statusBucket(result.status) === 'flaky'), manyTargets, options);
     const spend = spendLine(run, entries);
-    const head = [explore === undefined ? headline(run, selected, options) : exploreHeadline(run, explore, options), ...(spend === undefined ? [] : [spend]), ''];
+    const head = [explore === undefined ? headline(run, selected, options) : exploreHeadline(run, selected, explore, options), ...(spend === undefined ? [] : [spend]), ''];
     const groups = fileGroups(entries);
     const sections = explore === undefined
         ? [errors, ...failures, flaky, repeatsSection(entries, manyTargets), allTests(groups, selected.length, manyTargets)]
@@ -468,9 +491,9 @@ function failurePageName(result) {
     return `${sanitizePathSegment(`${result.file}-${result.titlePath.join('-')}`)}-${result.id.slice(0, 8)}.md`;
 }
 /**
- * The results that get a page: every one that failed, timed out, was
- * interrupted, or was flaky, except an exploration's own verdict, which its
- * findings already tell.
+ * The results that get a page: every one that failed, timed out, or was
+ * flaky, except an exploration's own verdict, which its findings already
+ * tell. An interrupted test reached no verdict, so it has no failure to tell.
  */
 function pagedResults(report) {
     const explore = report.run.explore;
@@ -487,7 +510,7 @@ function pagedResults(report) {
  * `summary.md` beside `report.json`, with evidence listed as paths from the
  * project root, for a reader with the checkout in front of it: a pull
  * request description, a coding agent's handoff, a wiki page. Every test
- * that did not pass gets a page of its own under `failures/`, with the
+ * that failed or was flaky gets a page of its own under `failures/`, with the
  * screen at failure inline; the run page links each block to its page. The
  * directory is the reporter's: what an earlier run left there is removed
  * first, so a stale page never describes a failure this run did not have.

package/dist/report/repeats.d.ts

@@ -15,6 +15,11 @@ export interface RepeatGroup {
     readonly runs: readonly RepeatRun[];
     /** Runs that passed on their first attempt; a flaky run needed a retry and does not count. */
     readonly passed: number;
+    /**
+     * Whether a run that reached a verdict did not pass: a flake. A run the
+     * run interrupted, or never started, says nothing about the test.
+     */
+    readonly unstable: boolean;
 }
 /**
  * Groups runs by `key`, keeping only tests that ran more than once and did
@@ -27,5 +32,5 @@ export declare function repeatGroups<T>(items: readonly T[], describe: (item: T)
 }): RepeatGroup[];
 /** `2 of 3 tests passed all 5 runs`; the run count is the most any test had. */
 export declare function repeatSummary(groups: readonly RepeatGroup[]): string;
-/** `3/5 passed · repeat 0 ASSERTION_FAILED · repeat 2 flaky`, naming each run that did not pass. */
+/** `3/5 passed · repeat 0 ASSERTION_FAILED · repeat 2 flaky · repeat 4 interrupted`, naming each run that did not pass. */
 export declare function repeatLine(group: RepeatGroup): string;

package/dist/report/repeats.js

@@ -3,6 +3,8 @@
  * of one test, target, and agent side by side, so a flake reads as `3/5
  * passed` with the runs that did not, instead of five results to count.
  */
+/** Statuses of a run that reached no verdict: stopped by the run, or never started. */
+const UNDECIDED = new Set(['interrupted', 'skipped']);
 /**
  * Groups runs by `key`, keeping only tests that ran more than once and did
  * not skip every run, in first-seen order.
@@ -19,7 +21,12 @@ export function repeatGroups(items, describe) {
         .filter((group) => group.runs.length > 1 && group.runs.some((run) => run.status !== 'skipped'))
         .map((group) => {
         const runs = group.runs.toSorted((a, b) => a.repeat - b.repeat);
-        return { label: group.label, runs, passed: runs.filter((run) => run.status === 'passed').length };
+        return {
+            label: group.label,
+            runs,
+            passed: runs.filter((run) => run.status === 'passed').length,
+            unstable: runs.some((run) => run.status !== 'passed' && !UNDECIDED.has(run.status)),
+        };
     });
 }
 /** `2 of 3 tests passed all 5 runs`; the run count is the most any test had. */
@@ -28,13 +35,15 @@ export function repeatSummary(groups) {
     const runs = Math.max(...groups.map((group) => group.runs.length));
     return `${stable} of ${groups.length} test${groups.length === 1 ? '' : 's'} passed all ${runs} runs`;
 }
-/** A run that did not pass, in a word: its error code, or `flaky` with the code its retry recovered from. */
+/** A run that did not pass, in a word: its error code, `flaky` with the code its retry recovered from, or why it reached no verdict. */
 function outcomeOf(run) {
     if (run.status === 'flaky')
         return run.code === undefined ? 'flaky' : `flaky (${run.code})`;
+    if (UNDECIDED.has(run.status))
+        return run.status;
     return run.code ?? run.status;
 }
-/** `3/5 passed · repeat 0 ASSERTION_FAILED · repeat 2 flaky`, naming each run that did not pass. */
+/** `3/5 passed · repeat 0 ASSERTION_FAILED · repeat 2 flaky · repeat 4 interrupted`, naming each run that did not pass. */
 export function repeatLine(group) {
     const misses = group.runs
         .filter((run) => run.status !== 'passed')

package/dist/run/artifacts.d.ts

@@ -2,7 +2,7 @@
 import type { ArtifactStore } from '../types.ts';
 import type { ArtifactSink } from './fixtures.ts';
 import type { ArtifactRecord } from './records.ts';
-import type { SessionSecrecy } from './secrecy.ts';
+import { type SessionSecrecy } from './secrecy.ts';
 export interface AttemptArtifacts {
     /** Absolute attempt artifact directory, created eagerly. */
     readonly dir: string;
@@ -38,9 +38,9 @@ export declare function createAttemptArtifacts(options: {
     /**
      * The secrecy of the session the attempt runs on, read when a download is
      * registered; undefined (no session open yet) leaves every download as
-     * served. Once a secret reached the session (filled, or held by the
-     * engine), a text-like download is rewritten through its ledger before it
-     * is hashed or stored.
+     * served. While its ledger holds a value (`redactsRecordings`), a
+     * text-like download is rewritten through it before it is hashed or
+     * stored.
      */
     secrecy?: () => SessionSecrecy | undefined;
     /**
@@ -56,6 +56,24 @@ export declare function createAttemptArtifacts(options: {
         readonly attemptId?: string;
     };
 }): AttemptArtifacts;
+/**
+ * Empties an artifact tree down to the files `keep` names, by their report
+ * paths, and removes the directories left empty. A `--last-failed` rerun
+ * starts this way rather than from an empty tree: the evidence the report it
+ * reruns names stays, since that report's results fold into the rerun's and
+ * its carried tests are not run again.
+ */
+export declare function pruneArtifacts(root: string, keep: ReadonlySet<string>): Promise<void>;
+/**
+ * Claims the directory a `--last-failed` rerun's attempts write under, beside
+ * the evidence it kept, and returns its name: `rerun-<n>`, past every number
+ * already there, so the tree reads in run order. The directory is created
+ * exclusively, so no attempt of the rerun writes into a directory an earlier
+ * run's report still names.
+ */
+export declare function claimRerunDir(root: string): Promise<string>;
+/** An attempt's report segments, under the rerun's directory on a `--last-failed` rerun. */
+export declare function attemptSegments(rerunDir: string | undefined, segments: readonly string[]): readonly string[];
 /**
  * Restricts a report path segment to a safe filename alphabet and length. A
  * value that is already safe and within the cap is unchanged. Any other value

package/dist/run/artifacts.js

@@ -1,10 +1,11 @@
 /** Attempt-scoped artifact directory and report registration. */
 import { createHash } from 'node:crypto';
 import { createReadStream, mkdirSync } from 'node:fs';
-import { readFile, stat } from 'node:fs/promises';
+import { mkdir, readdir, readFile, rm, rmdir, stat } from 'node:fs/promises';
 import path from 'node:path';
 import { pipeline } from 'node:stream/promises';
 import { writeFileAtomic } from '../internal/atomic-write.js';
+import { redactsRecordings } from './secrecy.js';
 /**
  * How much of each kind the runner masked, unless the registration says. A
  * screenshot masks secure fields at the source; a log passes through the
@@ -60,7 +61,7 @@ export function createAttemptArtifacts(options) {
             const reportPath = path.posix.join(...options.segments, relativePath);
             const secrecy = kind === 'download' && registration?.redaction === undefined ? options.secrecy?.() : undefined;
             pending.push((async () => {
-                if (secrecy !== undefined && secrecy.exposure.redactsRecordings && isTextLike(record.mediaType)) {
+                if (secrecy !== undefined && redactsRecordings(secrecy) && isTextLike(record.mediaType)) {
                     record.redaction = await redactDownload(absolute, secrecy);
                 }
                 // Without a store the file is streamed for its size and digest only;
@@ -156,6 +157,73 @@ export function createAttemptArtifacts(options) {
     };
     return { dir, records, sink, settle };
 }
+/** What a `--last-failed` rerun's attempt directory is called, `rerun-<n>`, numbered from 1. */
+const RERUN_DIR = /^rerun-([1-9][0-9]*)$/;
+/**
+ * Empties an artifact tree down to the files `keep` names, by their report
+ * paths, and removes the directories left empty. A `--last-failed` rerun
+ * starts this way rather than from an empty tree: the evidence the report it
+ * reruns names stays, since that report's results fold into the rerun's and
+ * its carried tests are not run again.
+ */
+export async function pruneArtifacts(root, keep) {
+    const prune = async (dir, relative) => {
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch (cause) {
+            if (cause.code === 'ENOENT')
+                return true;
+            throw cause;
+        }
+        let empty = true;
+        for (const entry of entries) {
+            const reportPath = relative === '' ? entry.name : `${relative}/${entry.name}`;
+            const absolute = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (await prune(absolute, reportPath))
+                    await rmdir(absolute);
+                else
+                    empty = false;
+            }
+            else if (keep.has(reportPath)) {
+                empty = false;
+            }
+            else {
+                await rm(absolute, { force: true });
+            }
+        }
+        return empty;
+    };
+    await prune(root, '');
+}
+/**
+ * Claims the directory a `--last-failed` rerun's attempts write under, beside
+ * the evidence it kept, and returns its name: `rerun-<n>`, past every number
+ * already there, so the tree reads in run order. The directory is created
+ * exclusively, so no attempt of the rerun writes into a directory an earlier
+ * run's report still names.
+ */
+export async function claimRerunDir(root) {
+    await mkdir(root, { recursive: true });
+    const taken = (await readdir(root)).map((name) => Number(RERUN_DIR.exec(name)?.[1] ?? 0));
+    for (let n = Math.max(0, ...taken) + 1;; n += 1) {
+        const name = `rerun-${n}`;
+        try {
+            await mkdir(path.join(root, name));
+            return name;
+        }
+        catch (cause) {
+            if (cause.code !== 'EEXIST')
+                throw cause;
+        }
+    }
+}
+/** An attempt's report segments, under the rerun's directory on a `--last-failed` rerun. */
+export function attemptSegments(rerunDir, segments) {
+    return rerunDir === undefined ? segments : [rerunDir, ...segments];
+}
 /**
  * Rewrites a text-like download through the session's ledger, the way a
  * trace's text entries are, and returns the redaction the record can claim:
@@ -168,7 +236,7 @@ async function redactDownload(absolute, secrecy) {
     try {
         const bytes = await readFile(absolute);
         const text = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(bytes);
-        const redacted = secrecy.ledger.redact(text);
+        const redacted = secrecy.ledger.redactFragments(text);
         if (redacted !== text)
             await writeFileAtomic(absolute, redacted);
         return 'complete';