@molecule/api-ai-tools 1.6.6 → 1.8.1

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/index.d.ts

@@ -140,6 +140,7 @@ export * from './schemas.js';
 export * from './suite-overlap.js';
 export * from './system-prompt.js';
 export * from './tools.js';
+export * from './trace-artifacts.js';
 export * from './types.js';
 export * from './utilities.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkIG;AAEH,cAAc,qBAAqB,CAAA;AACnC,cAAc,uBAAuB,CAAA;AACrC,cAAc,oBAAoB,CAAA;AAClC,cAAc,uBAAuB,CAAA;AACrC,cAAc,cAAc,CAAA;AAC5B,cAAc,uBAAuB,CAAA;AACrC,cAAc,kBAAkB,CAAA;AAChC,cAAc,cAAc,CAAA;AAC5B,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA;AAC1B,cAAc,gBAAgB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkIG;AAEH,cAAc,qBAAqB,CAAA;AACnC,cAAc,uBAAuB,CAAA;AACrC,cAAc,oBAAoB,CAAA;AAClC,cAAc,uBAAuB,CAAA;AACrC,cAAc,cAAc,CAAA;AAC5B,cAAc,uBAAuB,CAAA;AACrC,cAAc,kBAAkB,CAAA;AAChC,cAAc,cAAc,CAAA;AAC5B,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,cAAc,YAAY,CAAA;AAC1B,cAAc,sBAAsB,CAAA;AACpC,cAAc,YAAY,CAAA;AAC1B,cAAc,gBAAgB,CAAA"}

package/dist/index.js

@@ -140,5 +140,6 @@ export * from './schemas.js';
 export * from './suite-overlap.js';
 export * from './system-prompt.js';
 export * from './tools.js';
+export * from './trace-artifacts.js';
 export * from './types.js';
 export * from './utilities.js';

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;AAkF9C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAahG;AAwHD,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAgEnE;;;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;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,CAAC,EAAE,eAAe,GAAG,MAAM,EAAE,CAipExF"}
+{"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"}