@molecule/api-ai-tools 1.5.19 → 1.6.0

package/dist/tools.js

@@ -161,7 +161,7 @@ function waitProgressNote(o) {
     const sentence = parts.join('; ');
     return ` ${sentence[0].toUpperCase()}${sentence.slice(1)}.`;
 }
-import { checkBlockedCommand, declaredBudgetSeconds, DEFAULT_SEARCH_EXCLUDED_DIRS, directoryReadHint, findPatternArgs, fusedLine, htmlOutline, isEnvFilePath, isOutsideRoot, isValidGlob, MAX_BATCH_READ_BYTES, MAX_BATCH_READ_FILES, MAX_FIND_RESULTS, MAX_HTML_INLINE_CHARS, MAX_OUTPUT_SIZE, MAX_READ_RETURN_CHARS, MAX_READ_SIZE, MAX_SEARCH_CONTEXT_LINES, MAX_SEARCH_RESULTS, MAX_WRITE_SIZE, outputIsWithheldUntilExit, outputRedirectTarget, parseCheckCommand, parseCheckProblem, pathArgError, printsOnlySource, redactSecrets, redactSecretsInCode, repeatingFailure, repeatingFailureNote, resolvePath, RUNNING_FAILURE_LINES, runningCauseCommand, runningOutputSliceCommand, shellQuote, sliceLines, SMALL_FILE_WHOLE_CHARS, streamingBackgroundCommand, stripControlChars, suiteRunPriorityLaunch, truncateMiddle, whitespaceTolerantReplace, } from './utilities.js';
+import { checkBlockedCommand, declaredBudgetSeconds, DEFAULT_SEARCH_EXCLUDED_DIRS, directoryReadHint, failureCausesNote, findPatternArgs, fusedLine, htmlOutline, isEnvFilePath, isOutsideRoot, isPlaywrightRunCommand, isValidGlob, linesWithinSerialized, MAX_BATCH_READ_FILES, MAX_FIND_RESULTS, MAX_HTML_INLINE_CHARS, MAX_OUTPUT_SIZE, MAX_READ_CALL_CHARS, MAX_READ_RETURN_CHARS, MAX_READ_SIZE, MAX_SEARCH_CONTEXT_LINES, MAX_SEARCH_RESULTS, MAX_WRITE_SIZE, outputIsWithheldUntilExit, outputRedirectTarget, parseCheckCommand, parseCheckProblem, pathArgError, printsOnlySource, READ_RESULT_ENVELOPE_CHARS, redactSecrets, redactSecretsInCode, repeatingFailure, repeatingFailureNote, resolvePath, RUNNING_FAILURE_LINES, runningCauseCommand, runningOutputSliceCommand, serializedChars, shellQuote, sliceLines, SMALL_FILE_WHOLE_CHARS, streamingBackgroundCommand, stripControlChars, suiteRunPriorityLaunch, truncateMiddle, universalCause, whitespaceTolerantReplace, } from './utilities.js';
 /**
  * How long exec_command waits for a command it backgrounded only because the
  * command asked for more than the tool's ceiling, before handing back a task id.
@@ -488,36 +488,22 @@ export function buildTools(backend, config) {
      * listing, ENOENT parent listing, empty-read classification). Shared by the
      * single-path and batched forms of the tool.
      *
-     * @param rawPath - The path as the model sent it.
-     * @returns The same result shape read_file returns for one file.
-     */
-    /**
-     * How many leading lines of a file fit in a char budget.
-     *
-     * @param content - The file text.
-     * @param chars - The budget in chars.
-     * @returns The line count, at least one.
-     */
-    function linesWithin(content, chars) {
-        let used = 0;
-        let lines = 0;
-        for (const line of content.split('\n')) {
-            used += line.length + 1;
-            if (used > chars && lines > 0)
-                break;
-            lines++;
-        }
-        return Math.max(1, lines);
-    }
-    /**
-     * Read one file for the model: symlink-checked, size-bounded, optionally
-     * windowed by line, and never more than MAX_READ_RETURN_CHARS at once.
+     * Symlink-checked, size-bounded, optionally windowed by line, and never more
+     * than `ceiling` SERIALIZED chars at once (a window of raw text grows by its
+     * own newlines once the result is JSON — see {@link serializedChars}).
      *
      * @param rawPath - The path as the model sent it.
      * @param window - Optional `offset`/`limit` in lines.
+     * @param ceiling - The most this read may return, in serialized chars
+     *   ({@link MAX_READ_RETURN_CHARS} when the call has the whole result to
+     *   itself; a batched call passes what it has left, so the read stops short of
+     *   the request-side cut instead of being cut by it). A read that comes back
+     *   short carries `truncated: true`, which is how the batch tells a whole file
+     *   from a window of one.
      * @returns The file content (or a window of it) or a model-readable error.
      */
