@molecule/api-ai-tools 1.7.0 → 1.8.2

package/dist/cut-run.js

@@ -24,6 +24,12 @@
  *    `backends/sandbox.ts`), which reports 124 whatever the pipeline did, and returns everything
  *    printed until then. The budget is the tool's own, so its number belongs to the tool.
  *
+ * A runner's closing summary is what separates "used the bound and finished" from "stopped at the
+ * bound", but it is only half the evidence: Playwright prints one when its process is stopped too,
+ * listing just the tests it reached. So a summary is a finish only when it accounts for the total
+ * the runner announced before it started ({@link suiteSummary}) — a summary that does not
+ * reconcile is a stopped run like any other, and the result says so.
+ *
  * @module
  */
 import { commandTimeoutSeconds } from './command-position.js';
@@ -54,7 +60,8 @@ export function commandRunState(result) {
  * not a tolerance: a command killed at its bound reports AT LEAST the bound (the shell's own
  * bookkeeping runs after the kill, and this tool's round trip is on top), so any slack would only
  * make a SHORT bound fire on a run that finished inside it (`timeout 5 curl …` answering in 3 s).
- * A run that finished near its bound carried its runner's closing summary — {@link suiteTally}.
+ * A run that finished near its bound carried a summary that reconciles with its announced total —
+ * {@link suiteSummary}.
  *
  * @param boundSeconds - The bound the run was allowed.
  * @returns The elapsed ms a run stopped at that bound reports at least.
@@ -62,23 +69,126 @@ export function commandRunState(result) {
 function atBoundMs(boundSeconds) {
     return boundSeconds * 1000;
 }
+/** A runner's announcement of the whole walk — Playwright's `Running 139 tests using 1 worker`. */
+const ANNOUNCED_TOTAL = /^\s*Running\s+(\d+)\s+tests?\s+using\b/gm;
+/**
+ * One line of Playwright's end-of-run tally — `  1 failed`, `  36 passed (2.5m)`,
+ * `  1 did not run`.
+ */
+const SUMMARY_STATUS = /^\s*(\d+)\s+(passed|failed|flaky|skipped|interrupted|timed out|did not run)\b/gm;
+/**
+ * Vitest's end-of-run tally — `Tests  1 failed | 149 passed (151)` — whose parenthesised number is
+ * the total the line accounts for, and so its own announcement ({@link SuiteSummary.announced}).
+ */
+const VITEST_TESTS = /^\s*Tests\s+(.+?)\s+\((\d+)\)\s*$/gm;
+/** One status inside Vitest's `Tests` line — `149 passed`. */
+const VITEST_STATUS = /(\d+)\s+(passed|failed|skipped|todo)\b/g;
+/** Hurl's closing block, printed only by a run that walked its whole file list. */
+const HURL_TALLY = /\bExecuted files:\s*\d+/;
 /**
- * A runner's closing summary, printed only by a run that walked its whole suite: Hurl's
- * `Executed files:` block and the `N passed` / `N failed` / `N flaky` line Playwright and Vitest
- * print when they finish.
+ * The marker {@link truncateMiddle} puts before the tally lines it restores — read only when the
+ * truncated text carries no tally line of its own.
+ */
+const RESTORED_TALLY = /\[run tally\]\s*([^\n]*)/g;
+/** One status inside a restored tally line — `36 passed`. */
+const RESTORED_STATUS = /(\d+)\s+(passed|failed|flaky|skipped|interrupted|timed out|did not run)\b/g;
+/**
+ * Add the statuses in `text` to a running tally.
+ *
+ * Every status counts the same way: a test the runner skipped or left "did not run" was still
+ * reached, which is what a stopped run's count measures.
  *
- * This is what separates "stopped at the bound" from "used the bound and finished": a suite that
- * printed its summary ran to its end, and is read as the run it was.
+ * @param text - A tally line, or a block of them.
+ * @param re - The status pattern to read them with.
+ * @param counts - The tally to add to.
  */
-const SUITE_TALLY = /\bExecuted files:\s*\d+|\b\d+\s+(?:passed|failed|flaky|skipped)\b/;
+function addStatuses(text, re, counts) {
+    for (const m of text.matchAll(re)) {
+        counts.saw = true;
+        counts.accounted += Number(m[1]);
+    }
+}
 /**
- * Whether text carries a runner's closing summary ({@link SUITE_TALLY}).
+ * What the runner's closing summary accounts for, or null when it printed none.
+ *
+ * Three runners' summaries are read, each by its own wording: Playwright's per-status lines
+ * (reconciled against its `Running N tests` announcement), Vitest's single `Tests …` line (its own
+ * parenthesised total), and Hurl's `Executed files:` block (which it prints only at the end, and
+ * which announces no total — so it is a finish by construction).
+ *
+ * @param text - The run's stdout and stderr, RAW (a truncated copy can lose the announcement).
+ * @returns The summary, or null when the text carries none.
+ */
+export function suiteSummary(text) {
+    if (typeof text !== 'string' || !text)
+        return null;
+    let announced = null;
+    for (const m of text.matchAll(ANNOUNCED_TOTAL))
+        announced = Number(m[1]);
+    const counts = { accounted: 0, saw: false };
+    addStatuses(text, SUMMARY_STATUS, counts);
+    if (!counts.saw) {
+        // Only when no tally line of its own survived: the restored line is a copy of lines that may
+        // also be present, and adding both would over-count a cut run into a finish.
+        for (const m of text.matchAll(RESTORED_TALLY))
+            addStatuses(m[1] ?? '', RESTORED_STATUS, counts);
+    }
+    if (counts.saw) {
+        return {
+            announced,
+            accounted: counts.accounted,
+            finished: announced === null || counts.accounted >= announced,
+        };
+    }
+    const vitest = [...text.matchAll(VITEST_TESTS)].at(-1);
+    if (vitest) {
+        const total = Number(vitest[2]);
+        const line = { accounted: 0, saw: true };
+        addStatuses(vitest[1] ?? '', VITEST_STATUS, line);
+        return { announced: total, accounted: line.accounted, finished: line.accounted >= total };
+    }
+    // Hurl prints `Executed files:` only after walking its whole list.
+    if (HURL_TALLY.test(text))
+        return { announced: null, accounted: 0, finished: true };
+    return null;
+}
+/**
+ * Whether text carries a runner's closing summary.
+ *
+ * A summary is NOT a finish on its own — a stopped Playwright run prints one too. Use
+ * {@link suiteSummary} and its `finished` for that.
  *
  * @param text - The run's stdout and stderr.
  * @returns True when the runner's own end-of-run summary is there.
  */
 export function suiteTally(text) {
-    return SUITE_TALLY.test(text);
+    return suiteSummary(text) !== null;
+}
+/** A failure count in a runner's own tally — `1 failed`, `Tests  1 failed | 149 passed (151)`. */
+const FAILED_TALLY = /\b[1-9]\d*\s+failed\b/;
+/**
+ * The exit code a finished suite run may report.
+ *
+ * The code in a background result is the code of the command's LAST pipeline stage. When a stage
+ * after the suite runner still consumes its output (`| tee run.log`, or a filter the platform could
+ * not prove output-only), that stage produced the code, not the run — and `… | grep … | tail -20`
+ * exited 0 for a run with a failure in it (xr-molecule-flash-m101 +25:54). No code is reported
+ * then: the log's own tally decides.
+ *
+ * The same reading covers a code of 0 beside a tally that names a failure: whatever ended the
+ * pipeline, a run whose log counts a failure did not pass.
+ *
+ * @param exitCode - The code the pipeline reported (null when it has none).
+ * @param output - The run's full log.
+ * @param piped - Whether a pipeline stage after the suite runner still consumes its output.
+ * @returns The code the run may report, or null when the code is the filter's or contradicts the tally.
+ */
+export function suiteRunExitCode(exitCode, output, piped) {
+    if (piped)
+        return null;
+    if (exitCode === 0 && FAILED_TALLY.test(output))
+        return null;
+    return exitCode;
 }
 /** The last thing a run printed: its last non-blank line, as one line and short enough to quote. */
 function lastPrinted(text) {
@@ -98,19 +208,26 @@ const PROGRESS_LINE = /^\s*\[(\d+)\/(\d+)\]/gm;
  * What the runner's own output says the run got through.
  *
  * Hurl prints a line per finished file and no total unless it finished; Playwright's line reporter
- * prints `[n/K]` with both numbers. Neither is inferred from the command — a run that printed
- * nothing says nothing, which is what `null` means here.
+ * prints `[n/K]` with both numbers, and its end-of-run summary (with the `Running N tests` total it
+ * is reconciled against) says how far a stopped walk got. Neither is inferred from the command — a
+ * run that printed nothing says nothing, which is what `null` means here.
  *
- * @param text - The run's stdout and stderr.
+ * @param text - The run's stdout and stderr, raw.
  * @param suite - Whether the command runs a suite.
- * @returns How many finished, how many the run was walking, and the noun.
+ * @param summary - The closing summary the text carries, when it carries one.
+ * @returns How far it got, how many it was walking, and the noun.
  */
-function runProgress(text, suite) {
+function runProgress(text, suite, summary) {
     const files = new Set();
     for (const m of text.matchAll(HURL_FILE_LINE))
         files.add(m[1] ?? '');
     if (files.size > 0)
         return { ran: files.size, total: null, noun: 'files' };
+    // A summary that does not account for its announced total: both numbers come from the runner's
+    // own lines, so the sentence can say `Ran 38 of 139` without the caller counting anything.
+    if (summary && summary.announced !== null) {
+        return { ran: summary.accounted, total: summary.announced, noun: 'tests' };
+    }
     let ran = null;
     let total = null;
     for (const m of text.matchAll(PROGRESS_LINE)) {
@@ -127,6 +244,9 @@ function runProgress(text, suite) {
  *
  * Evidence, in order — never a guess:
  *
+ * - the runner's own summary, when it printed one: it is a finish only if it accounts for the total
+ *   the runner announced. A summary that accounts for fewer is a walk a process stopped early, and
+ *   falls through to the branches below with its own counts ({@link suiteSummary}).
  * - `timeout`'s own 124 (the code the backend's wrapper returns whenever the TOOL's budget fired,
  *   whatever the pipeline ended with) — and, when the clock says the command's own smaller bound
  *   ran out first and less than the budget, that bound instead.
@@ -135,14 +255,19 @@ function runProgress(text, suite) {
  *   killed at its own bound. Its exit code, when the pipeline handed one back, is the filter's.
  * - the run used this tool's whole budget behind a filter that withheld its output, and printed no
  *   closing summary: the budget stopped it, and no code in the result is the run's.
+ * - a summary that does not account for its announced total, with neither bound fired: something
+ *   outside this platform stopped the process ({@link CutBy} `process-stop`).
  *
  * @param command - The command the executor sent.
  * @param result - Its result.
  * @param elapsedMs - How long the command ran, in ms.
  * @param budgetSeconds - This tool's foreground budget, in seconds (0 when it has none).
+ * @param rawOutput - The run's output BEFORE truncation, when the caller has it: the announcement
+ *   a summary is reconciled against is the first line a long run prints, which is exactly what a
+ *   size cap drops. Detection reads this; the sentence's last line still comes from `result`.
  * @returns The stopped run, or null.
  */
-export function commandCutRun(command, result, elapsedMs, budgetSeconds = 0) {
+export function commandCutRun(command, result, elapsedMs, budgetSeconds = 0, rawOutput) {
     if (typeof command !== 'string' || !command.trim())
         return null;
     if (result === null || typeof result !== 'object')
@@ -152,12 +277,18 @@ export function commandCutRun(command, result, elapsedMs, budgetSeconds = 0) {
     const r = result;
     const exitCode = typeof r.exitCode === 'number' ? r.exitCode : null;
     const text = `${String(r.stdout ?? '')}\n${String(r.stderr ?? '')}`;
-    // A suite that printed its summary ran to its end, whatever it was wrapped in.
-    if (suiteTally(text))
+    const detected = typeof rawOutput === 'string' ? rawOutput : text;
+    // A runner's summary is a finish only when it accounts for the total the runner announced. A run
+    // stopped at 36 of 139 prints the same `36 passed` line a finished run does (X1 xr-molecule-flash-
+    // m101 +12:13 read `36 passed` as `exitCode: 0` and moved on), so the announcement decides.
+    const summary = suiteSummary(detected);
+    // Only a summary that ACCOUNTS for the announced total ends the search for a stop. No summary
+    // at all is not a finish — it is the case the bounds below exist for.
+    if (summary?.finished)
         return null;
     const suite = isSuiteRunCommand(command);
     const withheld = /\|\s*(?:tail|head|grep|egrep|fgrep|sort|uniq|wc|jq)\b/.test(command);
-    const progress = runProgress(text, suite);
+    const progress = runProgress(detected, suite, summary);
     const doing = lastPrinted(text);
     const declared = commandTimeoutSeconds(command);
     // A command whose own bound is inside this tool's budget is stopped by ITS bound: a larger one
@@ -203,6 +334,21 @@ export function commandCutRun(command, result, elapsedMs, budgetSeconds = 0) {
             doing,
         };
     }
+    // The runner printed a summary that does not account for the total it announced, and neither
+    // bound above fired: the process was stopped from outside the run. A run that used the whole
+    // budget is the backend's deadline (which sits just past it); anything else is a stop this tool
+    // does not own. Either way the summary counts are all that ran, and a pipeline's 0 is not the
+    // run's code — the run never reached its own verdict.
+    if (summary !== null && summary.announced !== null) {
+        const usedBudget = budgetSeconds > 0 && elapsedMs >= atBoundMs(budgetSeconds);
+        return {
+            seconds: usedBudget ? budgetSeconds : Math.max(1, Math.round(elapsedMs / 1000)),
+            stoppedBy: usedBudget ? 'tool-budget' : 'process-stop',
+            exitCode: withheld || exitCode === 0 ? null : exitCode,
+            ...progress,
+            doing,
+        };
+    }
     return null;
 }
 /**
@@ -239,29 +385,36 @@ export function cutRunFacts(result) {
     };
 }
 /**
- * The first line of a stopped run's result: how long it was allowed, what stopped it, how far it
- * got, and the last thing it printed.
+ * The first line of a stopped run's result: how far it got, what stopped it, the last thing it
+ * printed, and what the reader must do next.
  *
  * Written to be quotable by the model in one sentence and to leave no room for "nearly passing":
  * the counts come from the runner's own output ({@link runProgress}), and a `total` the caller
- * read elsewhere (the suite's own file count) fills in the "M of K" it can then state.
+ * read elsewhere (the suite's own file count) fills in the "of N" it can then state. The sentence
+ * says how many tests the stop left unrun — a number a reader cannot round up to "the suite
+ * passed" — and hands over the one move that survives a long run: run it in the background.
  *
  * @param run - The stopped run.
  * @returns The sentence.
  */
 export function cutRunSentence(run) {
-    const by = run.stoppedBy === 'tool-budget' ? "this tool's limit" : `its own \`timeout ${run.seconds}\``;
-    const lead = `This run was stopped after ${run.seconds}s (${by})`;
-    const count = run.ran !== null && run.total !== null
-        ? `: ${run.ran} of ${run.total} ${run.noun} ran, the rest did not run`
+    const by = run.stoppedBy === 'tool-budget'
+        ? "this tool's limit"
+        : run.stoppedBy === 'command-timeout'
+            ? `its own \`timeout ${run.seconds}\``
+            : 'a process kill outside this tool (no `timeout` of its own and no limit of this tool had fired)';
+    const background = 'run it in the background (run_in_background + wait_for_task)';
+    const missing = run.ran !== null && run.total !== null ? run.total - run.ran : null;
+    const lead = missing !== null
+        ? `Ran ${run.ran} of ${run.total} ${run.noun} in ${run.seconds} s and was stopped by ${by} — the ${missing} it never reached ${missing === 1 ? 'has' : 'have'} not run; ${background}`
         : run.ran !== null
-            ? `: ${run.ran} ${run.noun} ran and the rest did not run`
-            : ' before it finished';
-    const doing = run.doing ? `; the last thing it was doing: ${run.doing}` : '';
+            ? `Ran ${run.ran} ${run.noun} in ${run.seconds} s and was stopped by ${by} — the rest have not run; ${background}`
+            : `This run was stopped after ${run.seconds}s (${by}) before it finished; ${background}`;
+    const doing = run.doing ? ` The last thing it was doing: ${run.doing}.` : '';
     // Why the result carries no code: without this the model reads the missing field as an
     // omission, and the number it used to read there was the pipeline's own 0.
     const code = run.exitCode === null
         ? ' It has no exit code of its own to report — the one this pipeline produced belongs to the filter, not to the run.'
         : '';
-    return `${lead}${count}${doing}.${code}`;
+    return `${lead}.${doing}${code}`;
 }

package/dist/suite-overlap.d.ts

@@ -60,9 +60,13 @@ export declare function suiteCommandTarget(command: string): string;
  * @param locations - The failing `file:line`s to re-run, as the run's own log printed them — or,
  *   for a run that started outside the suite, the absolute form Playwright matches each file
  *   argument against.
+ * @param excluded - The test titles the request carves out. They are inverted out
+ *   (`--grep-invert`) so a re-run of the failing locations cannot report one of them again —
+ *   xr-molecule-flash-m101 re-ran the whole 139-test suite and spent ~4 minutes to be told about
+ *   a test the request had already said does not count.
  * @returns The scoped command, or the command unchanged when it runs no Playwright suite.
  */
-export declare function scopedRerunCommand(command: string, locations: readonly string[]): string;
+export declare function scopedRerunCommand(command: string, locations: readonly string[], excluded?: readonly string[]): string;
 /**
  * One suite run, as the rule that decides whether a second may start beside it reads it.
  *

package/dist/suite-overlap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"suite-overlap.d.ts","sourceRoot":"","sources":["../src/suite-overlap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAKH;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAoB1D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAexF;AAED;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,+FAA+F;IAC/F,SAAS,EAAE,OAAO,CAAA;IAClB,oFAAoF;IACpF,MAAM,EAAE,MAAM,CAAA;IACd;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC3B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,gBAAgB,EACzD,SAAS,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,EAC7B,QAAQ,EAAE,SAAS,CAAC,EAAE,GACrB,CAAC,GAAG,IAAI,CAMV;AAqDD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAQvD"}
+{"version":3,"file":"suite-overlap.d.ts","sourceRoot":"","sources":["../src/suite-overlap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAMH;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAoB1D;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,QAAQ,GAAE,SAAS,MAAM,EAAO,GAC/B,MAAM,CA2BR;AAED;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,+FAA+F;IAC/F,SAAS,EAAE,OAAO,CAAA;IAClB,oFAAoF;IACpF,MAAM,EAAE,MAAM,CAAA;IACd;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC3B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,gBAAgB,EACzD,SAAS,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,EAC7B,QAAQ,EAAE,SAAS,CAAC,EAAE,GACrB,CAAC,GAAG,IAAI,CAMV;AAqDD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAQvD"}

package/dist/suite-overlap.js

@@ -30,6 +30,7 @@
  */
 import { commandSegments } from './command-position.js';
 import { commandRunsNoTests } from './no-test-run.js';
+import { shellQuote } from './utilities.js';
 /**
  * A command with its heredoc bodies removed: the runs, kills and hosts it names in a file it
  * WRITES are not what the command itself does.
@@ -83,9 +84,13 @@ export function suiteCommandTarget(command) {
  * @param locations - The failing `file:line`s to re-run, as the run's own log printed them — or,
  *   for a run that started outside the suite, the absolute form Playwright matches each file
  *   argument against.
+ * @param excluded - The test titles the request carves out. They are inverted out
+ *   (`--grep-invert`) so a re-run of the failing locations cannot report one of them again —
+ *   xr-molecule-flash-m101 re-ran the whole 139-test suite and spent ~4 minutes to be told about
+ *   a test the request had already said does not count.
  * @returns The scoped command, or the command unchanged when it runs no Playwright suite.
  */
-export function scopedRerunCommand(command, locations) {
+export function scopedRerunCommand(command, locations, excluded = []) {
     const at = command.search(/\bplaywright\s+test\b/);
     if (at === -1)
         return command;
@@ -96,10 +101,19 @@ export function scopedRerunCommand(command, locations) {
     const end = rest.search(/&&|\|\||;|\|/);
     const statement = end === -1 ? rest : rest.slice(0, end);
     const tail = end === -1 ? '' : rest.slice(end);
+    // One literal alternation, regex-escaped and shell-quoted: a title carries parentheses and
+    // quotes (`should only allow comment author to delete`) that are regex and shell syntax alike.
+    const invert = excluded.length > 0 && !/--grep-invert\b/.test(command)
+        ? ` --grep-invert ${shellQuote(excluded
+            .map((t) => t.replace(/\s+/g, ' ').trim())
+            .filter(Boolean)
+            .map((t) => t.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
+            .join('|'))}`
+        : '';
     const scoped = statement
         .replace(/\s*--last-failed\b/g, '')
         .replace(/\s*--retries(?:[= ]\d+)?/g, '')
-        .replace(/^(playwright\s+test)\b/, `$1 ${locations.join(' ')} --retries=0`);
+        .replace(/^(playwright\s+test)\b/, `$1 ${locations.join(' ')} --retries=0${invert}`);
     return `${head}${scoped}${tail}`;
 }
 /**

package/dist/tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AA+F9C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAahG;AAyHD,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAiEnE;;;GAGG;AACH,eAAO,MAAM,iBAAiB,QAEA,CAAA;AAE9B;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB,QAI6C,CAAA;AAmBlF;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAUhE;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAsBxE;AAgDD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,CAAC,EAAE,eAAe,GAAG,MAAM,EAAE,CAovExF"}
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AA0G9C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAahG;AAyHD,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAkEnE;;;GAGG;AACH,eAAO,MAAM,iBAAiB,QAEA,CAAA;AAE9B;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB,QAI6C,CAAA;AAmBlF;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAUhE;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAsBxE;AAgDD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,CAAC,EAAE,eAAe,GAAG,MAAM,EAAE,CAyzExF"}

package/dist/tools.js

@@ -6,7 +6,7 @@
  *
  * @module
  */
-import { commandCutRun, CUT_AT_BUDGET, cutRunSentence } from './cut-run.js';
+import { commandCutRun, CUT_AT_BUDGET, cutRunSentence, suiteRunExitCode } from './cut-run.js';
 import { addChangeSpan, changedSpan, countLines, renderEditExcerpt, renderSmallFile, } from './edit-excerpt.js';
 import { guardToolExecute, missingParamError, ToolInputError } from './input-normalizer.js';
 import { TOOL_SCHEMAS } from './schemas.js';
@@ -36,6 +36,14 @@ const outputFileByTask = new Map();
  * resolves the failing test's `file:line` against the wrong suite.
  */
 const runByTask = new Map();
+/**
+ * Why a finished suite run's result carries no exit code: the code a pipeline reports is its last
+ * stage's, and a stage after the runner (or a code of 0 beside a failure in the tally) is not the
+ * run's verdict. Said in the result so the missing field does not read as an omission.
+ */
+const FILTERED_EXIT_NOTE = 'No exit code is reported for this run: a stage after the test runner produced the pipeline’s ' +
+    'code (or the code says 0 beside a failure in the tally), so read the pass/fail tally in the ' +
+    'log instead.';
 /**
  * Task ids whose own-output file has already been looked for this process.
  * {@link outputFileByTask} is empty for every task after a restart — it is
@@ -222,7 +230,7 @@ function runningNote(clauses) {
     return `${joined[0].toUpperCase()}${joined.slice(1)}.`;
 }
 import { diagnosisTraceCommand } from './trace-artifacts.js';
-import { checkBlockedCommand, declaredBudgetSeconds, DEFAULT_SEARCH_EXCLUDED_DIRS, directoryReadHint, earlyReturnCause, emptyCallError, failureCausesNote, findPathArgs, findPatternArgs, fusedLine, htmlOutline, isCommandTimeout, isEnvFilePath, isOutsideRoot, isPlaywrightRunCommand, isSuiteRunCommand, isValidGlob, linesWithinSerialized, literalDirPrefix, 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, searchTimeoutError, serializedChars, shellQuote, sliceLines, SMALL_FILE_WHOLE_CHARS, streamingBackgroundCommand, stripControlChars, suiteRunPriorityLaunch, truncateMiddle, universalCause, whitespaceTolerantReplace, } from './utilities.js';
+import { checkBlockedCommand, declaredBudgetSeconds, DEFAULT_SEARCH_EXCLUDED_DIRS, directoryReadHint, earlyReturnCause, emptyCallError, failureCausesNote, findPathArgs, findPatternArgs, fusedLine, htmlOutline, isCommandTimeout, isEnvFilePath, isOutsideRoot, isPlaywrightRunCommand, isSuiteRunCommand, isValidGlob, linesWithinSerialized, literalDirPrefix, 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, searchTimeoutError, serializedChars, shellQuote, sliceLines, SMALL_FILE_WHOLE_CHARS, streamingBackgroundCommand, stripControlChars, suiteRunPipedAfterRunner, 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.
@@ -377,7 +385,7 @@ function batchFailureError(path, total, failures) {
  * @returns Array of AITool objects ready to pass to an AI provider
  */
 export function buildTools(backend, config) {
-    const { include, exclude, pathGuards = true, symlinkGuards = false, redactSecrets: doRedact = true, blockDangerousCommands = false, blockCommand, execTimeoutMs = 120_000, commandBudgetMs, overCeilingGraceMs = OVER_CEILING_GRACE_MS, searchExcludedDirs, outlineLargeHtml, onAfterWrite, onFileDiff, onFileChange, } = config ?? {};
+    const { include, exclude, pathGuards = true, symlinkGuards = false, redactSecrets: doRedact = true, blockDangerousCommands = false, blockCommand, execTimeoutMs = 120_000, commandBudgetMs, overCeilingGraceMs = OVER_CEILING_GRACE_MS, searchExcludedDirs, outlineLargeHtml, excludedTestTitles, onAfterWrite, onFileDiff, onFileChange, } = config ?? {};
     const root = backend.projectRoot;
     // A host-filesystem backend with escape guards off is the combination the
     // audit flagged: `pathGuards` off lets `..` paths out of the workspace,
@@ -1879,6 +1887,9 @@ export function buildTools(backend, config) {
                         outputFileByTask.set(id, ownFile);
                     runByTask.set(id, { command: streaming.command, cwd });
                     await backend.writeFile(script, `${streaming.command}\n`);
+                    // The clock the grace return below reports a stopped run against: the command is
+                    // started here, and how long it ran is what a stop at its own bound is read from.
+                    const launchedAt = Date.now();
                     await backend.run(`nohup sh -c ${shellQuote(prioritized.launch)} ` +
                         `> /dev/null 2>&1 & echo $! > /tmp/${id}.pid`, { cwd, timeout: 15_000 });
                     // A command backgrounded only for the budget it ASKED for often ends in
@@ -1908,12 +1919,43 @@ export function buildTools(backend, config) {
                                     // Finished without writing anything: an empty output is still a result.
                                     output = '';
                                 }
+                                const stdout = sanitizeOutput(truncateMiddle(output, MAX_OUTPUT_SIZE));
+                                // A grace return is a foreground-shaped result, so it carries the same stop: this
+                                // command was started because its output is withheld until it ends (a Playwright
+                                // run behind a pipe), and a run that printed a tally accounting for fewer tests
+                                // than it announced was stopped — not "Finished … with exit code 0" (the pipeline's
+                                // 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);
+                                if (cut) {
+                                    return {
+                                        stdout,
+                                        stderr: '',
+                                        status: CUT_AT_BUDGET,
+                                        exitCode: cut.exitCode,
+                                        cutRun: cut,
+                                        ...(output.length > MAX_OUTPUT_SIZE
+                                            ? { truncated: true, fullOutput: log }
+                                            : {}),
+                                        error: `${cutRunSentence(cut)} ` +
+                                            (isSuiteRunCommand(command) ? SUITE_OVER_BUDGET_ADVICE : SPLIT_WORK_ADVICE),
+                                    };
+                                }
+                                // The exit file holds the PIPELINE's code: when a stage this rewrite could not
+                                // prove is output-only still follows the suite runner (`| tee run.log`), that code
+                                // is the filter's — report none and let the log's tally decide (m101 +25:54).
+                                const piped = suiteRunPipedAfterRunner(streaming.command);
+                                const reported = suiteRunExitCode(code, output, piped);
+                                const notes = [
+                                    ...streaming.changes,
+                                    ...(reported === null ? [FILTERED_EXIT_NOTE] : []),
+                                ];
                                 return {
-                                    stdout: sanitizeOutput(truncateMiddle(output, MAX_OUTPUT_SIZE)),
+                                    stdout,
                                     stderr: '',
-                                    exitCode: code,
+                                    exitCode: reported,
                                     ...(output.length > MAX_OUTPUT_SIZE ? { truncated: true, fullOutput: log } : {}),
-                                    ...(streaming.changes.length ? { note: streaming.changes.join(' ') } : {}),
+                                    ...(notes.length ? { note: notes.join(' ') } : {}),
                                 };
                             }
                             await new Promise((r) => setTimeout(r, 1_500));
@@ -2005,7 +2047,12 @@ export function buildTools(backend, config) {
                 // output and the clock in one place (cut-run.ts) so every reader of a run's verdict reads
                 // the same state (X1 xr-molecule-flash-m93: `timeout 280 hurl … | tail -60` came back
                 // `exitCode: 0` after 284 s and four of thirteen files, and the executor re-sent it).
-                const cut = commandCutRun(command, { exitCode: result.exitCode, stdout, stderr }, elapsedMs, budgetSeconds);
+                const cut = commandCutRun(command, { exitCode: result.exitCode, stdout, stderr }, elapsedMs, budgetSeconds, 
+                // Detection reads the RAW output: `truncateMiddle` keeps the head and the tail, and the
+                // runner's announcement (`Running 139 tests using 1 worker`) is the first line a long run
+                // prints — the one a size cap drops first. Only the counts and the tally come from here;
+                // what the result quotes is still the sanitized, truncated text.
+                `${result.stdout}\n${result.stderr}`);
                 if (cut) {
                     const cutLead = cutRunSentence(cut);
                     return {
@@ -2400,16 +2447,27 @@ export function buildTools(backend, config) {
             // 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);
+            // How this run was started, so the note can hand over the narrowed re-run of exactly its
+            // 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 tests the request excludes are not causes to fix, and the re-run below inverts them
+            // out — a result must never ask the executor to fix a test it also says does not count.
+            // The log's own path rides along so a recap that leaves causes out can hand over the ONE
+            // grep that prints their bodies: the stdout above is cut in the middle, so the log is where
+            // they still are whole.
+            const causes = failureCausesNote(output, excludedTestTitles?.() ?? [], run ? { ...run, log: ownFile ?? log } : undefined);
             // A backgrounded run is under no tool budget, and the exit file hands back the PIPELINE's
             // code — so a suite killed at a `timeout 280` the command carried behind a `| tail` reports
             // 0 here too. The run's start is in its own id ({@link taskStartedAt}), so the bound it used
             // is readable without new state: say stopped, and never hand the pipeline's 0 back as the
             // run's (X1 xr-molecule-flash-m93 re-sent that run three times).
-            const run = runByTask.get(taskId);
             const startedAtMs = taskStartedAt(taskId);
             const cut = run && startedAtMs !== null
-                ? commandCutRun(run.command, { exitCode, stdout: output, stderr: '' }, Date.now() - startedAtMs, 0)
+                ? commandCutRun(run.command, { exitCode, stdout: output, stderr: '' }, Date.now() - startedAtMs, 0, 
+                // Same reason as the foreground path: the log is raw here, and the returned stdout
+                // below is the truncated copy — detection must not read that copy.
+                output)
                 : null;
             if (cut) {
                 return {
@@ -2424,12 +2482,19 @@ export function buildTools(backend, config) {
                 };
             }
             // Same shaping as a foreground exec result, so the executor reads both
-            // the same way.
+            // the same way. The exit file holds the PIPELINE's code: when a stage this rewrite could not
+            // prove is output-only still follows the suite runner (`| tee run.log`), that code is the
+            // filter's — report none and let the log's tally decide (m101 +25:54).
+            const piped = run ? suiteRunPipedAfterRunner(run.command) : false;
+            const reported = suiteRunExitCode(exitCode, output, piped);
+            const noCodeNote = reported === null ? FILTERED_EXIT_NOTE : null;
             return {
                 taskId,
-                exitCode,
+                exitCode: reported,
                 waitedMs,
-                ...(causes ? { note: causes } : {}),
+                ...(causes || noCodeNote
+                    ? { note: [causes, noCodeNote].filter((n) => Boolean(n)).join(' ') }
+                    : {}),
                 stdout: sanitizeOutput(truncateMiddle(output, MAX_OUTPUT_SIZE)),
                 ...(output.length > MAX_OUTPUT_SIZE ? { truncated: true, fullOutput: log } : {}),
             };

package/dist/trace-artifacts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trace-artifacts.d.ts","sourceRoot":"","sources":["../src/trace-artifacts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAKH,iEAAiE;AACjE,MAAM,WAAW,YAAY;IAC3B,gCAAgC;IAChC,MAAM,EAAE,MAAM,CAAA;IACd,iGAAiG;IACjG,IAAI,EAAE,MAAM,CAAA;IACZ,uEAAuE;IACvE,MAAM,EAAE,MAAM,CAAA;CACf;AAED,iGAAiG;AACjG,MAAM,WAAW,aAAa;IAC5B,0FAA0F;IAC1F,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACnB,+EAA+E;IAC/E,IAAI,EAAE,MAAM,CAAA;IACZ,6FAA6F;IAC7F,QAAQ,EAAE,YAAY,EAAE,CAAA;IACxB,0DAA0D;IAC1D,OAAO,EAAE,MAAM,EAAE,CAAA;CAClB;AAED,sDAAsD;AACtD,eAAO,MAAM,mBAAmB,KAAK,CAAA;AAErC,sDAAsD;AACtD,eAAO,MAAM,mBAAmB,IAAI,CAAA;AAEpC,4DAA4D;AAC5D,eAAO,MAAM,kBAAkB,IAAI,CAAA;AAEnC,uDAAuD;AACvD,eAAO,MAAM,oBAAoB,IAAI,CAAA;AAErC,iDAAiD;AACjD,eAAO,MAAM,uBAAuB,IAAI,CAAA;AAExC,gEAAgE;AAChE,eAAO,MAAM,oBAAoB,KAAK,CAAA;AAEtC;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,oBAAoB,QAAO,MA+LvC,CAAA;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,EAAE,CAyBnE;AAiBD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,aAAa,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CA4B/F;AAaD;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAG9D;AAED,iFAAiF;AACjF,eAAO,MAAM,oBAAoB,8BAA8B,CAAA;AAuE/D,oGAAoG;AACpG,MAAM,WAAW,qBAAqB;IACpC,0BAA0B;IAC1B,OAAO,EAAE,MAAM,CAAA;IACf,4EAA4E;IAC5E,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CACtB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,qBAAqB,CAAC,IAAI,EAAE;IAChD,OAAO,EAAE,MAAM,CAAA;IACf,GAAG,EAAE,MAAM,CAAA;IACX,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;CAC5C,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAgBjC"}
+{"version":3,"file":"trace-artifacts.d.ts","sourceRoot":"","sources":["../src/trace-artifacts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAMH,iEAAiE;AACjE,MAAM,WAAW,YAAY;IAC3B,gCAAgC;IAChC,MAAM,EAAE,MAAM,CAAA;IACd,iGAAiG;IACjG,IAAI,EAAE,MAAM,CAAA;IACZ,uEAAuE;IACvE,MAAM,EAAE,MAAM,CAAA;CACf;AAED,iGAAiG;AACjG,MAAM,WAAW,aAAa;IAC5B,0FAA0F;IAC1F,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACnB,+EAA+E;IAC/E,IAAI,EAAE,MAAM,CAAA;IACZ,6FAA6F;IAC7F,QAAQ,EAAE,YAAY,EAAE,CAAA;IACxB,0DAA0D;IAC1D,OAAO,EAAE,MAAM,EAAE,CAAA;CAClB;AAED,sDAAsD;AACtD,eAAO,MAAM,mBAAmB,KAAK,CAAA;AAErC,sDAAsD;AACtD,eAAO,MAAM,mBAAmB,IAAI,CAAA;AAEpC,4DAA4D;AAC5D,eAAO,MAAM,kBAAkB,IAAI,CAAA;AAEnC,uDAAuD;AACvD,eAAO,MAAM,oBAAoB,IAAI,CAAA;AAErC,iDAAiD;AACjD,eAAO,MAAM,uBAAuB,IAAI,CAAA;AAExC,gEAAgE;AAChE,eAAO,MAAM,oBAAoB,KAAK,CAAA;AAEtC;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,oBAAoB,QAAO,MA+LvC,CAAA;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,EAAE,CAyBnE;AAiBD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,aAAa,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CA4B/F;AAaD;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAG9D;AAED,iFAAiF;AACjF,eAAO,MAAM,oBAAoB,8BAA8B,CAAA;AAuG/D,oGAAoG;AACpG,MAAM,WAAW,qBAAqB;IACpC,0BAA0B;IAC1B,OAAO,EAAE,MAAM,CAAA;IACf,4EAA4E;IAC5E,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CACtB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,qBAAqB,CAAC,IAAI,EAAE;IAChD,OAAO,EAAE,MAAM,CAAA;IACf,GAAG,EAAE,MAAM,CAAA;IACX,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;CAC5C,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAyBjC"}

package/dist/trace-artifacts.js

@@ -26,6 +26,7 @@
  *
  * @module
  */
+import { commandSegments } from './command-position.js';
 import { isDiagnosisRun } from './suite-overlap.js';
 import { isPlaywrightRunCommand } from './utilities.js';
 /** How many traces one read reports, newest first. */
@@ -374,6 +375,39 @@ export const DIAGNOSIS_TRACE_FLAG = '--trace=retain-on-failure';
 function namesTraceMode(command) {
     return /(?:^|[\s;&|(])--trace(?:=|\s)/.test(command);
 }
+/**
+ * Where the `test` word of the command's Playwright run ends, or null when it has none that the
+ * shell parse can place.
+ *
+ * The flag has to land INSIDE the Playwright step, not at the end of the whole command: a run
+ * Flash sends almost every time ends `… 2>&1 | tail -60` or `… > log 2>&1; echo "exit=$?";
+ * grep -c "" log`, and a flag appended after those is an operand of `tail`/`grep` — GNU `tail`
+ * refuses it outright (`tail: option used in invalid context -- 6`) and Playwright never sees it
+ * (xr-molecule-flash-m102 +07:40 → +07:53).
+ *
+ * The step is found by the package's own shell parse ({@link commandSegments}), the one every
+ * runner classifier reads: it answers which SEGMENT runs `playwright test` in command position,
+ * so a `playwright test` named in an argument (`grep -n "playwright test" e2e/README.md`) is not
+ * a run and is left alone. Each segment's text is its program and arguments re-joined with single
+ * spaces, so its offset in the command is found by locating that text, walking the segments in
+ * order. A segment whose text cannot be located verbatim (irregular whitespace) ends the walk —
+ * null, and the caller adds nothing rather than splicing into a guess.
+ *
+ * @param command - The shell command.
+ * @returns The offset just after `test`, or null.
+ */
+function playwrightTestWordEnd(command) {
+    let cursor = 0;
+    for (const segment of commandSegments(command)) {
+        const at = command.indexOf(segment.text, cursor);
+        if (at < 0)
+            return null;
+        cursor = at + segment.text.length;
+        if (/^playwright\s+test\b/.test(segment.text))
+            return at + 'playwright test'.length;
+    }
+    return null;
+}
 /** The config paths a candidate directory could hold, in the order Playwright itself looks. */
 const CONFIG_NAMES = [
     'playwright.config.ts',
@@ -458,8 +492,18 @@ export async function diagnosisTraceCommand(args) {
     const config = await readRunConfig(args.command, args.cwd, args.readFile);
     if (suiteRecordsTraces(config))
         return unchanged;
+    // The flag goes into the Playwright step, right after its `test` word — an option of the run
+    // itself, whatever the command opens with and wherever it pipes or redirects its output. Appended
+    // at the end of the whole command it belonged to the LAST pipeline stage instead (`tail`, `grep`),
+    // which either refused it or silently ran without it (xr-molecule-flash-m102 +07:40 → +07:53). The
+    // step's shape is untouched otherwise, so the rewrites that run on this command afterwards still
+    // see what they expect: a trailing `| tail -60` is still trailing and is still dropped
+    // (`streamingBackgroundCommand`).
+    const at = playwrightTestWordEnd(args.command);
+    if (at === null)
+        return unchanged;
     return {
-        command: `${args.command.trimEnd()} ${DIAGNOSIS_TRACE_FLAG}`,
+        command: `${args.command.slice(0, at)} ${DIAGNOSIS_TRACE_FLAG}${args.command.slice(at)}`,
         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.',