@molecule/api-ai-tools 1.5.20 → 1.6.2

package/dist/utilities.js

@@ -5,6 +5,7 @@
  * @module
  */
 import { posix } from 'path';
+import { commandSegments } from './command-position.js';
 import { commandRunsNoTests } from './no-test-run.js';
 /**
  * Shell-safe quoting using single quotes. Unlike JSON.stringify (double quotes),
@@ -288,8 +289,43 @@ export function outputRedirectTarget(command) {
 }
 /** A trailing `| tail -N` / `| tail -n N` (stderr redirects before it stay). */
 const TRAILING_TAIL = /\s*\|\s*tail(?:\s+-n)?\s+[-+]?\d+\s*$/;
-/** `--reporter=line` / `--reporter line`, the one reporter the platform cannot read back. */
-const LINE_REPORTER_FLAG = /--reporter([= ])line\b/;
+/** `--reporter line` / `--reporter=line` / `--reporter="list,line"`, with its value. */
+const REPORTER_FLAG = /--reporter(=|\s+)(?:"([^"]*)"|'([^']*)'|(\S+))/g;
+/**
+ * The reporters a step's LAST `--reporter` names (`--reporter=list,line` → `['list', 'line']`).
+ *
+ * Playwright takes the last `--reporter`, so an earlier one is not what runs.
+ *
+ * @param step - The command's last step.
+ * @returns The flag's span and its reporters, or null when the step names none.
+ */
+function lastReporterFlag(step) {
+    REPORTER_FLAG.lastIndex = 0;
+    let last = null;
+    for (let m = REPORTER_FLAG.exec(step); m !== null; m = REPORTER_FLAG.exec(step))
+        last = m;
+    if (!last)
+        return null;
+    const value = last[2] ?? last[3] ?? last[4] ?? '';
+    return {
+        start: last.index,
+        end: last.index + last[0].length,
+        separator: last[1] ?? '=',
+        values: value
+            .split(',')
+            .map((v) => v.trim())
+            .filter(Boolean),
+    };
+}
+/**
+ * The reporters that print one line (or one mark) per test into the log, `list` among them.
+ *
+ * `list` is the only one of these the platform can read back — `suite-fail-fast.ts`'s fail-fast
+ * note and the Tests bar both parse its `  ✓/✘  <n> … (…)` lines — so it is the one a background
+ * run is put on. The rest are here because they print each failure TOO: a log with two of them
+ * carries every result twice.
+ */
+const PRINTING_REPORTERS = new Set(['list', 'line', 'dot', 'basic', 'spec']);
 /**
  * Rewrite a command about to run in the background so its log grows while it
  * runs. Two shapes left the log empty until exit, and an empty log is what
@@ -302,19 +338,18 @@ const LINE_REPORTER_FLAG = /--reporter([= ])line\b/;
  *   often `html`, which prints nothing per test. `--reporter=list` is added
  *   when the playwright run is the command's last step and nothing is piped or
  *   redirected from it: it writes each result as it finishes, and it is the
- *   shape the platform reads a background suite back in (`suite-fail-fast.ts`'s
- *   fail-fast note and the Tests bar both parse `list` lines). A run that names
- *   `--reporter=line` is switched to `list` for the same reason — `line` writes
- *   `[n/N] <title>` with no ✓/✘ mark and no duration, so on X1 flash-m62 an
- *   8.3-minute walk of one suite could never trip the fail-fast note.
- *
- * A run being ITERATED on (capped, narrowed, or by file) gets `list,line` instead
- * of `list` alone. `list` holds every failure's error for the summary at the end,
- * so mid-run its log says only how long each failure took; `line` writes the body
- * as the failure happens, and a look at a running suite (`wait_for_task`'s
- * repeating-cause note, `suite-fail-fast.ts`) can then name the repeating cause by
- * its error message. X1 flash-m76 walked 15 tests for 4.0 minutes, every one a
- * `TimeoutError: page.waitForURL` from one missing `navigate('/')`.
+ *   shape the platform reads a background suite back in.
+ *
+ * The run ends up with exactly ONE reporter that prints each failure — `list`. A run that names
+ * any other printing reporter has it REPLACED, never joined: two of them write every test result
+ * into the log twice, which on X1 flash-m83 (2026-10-16) made a `--reporter=list,line` run (its
+ * `line` added by this function one run earlier) report two distinct failures as "4 of this run's
+ * tests have already failed the same way", and the executor stopped a 139-test walk at test 21
+ * with a single cause in hand. `line` alone is no use either: it writes `[n/N] <title>` with no
+ * ✓/✘ mark and no duration, so on X1 flash-m62 an 8.3-minute walk of one suite could never trip
+ * the fail-fast note. A reporter set that writes a machine format to a file (`json`, `html`,
+ * `junit`) is the
+ * executor's own and is left exactly as it is — so is any reporter this build does not know.
  *
  * Only the command's last step is touched, and only its reporter, and only when that step runs
  * something: `npx playwright test --list` takes two seconds and writes nothing per test, so
@@ -353,40 +388,54 @@ export function streamingBackgroundCommand(command) {
     // which had dropped the `--retries=0` it used one command earlier. The uncapped proof run
     // keeps the suite's retries.
     const iterating = /--max-failures\b|--last-failed\b|(?:^|\s)(?:-g|--grep)\b|\S+\.(?:spec|test)\.[cm]?[jt]sx?(?::\d+)?\b/.test(lastStep);
-    // `list` is the shape the platform reads a background suite back in (the fail-fast note and
-    // the Tests bar both parse its `  ✓/✘  <n> … (…)` lines), and it prints each failure's error
-    // only in the summary at the END. A run being iterated on is the one whose failures are read
-    // mid-run and stopped early, and for that the log has to carry the error as it happens —
-    // `line` writes exactly that, so an iterating run gets both reporters and a proof run, which
-    // nothing stops early, keeps `list` alone rather than doubling its log.
-    const wanted = iterating ? 'list,line' : 'list';
-    if (finalPlaywrightRun && LINE_REPORTER_FLAG.test(lastStep)) {
-        // Only the last step is rewritten, and `lastStep` is a suffix of `out`.
-        out =
-            out.slice(0, out.length - lastStep.length) +
-                lastStep.replace(LINE_REPORTER_FLAG, `--reporter$1${wanted}`);
-        changes.push(`Switched \`--reporter=line\` to \`--reporter=${wanted}\`: it also writes each test result as it ` +
-            'finishes, and it is the shape the platform reads back from a background run.' +
-            (iterating
-                ? ' `line` stays alongside it so each failure writes its error to the log as it happens — that is what a mid-run look reads.'
-                : ''));
-    }
-    else if (finalPlaywrightRun && iterating && /--reporter([= ])list\b/.test(lastStep)) {
-        // Only the last step's reporter, the same rule as above.
-        out =
-            out.slice(0, out.length - lastStep.length) +
-                lastStep.replace(/--reporter([= ])list\b/, '--reporter$1list,line');
-        changes.push('Added `line` to your `--reporter=list`: `list` writes each test result as it finishes but ' +
-            'holds every failure’s error for the summary at the end, and `line` writes it as the failure ' +
-            'happens — which is what names a cause that repeats while this run is still going.');
+    // The last step's reporters: one printer, and it is `list`. Every branch below only ever moves
+    // the command TO that shape — a reporter set is never left with two printers in it.
+    const reporters = finalPlaywrightRun ? lastReporterFlag(lastStep) : null;
+    if (reporters) {
+        const printing = reporters.values.filter((v) => PRINTING_REPORTERS.has(v));
+        // Already exactly `list`: the shape, and nothing printing beside it. Left verbatim — the
+        // executor's own spelling of the command is not rewritten for nothing.
+        if (printing.length > 0 && !(printing.length === 1 && printing[0] === 'list')) {
+            // The printing reporters become ONE `list`, in the place of the first of them; every other
+            // reporter (a `json`/`html`/`junit` file the executor asked for, or one this build does not
+            // know) is left where it was.
+            let placed = false;
+            const kept = reporters.values
+                .map((v) => {
+                if (!PRINTING_REPORTERS.has(v))
+                    return v;
+                if (placed)
+                    return null;
+                placed = true;
+                return 'list';
+            })
+                .filter((v) => v !== null);
+            // Only the last step is rewritten, and `lastStep` is a suffix of `out`.
+            out =
+                out.slice(0, out.length - lastStep.length) +
+                    lastStep.slice(0, reporters.start) +
+                    `--reporter${reporters.separator}${kept.join(',')}` +
+                    lastStep.slice(reporters.end);
+            changes.push(
+            // `list` was already there and a second printer sat beside it: that one is dropped. When
+            // no `list` was named at all, the printer is SWITCHED to it (flash-m62's `line`).
+            printing.includes('list')
+                ? `Dropped \`${printing
+                    .filter((v) => v !== 'list')
+                    .join(',')}\` from your \`--reporter=${reporters.values.join(',')}\`: ` +
+                    'two reporters that both print each failure write every test result into the log ' +
+                    'twice — the whole log doubled for nothing (X1 flash-m83) — so this run keeps ' +
+                    '`list` alone.'
+                : `Switched the test reporters to \`--reporter${reporters.separator}${kept.join(',')}\`: ` +
+                    '`list` writes each test result as it finishes and is the shape the platform reads ' +
+                    'back from a background run, and it is the only printing reporter — two of them ' +
+                    'write every result into the log twice (X1 flash-m83).');
+        }
     }
-    else if (finalPlaywrightRun && !/--reporter\b/.test(lastStep)) {
-        out = `${out.trimEnd()} --reporter=${wanted}`;
-        changes.push(`Added \`--reporter=${wanted}\` so each test result is written to the log as it finishes ` +
-            '(the config reporter may print nothing until the end).' +
-            (iterating
-                ? ' `line` writes each failure’s error as it happens, which is what a mid-run look reads.'
-                : ''));
+    else if (finalPlaywrightRun) {
+        out = `${out.trimEnd()} --reporter=list`;
+        changes.push('Added `--reporter=list` so each test result is written to the log as it finishes ' +
+            '(the config reporter may print nothing until the end).');
     }
     if (finalPlaywrightRun && iterating && !/--retries\b/.test(lastStep)) {
         out = `${out.trimEnd()} --retries=0`;
@@ -400,14 +449,18 @@ export function streamingBackgroundCommand(command) {
  * of from a sandbox; `suiteRunKind` (molecule-dev `api/src/ai/suite-proof.ts`)
  * is the platform's fuller list of URL-testing runners, and the shapes here are
  * its shapes.
+ *
+ * Each is matched at the START of a pipeline segment's command-position text
+ * (`commandSegments`), so a runner named as an argument is not an invocation:
+ * `grep -n playwright e2e/README.md` reads a file and starts nothing.
  */
 const SUITE_RUN_COMMANDS = [
     // `playwright test`, not a bare `playwright` (`--version` is not a run).
-    /(?:^|[\s;&|(])(?:npx\s+(?:--no-install\s+)?)?(?:\S*\/)?playwright\s+test\b/,
+    /^playwright\s+test\b/,
     // Vitest, however it is invoked (`vitest`, `npx vitest run`).
-    /(?:^|[\s;&|(])(?:npx\s+(?:--no-install\s+)?)?(?:\S*\/)?vitest\b/,
+    /^vitest\b/,
     // `hurl --test …` or `hurl … x.hurl`.
-    /(?:^|[\s;&|(])(?:\S*\/)?hurl\s+[^|\n]*(?:--test|\.hurl)/,
+    /^hurl\s+[^|\n]*(?:--test|\.hurl)/,
 ];
 /**
  * Whether a command runs a whole test suite — a Playwright, Vitest or Hurl run
@@ -421,21 +474,29 @@ const SUITE_RUN_COMMANDS = [
  * @returns True when the command starts one of those runners.
  */
 export function isSuiteRunCommand(command) {
-    return !commandRunsNoTests(command) && SUITE_RUN_COMMANDS.some((re) => re.test(command));
+    if (commandRunsNoTests(command))
+        return false;
+    return commandSegments(command).some((segment) => SUITE_RUN_COMMANDS.some((re) => re.test(segment.text)));
 }
 /**
- * Whether a command starts a Playwright run — `playwright test` in a form that runs something.
+ * Whether a command starts a Playwright run — a `playwright test` in command position, in a form
+ * that runs something.
  *
  * `npx playwright test --list` matched every `\bplaywright\s+test\b` test in the platform and was
  * then treated as a run: held (flash-m79's config check), backgrounded for a run that outlasts
  * the tool's ceiling, and rewritten with `--reporter`. A list takes two seconds, prints its lines
  * and exits, so it is none of those; {@link commandRunsNoTests} is what decides.
  *
+ * A `playwright test` named as an argument is not a run either (`head -30 run-tests.sh`,
+ * `grep -n "playwright test" e2e/README.md`): the command that runs is the reader.
+ *
  * @param command - The shell command.
  * @returns True when the command starts a Playwright run.
  */
 export function isPlaywrightRunCommand(command) {
-    return /\bplaywright\s+test\b/.test(command) && !commandRunsNoTests(command);
+    if (commandRunsNoTests(command))
+        return false;
+    return commandSegments(command).some((segment) => /^playwright\s+test\b/.test(segment.text));
 }
 /**
  * Start a background suite run at lower CPU and IO priority, so the sandbox it
@@ -669,6 +730,30 @@ export function pathArgError(path, tool) {
         return `${tool} requires a non-empty "path" argument (a file path relative to the project root, e.g. "api/src/handlers/index.ts").`;
     return null;
 }
+/**
+ * The error for a file tool called with NO arguments at all — `edit_file {}`, the
+ * shape a truncated provider stream leaves behind.
+ *
+ * The path message is the wrong reading of it: "requires a non-empty path
+ * argument" says the call was understood and the path was left out, so the model
+ * retries the call it just made instead of sending the whole call again (x0
+ * flash-m83 +29:32: `edit_file {}`, one round lost). An empty object and a
+ * missing `path` are different failures and deserve different sentences.
+ *
+ * @param input - The raw tool input.
+ * @param tool - The tool name, for the message.
+ * @returns The truncation message, or null when the call carried any argument.
+ */
+export function emptyCallError(input, tool) {
+    const empty = input === undefined ||
+        input === null ||
+        (typeof input === 'object' &&
+            !Array.isArray(input) &&
+            Object.keys(input).length === 0);
+    return empty
+        ? `${tool} arrived with no arguments at all — the call was cut short, usually a truncated response. Send the whole call again.`
+        : null;
+}
 /**
  * Detect a "read/edit targeted a directory, not a file" failure from a backend
  * error message (local fs `EISDIR` or the sandbox's `cat: X: Is a directory`),
@@ -740,31 +825,96 @@ export function sliceLines(content, window) {
         truncated: offset > 1 || offset - 1 + picked.length < totalLines,
     };
 }
-/** Max search results. */
+/**
+ * A file's text as the request counts it: the length of its JSON string.
+ *
+ * JSON escaping (`\n` → `\\n`, `"` → `\"`) costs characters, and the request
+ * side counts the SERIALIZED tool result. A window of 59,000 characters of
+ * source — 1,200 lines — arrives as ~60,200 characters of JSON, over the
+ * ceiling it was sized for, so a window is measured with this rather than by
+ * its raw text length.
+ *
+ * @param text - The text.
+ * @returns Its serialized length, without the surrounding quotes.
+ */
+export function serializedChars(text) {
+    return JSON.stringify(text).length - 2;
+}
+/**
+ * How many leading lines of a file fit inside a budget of SERIALIZED chars,
+ * the way `read_file` sizes a window (see {@link serializedChars}).
+ *
+ * @param content - The file's full text.
+ * @param chars - The budget in serialized chars.
+ * @returns The line count, at least one.
+ */
+export function linesWithinSerialized(content, chars) {
+    let used = 0;
+    let lines = 0;
+    for (const line of content.split('\n')) {
+        // +2: the newline between two lines escapes to `\n`. The last line of a
+        // window has no trailing newline, so this counts 2 chars it does not use —
+        // a window that errs small is the safe direction here.
+        used += serializedChars(line) + 2;
+        if (used > chars && lines > 0)
+            break;
+        lines++;
+    }
+    return Math.max(1, lines);
+}
 /**
  * Most files one batched `read_file` call returns. The cap exists so a survey
- * of a large tree cannot swallow the turn's context in one result; the tool
- * reports where it stopped so the model continues from there.
+ * of a large tree cannot swallow the turn's context in one result; every path
+ * past it is named in the result's `note` and listed with its own `error`, so
+ * the model continues from there.
  */
 export const MAX_BATCH_READ_FILES = 25;
 /**
- * Total content bytes one batched `read_file` call returns, across all files.
- * The per-file {@link MAX_READ_SIZE} still applies to each one.
+ * The most one `read_file` RESULT may carry, in chars of its JSON — every file
+ * the call returns, the envelope and the note included. That is how the request
+ * side counts a tool result, so it is how this tool counts one too
+ * ({@link serializedChars}).
+ *
+ * One tool result is ONE block in the request, and the request side caps a
+ * block: molecule-dev cuts any block over `MAX_TAIL_BLOCK_CHARS` (60,000) in
+ * place, keeping ~30 KB of each end. A batched read that crossed it lost its
+ * MIDDLE — the cut lands between two `"content"` values, so whole files fell
+ * out and the note in their place said only "N characters cut here" — while
+ * this tool's own note had promised each of those files that it "fits in one
+ * call, so it is not paged": X0 flash-m81 (2026-10-16) read ten e2e specs in
+ * one call (121,467 chars), lost the middle six, and bought them again in six
+ * further calls (52,908 chars).
+ *
+ * So the CALL gets the ceiling the request gives it. Whole files are returned
+ * up to it; the paths that did not fit are named in `note` and listed in
+ * `files` with their own `error`, the shape every other entry has. No file is
+ * ever cut, and no read result reaches the request-side cut. A test in
+ * molecule-dev's `context-fit` asserts the two ceilings still agree.
+ */
+export const MAX_READ_CALL_CHARS = 60_000;
+/**
+ * Room inside one read result for what is not file content: the `path`, the
+ * offset/line fields, and the note.
+ *
+ * A batch sizes each file against what the call has left
+ * ({@link MAX_READ_CALL_CHARS} less this), so the entry that does not fit is
+ * caught here rather than by the request-side cut.
  */
-export const MAX_BATCH_READ_BYTES = 200 * 1024;
+export const READ_RESULT_ENVELOPE_CHARS = 1_000;
 /**
  * The most one read_file call returns for ONE file when no window was asked
- * for, in chars. Larger files come back as their first window with a note
- * saying how to read the rest.
+ * for, in serialized chars: larger files come back as their first window, with
+ * a note saying how to read the rest.
  *
  * MAX_READ_SIZE (5 MB) is a bound on what the tool will open, not on what it
  * should hand a model: a single batched read that returned a 1.2 MB README
  * put the next three provider calls at 366k tokens (~330k of them fresh)
- * against a 120k-token context cap (X0 run x5, call 26). ~80 KB is ~20–25k
- * tokens — a fifth of that cap, and more than any one file read usually
- * needs.
+ * against a 120k-token context cap (X0 run x5, call 26). This is the call's
+ * own ceiling ({@link MAX_READ_CALL_CHARS}) less the room its envelope takes,
+ * so one read result — one file or twenty-five — fits inside what the request
+ * side carries without being cut.
  */
-export const MAX_READ_RETURN_CHARS = 80 * 1024;
+export const MAX_READ_RETURN_CHARS = MAX_READ_CALL_CHARS - READ_RESULT_ENVELOPE_CHARS;
 /**
  * A file this small is returned whole on a second window of it (paging it costs a call each).
  * The same bound as {@link MAX_READ_RETURN_CHARS}: the windowed-read note promises that a
@@ -1065,7 +1215,10 @@ export function runningCauseCommand(log, own) {
     const read = `cat ${log}${own ? ` ${shellQuote(own)}` : ''} 2>/dev/null`;
     return `${read} | tail -c ${REPEATING_CAUSE_TAIL_BYTES}`;
 }
-/** Failures that must share one signature before a running suite's repeating cause is named. */
+/**
+ * DISTINCT tests that must share one signature before a running suite's repeating cause is named.
+ * A test the log prints twice, or a test that failed twice, is still one test.
+ */
 export const REPEATING_FAILURE_MIN = 3;
 /** ANSI SGR sequences — the `line` reporter writes cursor moves even into a file. */
 // eslint-disable-next-line no-control-regex -- an escape sequence IS a control character
@@ -1130,23 +1283,106 @@ function failedTests(log) {
  * while running "beforeEach" hook.`), which changes with the hook; the thrown error below it is
  * what repeats verbatim, so it is preferred.
  *
- * @param block - One block from {@link failureBlocks}.
+ * @param body - The block's lines, from {@link failureBody}.
  * @returns The error line, or null when the block has no body.
  */
-function failureMessage(block) {
-    const body = block
+function failureErrorLine(body) {
+    const thrown = body.find((l) => /^[A-Za-z_$][\w.$]*(?:Error|Exception)\b/.test(l));
+    return thrown ?? body[0] ?? null;
+}
+/**
+ * A failure block's own words, one per line: its body without the runner's progress lines (the
+ * `list` reporter interleaves them with the `line` reporter's blocks), without a code frame or an
+ * `at …` line (where the error happened, not what it said), and without the report's file list.
+ *
+ * @param block - One block from {@link failureBlocks}.
+ * @returns The body's lines, ANSI stripped and trimmed.
+ */
+function failureBody(block) {
+    return block
         .split('\n')
         .slice(1)
         .map((l) => l.replace(ANSI_SGR, '').trim())
-        // Progress lines the `list` reporter interleaves with the `line` reporter's blocks are not
-        // the block's own words, and a code frame or an `at …` line is where the error happened, not
-        // what it said.
         .filter((l) => l &&
         !LIST_RESULT_LINE.test(l) &&
         !/^(?:at\s|\d+ \||>\s*\d+ \||\|)/.test(l) &&
         !/^Error Context:/.test(l));
-    const thrown = body.find((l) => /^[A-Za-z_$][\w.$]*(?:Error|Exception)\b/.test(l));
-    return thrown ?? body[0] ?? null;
+}
+/**
+ * What a failure block says the failure is ABOUT, when its error line does not already say it:
+ * the locator it waited for, the navigation it waited on, or the locator and the expected/received
+ * pair of a failed assertion.
+ *
+ * Without this, every `TimeoutError: page.press: Timeout 5000ms exceeded.` in a log is one
+ * message, because that line names the ACTION (`page.press`) and never its subject. X1 flash-m84
+ * (2026-10-16) had four such failures in one run — one waiting on
+ * `button:has-text("Publish Article")`, one on `.article-preview h1`, one on
+ * `.article-preview').first().locator('.author')`, one on a generated `h1:has-text("Test
+ * Article …")` — and the run's summary called them two causes while its mid-run note called them
+ * one. The subject is what separates causes; it is in the block, and nothing else in the block
+ * carries it.
+ *
+ * @param body - The block's lines, from {@link failureBody}.
+ * @returns The detail line, or null when the block names none.
+ */
+function failureDetail(body) {
+    const waited = body.find((l) => /^-?\s*waiting for (?:locator\(|navigation|element|selector)/.test(l));
+    if (waited !== undefined)
+        return waited.replace(/^-\s*/, '');
+    // A failed assertion names its locator and the two values that differ.
+    const locator = body.find((l) => /^Locator:\s/.test(l));
+    if (locator === undefined)
+        return null;
+    const parts = [
+        locator,
+        body.find((l) => /^Expected\b/.test(l)),
+        body.find((l) => /^Received\b/.test(l)),
+    ];
+    return parts.filter((p) => p !== undefined).join(' · ');
+}
+/**
+ * A cause signature with the values that differ between two tests of ONE cause replaced by `<n>`:
+ * a duration, a generated id or timestamp, a host's port.
+ *
+ * The duration is the one that matters. A suite that sets `actionTimeout: 5_000` — the X1
+ * realworld suite does — spends `5 s` plus teardown on every "the locator never appeared"
+ * failure, so `~7 s` is a property of the CONFIG, not of the cause, and four different missing
+ * elements print the same number (X1 flash-m84, 2026-10-16). Two tests waiting on the same
+ * locator for 5 s and for 10 s wait for the same thing; two waiting on different locators do not
+ * become one cause by timing out together.
+ *
+ * @param s - An error line, with its detail.
+ * @returns The signature.
+ */
+function normalizedSignature(s) {
+    return (s
+        // A duration: the suite's own timeout, in whatever unit the runner printed.
+        .replace(/\b\d+(?:\.\d+)?\s*(?:ms|s|m)\b/g, '<n>')
+        // A host's port. The shape is what makes it a port: a bare `:32` is a line number.
+        .replace(/\b(\d{1,3}(?:\.\d{1,3}){3}|localhost|0\.0\.0\.0):\d+/g, '$1:<n>')
+        // A generated id, a timestamp, a serial: five digits or more is no part of a selector.
+        .replace(/\b\d{5,}\b/g, '<n>')
+        .replace(/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi, '<id>'));
+}
+/**
+ * What separates one cause from another in a `playwright test` log: the error CLASS plus the
+ * normalized message — the error line, the thing it waited for or asserted on, and the values
+ * with the test's own data normalized out.
+ *
+ * One test printed twice, or two tests failing the same way, share a signature; two tests whose
+ * errors differ in their locator do not, however alike the rest of the line is.
+ *
+ * @param block - One block from {@link failureBlocks}.
+ * @returns The signature, or null when the block has no body.
+ */
+function failureMessage(block) {
+    const body = failureBody(block);
+    const line = failureErrorLine(body);
+    if (line === null)
+        return null;
+    const detail = failureDetail(body);
+    const signature = detail !== null && !line.includes(detail) ? `${line} — ${detail}` : line;
+    return normalizedSignature(signature);
 }
 /**
  * The largest group of items sharing a key.
@@ -1162,42 +1398,84 @@ function largestGroup(groups) {
     }
     return best;
 }
+/**
+ * One test's identity in a log: where it sits and what it is called.
+ *
+ * A test printed twice by two reporters, or failed twice by a retry, is the same test — the
+ * identity is what it is called and where it lives, never which line of the log it came from.
+ *
+ * @param t - A failed test.
+ * @returns The key two prints of one test share.
+ */
+function testKey(t) {
+    return `${t.where}|${t.title}`;
+}
+/**
+ * The same tests with each one kept once, in first-seen order.
+ *
+ * @param tests - Failed tests, as the log printed them (possibly more than once each).
+ * @returns The distinct tests.
+ */
+function distinctTests(tests) {
+    const seen = new Set();
+    return tests.filter((t) => {
+        const key = testKey(t);
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
 /**
  * The cause repeating among a running suite's failures, or null.
  *
  * Playwright's `list` reporter prints one line per test as it finishes — its mark, its title
  * path and how long it ran — and defers each failure's error to the summary at the end, so
- * mid-run the only signature those lines carry is the duration. A `line` reporter prints the
- * failure bodies as they happen, and there the repeated error message itself is the signature,
- * which is stronger (it needs no assumption about how long a failure should take), so the
- * message is looked for first.
+ * mid-run the only signature those lines carry is the duration. Where the log carries the
+ * failure bodies (a `line` reporter's output, or a finished run's summary) the signature is the
+ * error itself — {@link failureMessage}: the error class plus the locator or the values that
+ * differ — which is stronger (it needs no assumption about how long a failure should take), so
+ * the message is looked for first and the duration is then left with the tests whose bodies the
+ * log does NOT carry.
  *
  * Either way the point is the same: a suite whose failures repeat one cause spends its whole
  * runtime proving that one cause, and the executor watching it can be told so at the third
  * failure instead of at the last. X1 flash-m76 walked 15 tests in 4.0 minutes where 15.6 s
  * each was the test timeout and one missing `navigate('/')` was the cause of all of them.
  *
+ * The quorum is of DISTINCT tests — {@link REPEATING_FAILURE_MIN} of them — because a log that
+ * prints each failure twice (a second reporter, a retry) had X1 flash-m83 told that four of its
+ * tests had failed the same way when two had, so the executor stopped a 139-test walk at test 21
+ * with one cause in hand (2026-10-16).
+ *
  * @param log - The log so far.
  * @returns The repeating cause, or null when no signature has {@link REPEATING_FAILURE_MIN}
- *   failures behind it.
+ *   distinct tests behind it.
  */
 export function repeatingFailure(log) {
     const text = log.replace(ANSI_SGR, '');
-    // The failure BODIES first: a message repeating verbatim names the cause itself.
+    // The failure BODIES first: a message repeating verbatim names the cause itself. Grouped by
+    // DISTINCT test, so the largest group is the cause the most tests share — not the one whose
+    // failures happen to have been printed the most times.
     const byMessage = new Map();
+    const withBody = new Set();
     for (const block of failureBlocks(text)) {
+        const m = FAILURE_BLOCK_HEADER.exec(block.split('\n')[0] ?? '');
+        const { where, title } = splitTitlePath(m?.[1] ?? '');
         const message = failureMessage(block);
         if (message === null)
             continue;
-        const m = FAILURE_BLOCK_HEADER.exec(block.split('\n')[0] ?? '');
-        const { where, title } = splitTitlePath(m?.[1] ?? '');
+        withBody.add(testKey({ where, title, seconds: null }));
         const group = byMessage.get(message);
         if (group)
             group.push({ where, title, seconds: null });
         else
             byMessage.set(message, [{ where, title, seconds: null }]);
     }
-    const messageGroup = largestGroup(byMessage);
+    const distinctByMessage = new Map();
+    for (const [message, members] of byMessage)
+        distinctByMessage.set(message, distinctTests(members));
+    const messageGroup = largestGroup(distinctByMessage);
     if (messageGroup && messageGroup.members.length >= REPEATING_FAILURE_MIN)
         return {
             count: messageGroup.members.length,
@@ -1205,10 +1483,16 @@ export function repeatingFailure(log) {
             seconds: null,
             tests: messageGroup.members,
         };
-    // Otherwise the durations: the largest set of failures that took the same time to within the
-    // band. A test that runs to its timeout prints slightly different durations on each attempt
-    // (15.6 s, 15.1 s, 15.0 s), so the band is 0.5 s or 5% of the duration, whichever is larger.
-    const tests = failedTests(text);
+    // Otherwise the durations — of the tests the log says nothing ELSE about. A test whose failure
+    // body is in the log has a signature, and how long it took must not overrule it: a suite whose
+    // config sets a timeout makes every failure that waits for anything land on the same number, so
+    // the duration would merge causes the bodies just separated (X1 flash-m84, 2026-10-16 — four
+    // failures at 6.8-7.4 s, four locators, `actionTimeout: 5_000`). What is left is the shape this
+    // was written for: a `list`-only log, or a run whose bodies have not been printed yet, where
+    // the duration is the ONLY signature the log carries. A test that runs to its timeout prints
+    // slightly different durations on each attempt (15.6 s, 15.1 s, 15.0 s), so the band is 0.5 s
+    // or 5% of the duration, whichever is larger.
+    const tests = distinctTests(failedTests(text)).filter((t) => !withBody.has(testKey(t)));
     const withSeconds = tests.filter((t) => t.seconds !== null);
     let best = [];
     for (const t of withSeconds) {
@@ -1224,37 +1508,241 @@ export function repeatingFailure(log) {
 }
 /** How many of a repeating cause's failures the note lists before it says "and N more". */
 export const REPEATING_FAILURE_LISTED = 5;
+/** How many causes a finished run's summary lists before it says "and N more". */
+export const FAILURE_CAUSES_LISTED = 5;
+/** How many of one cause's tests that summary names before it says "and N more". */
+export const FAILURE_CAUSE_TESTS_LISTED = 6;
 /**
- * The shortest unambiguous tail of a logged path (`…/specs/e2e/articles.spec.ts:32` →
- * `e2e/articles.spec.ts:32`).
+ * The shortest unambiguous tail of a logged path's FILE (`…/specs/e2e/articles.spec.ts` →
+ * `e2e/articles.spec.ts`).
  *
- * @param where - The location the log wrote.
+ * @param file - A path as {@link specFile} returns it.
  * @returns The last two path segments.
  */
-function shortWhere(where) {
-    const parts = where.split('/');
-    return parts.slice(-2).join('/');
+function shortFile(file) {
+    return file.split('/').slice(-2).join('/');
+}
+/**
+ * The spec file a logged location names (`…/e2e/articles.spec.ts:32` → `…/e2e/articles.spec.ts`).
+ *
+ * @param where - A location from {@link FailedTest.where}.
+ * @returns The path without its line number.
+ */
+function specFile(where) {
+    return where.replace(/:\d+$/, '');
+}
+/**
+ * The mark of every test result a log names, in the order it printed them (`✘` failed, `✓`
+ * passed).
+ *
+ * A `line`-only log writes none: `[n/N] <title>` carries no mark. An empty list therefore means
+ * the log cannot say whether anything passed, not that nothing did.
+ *
+ * @param text - The log (ANSI already stripped).
+ * @returns The marks.
+ */
+function resultMarks(text) {
+    const out = [];
+    for (const line of text.split('\n')) {
+        const m = LIST_RESULT_LINE.exec(line);
+        if (m)
+            out.push(m[1]);
+    }
+    return out;
+}
+/**
+ * Every test the log's numbered failure blocks name, in the order it names them.
+ *
+ * @param text - The log (ANSI already stripped).
+ * @returns The failed tests, with the location and title their header carries.
+ */
+function failureBlockTests(text) {
+    return failureBlocks(text).map((block) => {
+        const m = FAILURE_BLOCK_HEADER.exec(block.split('\n')[0] ?? '');
+        const { where, title } = splitTitlePath(m?.[1] ?? '');
+        return { where, title, seconds: null };
+    });
+}
+/**
+ * Distinct spec FILES a repeating cause must span — with every failure sharing it and nothing
+ * passing since — before a run is called broken for the whole suite.
+ *
+ * One file's failures can be that file's own setup, so a cause confined to one file is never
+ * this. Across {@link UNIVERSAL_CAUSE_FILES} files, on the other hand, whatever it is is a
+ * property of the run rather than of a page.
+ */
+export const UNIVERSAL_CAUSE_FILES = 3;
+/**
+ * Whether a repeating cause is failing the whole run — the one case where stopping it is the
+ * right call.
+ *
+ * The test is: the cause accounts for every failure the log names, it has hit
+ * {@link UNIVERSAL_CAUSE_FILES} spec files or more, and nothing has passed since its first
+ * failure. An app that is not up, a 5xx on every request, or a selector that is missing on every
+ * page all look like that, and every remaining test will fail the same way — so the run's
+ * remaining minutes measure nothing. Anything less is NOT this: a cause that stops at one file,
+ * or that leaves other tests passing, or that shares the run with failures of another shape,
+ * leaves the run with something to say, and the run is the only thing that will say it. X1
+ * flash-m83 (2026-10-16) stopped eight local runs at their first repeating cause over 14.5
+ * minutes and never finished one; three of its deploys each fixed a single cause that a finished
+ * run would have listed alongside the others.
+ *
+ * @param log - The log so far.
+ * @param found - The repeating cause {@link repeatingFailure} found in it.
+ * @returns The cause's count and files, or null when the run is not failing whole.
+ */
+export function universalCause(log, found) {
+    const text = log.replace(ANSI_SGR, '');
+    const files = [...new Set(found.tests.map((t) => specFile(t.where)).filter(Boolean))];
+    if (files.length < UNIVERSAL_CAUSE_FILES)
+        return null;
+    // Every failure the log names has to be this cause: another cause anywhere in the run means
+    // the run still has something to say, and stopping it throws that away.
+    const named = Math.max(distinctTests(failedTests(text)).length, distinctTests(failureBlockTests(text)).length);
+    if (found.count < named)
+        return null;
+    // And nothing may have passed since its first failure. A pass after it means the app answered
+    // a request, so a test that still fails the same way fails for a reason this run has not seen.
+    const marks = resultMarks(text);
+    const firstFailure = marks.indexOf('✘');
+    if (firstFailure === -1 || marks.slice(firstFailure).includes('✓'))
+        return null;
+    return { count: found.count, files };
+}
+/**
+ * Every failure a run names, grouped by the cause behind it — one group per cause, with the
+ * tests it hit.
+ *
+ * The point is that ONE run yields EVERY cause. A Playwright report prints its failures one
+ * after another with no statement of which of them share a cause, so a run of 19 failures is 19
+ * bodies to read; X1 flash-m83 (2026-10-16) spent three deploys (6.7 minutes) each fixing a
+ * single cause, two of them found by runs stopped before they walked the rest.
+ *
+ * The signature is the cause itself where the log carries the failures' bodies (a finished run,
+ * or a `line` reporter) — {@link failureMessage}: the error class plus the locator or the values
+ * that differ — and how long they took where it does not (a still-running `list` log, which is
+ * why a duration group is labelled as a duration and not as a proven cause). A test the log
+ * printed twice, or failed twice, is one test.
+ *
+ * @param log - The log of a finished or running run.
+ * @returns The causes, the one with the most tests first.
+ */
+export function failuresByCause(log) {
+    const text = log.replace(ANSI_SGR, '');
+    const byMessage = new Map();
+    for (const block of failureBlocks(text)) {
+        const message = failureMessage(block);
+        if (message === null)
+            continue;
+        const m = FAILURE_BLOCK_HEADER.exec(block.split('\n')[0] ?? '');
+        const { where, title } = splitTitlePath(m?.[1] ?? '');
+        const group = byMessage.get(message);
+        if (group)
+            group.push({ where, title, seconds: null });
+        else
+            byMessage.set(message, [{ where, title, seconds: null }]);
+    }
+    const causes = [];
+    for (const [message, members] of byMessage) {
+        const tests = distinctTests(members);
+        if (tests.length > 0)
+            causes.push({ message, seconds: null, tests });
+    }
+    // The failures with no body of their own — every failure of a still-running `list` log — are
+    // grouped by how long they took: a band is opened by its first test and takes the ones that
+    // then ran the same length, the same band {@link repeatingFailure} uses.
+    const claimed = new Set(causes.flatMap((c) => c.tests.map(testKey)));
+    const unclaimed = distinctTests(failedTests(text)).filter((t) => t.seconds !== null && !claimed.has(testKey(t)));
+    const byDuration = [];
+    for (const t of unclaimed) {
+        const band = Math.max(0.5, t.seconds * 0.05);
+        const open = byDuration.find((g) => Math.abs(g.seconds - t.seconds) <= Math.max(band, g.seconds * 0.05));
+        if (open)
+            open.tests.push(t);
+        else
+            byDuration.push({ seconds: t.seconds, tests: [t] });
+    }
+    for (const g of byDuration)
+        causes.push({ message: null, seconds: g.seconds, tests: g.tests });
+    return causes.sort((a, b) => b.tests.length - a.tests.length);
+}
+/**
+ * The one-line-per-cause summary of a finished run's failures, or null when the run named fewer
+ * than two of them.
+ *
+ * This is what makes a run worth finishing: every cause the run found, in the result the
+ * executor reads, so one round of fixes covers all of them rather than the one cause a run
+ * stopped early happened to reach.
+ *
+ * @param log - The finished run's output.
+ * @returns The note, or null.
+ */
+export function failureCausesNote(log) {
+    const causes = failuresByCause(log);
+    const total = causes.reduce((n, c) => n + c.tests.length, 0);
+    if (total < 2)
+        return null;
+    const listed = causes.slice(0, FAILURE_CAUSES_LISTED);
+    const lines = listed.map((c, i) => {
+        // The path the log itself wrote, never a shortened one: it is relative to the command's own
+        // cwd, so it is the form the executor can paste back (X1 flash-m82 read a shortened
+        // `e2e/auth.spec.ts:19` as the suite's own stale starter spec, rewrote its Playwright config
+        // over it and deleted the app's tests — 4 minutes of a 60-minute run on a working config).
+        const tests = c.tests.slice(0, FAILURE_CAUSE_TESTS_LISTED).map((t) => t.where || t.title);
+        const more = c.tests.length > tests.length ? `, … and ${c.tests.length - tests.length} more` : '';
+        const signature = c.message !== null
+            ? `\`${c.message}\``
+            : `each after ~${c.seconds}s (a shared duration, not a proven cause)`;
+        const files = new Set(c.tests.map((t) => specFile(t.where)).filter(Boolean)).size;
+        return (`  ${i + 1}. ${signature} — ${c.tests.length} test${c.tests.length === 1 ? '' : 's'} ` +
+            `in ${files} file${files === 1 ? '' : 's'}: ${tests.join(', ')}${more}`);
+    });
+    const moreCauses = causes.length > listed.length ? `\n  … and ${causes.length - listed.length} more causes` : '';
+    return (`${total} failure${total === 1 ? '' : 's'} in this run, grouped by cause — fix every cause ` +
+        `below before the next deploy:\n${lines.join('\n')}${moreCauses}`);
 }
 /**
- * The sentence that names a cause repeating among a running suite's failures, and the command
- * that stops the run so the cause can be fixed first.
+ * The sentence that names a cause repeating among a running suite's failures, mid-run.
  *
  * Kept here, beside {@link repeatingFailure}, so the two stay in step: every word below is about
- * what that function could actually see in the log.
+ * what that function could actually see in the log — including the count, which is of DISTINCT
+ * tests, so the note never names one or two tests as a cause.
+ *
+ * The note names the cause early so the executor can START FIXING while the run keeps walking,
+ * and it asks for the run to be stopped only when {@link universalCause} says the cause is
+ * failing the whole run. X1 flash-m76 (2026-10-16) spent 4.0 minutes walking 15 tests whose one
+ * cause was certain at the third, 47 s in, and the note answers exactly that; X1 flash-m83 then
+ * stopped eight runs at their first repeating cause in 14.5 minutes and never finished one, so
+ * the note must not say to stop when the run still has other causes to name.
  *
  * @param found - What {@link repeatingFailure} found.
- * @param o - The run's facts: its `taskId`, its `log` path, and `stop` — the shell command that
- *   stops it (the pids the platform's own pid file leads to).
+ * @param o - The run's facts: its `taskId`, its `log` path, `stop` — the shell command that
+ *   stops it, printed only for a {@link UniversalCause} — and `universal`, what
+ *   {@link universalCause} found (absent means the run is not failing whole).
  * @returns The note.
  */
 export function repeatingFailureNote(found, o) {
     const listed = found.tests.slice(0, REPEATING_FAILURE_LISTED);
+    // Every row names its test by the SAME path the re-run hint below uses (`shortWhere`
+    // would print this one file under two names: X1 flash-m82 read `✘ e2e/auth.spec.ts:19`
+    // here against `Re-run fixtures/realworld/specs/e2e/auth.spec.ts:19 alone` three lines
+    // down, took the suite-relative form for "the project's own stale starter spec" and
+    // rewrote its Playwright config over it, deleted the app's tests and wrote its own —
+    // 4 minutes of a 60-minute run, on a run whose config was right). The path the log
+    // wrote is relative to the command's own cwd, so it is the one the executor can paste
+    // back into a command.
     const rows = listed
-        .map((t) => `  ✘ ${[t.where && shortWhere(t.where), t.title].filter(Boolean).join(' › ')}` +
+        .map((t) => `  ✘ ${[t.where, t.title].filter(Boolean).join(' › ')}` +
         (t.seconds === null ? '' : ` (${t.seconds}s)`))
         .join('\n');
     const more = found.count > listed.length ? `\n  … and ${found.count - listed.length} more` : '';
-    const signature = found.message !== null
+    // Two signatures, and only ONE of them is a cause. An error repeating verbatim is the cause
+    // itself; a duration repeating is what a suite's own `actionTimeout` does to every failure that
+    // waits for anything, so the note must not call it one cause (X1 flash-m84, 2026-10-16: four
+    // failures at 6.8-7.4 s, four different missing elements, and this sentence told the executor
+    // "one cause is repeating").
+    const isCause = found.message !== null;
+    const signature = isCause
         ? `every one with \`${found.message}\``
         : `each after ~${found.seconds}s — the same duration to within half a second`;
     const first = found.tests[0];
@@ -1263,10 +1751,33 @@ export function repeatingFailureNote(found, o) {
         : first?.where
             ? ` Re-run \`${first.where}\` alone to see its error in full.`
             : '';
-    return (`${found.count} of this run’s tests have already failed the same way — ${signature} — so one ` +
-        `cause is repeating and the rest of the run only repeats it:\n${rows}${more}\n` +
-        `Stop this run and fix that cause before the rest: \`exec_command: ${o.stop}\`. ` +
-        `It is still going (task ${o.taskId}, log ${o.log}) — do not wait for the rest of it.${reproduce}`);
+    const where = `task ${o.taskId}, log ${o.log}`;
+    if (o.universal) {
+        const files = o.universal.files.map(shortFile);
+        const shown = files.slice(0, 4).join(', ');
+        const moreFiles = files.length > 4 ? `, … and ${files.length - 4} more` : '';
+        return (`Every test this run has walked so far has failed the same way — all ${found.count} of ` +
+            `them, ${signature} — across ${files.length} files (${shown}${moreFiles}), with nothing ` +
+            `passing since the first:\n${rows}${more}\n` +
+            `Every remaining test will fail the same way too, so walking the rest of this run only ` +
+            `repeats this one cause. Stop it and fix that cause first: \`exec_command: ${o.stop}\`, ` +
+            `then run the whole suite again. It is still going (${where}).${reproduce}`);
+    }
+    const keepGoing = `Let the rest of the run finish — it is the only thing that will name the causes that are NOT ` +
+        `this one, and a run stopped at its first repeating cause costs a second whole run to find ` +
+        `them. Stop it only if every test it walks fails this same way (the app unreachable, a 5xx on ` +
+        `every request, the same selector timing out on every test of every file so far). ` +
+        `It is still going (${where}).`;
+    if (isCause)
+        return (`${found.count} different tests in this run have already failed the same way — ${signature} — ` +
+            `so one cause is repeating:\n${rows}${more}\n` +
+            `Start fixing it now, while the run keeps walking.${reproduce} ${keepGoing}`);
+    return (`${found.count} different tests in this run each failed after ~${found.seconds}s — the same ` +
+        `duration to within half a second. A shared duration is a lead, not a cause: a suite whose ` +
+        `config sets a timeout spends that timeout on every failure that waits for anything, so ` +
+        `different missing elements land on the same number. Read these failures before fixing one ` +
+        `of them:\n${rows}${more}\n` +
+        `Start on them now, while the run keeps walking.${reproduce} ${keepGoing}`);
 }
 /**
  * Attempt a whitespace-tolerant replacement when an exact `old_string` match