@molecule/api-ai-tools 1.12.0 → 1.13.1

package/dist/suite-overlap.js

@@ -29,7 +29,7 @@
  * @module
  */
 import { posix } from 'node:path';
-import { commandSegments, locatedCommandSegments } from './command-position.js';
+import { commandSegments, locatedCommandSegments, statementBoundary, } from './command-position.js';
 import { commandRunsNoTests } from './no-test-run.js';
 import { matchingExcludedTitles, shellQuote, suiteRunStatements } from './utilities.js';
 /**
@@ -127,8 +127,165 @@ const FILE_REDIRECT = /(^|\s)(&>>?|1?>>?)(\s*)(?:'([^']+)'|"([^"]+)"|([^\s;&|]+)
 /** A target that is not a log anyone could lose: rewriting it would CREATE a file. */
 const DEVICE_TARGET = /^\/dev\//;
 /**
- * The command with every file redirect pointed at a fresh file beside its original target
- * (`/tmp/pw-full.log` → `/tmp/pw-full.rerun.log`), and nothing else changed.
+ * The command's words, quotes kept whole and with the offsets they were written at — the reading
+ * {@link dropSupersededSelections} tokenizes the runner's arguments with AND the one a redirect
+ * reader may not look inside: a quoted `--grep 'a > b'` is one word, and its `>` is the filter's
+ * text, not a redirect.
+ */
+const ARGUMENT_WORD = /"(?:\\.|[^"\\])*"|'[^']*'|\S+/g;
+/**
+ * The command's words as spans, in the order they were written.
+ *
+ * @param command - The shell command.
+ * @returns Each word's span in the command.
+ */
+function wordSpans(command) {
+    return [...command.matchAll(ARGUMENT_WORD)].map((match) => ({
+        start: match.index ?? 0,
+        end: (match.index ?? 0) + match[0].length,
+    }));
+}
+/**
+ * Whether an offset sits strictly INSIDE one of the command's words rather than between them —
+ * the quoted data a redirect reader must leave alone.
+ *
+ * @param at - The offset being read.
+ * @param words - The command's word spans.
+ * @returns True when the offset is inside a word.
+ */
+function insideWord(at, words) {
+    return words.some((word) => at > word.start && at < word.end);
+}
+/**
+ * The command with the edits applied — right to left, so every edit's offsets are still the ones
+ * its reader reported.
+ *
+ * @param command - The command the edits were read from.
+ * @param edits - The replacements, as offsets in that command.
+ * @returns The command with each span replaced.
+ */
+function applyTextEdits(command, edits) {
+    let out = command;
+    for (const edit of [...edits].sort((a, b) => b.start - a.start))
+        out = out.slice(0, edit.start) + edit.text + out.slice(edit.end);
+    return out;
+}
+/**
+ * The output redirects of ONE statement's text that name a file, as edits that point them at a
+ * fresh sibling of the file they wrote (`/tmp/pw-full.log` → `/tmp/pw-full.rerun.log`).
+ *
+ * A redirect whose operator sits inside a quoted word is that word's text, not a redirect of the
+ * statement: `npx playwright test --grep 'a > b' > /tmp/full.log` carries exactly one redirect.
+ *
+ * @param statement - The statement's text.
+ * @param offset - The statement's offset in the command.
+ * @param words - The command's word spans.
+ * @returns The edits, in statement order.
+ */
+function freshRedirectEdits(statement, offset, words) {
+    const edits = [];
+    for (const match of statement.matchAll(FILE_REDIRECT)) {
+        const before = match[1] ?? '';
+        const op = match[2] ?? '';
+        const space = match[3] ?? '';
+        const single = match[4];
+        const double = match[5];
+        const target = single ?? double ?? match[6] ?? '';
+        // A `>` written inside a quoted value is that value's own text.
+        if (insideWord(offset + (match.index ?? 0) + before.length, words))
+            continue;
+        // `/dev/null` and friends are not a report to preserve; leaving them keeps the re-run silent
+        // the way the run was, where rewriting them would create a file nobody asked for.
+        if (!target || DEVICE_TARGET.test(target))
+            continue;
+        // A descriptor (`>&2`) or a process substitution (`> >(tee …)`) is no file either.
+        if (target.startsWith('&') || target.startsWith('(') || /^\d+$/.test(target))
+            continue;
+        const quote = single !== undefined || double !== undefined ? 1 : 0;
+        const start = offset + (match.index ?? 0) + before.length + op.length + space.length + quote;
+        edits.push({ start, end: start + target.length, text: `${target}.rerun.log` });
+    }
+    return edits;
+}
+/**
+ * The file arguments of a `tee` stage, as edits that point them at a fresh sibling.
+ *
+ * A pipeline the suite feeds (`… 2>&1 | tee /tmp/full.log`) writes the run's own stream to the
+ * files `tee` names, so a re-run through the same pipeline would overwrite the walk's report
+ * exactly the way its own `> <file>` redirect would ({@link freshRedirectEdits}). A stage that
+ * names no file, reads a device or carries flags keeps those words as written.
+ *
+ * @param statement - The stage's text.
+ * @param offset - The stage's offset in the command.
+ * @returns The edits, in stage order.
+ */
+function freshTeeEdits(statement, offset) {
+    const words = [...statement.matchAll(ARGUMENT_WORD)].map((match) => ({
+        text: match[0],
+        start: offset + (match.index ?? 0),
+    }));
+    const program = words.findIndex((word) => unquoted(word.text).replace(/\/+$/, '').split('/').at(-1) === 'tee');
+    if (program < 0)
+        return [];
+    const edits = [];
+    for (const word of words.slice(program + 1)) {
+        const bare = unquoted(word.text);
+        if (!bare || bare.startsWith('-') || DEVICE_TARGET.test(bare))
+            continue;
+        const quote = /^['"]/.test(word.text) ? 1 : 0;
+        edits.push({
+            start: word.start + quote,
+            end: word.start + word.text.length - quote,
+            text: `${bare}.rerun.log`,
+        });
+    }
+    return edits;
+}
+/**
+ * The statements that carry the suite run's OWN output: the Playwright statement, and every stage
+ * of the pipeline it feeds (`| tee /tmp/full.log | tail -5`).
+ *
+ * The parse's own spans answer this, so the setup and the tail around the run are never read as
+ * its output: `printf … > app/public/_redirects` writes a file BEFORE any suite starts, and
+ * `; echo done > /tmp/done` runs after it, whatever their redirects look like. Only a `|` joins a
+ * stage to the run's stream; a `;`, `&&` or newline starts a statement of its own whose output is
+ * not the run's ({@link redirectRunnerOutputsToFreshFiles}).
+ *
+ * @param command - The composed command.
+ * @returns The statements, or null when the command starts no Playwright run that can be placed.
+ */
+function runnerOutputStatements(command) {
+    const located = locatedCommandSegments(command);
+    const at = located.findIndex((entry) => entry.segment !== null && PLAYWRIGHT_RUN.test(entry.segment.text));
+    if (at < 0)
+        return null;
+    const place = (entry, tee) => {
+        if (entry.start === null || entry.end === null)
+            return null;
+        // A statement can end on an enclosing group's closer (`( … 2>&1)`); the closer is the
+        // shell's, not the statement's, so it is not part of what a redirect reader may rewrite.
+        const end = statementBoundary(command, entry.start, entry.end)?.textEnd ?? entry.end;
+        return { start: entry.start, end, tee };
+    };
+    const runner = located[at];
+    const first = runner === undefined ? null : place(runner, false);
+    if (first === null)
+        return null;
+    const statements = [first];
+    for (let i = at + 1; i < located.length; i += 1) {
+        const entry = located[i];
+        // Only a stage of the SAME pipeline carries the run's output; anything else is the tail.
+        if (entry === undefined || entry.separator !== '|')
+            break;
+        const stage = place(entry, entry.segment?.program === 'tee');
+        if (stage !== null)
+            statements.push(stage);
+    }
+    return statements;
+}
+/**
+ * The command with the SUITE RUN's own log files pointed at fresh siblings, and nothing else
+ * changed.
  *
  * A re-run composed from a run's own command keeps the run's redirect by construction, and the
  * run wrote the walk's only report to that file: xr-molecule-flash-m173 handed over *"Send this
@@ -137,29 +294,42 @@ const DEVICE_TARGET = /^\/dev\//;
  * full walk's log, destroying the other 11 failures' error reports. Following the platform's own
  * advice must never destroy the evidence it was based on.
  *
- * @param command - A shell command.
- * @returns The command whose file redirects write to a fresh target.
+ * Only the run's OWN stream moves. What surrounds it is SETUP and POSTLUDE, and those writes are
+ * the command's meaning, not a report: xr-molecule-flash-m429 (2026-10-22) composed
+ * `printf '/index.html 200' > app/public/_redirects && npx playwright test specs/auth.spec.ts
+ * > /tmp/full.log 2>&1` with its SPA fallback written to `_redirects.rerun.log`, so the re-run
+ * measured an app with no fallback at all. A heredoc config, a `.env` the command writes and a
+ * source asset it lays down are the same shape: their targets stay byte-for-byte, and so does
+ * every statement chained after the run (`; echo EXIT $? > /tmp/done`).
+ *
+ * @param command - The composed command.
+ * @returns The command whose suite-run redirects write to a fresh target.
  */
-function redirectToFreshFile(command) {
-    return command.replace(FILE_REDIRECT, (whole, before, op, space, single, double, bare) => {
-        const target = single ?? double ?? bare ?? '';
-        // `/dev/null` and friends are not a report to preserve; leaving them keeps the re-run silent
-        // the way the run was, where rewriting them would create a file nobody asked for.
-        if (!target || DEVICE_TARGET.test(target))
-            return whole;
-        const quote = single !== undefined ? "'" : double !== undefined ? '"' : '';
-        return `${before}${op}${space}${quote}${target}.rerun.log${quote}`;
-    });
+function redirectRunnerOutputsToFreshFiles(command) {
+    const statements = runnerOutputStatements(command);
+    if (statements === null)
+        return command;
+    const words = wordSpans(command);
+    const edits = [];
+    for (const statement of statements) {
+        const text = command.slice(statement.start, statement.end);
+        edits.push(...freshRedirectEdits(text, statement.start, words));
+        if (statement.tee)
+            edits.push(...freshTeeEdits(text, statement.start));
+    }
+    return applyTextEdits(command, edits);
 }
 /**
  * The whole-suite command made scoped to the tests it should re-run instead: the same
- * invocation — same directory, same settings — with the named `file:line`s in place of the whole
- * suite, `--last-failed` dropped (it re-runs the tests that never ran too, X1 flash-m60) and
+ * invocation — same launcher, same settings — with the named `file:line`s in place of every
+ * positional selection the run carried (a spec file, a suite directory or a regex filter),
+ * `--last-failed` dropped (it re-runs the tests that never ran too, X1 flash-m60) and
  * `--retries=0` set (a re-run of a known failure does not need to pay for retries).
  *
  * The re-run keeps the run's `> <file>` redirect only in the sense of keeping its OUTPUT there:
- * the target is rewritten to a fresh sibling ({@link redirectToFreshFile}), so a re-run never
- * overwrites the log the run itself is the evidence for (xr-molecule-flash-m173).
+ * the target is rewritten to a fresh sibling ({@link redirectRunnerOutputsToFreshFiles}), so a
+ * re-run never overwrites the log the run itself is the evidence for (xr-molecule-flash-m173) —
+ * and the setup around the run keeps its own file writes untouched (xr-molecule-flash-m429).
  *
  * `config` is the config the run was measured under ({@link withSuiteConfig}): the narrowed re-run
  * carries it whenever the command itself does not, so a run that dropped `--config` cannot be
@@ -215,8 +385,10 @@ export function scopedRerunCommand(command, locations, excluded = [], config, cw
     // nothing — "No tests found" — so every location is rendered in a form Playwright can match
     // ({@link playwrightLocations}).
     const narrowed = playwrightLocations(locations, command, cwd);
-    const dropped = dropSupersededSpecFiles(args, narrowed)
-        .replace(/\s*--last-failed\b/g, '')
+    const dropped = dropSupersededSelections(args, narrowed)
+        // `--last-failed` re-runs the tests that never ran too (flash-m60); its `--last-failed-file`
+        // sibling only moves the file it reads and is a real option of the re-run.
+        .replace(/\s*--last-failed(?!-)/g, '')
         .replace(/\s*--retries(?:[= ]\d+)?/g, '');
     const scoped = command.slice(0, run.afterRunner) +
         ` ${narrowed.join(' ')} --retries=0${carry}${invert}` +
@@ -226,7 +398,7 @@ export function scopedRerunCommand(command, locations, excluded = [], config, cw
     // X1 xr-molecule-flash-m157 (+14:02) was handed a re-run that still carried the chain's second
     // whole walk — 4.5 minutes measuring code it had not changed.
     const rerunTail = suiteRunStatements(tail).length > 0 ? '' : tail;
-    return withRunEnv(`${redirectToFreshFile(scoped)}${redirectToFreshFile(rerunTail)}`, env);
+    return withRunEnv(redirectRunnerOutputsToFreshFiles(`${scoped}${rerunTail}`), env);
 }
 /** A `NAME=value` word in command position, optionally behind `export`/`env`. */
 const ENV_WORD = /(^|[\s;&|(])(?:export[ \t]+|env[ \t]+)?([A-Za-z_][A-Za-z0-9_]*)=('[^']*'|"[^"]*"|[^\s;&|]+)/g;
@@ -366,33 +538,145 @@ function playwrightLocations(locations, command, cwd) {
         return `${resolved}${suffix}`;
     });
 }
-/** A spec-file argument Playwright accepts as its positional filter — never a flag. */
-const SPEC_FILE_ARGUMENT = /^(?!-)[^\s]*\.(?:spec|test)\.[cm]?[jt]sx?(?::\d+(?::\d+)?)?$/;
 /**
- * The runner's own arguments with every bare spec-file argument taken out once the re-run names
+ * Every Playwright `test` option that takes its value from the NEXT word, read from the runner's
+ * own option table (`playwright test --help`, Playwright 1.63 as the sandbox image ships it).
+ *
+ * A value here is never a positional selection however much it looks like a path:
+ * `--config playwright.config.ts` names the config the run was measured under, and dropping it
+ * because it ends in `.ts` would re-create m113 exactly (a re-run with no base URL).
+ */
+const SUITE_VALUE_FLAGS = new Set([
+    '--add-reporter',
+    '--browser',
+    '-c',
+    '--config',
+    '--global-timeout',
+    '-g',
+    '--grep',
+    '-G',
+    '--grep-invert',
+    '--last-failed-file',
+    '--max-failures',
+    '--output',
+    '--repeat-each',
+    '--reporter',
+    '--retries',
+    '--run-agents',
+    '--shard',
+    '--test-list',
+    '--test-list-invert',
+    '--timeout',
+    '--trace',
+    '--tsconfig',
+    '--ui-host',
+    '--ui-port',
+    '--update-source-method',
+    '-j',
+    '--workers',
+]);
+/**
+ * Options whose value is optional (`--debug [mode]`, `--only-changed [ref]`): the next word is
+ * theirs unless it is another flag — the reading the runner's own command line takes.
+ */
+const SUITE_OPTIONAL_VALUE_FLAGS = new Set([
+    '--debug',
+    '--only-changed',
+    '-u',
+    '--update-snapshots',
+]);
+/**
+ * `--project <project-name...>` takes every word up to the next flag, as the runner's own command
+ * line does; a project name is a selection of projects, never a positional test filter.
+ */
+const SUITE_VARIADIC_VALUE_FLAGS = new Set(['--project']);
+/** A redirect written as one word (`2>&1`, `>/tmp/out.log`): not a selection. */
+const ARGUMENT_REDIRECT = /^(?:\d*|&)(?:<<<|<<-?|>>?\|?|<>|>&|<&)(?:&?\d+|-|[^\s;&|()<>]*)?$/;
+/** A redirect operator whose target is the word after it (`> /tmp/out.log`). */
+const ARGUMENT_REDIRECT_OPERATOR = /^(?:\d*|&)(?:<<<|<<-?|>>?\|?|<>|>&|<&)$/;
+/**
+ * The runner's own arguments with every positional selection taken out once the re-run names
  * failure locations.
  *
- * The re-run is "just these": Playwright matches each positional argument against every collected
- * file's path, so a bare file left beside the `file:line`s re-admits ALL of that file's tests.
- * xr-molecule-flash-m118 (+45:24) kept the one file its 14 failures were in ("~297s" for a file and
- * fourteen duplicates); xr-molecule-flash-m134 (+20:0x) kept all four files of a run whose 8
- * failures sat in two of them — 32 tests, ~3 min, instead of the 8 failures' ~30 s. A file with no
- * failure in it has nothing to re-run, so it goes too.
+ * The re-run is "just these", and Playwright OR-s every positional argument into one selection:
+ * ANY leftover positional re-admits tests the re-run is supposed to skip. A bare spec file
+ * re-admits all of that file's tests (xr-molecule-flash-m118 (+45:24) ~297 s for one file and
+ * fourteen duplicates; xr-molecule-flash-m134 (+20:0x) 32 tests instead of 8). A suite DIRECTORY
+ * is the same argument and re-admits the WHOLE walk even beside fourteen exact `file:line`s —
+ * xr-molecule-flash-m428's suggested "Re-run just these" kept
+ * `/workspace/fixtures/realworld/specs/e2e` after `--config playwright.config.ts`, so the command
+ * said 14 locations and selected every spec again. A regex positional filter selects files the
+ * same way and goes too.
+ *
+ * What is NOT a selection survives byte-for-byte: every option and its value — whatever it looks
+ * like (`--config playwright.config.ts`, `--output test-results`, `--grep 'a|b'`, a `--project`
+ * list) — and every redirect. Quoting and spacing survive because the result is a span splice on
+ * the raw text, never a rebuild from words.
  *
- * The launcher's words are not arguments and are not here: the caller passes what follows
- * `playwright test` ({@link playwrightStatement}'s `afterRunner`), so `node <path>/playwright
- * test` and `npx playwright test` lose the same spec files.
+ * An empty `locations` list keeps the original selection untouched:
+ * {@link scopedRerunCommand} is not narrowing anything then.
  *
  * @param args - The run's own arguments, after `playwright test`.
  * @param locations - The failing `file:line`s the re-run names.
- * @returns The arguments without their bare spec-file arguments.
+ * @returns The arguments without their positional selections.
  */
-function dropSupersededSpecFiles(args, locations) {
+function dropSupersededSelections(args, locations) {
     if (locations.length === 0)
         return args;
-    return args.replace(/(^|\s+)([^\s]+)(?=\s|$)/g, (whole, _space, token) => {
-        return SPEC_FILE_ARGUMENT.test(token) ? '' : whole;
-    });
+    const words = [];
+    for (const match of args.matchAll(ARGUMENT_WORD))
+        words.push({ text: match[0], start: match.index ?? 0 });
+    const dropped = new Array(words.length).fill(false);
+    let at = 0;
+    while (at < words.length) {
+        const word = words[at]?.text ?? '';
+        if (ARGUMENT_REDIRECT_OPERATOR.test(word)) {
+            // The operator and the target after it are one redirect, not two words to judge.
+            at += 2;
+            continue;
+        }
+        if (ARGUMENT_REDIRECT.test(word)) {
+            at += 1;
+            continue;
+        }
+        if (word.startsWith('-') && word !== '-') {
+            // `--flag=value` carries its value inside the same word; only the flag's own name is read.
+            if (word.includes('=')) {
+                at += 1;
+                continue;
+            }
+            if (SUITE_OPTIONAL_VALUE_FLAGS.has(word)) {
+                const next = words[at + 1]?.text;
+                at += next !== undefined && !next.startsWith('-') ? 2 : 1;
+                continue;
+            }
+            if (SUITE_VARIADIC_VALUE_FLAGS.has(word)) {
+                at += 1;
+                while (at < words.length && !(words[at]?.text ?? '').startsWith('-'))
+                    at += 1;
+                continue;
+            }
+            at += SUITE_VALUE_FLAGS.has(word) ? 2 : 1;
+            continue;
+        }
+        // A bare word — a spec file, a directory or a regex filter — is a positional selection.
+        dropped[at] = true;
+        at += 1;
+    }
+    let out = '';
+    let cursor = 0;
+    for (let i = 0; i < words.length; i += 1) {
+        const word = words[i];
+        if (word === undefined || !dropped[i])
+            continue;
+        // The whitespace in front of the word goes with it, so the result is not left double-spaced.
+        let start = word.start;
+        while (start > cursor && /\s/.test(args[start - 1] ?? ''))
+            start -= 1;
+        out += args.slice(cursor, start);
+        cursor = word.start + word.text.length;
+    }
+    return out + args.slice(cursor);
 }
 /**
  * The run in flight that makes a second run a hazard, or null when nothing is in the way.

package/dist/tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AA4O9C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAahG;AAudD,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AA+HnE;;;GAGG;AACH,eAAO,MAAM,iBAAiB,QAEA,CAAA;AAE9B;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB,QAI6C,CAAA;AA2DlF;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAUhE;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,qBAAqB;IACpC,iFAAiF;IACjF,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,8FAA8F;IAC9F,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;CAC5B;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,qBAAqB,CAAC,CAAA;AAoBpF;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,CAAC,GACxE,qBAAqB,CAkBvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAsB,4BAA4B,CAChD,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,qBAAqB,GAC5B,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAiCxB;AA2GD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,CAAC,EAAE,eAAe,GAAG,MAAM,EAAE,CA27FxF"}
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAgS9C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAahG;AAudD,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAgInE;;;GAGG;AACH,eAAO,MAAM,iBAAiB,QAEA,CAAA;AAE9B;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB,QAI6C,CAAA;AA2DlF;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAUhE;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,qBAAqB;IACpC,iFAAiF;IACjF,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,8FAA8F;IAC9F,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;CAC5B;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,qBAAqB,CAAC,CAAA;AAoBpF;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,CAAC,GACxE,qBAAqB,CAkBvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAsB,4BAA4B,CAChD,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,qBAAqB,GAC5B,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAiCxB;AA2GD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,CAAC,EAAE,eAAe,GAAG,MAAM,EAAE,CAq/FxF"}

package/dist/tools.js

@@ -15,6 +15,7 @@ import { INLINE_SCRIPT_BUDGET_MS, inlineLocalScriptCommand, inlineScriptRunawayS
 import { guardToolExecute, missingParamError, ToolInputError } from './input-normalizer.js';
 import { diffLineCount } from './line-diff.js';
 import { pipelineExitCodeNote } from './pipeline-exit-note.js';
+import { commandWritesReportTo, PLAYWRIGHT_REPORT_SUFFIX, playwrightReportPathFor, summarizePlaywrightReport, } from './playwright-report.js';
 import { TOOL_SCHEMAS } from './schemas.js';
 import { foregroundBrowserProbe, foregroundServerCommand, SERVER_OVER_BUDGET_ADVICE, serverCommandRefusal, startsServerProgram, } from './server-command.js';
 import { leadingSleepPeek } from './sleep-peek.js';
@@ -34,6 +35,45 @@ const waitedByTask = new Map();
 const logBytesByTask = new Map();
 /** The file a background command writes its own output to, when it redirects it. */
 const outputFileByTask = new Map();
+/**
+ * The standard Playwright machine report each background task was launched with, when the launch
+ * could carry one ({@link streamingBackgroundCommand}'s `reportPath`).
+ *
+ * The path is derived from the task id (`playwright-report.ts`), so a process that restarted
+ * mid-run still finds it — nothing here is the only record of where the file is.
+ */
+const reportByTask = new Map();
+/**
+ * One report file's bounded facts, or the honest reason there are none.
+ *
+ * A report that is not there is NOT "the run failed nothing": `summarizePlaywrightReport` answers
+ * `missing`, and every reader treats that as no machine data rather than as a clean run.
+ *
+ * @param backend - The project's execution backend.
+ * @param path - The report file's absolute path (`/tmp/…`).
+ * @param sanitize - The consumer's redactor for the error text the record carries.
+ * @returns The bounded record; never a verdict.
+ */
+async function readPlaywrightRunReport(backend, path, sanitize) {
+    let text;
+    try {
+        text = await backend.readFile(path);
+    }
+    catch (error) {
+        // No file under this path: the run left no report (killed before it ended, or it was launched
+        // before this sideband existed). Absence is said, never read as a clean run.
+        return {
+            status: 'missing',
+            path,
+            reason: 'the run left no report at this path' +
+                (error instanceof Error && error.message ? ` (${error.message})` : ''),
+            stats: null,
+            failures: [],
+            omittedFailures: 0,
+        };
+    }
+    return summarizePlaywrightReport(text, { path, sanitize });
+}
 /**
  * Recovered legacy task ids whose command ENDS with a backgrounded statement (`… &`).
  *
@@ -663,7 +703,7 @@ async function backgroundTaskState(backend, command, seconds, ceilingMs) {
 }
 import { suiteCommandTarget } from './suite-overlap.js';
 import { diagnosisTraceCommand } from './trace-artifacts.js';
-import { addedRedactionMask, BRACE_GLOB_HINT, checkBlockedCommand, declaredBudgetSeconds, DEFAULT_SEARCH_EXCLUDED_DIRS, directoryReadHint, earlyReturnCause, emptyCallError, expandBraceGlob, failureCausesNote, findPathArgs, findPatternArgs, fusedLine, htmlOutline, isCommandTimeout, isEnvFilePath, isOutsideRoot, isPlaywrightRunCommand, isReadOnlyInspection, isSuiteRunCommand, linesWithinSerialized, literalDirPrefix, logShowsInlineFailureBodies, 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, READ_RESULT_ENVELOPE_CHARS, redactSecrets, redactSecretsInCode, repeatedSuiteRunError, repeatingFailure, repeatingFailureNote, resolvePath, RUNNING_FAILURE_LINES, runningCauseCommand, runningOutputSliceCommand, searchTimeoutError, serializedChars, shellQuote, sliceLines, SMALL_FILE_WHOLE_CHARS, streamingBackgroundCommand, stripControlChars, suiteRunBudgetCommand, suiteRunConfigCommand, suiteRunPipelinePlacement, suiteRunPriorityLaunch, TOOL_RESULT_CHARS, truncateMiddle, universalCause, whitespaceTolerantReplace, withoutSuiteTimeout, } from './utilities.js';
+import { addedRedactionMask, BRACE_GLOB_HINT, checkBlockedCommand, declaredBudgetSeconds, DEFAULT_SEARCH_EXCLUDED_DIRS, directoryReadHint, earlyReturnCause, emptyCallError, expandBraceGlob, failureCausesNote, findPathArgs, findPatternArgs, fusedLine, htmlOutline, isCommandTimeout, isEnvFilePath, isOutsideRoot, isPlaywrightRunCommand, isReadOnlyInspection, isSuiteRunCommand, linesWithinSerialized, literalDirPrefix, logShowsInlineFailureBodies, 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, READ_RESULT_ENVELOPE_CHARS, redactSecrets, redactSecretsInCode, repeatedSuiteRunError, repeatingFailure, repeatingFailureNote, resolvePath, RUNNING_FAILURE_LINES, runningCauseCommand, runningOutputSliceCommand, searchTimeoutError, serializedChars, shellQuote, sliceLines, SMALL_FILE_WHOLE_CHARS, streamingBackgroundCommand, stripControlChars, suiteRunBudgetCommand, suiteRunConfigCommand, suiteRunPipelinePlacement, suiteRunPriorityLaunch, TOOL_RESULT_CHARS, truncateMiddle, universalCause, whitespaceTolerantReplace, withoutSuiteTimeout, withPlaywrightRunReport, } 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.
@@ -2845,14 +2885,19 @@ export function buildTools(backend, config) {
                     // The request's own exclusions ride along: a `--grep-invert` that names one of them is
                     // the proof scope written as a flag, not a diagnosis, so it keeps the suite's retries
                     // (xr-molecule-flash-m170 +33:16). The getter is the host's, read here at launch time.
-                    const streaming = streamingBackgroundCommand(command, {
-                        approvedExclusions: excludedTestTitles?.() ?? [],
-                    });
+                    // The standard Playwright machine report this run may carry, at a path derived from the
+                    // task's own id: unique per launch, and still findable from the id after a process
+                    // restart (see reportByTask). A run whose reporter set is not this tool's to place — or
+                    // one that already writes a report of its own — comes back with no report path and is
+                    // launched exactly as before.
+                    const streaming = streamingBackgroundCommand(command, { approvedExclusions: excludedTestTitles?.() ?? [] }, playwrightReportPathFor(id));
                     // A command that starts the suite more than once is refused here, before anything is
                     // written or launched: each walk measures the same code, and only the last is rewritten
                     // (X1 xr-molecule-flash-m157 +14:02 — two whole walks chained with `;`).
                     if (streaming.error)
                         return { error: streaming.error };
+                    if (streaming.reportPath !== undefined)
+                        reportByTask.set(id, streaming.reportPath);
                     // This tool already backgrounds the script. If its last statement also uses `&`,
                     // let the same shell wait for that child and preserve its exit code. Inferring its
                     // completion from output cannot work for silent commands such as `true &`.
@@ -2934,6 +2979,11 @@ export function buildTools(backend, config) {
                                 // 0 is the filter's). No tool budget applies to a detached run, so the command's
                                 // own `timeout` is the only bound here.
                                 const cut = commandCutRun(command, { exitCode: code, stdout, stderr: '' }, Date.now() - launchedAt, 0, output);
+                                // The machine report is read here exactly as a wait reads it: a grace return is the
+                                // same finished run, handed back without a task id.
+                                const graceReport = streaming.reportPath === undefined
+                                    ? null
+                                    : await readPlaywrightRunReport(backend, streaming.reportPath, sanitizeOutput);
                                 if (cut) {
                                     return {
                                         stdout,
@@ -2955,6 +3005,7 @@ export function buildTools(backend, config) {
                                                 : ` ${isSuiteRunCommand(command)
                                                     ? SUITE_OVER_BUDGET_ADVICE
                                                     : SPLIT_WORK_ADVICE}`),
+                                        ...(graceReport === null ? {} : { runReport: graceReport }),
                                     };
                                 }
                                 // The exit file holds the PIPELINE's code: when a stage this rewrite could not
@@ -2984,6 +3035,7 @@ export function buildTools(backend, config) {
                                     ...(output.length > MAX_OUTPUT_SIZE ? { truncated: true, fullOutput: log } : {}),
                                     ...(notes.length ? { note: notes.join(' ') } : {}),
                                     ...suiteBudgetField(budget),
+                                    ...(graceReport === null ? {} : { runReport: graceReport }),
                                 };
                             }
                             await new Promise((r) => setTimeout(r, 1_500));
@@ -3056,12 +3108,22 @@ export function buildTools(backend, config) {
                     ? Math.min(requestedMs, toolCeilingMs)
                     : toolCeilingMs;
                 const startedAt = Date.now();
-                const result = await backend.run(command, {
+                // The standard Playwright machine report, when this run names its own reporters
+                // (`withPlaywrightRunReport`): `json` joins that set and its output goes to a file of this
+                // call's own. A run that names no reporter is left exactly as written — its reporters are
+                // the suite config's, and replacing them would stop writing what the executor configured.
+                const reported = withPlaywrightRunReport(command, `/tmp/mol-pw-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}${PLAYWRIGHT_REPORT_SUFFIX}`);
+                const result = await backend.run(reported.command, {
                     cwd,
                     timeout: execTimeoutMs,
                     ...(effectiveBudgetMs ? { budgetMs: effectiveBudgetMs } : {}),
                 });
                 const elapsedMs = Date.now() - startedAt;
+                // Read once, after the run: the runner's own per-test identities and attachment paths, or
+                // the honest absence of a report. Never a verdict — pass/fail stays the caller's reading.
+                const runReport = reported.reportPath === null
+                    ? null
+                    : await readPlaywrightRunReport(backend, reported.reportPath, sanitizeOutput);
                 // The clamped ask is only worth a line when the clamp was felt: a command
                 // that asked for 600 s and finished in 25 s says nothing about splitting
                 // work, and the note read as a warning about a run that had already
@@ -3090,6 +3152,12 @@ export function buildTools(backend, config) {
                     : sanitizeOutput;
                 const stdout = grade(truncateMiddle(result.stdout, MAX_OUTPUT_SIZE));
                 const stderr = sanitizeOutput(truncateMiddle(result.stderr, MAX_OUTPUT_SIZE));
+                // Whether the stdout above is a middle cut of what the command printed. Said on the
+                // result because a reader that records what this call DELIVERED cannot otherwise tell
+                // a whole file from a holed one, and must not point at a holed output as "already
+                // above" (xr-molecule-flash-m420: a clipped multi-file `cat` armed both a shell and a
+                // read_file re-read hold on a helper whose middle never arrived).
+                const stdoutTruncated = result.stdout.length > MAX_OUTPUT_SIZE;
                 // A run a budget stopped is NOT a run that ended: it reports `status: 'cut_at_budget'`,
                 // never a 0 the pipeline produced, and names how far it got. Read from the command, the
                 // output and the clock in one place (cut-run.ts) so every reader of a run's verdict reads
@@ -3140,6 +3208,8 @@ export function buildTools(backend, config) {
                                         : isSuiteRunCommand(command)
                                             ? SUITE_OVER_BUDGET_ADVICE
                                             : SPLIT_WORK_ADVICE),
+                        ...(runReport === null ? {} : { runReport }),
+                        ...(stdoutTruncated ? { stdoutTruncated: true } : {}),
                     };
                 }
                 // A pipeline reports its LAST stage's code: `tsc | head` says 0 beside a printed type
@@ -3159,6 +3229,8 @@ export function buildTools(backend, config) {
                             note: [sleepNote, ceilingNote, traced.change, budgetNote].filter(Boolean).join(' '),
                         }
                         : {}),
+                    ...(runReport === null ? {} : { runReport }),
+                    ...(stdoutTruncated ? { stdoutTruncated: true } : {}),
                 };
             }
             catch (e) {
@@ -3268,6 +3340,12 @@ export function buildTools(backend, config) {
                     // a command that ended in `&` is still a launch acknowledgement, not a finished run.
                     if (endsInBackground(script))
                         detachedByTask.add(taskId);
+                    // …and so does the machine report the launch wired (`playwright-report.ts`): its path is
+                    // the task's own id derived, and only a script that sets it to exactly that path is this
+                    // platform's own — a `PLAYWRIGHT_JSON_OUTPUT_FILE` the executor chose is theirs.
+                    const expectedReport = playwrightReportPathFor(taskId);
+                    if (!reportByTask.has(taskId) && commandWritesReportTo(script, expectedReport))
+                        reportByTask.set(taskId, expectedReport);
                 }
                 catch (_error) {
                     // No script under that id: this process did not start the task, so
@@ -3651,6 +3729,15 @@ export function buildTools(backend, config) {
             // failing tests instead of leaving the executor to re-run the whole suite (xr-molecule-
             // flash-m101 +12:13: 139 tests, ~4 minutes, to check two fixes).
             const run = runByTask.get(taskId);
+            // The standard machine report this launch wired, when it did (`reportByTask`). Read once per
+            // finished wait: it is the runner's own record of each failing test's identity and of the
+            // artifacts saved for that test, so a diagnosis can stop reconstructing them from the log.
+            // A launch that carried no report path attaches nothing here — there is nothing honest to
+            // say about a run that was never asked to write one.
+            const reportPath = reportByTask.get(taskId);
+            const runReport = reportPath === undefined
+                ? null
+                : await readPlaywrightRunReport(backend, reportPath, sanitizeOutput);
             // What the REQUEST requires of this suite and the run left out: the narrowed re-run below
             // is composed from the run's own command, so without these it would measure the same wrong
             // configuration again (m182: the request names `TEST_MODE=fullstack`, the run and its
@@ -3687,6 +3774,7 @@ export function buildTools(backend, config) {
                     note: [cutRunSentence(cut), causes].filter((n) => Boolean(n)).join(' '),
                     stdout: sanitizeOutput(truncateMiddle(output, MAX_OUTPUT_SIZE)),
                     ...(output.length > MAX_OUTPUT_SIZE ? { truncated: true, fullOutput: log } : {}),
+                    ...(runReport === null ? {} : { runReport }),
                 };
             }
             // Same shaping as a foreground exec result, so the executor reads both
@@ -3726,6 +3814,7 @@ export function buildTools(backend, config) {
                     : {}),
                 stdout: sanitizeOutput(truncateMiddle(output, MAX_OUTPUT_SIZE)),
                 ...(output.length > MAX_OUTPUT_SIZE ? { truncated: true, fullOutput: log } : {}),
+                ...(runReport === null ? {} : { runReport }),
             };
         },
         async save_plan(input) {