-    async function readOneFile(rawPath, window) {
+    async function readOneFile(rawPath, window, ceiling) {
+        const maxChars = ceiling ?? MAX_READ_RETURN_CHARS;
         const argErr = pathArgError(rawPath, 'read_file');
         if (argErr)
             return { error: argErr };
@@ -589,8 +575,8 @@ export function buildTools(backend, config) {
             // No window asked for and the file is bigger than one call should hand
             // back: return its first window, sized to the ceiling, and say so. The
             // model can read on with offset/limit; it cannot un-send 300k tokens.
-            const effectiveWindow = !sliceLines(content, window) && content.length > MAX_READ_RETURN_CHARS
-                ? { offset: 1, limit: linesWithin(content, MAX_READ_RETURN_CHARS) }
+            const effectiveWindow = !sliceLines(content, window) && serializedChars(content) > maxChars
+                ? { offset: 1, limit: linesWithinSerialized(content, maxChars) }
                 : window;
             // A SECOND window of the same small file: hand back all of it (one window is a targeted read). X1 flash-m50 paged files that fit in one
             // call 13 times in a row, each window answered with "read it again with no offset/limit".
@@ -606,7 +592,7 @@ export function buildTools(backend, config) {
             if (small?.truncated &&
                 pagedBefore &&
                 !sentWhole &&
-                content.length <= SMALL_FILE_WHOLE_CHARS) {
+                serializedChars(content) <= Math.min(SMALL_FILE_WHOLE_CHARS, maxChars)) {
                 wholeReturned.set(path, content);
                 return noted({
                     path,
@@ -625,6 +611,10 @@ export function buildTools(backend, config) {
                     offset: windowed.offset,
                     lines: windowed.lines,
                     totalLines: windowed.totalLines,
+                    // What the model has is PART of the file. Named on the result, not only
+                    // in the note: a batched read keeps whole files and lists the rest, and
+                    // this is how it tells the two apart (see the `paths` branch).
+                    ...(windowed.truncated ? { truncated: true } : {}),
                     // The note decides the executor's next call. Observed (X0 run x7): a
                     // 44 KB README read as seven 300-line windows, one round trip each,
                     // because the note only ever said "read another window" — when the
@@ -635,7 +625,7 @@ export function buildTools(backend, config) {
                             note: sentWhole
                                 ? `Lines ${windowed.offset}-${windowed.offset + windowed.lines - 1} of ${windowed.totalLines}; ` +
                                     'the whole file, unchanged, was returned earlier in this conversation.'
-                                : content.length <= MAX_READ_RETURN_CHARS
+                                : serializedChars(content) <= MAX_READ_RETURN_CHARS
                                     ? `Lines ${windowed.offset}-${windowed.offset + windowed.lines - 1} of ` +
                                         `${windowed.totalLines}. The whole file is ${Math.round(content.length / 1024)} KB ` +
                                         `and fits in ONE call — read it again with no offset/limit instead of paging.`
@@ -759,28 +749,86 @@ export function buildTools(backend, config) {
                     };
                 }
                 const files = [];
-                let budget = MAX_BATCH_READ_BYTES;
-                let stoppedAt = null;
+                // The paths this call does NOT return, in request order, each with the
+                // reason it is missing. Never a partial file in their place: a batch
+                // that broke off mid-file is what MAX_READ_CALL_CHARS exists to stop —
+                // the request side cuts a longer block through its middle, between two
+                // `"content"` values, so whole files vanish and the note says only
+                // "N characters cut here" (X0 flash-m81).
+                const notReturned = [];
+                const explicitWindow = input.offset !== undefined || input.limit !== undefined;
+                // Every entry names its file the way a returned entry does — resolved —
+                // so a path out of this list can go straight back into the next call.
+                const missing = (requestedPath, reason) => {
+                    notReturned.push({ path: resolve(requestedPath), reason });
+                };
                 for (const [index, requestedPath] of requested.entries()) {
-                    if (index >= MAX_BATCH_READ_FILES || budget <= 0) {
-                        stoppedAt = requestedPath;
-                        break;
+                    if (index >= MAX_BATCH_READ_FILES) {
+                        missing(requestedPath, 'count');
+                        continue;
+                    }
+                    // What this file's read may still carry: the call's ceiling less the
+                    // envelope, which has to hold the note and one entry per missing path.
+                    const room = MAX_READ_CALL_CHARS - JSON.stringify(files).length - READ_RESULT_ENVELOPE_CHARS;
+                    if (room <= 0) {
+                        missing(requestedPath, 'budget');
+                        continue;
+                    }
+                    const one = (await readOneFile(requestedPath, input, room));
+                    // A window is not a batch entry. It is returned only when the caller
+                    // asked for a window, or when the FIRST file alone is bigger than the
+                    // whole call — then a window with its own offset/limit note is the only
+                    // answer available, and everything after it is listed anyway.
+                    if (one.truncated === true && !explicitWindow && files.length > 0) {
+                        missing(requestedPath, 'budget');
+                        continue;
                     }
-                    const one = (await readOneFile(requestedPath, input));
                     files.push(one);
-                    if (typeof one.content === 'string')
-                        budget -= one.content.length;
                 }
-                return {
-                    files,
-                    ...(stoppedAt
-                        ? {
-                            note: `Stopped after ${files.length} of ${requested.length} files (limit: ${MAX_BATCH_READ_FILES} ` +
-                                `files or ${Math.round(MAX_BATCH_READ_BYTES / 1024)}KB per call). Call read_file again ` +
-                                `starting at ${stoppedAt}.`,
-                        }
-                        : {}),
+                const entryError = (reason) => reason === 'count'
+                    ? `not returned: one read_file call returns at most ${MAX_BATCH_READ_FILES} files. Read this file in its own read_file call.`
+                    : `not returned: this call goes in order and has reached the ${Math.round(MAX_READ_CALL_CHARS / 1024)} KB one read_file result carries. Read this file in its own read_file call.`;
+                const build = (returned) => {
+                    let returnedChars = 0;
+                    let windowed = 0;
+                    for (const f of returned) {
+                        const entry = f;
+                        if (typeof entry.content === 'string')
+                            returnedChars += entry.content.length;
+                        if (entry.truncated === true)
+                            windowed++;
+                    }
+                    const size = `${Math.round(returnedChars / 1024)} KB of the ` +
+                        `${Math.round(MAX_READ_CALL_CHARS / 1024)} KB one read_file result carries`;
+                    return {
+                        files: [
+                            ...returned,
+                            ...notReturned.map(({ path, reason }) => ({ path, error: entryError(reason) })),
+                        ],
+                        ...(notReturned.length
+                            ? {
+                                note: (windowed > 0
+                                    ? `Returned ${returned.length} of ${requested.length} files (${size}); the ` +
+                                        `${windowed} marked truncated is a first window — its own note names the next one. `
+                                    : `Returned whole: ${returned.length} of ${requested.length} files (${size}). `) +
+                                    'Not returned — read these next, in this order, in further read_file calls: ' +
+                                    `${notReturned.map((n) => n.path).join(', ')}.`,
+                            }
+                            : {}),
+                    };
                 };
+                let result = build(files);
+                // The envelope is measured, not estimated: if the note and the entries for
+                // the missing paths take more than their share, whole files — from the end
+                // — move to the missing list until the result fits.
+                while (notReturned.length > 0 &&
+                    files.length > 0 &&
+                    JSON.stringify(result).length > MAX_READ_CALL_CHARS) {
+                    const last = files.pop();
+                    notReturned.unshift({ path: String(last?.path ?? ''), reason: 'budget' });
+                    result = build(files);
+                }
+                return result;
             }
             return readOneFile(input.path, input);
         },
@@ -1371,12 +1419,15 @@ export function buildTools(backend, config) {
             // declaring a budget too: a suite routinely outlasts the ceiling, and killed there
             // behind `| tail` it returns nothing (X1 flash-m29 lost a 290 s run that way).
             // A short one still comes back as a foreground result, through the grace below.
+            // A Playwright command that runs no test is not one of these either: `playwright test
+            // --list` piped through `tail` takes two seconds, and backgrounding it costs the round
+            // trip `wait_for_task` owes the executor (flash-m79's config check).
             const overCeiling = commandBudgetMs !== undefined &&
                 ((outputIsWithheldUntilExit(command) &&
-                    (declaredSeconds > ceilingSeconds || /\bplaywright\s+test\b/.test(command))) ||
+                    (declaredSeconds > ceilingSeconds || isPlaywrightRunCommand(command))) ||
                     // A redirected Playwright run shows nothing either (`> out.txt`), and was killed at
                     // the ceiling with 38 tests unrun (X1 flash-m36).
-                    (/\bplaywright\s+test\b/.test(command) && outputRedirectTarget(command) !== null));
+                    (isPlaywrightRunCommand(command) && outputRedirectTarget(command) !== null));
             if (input.run_in_background === true || overCeiling) {
                 const id = `mol-bg-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
                 const log = `/tmp/${id}.log`;
@@ -1695,7 +1746,11 @@ export function buildTools(backend, config) {
             // from the finished log: X1 flash-m76 waited out 4.0 minutes of 15 tests where every
             // failure was the same `TimeoutError: page.waitForURL` from one missing `navigate('/')`,
             // and then fixed it in 51 s. The task is NOT stopped — the executor is handed the cause and
-            // its own pid command and decides.
+            // decides, and the note tells it to let the run finish because the run's other causes only
+            // surface in it (X1 flash-m83 stopped eight runs at their first repeating cause and never
+            // finished one). Only a cause that is failing the WHOLE run — every failure sharing it,
+            // across `UNIVERSAL_CAUSE_FILES` files or more, with nothing passing since the first —
+            // comes with a stop command.
             let lastCauseLookAt = startedAt - repeatingCauseLookMs();
             let exitCode = await readExit();
             while (exitCode === null && Date.now() - startedAt < budgetMs) {
@@ -1724,6 +1779,9 @@ export function buildTools(backend, config) {
                 const found = repeatingFailure(causeLog);
                 if (!found)
                     continue;
+                // Only a cause that is failing the whole run gets a stop command — and only then is the
+                // pid walk paid for.
+                const universal = universalCause(causeLog, found);
                 repeatingCauseNoted.add(taskId);
                 const earlyMs = Date.now() - startedAt;
                 waitedByTask.set(taskId, waitedBefore + earlyMs);
@@ -1734,7 +1792,8 @@ export function buildTools(backend, config) {
                     note: repeatingFailureNote(found, {
                         taskId,
                         log,
-                        stop: await taskStopCommand(backend, taskId),
+                        stop: universal ? await taskStopCommand(backend, taskId) : '',
+                        universal,
                     }),
                 };
             }
@@ -1834,12 +1893,20 @@ export function buildTools(backend, config) {
                     // The file is gone or unreadable: the task log is the whole result, as before.
                 }
             }
+            // Every cause a finished run found, one line each, so ONE round of fixes covers all of
+            // them. A Playwright report prints its failures in sequence with nothing saying which of
+            // them share a cause, so a run's other causes are read only by reading every failure: X1
+            // flash-m83 (2026-10-16) spent three deploys (6.7 minutes) each fixing a single cause, and
+            // the second and third were found by runs stopped before they walked the rest. Null for
+            // anything that is not a run with failures in it.
+            const causes = failureCausesNote(output);
             // Same shaping as a foreground exec result, so the executor reads both
             // the same way.
             return {
                 taskId,
                 exitCode,
                 waitedMs,
+                ...(causes ? { note: causes } : {}),
                 stdout: sanitizeOutput(truncateMiddle(output, MAX_OUTPUT_SIZE)),
                 ...(output.length > MAX_OUTPUT_SIZE ? { truncated: true, fullOutput: log } : {}),
             };

package/dist/utilities.d.ts

@@ -122,21 +122,22 @@ export declare function outputRedirectTarget(command: string): string | null;
  *   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('/')`.
- *
- * Only the command's last step is touched, and only its reporter.
+ *   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
+ * neither reporter nor `--retries=0` is added to it ({@link isPlaywrightRunCommand}).
  *
  * @param command - The command as the executor sent it.
  * @returns The command to run and one sentence per change made (empty when none).
@@ -149,10 +150,30 @@ export declare function streamingBackgroundCommand(command: string): {
  * Whether a command runs a whole test suite — a Playwright, Vitest or Hurl run
  * — rather than a build, an install or a one-off script.
  *
+ * A command that invokes a runner only to print is not one of these
+ * ({@link commandRunsNoTests}): `npx playwright test --list` prints the tests it would run and
+ * exits, and `npx playwright install`, `vitest list` and `hurl --help` start no test either.
+ *
  * @param command - The shell command.
  * @returns True when the command starts one of those runners.
  */
 export declare function isSuiteRunCommand(command: string): boolean;
+/**
+ * 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 declare function isPlaywrightRunCommand(command: string): boolean;
 /**
  * Start a background suite run at lower CPU and IO priority, so the sandbox it
  * shares with everything else stays responsive to what the executor does next.
@@ -311,29 +332,79 @@ export declare function sliceLines(content: string, window?: {
     totalLines: number;
     truncated: boolean;
 } | null;
-/** 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 declare function serializedChars(text: string): number;
+/**
+ * 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 declare function linesWithinSerialized(content: string, chars: number): number;
 /**
  * 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 declare 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 declare const MAX_BATCH_READ_BYTES: number;
+export declare const MAX_READ_CALL_CHARS = 60000;
+/**
+ * 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 declare const READ_RESULT_ENVELOPE_CHARS = 1000;
 /**
  * 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 declare const MAX_READ_RETURN_CHARS: number;
 /**
@@ -468,7 +539,10 @@ export declare const REPEATING_CAUSE_TAIL_BYTES = 40000;
  * @returns The shell command, safe to hand to the execution backend as-is.
  */
 export declare function runningCauseCommand(log: string, own?: string): string;
-/** 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 declare const REPEATING_FAILURE_MIN = 3;
 /** One failed test, as a running suite's log names it. */
 export interface FailedTest {
@@ -481,13 +555,16 @@ export interface FailedTest {
 }
 /** A cause repeating among a running suite's failures. */
 export interface RepeatingFailure {
-    /** How many failures share the signature. */
+    /**
+     * How many DISTINCT tests share the signature — a test printed twice (two reporters in the
+     * log) or failed twice (a retry) is one test.
+     */
     count: number;
     /** The shared error line, when the log carries the failures' bodies (`line` reporter). */
     message: string | null;
     /** The shared duration in seconds, when the failures line up by how long they ran. */
     seconds: number | null;
-    /** The failures that share it, in log order. */
+    /** The distinct tests that share it, in log order. */
     tests: FailedTest[];
 }
 /**
@@ -495,39 +572,131 @@ export interface RepeatingFailure {
  *
  * 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 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.
  *
  * 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 declare function repeatingFailure(log: string): RepeatingFailure | null;
 /** How many of a repeating cause's failures the note lists before it says "and N more". */
 export declare const REPEATING_FAILURE_LISTED = 5;
+/** How many causes a finished run's summary lists before it says "and N more". */
+export declare const FAILURE_CAUSES_LISTED = 5;
+/** How many of one cause's tests that summary names before it says "and N more". */
+export declare const FAILURE_CAUSE_TESTS_LISTED = 6;
+/**
+ * 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 declare const UNIVERSAL_CAUSE_FILES = 3;
+/** A repeating cause that is failing the WHOLE run — see {@link universalCause}. */
+export interface UniversalCause {
+    /** How many distinct tests share it. */
+    count: number;
+    /** The distinct spec files they live in, in the order the log named them. */
+    files: string[];
+}
+/**
+ * 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 declare function universalCause(log: string, found: RepeatingFailure): UniversalCause | null;
+/** One cause of failure in a run, and the tests it hit. */
+export interface FailureCause {
+    /** The error line its tests all reported, or null when only the duration ties them together. */
+    message: string | null;
+    /** The duration they shared in seconds, or null when the error line is the signature. */
+    seconds: number | null;
+    /** The distinct tests it hit, in the order the log named them. */
+    tests: FailedTest[];
+}
+/**
+ * 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 failures' own error line where the log carries their bodies (a finished
+ * run, or a `line` reporter), and how long they took where it does not (a still-running `list`
+ * log). 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 declare function failuresByCause(log: string): FailureCause[];
 /**
- * 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 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 declare function failureCausesNote(log: string): string | null;
+/**
+ * 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 declare function repeatingFailureNote(found: RepeatingFailure, o: {
     taskId: string;
     log: string;
     stop: string;
+    universal?: UniversalCause | null;
 }): string;
 /**
  * Attempt a whitespace-tolerant replacement when an exact `old_string` match

package/dist/utilities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utilities.d.ts","sourceRoot":"","sources":["../src/utilities.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"utilities.d.ts","sourceRoot":"","sources":["../src/utilities.ts"],"names":[],"mappings":"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"}