@molecule/api-ai-tools 1.6.6 → 1.7.0

package/dist/trace-artifacts.js

@@ -0,0 +1,467 @@
+/**
+ * What a failed Playwright run's own trace files say about the requests its page made — read
+ * headlessly, in the sandbox, from the `trace.zip` files the run left behind.
+ *
+ * X1 xr-molecule-flash-m100 (+51:19 → +53:00, 2026-10-16) ended with three failures against the
+ * deployed URL — `social.spec.ts:22` and `:153` waited for a "Unfollow" button that never appeared
+ * after the click, and `url-navigation.spec.ts:234` was bounced to `/login` mid-test — and nothing
+ * in the run's result said why. The app's own `toggleFollow` swallowed the error of its request
+ * with a bare `catch` and a comment, so the page showed nothing; the ONE artifact
+ * that held the answer, the failing tests' own traces, was never read. The executor spent the
+ * last minutes of the run writing throwaway Chromium probes against localhost — where the same
+ * tests passed — and finished chasing an artifact of its own probe
+ * (`waitForURL('/')` resolved against a `baseURL` its script did not have).
+ *
+ * A trace is not a debugging aid that has to be enabled by hand: Playwright writes the request
+ * log and the console into `test-results/<test>/trace.zip` whenever a run retains traces, and the
+ * evidence a swallowed failure hides is exactly one line of it — `POST /api/articles/x/favorite →
+ * 401`. So the platform reads it (bounded, per test) and puts it in the run's result
+ * ({@link failureTraceNote}), instead of leaving the executor to build its own browser to find out.
+ *
+ * Everything here is text in, text out: the sandbox runs {@link traceArtifactsScript} (Node, no
+ * dependencies — Playwright's zip reader is not importable from a project) and prints one
+ * `TRACE <json>` line per trace; the platform parses those lines ({@link parseTraceArtifacts}) and
+ * writes the note ({@link failureTraceNote}). Both halves are covered by a test that runs the
+ * script against a `trace.zip` produced by a real Playwright run, in the sandbox's own shape.
+ *
+ * @module
+ */
+import { isDiagnosisRun } from './suite-overlap.js';
+import { isPlaywrightRunCommand } from './utilities.js';
+/** How many traces one read reports, newest first. */
+export const MAX_TRACE_ARTIFACTS = 12;
+/** How many requests one test's trace contributes. */
+export const MAX_TRACED_REQUESTS = 6;
+/** How many console errors one test's trace contributes. */
+export const MAX_TRACED_CONSOLE = 4;
+/** How many tests the note in a run's result names. */
+export const MAX_TRACE_NOTE_TESTS = 5;
+/** How many requests the note names per test. */
+export const MAX_TRACE_NOTE_REQUESTS = 4;
+/** How long a URL the note prints, before the middle is cut. */
+export const TRACE_NOTE_URL_CHARS = 96;
+/**
+ * The Node program the sandbox runs to read a failed run's traces: `node <script> <dir>` prints one
+ * `TRACE <json>` line per `trace.zip` under `<dir>` (newest first, {@link MAX_TRACE_ARTIFACTS} of
+ * them), each with the test it belongs to, the requests its page made and its console errors.
+ *
+ * It is a standalone program, not an import, for the reason `@molecule/api-code-sandbox` runs it:
+ * Playwright's own zip reader is not reachable from a project's `node_modules`, and a dependency
+ * on `unzip` would make the read fail on every sandbox that has none. The zip is read with the
+ * central directory and `zlib.inflateRawSync` — about forty lines, and the only thing that has to
+ * be true of a `trace.zip` is that it IS one.
+ *
+ * A request is kept over a static asset when it failed (`status >= 400`) or never answered
+ * (`status === 0`), and over anything else when it is the page talking to the app
+ * (`fetch`/`xhr`/`document`): a failing test's trace holds the whole page load, and the answer is
+ * always at the end of it.
+ *
+ * @returns The program's source, to write to a file and run.
+ */
+export const traceArtifactsScript = () => `
+const fs = require('node:fs')
+const path = require('node:path')
+const zlib = require('node:zlib')
+
+const ROOT = process.argv[2] || '/workspace'
+const MAX_TRACES = ${MAX_TRACE_ARTIFACTS}
+const MAX_REQUESTS = ${MAX_TRACED_REQUESTS}
+const MAX_CONSOLE = ${MAX_TRACED_CONSOLE}
+const MAX_URL = 200
+
+function walk(dir, depth, out) {
+  if (depth < 0) return
+  let entries
+  try { entries = fs.readdirSync(dir, { withFileTypes: true }) } catch (e) { return }
+  for (const entry of entries) {
+    if (entry.name === 'node_modules' || entry.name === '.git') continue
+    const full = path.join(dir, entry.name)
+    if (entry.isDirectory()) { walk(full, depth - 1, out); continue }
+    if (entry.name !== 'trace.zip') continue
+    let mtime = 0
+    try { mtime = fs.statSync(full).mtimeMs } catch (e) { mtime = 0 }
+    out.push({ file: full, mtime: mtime })
+  }
+}
+
+function zipEntries(buf) {
+  let eocd = -1
+  const floor = Math.max(0, buf.length - 66000)
+  for (let i = buf.length - 22; i >= floor; i--) {
+    if (buf.readUInt32LE(i) === 0x06054b50) { eocd = i; break }
+  }
+  if (eocd === -1) return []
+  const count = buf.readUInt16LE(eocd + 10)
+  let at = buf.readUInt32LE(eocd + 16)
+  const out = []
+  for (let n = 0; n < count; n++) {
+    if (at + 46 > buf.length || buf.readUInt32LE(at) !== 0x02014b50) break
+    const nameLen = buf.readUInt16LE(at + 28)
+    const extraLen = buf.readUInt16LE(at + 30)
+    const commentLen = buf.readUInt16LE(at + 32)
+    out.push({
+      name: buf.toString('utf8', at + 46, at + 46 + nameLen),
+      method: buf.readUInt16LE(at + 10),
+      size: buf.readUInt32LE(at + 20),
+      at: buf.readUInt32LE(at + 42),
+    })
+    at += 46 + nameLen + extraLen + commentLen
+  }
+  return out
+}
+
+function zipData(buf, entry) {
+  const at = entry.at
+  if (at + 30 > buf.length || buf.readUInt32LE(at) !== 0x04034b50) return null
+  const start = at + 30 + buf.readUInt16LE(at + 26) + buf.readUInt16LE(at + 28)
+  const raw = buf.subarray(start, start + entry.size)
+  if (entry.method === 0) return raw
+  if (entry.method === 8) { try { return zlib.inflateRawSync(raw) } catch (e) { return null } }
+  return null
+}
+
+function ndjson(buf) {
+  const out = []
+  if (!buf) return out
+  for (const line of buf.toString('utf8').split('\\n')) {
+    if (!line) continue
+    try { out.push(JSON.parse(line)) } catch (e) { /* a partial final line */ }
+  }
+  return out
+}
+
+function messageOf(value) {
+  let at = value
+  for (let i = 0; i < 4 && at && typeof at === 'object'; i++) {
+    if (typeof at.message === 'string') return at.message
+    at = at.error
+  }
+  return null
+}
+
+let origin = ''
+function pathOf(url) {
+  try {
+    const parsed = new URL(url)
+    return parsed.origin === origin ? parsed.pathname + parsed.search : url
+  } catch (e) { return url }
+}
+function originOf(url) {
+  try { return new URL(url).origin } catch (e) { return '' }
+}
+const SUITE_DIRS = ['e2e', 'specs', 'tests', 'test', '__tests__']
+function specPathOf(file) {
+  const parts = file.split('/')
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (SUITE_DIRS.indexOf(parts[i]) !== -1) return parts.slice(i).join('/')
+  }
+  const rel = path.relative(ROOT, file)
+  return rel && rel.slice(0, 2) !== '..' ? rel : file
+}
+
+const found = []
+walk(ROOT, 5, found)
+found.sort(function (a, b) { return b.mtime - a.mtime })
+
+for (const one of found.slice(0, MAX_TRACES)) {
+  let buf
+  try { buf = fs.readFileSync(one.file) } catch (e) { continue }
+  let entries
+  try { entries = zipEntries(buf) } catch (e) { continue }
+  const network = []
+  const trace = []
+  for (const entry of entries) {
+    if (/\\.network$/.test(entry.name)) network.push.apply(network, ndjson(zipData(buf, entry)))
+    else if (/\\.trace$/.test(entry.name)) trace.push.apply(trace, ndjson(zipData(buf, entry)))
+  }
+  const requests = []
+  for (const line of network) {
+    if (!line || line.type !== 'resource-snapshot') continue
+    const snapshot = line.snapshot || {}
+    const request = snapshot.request || {}
+    if (!request.url || !request.method) continue
+    const response = snapshot.response || {}
+    const type = String(snapshot._resourceType || '')
+    if (!origin) origin = type === 'document' ? originOf(String(request.url)) : ''
+    requests.push({
+      method: String(request.method).toUpperCase(),
+      path: String(request.url).slice(0, MAX_URL),
+      status: Number(response.status) || 0,
+      type: type,
+    })
+  }
+  if (!origin) {
+    const first = requests.find(function (r) { return r.type === 'document' }) || requests[0]
+    origin = first ? originOf(first.path) : ''
+  }
+  for (const r of requests) r.path = pathOf(r.path).slice(0, MAX_URL)
+  const failing = []
+  const api = []
+  const rest = []
+  for (let i = 0; i < requests.length; i++) {
+    const r = requests[i]
+    if (r.status === 0 || r.status >= 400) failing.push(i)
+    else if (r.type === 'fetch' || r.type === 'xhr' || r.type === 'document') api.push(i)
+    else rest.push(i)
+  }
+  const keep = failing.slice(-MAX_REQUESTS).concat(api.slice(-MAX_REQUESTS)).concat(rest.slice(-2))
+  const chosen = []
+  const seen = new Set()
+  for (const i of keep.sort(function (a, b) {
+    const wrong = requests[a].status === 0 || requests[a].status >= 400 ? 0 : 1
+    const other = requests[b].status === 0 || requests[b].status >= 400 ? 0 : 1
+    return wrong === other ? a - b : wrong - other
+  })) {
+    const r = requests[i]
+    const key = r.method + ' ' + r.path + ' ' + r.status
+    if (seen.has(key)) continue
+    seen.add(key)
+    chosen.push({ method: r.method, path: r.path, status: r.status })
+  }
+  const consoleErrors = []
+  let spec = null
+  let line = 0
+  for (const entry of trace) {
+    if (!entry) continue
+    if (entry.type === 'console' && entry.messageType === 'error' && typeof entry.text === 'string')
+      consoleErrors.push(entry.text)
+    else if (entry.type === 'event' && entry.method === 'pageError') {
+      const message = messageOf(entry.params)
+      if (message) consoleErrors.push(message)
+    } else if (entry.type === 'before' && Array.isArray(entry.stack) && entry.stack.length) {
+      const frame = entry.stack[0] || {}
+      if (typeof frame.file === 'string' && /\\.(?:spec|test)\\.[cm]?[jt]sx?$/.test(frame.file)) {
+        spec = specPathOf(frame.file)
+        line = Number(frame.line) || 0
+      }
+    }
+  }
+  // Chromium reports every failed request as a console error too; where the page logged something
+  // of its own about it, that is the line worth reading.
+  const specific = consoleErrors.filter(function (text) { return !/^Failed to load resource/.test(text) })
+  const keptConsole = specific.length > 0 ? specific : consoleErrors
+  if (chosen.length === 0 && keptConsole.length === 0) continue
+  process.stdout.write('TRACE ' + JSON.stringify({
+    dir: path.relative(ROOT, path.dirname(one.file)),
+    spec: spec,
+    line: line,
+    requests: chosen.slice(-MAX_REQUESTS),
+    console: keptConsole.slice(0, MAX_CONSOLE).map(function (text) { return text.slice(0, 300) }),
+  }) + '\\n')
+}
+`;
+/**
+ * The traces {@link traceArtifactsScript} printed, parsed.
+ *
+ * A line that is not a complete `TRACE <json>` (a truncated read, a program that died mid-write) is
+ * dropped: a partial trace is not evidence about the test it came from.
+ *
+ * @param stdout - The program's output.
+ * @returns One entry per trace it printed.
+ */
+export function parseTraceArtifacts(stdout) {
+    const out = [];
+    for (const line of stdout.split('\n')) {
+        if (!line.startsWith('TRACE '))
+            continue;
+        try {
+            const raw = JSON.parse(line.slice('TRACE '.length));
+            const requests = Array.isArray(raw.requests) ? raw.requests : [];
+            const consoleMessages = Array.isArray(raw.console) ? raw.console : [];
+            out.push({
+                spec: typeof raw.spec === 'string' ? raw.spec : null,
+                line: typeof raw.line === 'number' ? raw.line : 0,
+                requests: requests
+                    .filter((r) => typeof r === 'object' && r !== null)
+                    .map((r) => ({
+                    method: String(r.method ?? ''),
+                    path: String(r.path ?? ''),
+                    status: Number(r.status ?? 0) || 0,
+                })),
+                console: consoleMessages.map(String),
+            });
+        }
+        catch (_error) {
+            continue;
+        }
+    }
+    return out;
+}
+/** Where a trace's test is: the spec and line it names, else the folder Playwright wrote it in. */
+function whereOf(item) {
+    if (!item.spec)
+        return 'a failing test';
+    return item.line > 0 ? `${item.spec}:${item.line}` : item.spec;
+}
+/** One request as the note writes it: `POST /api/articles/x/favorite → 401`. */
+function requestLine(request) {
+    const url = request.path.length > TRACE_NOTE_URL_CHARS
+        ? `${request.path.slice(0, TRACE_NOTE_URL_CHARS)}…`
+        : request.path;
+    return `${request.method} ${url} → ${request.status === 0 ? 'no response' : request.status}`;
+}
+/**
+ * The note a failed suite run's result carries: what each failing test's page actually sent, and
+ * what came back.
+ *
+ * This is the answer to the question a swallowed error hides — a click that changed nothing is
+ * usually a request that failed — so the note leads with the failing requests and says what to do
+ * with them: read the handler the route reaches, not the selector. It is BOUNDED to
+ * {@link MAX_TRACE_NOTE_TESTS} tests with {@link MAX_TRACE_NOTE_REQUESTS} requests each, because it
+ * rides in a result the model pays for.
+ *
+ * @param items - The traces {@link parseTraceArtifacts} read.
+ * @param target - Where the run went — the deployed host, as the note names it.
+ * @returns The note, or null when no trace held a request or a console error.
+ */
+export function failureTraceNote(items, target) {
+    const withEvidence = items.filter((item) => item.requests.length > 0 || item.console.length > 0);
+    if (withEvidence.length === 0)
+        return null;
+    const rows = [];
+    for (const [index, item] of withEvidence.slice(0, MAX_TRACE_NOTE_TESTS).entries()) {
+        const requests = item.requests.slice(-MAX_TRACE_NOTE_REQUESTS).map(requestLine);
+        const parts = [];
+        if (requests.length > 0)
+            parts.push(requests.join('; '));
+        if (item.console.length > 0)
+            parts.push(`console: ${item.console
+                .slice(0, 2)
+                .map((text) => text.replace(/\s+/g, ' ').trim().slice(0, 160))
+                .join(' | ')}`);
+        rows.push(`  ${index + 1}. ${whereOf(item)} — ${parts.join(' — ')}`);
+    }
+    const more = withEvidence.length > MAX_TRACE_NOTE_TESTS
+        ? `\n  … and ${withEvidence.length - MAX_TRACE_NOTE_TESTS} more traced failures`
+        : '';
+    return (`The platform read the failing tests' own Playwright traces from the run against ${target} ` +
+        `(the last requests each page made and what came back):\n${rows.join('\n')}${more}\n` +
+        'A click that changed nothing is usually one of these requests failing, not the selector: ' +
+        'read the handler this route reaches in your own source, and stop `catch`-ing the request of a ' +
+        'user action silently — log it.');
+}
+/** The Playwright trace modes that leave a zip behind for a FAILING test, whatever the retries. */
+const RECORDING_TRACE_MODES = ['on', 'retain-on-failure'];
+/**
+ * A `trace:` setting and its value, however the config spells it (`trace: 'on'`,
+ * `trace: "on-first-retry"`, `trace: { mode: 'retain-on-failure', screenshots: true }`). The value
+ * is captured from the object form's `mode` or from the plain one.
+ */
+const TRACE_SETTING = /trace:\s*(?:\{[^{}]*?mode:\s*)?['"]?(on-first-retry|on-all-retries|retain-on-failure|on|off)(?![\w-])/g;
+/**
+ * Whether a Playwright config records traces for the tests that fail.
+ *
+ * Only `on` and `retain-on-failure` keep a `trace.zip` for a failure whatever the retries do: the
+ * two retry modes need a retry to happen at all, and a diagnosis run is given `--retries=0`
+ * (`streamingBackgroundCommand`), so on X1 xr-molecule-flash-m100 the run's own
+ * `trace: 'on-first-retry'` recorded nothing — which is what left the failing tests' network log
+ * unreadable. A config that sets no `trace:` at all records nothing either (Playwright's default
+ * is off); so does one that cannot be read.
+ *
+ * @param configText - The config's source, or '' when none could be read.
+ * @returns True when the config records traces for failures.
+ */
+export function suiteRecordsTraces(configText) {
+    const text = configText.replace(/\/\*[\s\S]*?\*\//g, '').replace(/(^|[^:])\/\/[^\n]*/g, '$1');
+    return [...text.matchAll(TRACE_SETTING)].some((m) => RECORDING_TRACE_MODES.includes(m[1] ?? ''));
+}
+/** The `--trace` flag this platform adds, and the only value it adds it with. */
+export const DIAGNOSIS_TRACE_FLAG = '--trace=retain-on-failure';
+/**
+ * Whether a command already decides its own tracing: `--trace=on`, `--trace retain-on-failure`.
+ * A run that names one is left exactly as the executor wrote it.
+ */
+function namesTraceMode(command) {
+    return /(?:^|[\s;&|(])--trace(?:=|\s)/.test(command);
+}
+/** The config paths a candidate directory could hold, in the order Playwright itself looks. */
+const CONFIG_NAMES = [
+    'playwright.config.ts',
+    'playwright.config.mts',
+    'playwright.config.js',
+    'playwright.config.mjs',
+    'playwright.config.cjs',
+];
+/** The directories a command changes into, in order, as it writes them. */
+function cdDirectories(command) {
+    const out = [];
+    for (const m of command.matchAll(/(?:^|[\s;&|(])cd\s+(?:'([^']+)'|"([^"]+)"|([^\s;&|)]+))/g)) {
+        const dir = m[1] ?? m[2] ?? m[3];
+        if (dir && !out.includes(dir))
+            out.push(dir);
+    }
+    return out;
+}
+/** A path joined under a base, unless it is already absolute. */
+function under(base, path) {
+    if (path.startsWith('/'))
+        return path;
+    return `${base.replace(/\/+$/, '')}/${path.replace(/^\.\//, '')}`;
+}
+/**
+ * The config a Playwright command reads, read from the backend — the file its own `--config`
+ * names (resolved against the directory the command starts in, then against each `cd` it does
+ * first), else the first `playwright.config.*` in those directories.
+ *
+ * Best-effort and bounded: at most four candidate files are read, and a read that fails is a
+ * config that records nothing — the caller's `--trace` flag is what makes a missing trace
+ * impossible either way.
+ *
+ * @param command - The shell command.
+ * @param cwd - The directory the command starts in.
+ * @param readFile - The backend's file read.
+ * @returns The config's text, or '' when none could be read.
+ */
+async function readRunConfig(command, cwd, readFile) {
+    const bases = [cwd, ...cdDirectories(command).map((dir) => under(cwd, dir))].slice(0, 2);
+    const config = /(?:^|[\s;&|(])--config(?:=|\s+)(?:'([^']+)'|"([^"]+)"|([^\s;&|)]+))/.exec(command);
+    const explicit = config?.[1] ?? config?.[2] ?? config?.[3] ?? null;
+    const candidates = explicit
+        ? bases.map((base) => under(base, explicit))
+        : bases.flatMap((base) => CONFIG_NAMES.map((name) => `${base.replace(/\/+$/, '')}/${name}`));
+    for (const candidate of candidates.slice(0, 4)) {
+        try {
+            const text = await readFile(candidate);
+            if (text)
+                return text;
+        }
+        catch (_error) {
+            continue;
+        }
+    }
+    return '';
+}
+/**
+ * The command a DIAGNOSIS run needs to leave a readable trace behind, when the suite's config
+ * would record none.
+ *
+ * The failing tests' requests are only readable if the run wrote them down (see the module doc),
+ * and the config is where the decision about that lives — the platform does not edit the suite's
+ * config, so it passes the flag instead, and only where it can do no harm: on a run narrowed to a
+ * part of the suite or capped ({@link isDiagnosisRun}), never on the whole-suite proof run, and
+ * never over a `--trace` the executor wrote itself. A capped walk is exactly the run whose
+ * failures someone is about to work on; the proof run is graded as it is.
+ *
+ * @param args - The command, the directory it starts in, and the backend's file read.
+ * @returns The command to run and the sentence to report, or the command unchanged.
+ */
+export async function diagnosisTraceCommand(args) {
+    const unchanged = { command: args.command, change: null };
+    // The proof run is the one run this must never touch: its flags are graded.
+    if (!isDiagnosisRun(args.command))
+        return unchanged;
+    if (namesTraceMode(args.command))
+        return unchanged;
+    // Only a Playwright run leaves a trace to read.
+    if (!isPlaywrightRunCommand(args.command))
+        return unchanged;
+    const config = await readRunConfig(args.command, args.cwd, args.readFile);
+    if (suiteRecordsTraces(config))
+        return unchanged;
+    return {
+        command: `${args.command.trimEnd()} ${DIAGNOSIS_TRACE_FLAG}`,
+        change: `Added \`${DIAGNOSIS_TRACE_FLAG}\`: the suite's config records no trace for a failure` +
+            `${/trace:/.test(config) ? '' : ' (it sets none)'}, and this diagnosis run's failures are ` +
+            'what the platform reads the network log from. The proof run keeps the suite’s own settings.',
+    };
+}

package/dist/utilities.d.ts

@@ -110,6 +110,20 @@ export declare function outputIsWithheldUntilExit(command: string): boolean;
  * @returns The target as written, or null (`/dev/null` and `&1`/`&2` are not files).
  */
 export declare function outputRedirectTarget(command: string): string | null;
+/**
+ * Playwright's switch for printing each failure's own error as that test fails, instead of only in
+ * the summary at the end: `list` reads it in its constructor (`ListReporterOptions.printFailuresInline`,
+ * `playwright/lib/reporters/list.js` — 1.63, the version the toolchain pins), and when it prints
+ * inline the end-of-run repeat is suppressed with it (`epilogue(!printFailuresInline)`), so one
+ * reporter still prints each failure exactly once.
+ *
+ * A background suite is put on `list` (see {@link streamingBackgroundCommand}) and this with it, so
+ * the log names its causes WHILE it walks. Without it the log's only failure lines are `✘` rows:
+ * X1 xr-molecule-flash-m99 (+19:27 → +21:00, 2026-10-16) was told to `grep -n -A 20 '<test name>'`
+ * the log, got nothing back through four greps, inferred causes from the spec prose instead, and
+ * edited `app/src` while the run was still walking — which voids the run.
+ */
+export declare const PLAYWRIGHT_FAILURES_INLINE_ENV = "PLAYWRIGHT_LIST_PRINT_FAILURES_INLINE";
 /**
  * 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
@@ -135,6 +149,11 @@ export declare function outputRedirectTarget(command: string): string | null;
  * `junit`) is the
  * executor's own and is left exactly as it is — so is any reporter this build does not know.
  *
+ * A run put on `list` is also given {@link PLAYWRIGHT_FAILURES_INLINE_ENV}, so each failure's own
+ * error is in the log as that test fails rather than only at the end: a suite that is still walking
+ * is exactly when the executor reads the log, and without it a running log carries `✘` rows and
+ * nothing else (xr-molecule-flash-m99 spent ~90 s on greps of one, then fixed what it guessed).
+ *
  * 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}).
@@ -602,10 +621,12 @@ export declare const RUNNING_FAILURE_LINE_RE = "^[[:space:]]*(\u2718|\u2717|\u00
  * The shell command whose stdout is the interesting part of a log that is still being written:
  * the failure lines so far (capped at {@link RUNNING_FAILURE_LINES}), then the end of the log.
  *
- * A Playwright `list` run prints one line per test as it finishes and its error blocks only at
- * the end, so the LAST bytes of a running log are its least informative part — in X1 flash-m61
- * the last 3 000 bytes of a 139-test walk were the skip list, and all 61 failures were above
- * them, which cost the run the grep it had to make anyway.
+ * A Playwright `list` run prints one line per test as it finishes, so the LAST bytes of a running
+ * log are its least informative part — in X1 flash-m61 the last 3 000 bytes of a 139-test walk
+ * were the skip list, and all 61 failures were above them, which cost the run the grep it had to
+ * make anyway. A background run also carries each failure's own error as it fails
+ * ({@link PLAYWRIGHT_FAILURES_INLINE_ENV}), and {@link RUNNING_FAILURE_LINE_RE} already matches
+ * those blocks' headers and their `Error:` lines, so this slice shows the causes too.
  *
  * @param log - The task log path.
  * @param own - A file the command redirects its own output to, if any.
@@ -661,9 +682,11 @@ export interface RepeatingFailure {
  * 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. Where the log carries the
- * failure bodies (a `line` reporter's output, or a finished run's summary) the signature is the
+ * path and how long it ran — and, on a run the platform started in the background, each failure's
+ * own error with it ({@link PLAYWRIGHT_FAILURES_INLINE_ENV}); a `list` run with no error bodies in
+ * its log (an older Playwright, a log the bodies have been cut from) carries only the duration as
+ * a signature. Where the log carries the failure bodies (either inline, or in 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
@@ -726,6 +749,38 @@ export interface UniversalCause {
  * @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;
+/**
+ * The ONE finding that ends a wait early, and the only one a note may hand a stop command over
+ * for: a PROVEN cause that is failing the whole run.
+ *
+ * Both halves are load-bearing, each of them learned from a run that lost minutes to the other.
+ *
+ * - **Failing the WHOLE run** is {@link universalCause}: every failure the log names, across
+ *   {@link UNIVERSAL_CAUSE_FILES} spec files or more, with nothing passing since the first — the
+ *   dont-stop-runs rule. X1 flash-m83 (2026-10-16) stopped eight local runs at their first
+ *   repeating cause in 14.5 minutes and never finished one, and a run that still has other causes
+ *   left to name is the only thing that will name them.
+ * - **A PROVEN cause** is an error repeated VERBATIM. A shared DURATION is a LEAD, never a cause:
+ *   a suite whose config sets a timeout spends that timeout on every failure that waits for
+ *   anything, so three unrelated tests timing out together look exactly like one broken run
+ *   (`~7 s` is a property of the CONFIG, not of the cause — {@link normalizedSignature}). X1
+ *   xr-molecule-flash-m99 (2026-10-16) was told `status: 'repeating_failure'` twice on that
+ *   shape — three `url-navigation.spec.ts` tests at ~16.2 s, one `timeout: 15_000` plus teardown
+ *   — read the early return as "stop waiting, edit now", and voided a run that was still walking;
+ *   the second cost a 224 s wait that ended with no result at all.
+ *
+ * Neither half alone is enough, and {@link repeatingFailure} finding a signature is not either:
+ * that answers "is a cause repeating among this run's failures", which is worth telling the
+ * executor mid-run as a NOTE while the wait goes on. This answers the narrower question the wait
+ * needs — is the run over as a measuring instrument — and it is THE one predicate behind both
+ * that decision and the note's wording, so the two cannot come to different verdicts.
+ *
+ * @param found - What {@link repeatingFailure} found mid-run.
+ * @param universal - What {@link universalCause} found for it, if anything.
+ * @returns The cause to stop the run over, or null — in which case nothing may be stopped, the
+ *   wait keeps going, and the finding rides the run's result as a note.
+ */
+export declare function earlyReturnCause(found: RepeatingFailure, universal: UniversalCause | null | undefined): 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. */
@@ -744,11 +799,11 @@ export interface FailureCause {
  * 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.
+ * The signature is the cause itself where the log carries the failures' bodies (a finished run, a
+ * background `list` run — whose failures print as they fail — 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, 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.
@@ -795,11 +850,15 @@ export declare function rerunOfRunningSuite(run: {
  * 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.
+ * and it hands a stop command over only when {@link earlyReturnCause} says so — the SAME
+ * predicate the wait uses to decide whether to return early, so a finding the wait keeps waiting
+ * on is a finding this note never asks to stop for. 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. X1 xr-molecule-flash-m99 (2026-10-16) is the third shape: a shared duration is
+ * not a cause at all, so a lead reaches the executor as a note on a result it is still waiting
+ * for — never as a verdict with a stop command in it.
  *
  * The run is STILL WALKING while this note is written — both callers produce it mid-run — so a
  * re-run of one of its tests is a second run against the same app and database, and the platform
@@ -813,7 +872,7 @@ export declare function rerunOfRunningSuite(run: {
  *
  * @param found - What {@link repeatingFailure} found.
  * @param o - The run's facts: its `taskId`, its `log` path, `stop` — the shell command that
- *   stops it, printed only for a {@link UniversalCause} — `universal`, what
+ *   stops it, printed only for an {@link earlyReturnCause} — `universal`, what
  *   {@link universalCause} found (absent means the run is not failing whole), and `run`, how the
  *   run was started ({@link rerunOfRunningSuite}) when the caller knows it.
  * @returns The note.

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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"}