@molecule/api-ai-tools 1.8.1 → 1.8.3

package/dist/trace-artifacts.js

@@ -26,7 +26,7 @@
  *
  * @module
  */
-import { commandSegments } from './command-position.js';
+import { locatedCommandSegments } from './command-position.js';
 import { isDiagnosisRun } from './suite-overlap.js';
 import { isPlaywrightRunCommand } from './utilities.js';
 /** How many traces one read reports, newest first. */
@@ -380,31 +380,36 @@ function namesTraceMode(command) {
  * 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
+ * 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.
+ * The step is found by the package's own shell parse ({@link locatedCommandSegments}), the one
+ * every runner classifier reads: it answers which STATEMENT runs `playwright test` in command
+ * position, and where that statement's program word sits in the command. The offset is the parse's
+ * own token position, never a search for the re-joined text — that text drops grouping braces and
+ * single-space-joins the words, so a command carrying a heredoc body or a `"quoted"` program found
+ * nothing at all and the flag was not added.
  *
  * @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;
+    for (const located of locatedCommandSegments(command)) {
+        const segment = located.segment;
+        if (!segment || located.programOffset === null)
+            continue;
+        if (!/^playwright\s+test\b/.test(segment.text))
+            continue;
+        // `playwright` and `test` are the statement's own first two words; the flag follows `test`.
+        const words = new RegExp(/\S+/.source, 'g');
+        words.lastIndex = located.programOffset;
+        const program = words.exec(command);
+        if (!program)
+            continue;
+        const second = words.exec(command);
+        return second ? second.index + second[0].length : null;
     }
     return null;
 }

package/dist/utilities.d.ts

@@ -222,18 +222,44 @@ export interface SuiteFilterStrip {
  * @returns The rewritten command and the stages dropped.
  */
 export declare function stripTrailingSuiteFilters(command: string): SuiteFilterStrip;
+/** Whether a finished run's exit code belongs to a stage after the suite runner. */
+export interface SuiteRunPipelinePlacement {
+    /**
+     * True when a pipe this tool must not drop still follows the suite runner: the code in the
+     * result is that stage's, not the run's.
+     */
+    piped: boolean;
+    /**
+     * True when the suite (or a stage of its pipeline) sits inside a nested `sh -c '<command>'`
+     * string, so the parse cannot place it in the command's own text. The caller then says so
+     * plainly instead of implying a stage it can point at — and keeps the command's own code when
+     * no pipe follows the runner, because on that command the pipeline's last stage IS the run.
+     */
+    unplaced: boolean;
+}
+/**
+ * Where the suite runner's exit code comes from: the runner itself, or a stage piped after it.
+ *
+ * {@link suiteRunPipedAfterRunner}'s one question, with the honest third answer kept apart. The
+ * code a finished run reports is its LAST pipeline stage's, so a stage after the runner makes the
+ * code the stage's — but only when such a stage EXISTS. The platform used to report "piped" for
+ * any run whose statements it could not place in the text, which one heredoc body was enough to
+ * cause: on X1 xr-molecule-flash-m105 (+08:12) a config written in the same `exec_command` made
+ * the run come back with no exit code at all, and the note under it claimed a stage after the
+ * runner that was not there. The parse now places every statement (`locatedCommandSegments`), so
+ * "unplaced" is the rare, named case rather than a guess dressed as an answer.
+ *
+ * @param command - The shell command, after the streaming rewrite when one was applied.
+ * @returns Whether a stage follows the runner, and whether the run could be placed at all.
+ */
+export declare function suiteRunPipelinePlacement(command: string): SuiteRunPipelinePlacement;
 /**
  * Whether the command's last step runs a suite whose output still passes through a stage after
  * the runner — one {@link stripTrailingSuiteFilters} could not prove is output-only (`| tee log`,
  * `| xargs …`). The pipeline's exit status is that stage's, not the run's.
  *
- * A command whose stages cannot be placed in the text (irregular whitespace inside the run) is
- * reported as piped too: whether a pipe follows the runner is then UNKNOWN, and an unknown exit
- * code that gets trusted is a failing run read as a pass — the failure this rule exists to stop.
- *
  * @param command - The shell command, after the streaming rewrite when one was applied.
- * @returns True when a pipe this tool must not drop still follows the suite runner, or when the
- *   command runs a suite the parse cannot place.
+ * @returns True when a pipe this tool must not drop still follows the suite runner.
  */
 export declare function suiteRunPipedAfterRunner(command: string): boolean;
 /**
@@ -916,9 +942,12 @@ export declare function failuresByCause(log: string, excluded?: readonly string[
  * stopped early happened to reach.
  *
  * A test the request excludes is not one of the causes — it is dropped and named once, at the
- * end, so a result never asks to fix a test it also says to ignore. Where the caller knows how
- * the run was started, the note also hands over the narrowed re-run of exactly those tests
- * ({@link rerunOfRunningSuite}) instead of leaving the executor to re-run the whole suite.
+ * end, so a result never asks to fix a test it also says to ignore. A test the runner itself
+ * declared `flaky` (it failed once and passed on its config retry) is not a cause either: it is
+ * named apart from them, once, as what the tally called it ({@link flakyTestsDeclared}). Where
+ * the caller knows how the run was started, the note also hands over the narrowed re-run of
+ * exactly those tests ({@link rerunOfRunningSuite}) instead of leaving the executor to re-run the
+ * whole suite.
  *
  * @param log - The finished run's output.
  * @param excluded - The test titles the request carves out, if the caller knows them.

package/dist/utilities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utilities.d.ts","sourceRoot":"","sources":["../src/utilities.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"utilities.d.ts","sourceRoot":"","sources":["../src/utilities.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAcH;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAS5C;AAED;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAAI,GAAG,MAAM,KAAG,MAEE,CAAA;AAuGhD;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAK/C;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAErD;AAKD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAsCzD;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAGnD;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,OAAO,GAAG,MAAM,CAUpF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAElE;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAWnE;AAuDD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,8BAA8B,0CAA0C,CAAA;AAErF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,MAAM,GAAG;IAC3D,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,EAAE,CAAA;CAClB,CAuJA;AAsBD;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAK1D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAG/D;AAmID,wEAAwE;AACxE,MAAM,WAAW,gBAAgB;IAC/B,0BAA0B;IAC1B,OAAO,EAAE,MAAM,CAAA;IACf,6FAA6F;IAC7F,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,GAAG,gBAAgB,CAoB3E;AAED,oFAAoF;AACpF,MAAM,WAAW,yBAAyB;IACxC;;;OAGG;IACH,KAAK,EAAE,OAAO,CAAA;IACd;;;;;OAKG;IACH,QAAQ,EAAE,OAAO,CAAA;CAClB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,GAAG,yBAAyB,CAkBpF;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEjE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,GACb;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAalC;AA4BD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAuBlE;AAID;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAQrE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAOxE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAQpD;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAGvD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAGpD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAU/D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAGxD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,GACX,MAAM,CAKR;AAkCD;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAIvE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAU1E;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAI9E;AAID,yCAAyC;AACzC,eAAO,MAAM,aAAa,QAAkB,CAAA;AAC5C,8CAA8C;AAC9C,eAAO,MAAM,cAAc,QAAmB,CAAA;AAC9C,kDAAkD;AAClD,eAAO,MAAM,eAAe,QAAa,CAAA;AACzC;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,KAAK,CAAA;AAE1C;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CACxB,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAC7C;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CA6BhG;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAY5E;AAED;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,KAAK,CAAA;AAEtC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,mBAAmB,QAAS,CAAA;AAEzC;;;;;;;GAOG;AACH,eAAO,MAAM,0BAA0B,OAAQ,CAAA;AAE/C;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,qBAAqB,QAAmD,CAAA;AAErF;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,QAAwB,CAAA;AAE3D;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,qBAAqB,QAAY,CAAA;AAE9C,qEAAqE;AACrE,eAAO,MAAM,sBAAsB,MAAM,CAAA;AAKzC,6EAA6E;AAC7E,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEnD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,SAAa,GAAG,MAAM,GAAG,IAAI,CAyC3E;AAED,0BAA0B;AAC1B,eAAO,MAAM,kBAAkB,KAAK,CAAA;AACpC,wBAAwB;AACxB,eAAO,MAAM,gBAAgB,MAAM,CAAA;AAEnC;;;;;;;GAOG;AACH,eAAO,MAAM,4BAA4B,mHAW/B,CAAA;AAEV;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAG7D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAOnE;AAmFD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAiBjD;AAED,kEAAkE;AAClE,eAAO,MAAM,qBAAqB,KAAK,CAAA;AAEvC,qEAAqE;AACrE,eAAO,MAAM,kBAAkB,OAAO,CAAA;AAEtC;;;GAGG;AACH,eAAO,MAAM,uBAAuB,0KAC4G,CAAA;AAEhJ;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAM3E;AAED,gEAAgE;AAChE,eAAO,MAAM,0BAA0B,QAAS,CAAA;AAEhD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAGrE;AAED;;;GAGG;AACH,eAAO,MAAM,qBAAqB,IAAI,CAAA;AAEtC,0DAA0D;AAC1D,MAAM,WAAW,UAAU;IACzB,gGAAgG;IAChG,KAAK,EAAE,MAAM,CAAA;IACb,iEAAiE;IACjE,KAAK,EAAE,MAAM,CAAA;IACb,qFAAqF;IACrF,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;CACvB;AAED,0DAA0D;AAC1D,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAA;IACb,0FAA0F;IAC1F,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,sFAAsF;IACtF,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,sDAAsD;IACtD,KAAK,EAAE,UAAU,EAAE,CAAA;CACpB;AAqQD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CA+CrE;AAED,2FAA2F;AAC3F,eAAO,MAAM,wBAAwB,IAAI,CAAA;AAEzC;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,OAAO,CAAA;AAErC;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,QAA2B,CAAA;AAE5D;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,KAAK,CAAA;AAKvC,oFAAoF;AACpF,eAAO,MAAM,0BAA0B,IAAI,CAAA;AA8D3C;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,IAAI,CAAA;AAEtC,oFAAoF;AACpF,MAAM,WAAW,cAAc;IAC7B,wCAAwC;IACxC,KAAK,EAAE,MAAM,CAAA;IACb,6EAA6E;IAC7E,KAAK,EAAE,MAAM,EAAE,CAAA;CAChB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,gBAAgB,GAAG,cAAc,GAAG,IAAI,CAiB1F;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,gBAAgB,EACvB,SAAS,EAAE,cAAc,GAAG,IAAI,GAAG,SAAS,GAC3C,cAAc,GAAG,IAAI,CAGvB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAQ7F;AAED,2DAA2D;AAC3D,MAAM,WAAW,YAAY;IAC3B,gGAAgG;IAChG,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,yFAAyF;IACzF,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,kEAAkE;IAClE,KAAK,EAAE,UAAU,EAAE,CAAA;IACnB;;;;OAIG;IACH,QAAQ,EAAE,MAAM,EAAE,CAAA;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,GAAE,SAAS,MAAM,EAAO,GAAG,YAAY,EAAE,CAE7F;AAiID;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,MAAM,EACX,QAAQ,GAAE,SAAS,MAAM,EAAO,EAChC,GAAG,CAAC,EAAE;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GACpD,MAAM,GAAG,IAAI,CA2Cf;AA2FD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,EACtC,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,QAAQ,GAAE,SAAS,MAAM,EAAO,GAC/B,MAAM,GAAG,IAAI,CAOf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,gBAAgB,EACvB,CAAC,EAAE;IACD,MAAM,EAAE,MAAM,CAAA;IACd,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,CAAC,EAAE,cAAc,GAAG,IAAI,CAAA;IACjC,GAAG,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;CACxC,GACA,MAAM,CAkGR;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,MAAM,GAAG,IAAI,CAsCf;AAED,qEAAqE;AACrE,eAAO,MAAM,eAAe,QAA0C,CAAA;AAEtE;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAgB7D;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE;IACxC,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;CACjB,GAAG,MAAM,GAAG,IAAI,CAKhB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CACvB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,GAChB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAgBvC"}

package/dist/utilities.js

@@ -5,7 +5,7 @@
  * @module
  */
 import { posix } from 'path';
-import { commandSegments } from './command-position.js';
+import { commandSegments, locatedCommandSegments } from './command-position.js';
 import { commandRunsNoTests } from './no-test-run.js';
 import { isDiagnosisRun, scopedRerunCommand, suiteCommandTarget, suiteRunInTheWay, withoutHeredocs, } from './suite-overlap.js';
 /**
@@ -430,16 +430,23 @@ export function streamingBackgroundCommand(command) {
     // joins stderr to it.
     const finalPlaywrightRun = isPlaywrightRunCommand(lastStep) && !/>/.test(lastStep.replace(/\d?>&\d/g, ''));
     /**
-     * Add a word to the suite runner's own arguments. A pipe this rewrite could not drop still
-     * follows the runner (`| tee run.log`), so appending at the end of the whole command would make
-     * the word an operand of the filter — m102's dangling `--trace` flag, in the same shape.
+     * Add a word to the suite runner's own arguments; false when the runner could not be placed.
+     *
+     * A pipe this rewrite could not drop still follows the runner (`| tee run.log`), so appending at
+     * the end of the whole command would make the word an operand of the filter — m102's dangling
+     * `--trace` flag, in the same shape. A suite inside a nested `sh -c '<command>'` string has no
+     * offsets in this command (they are positions in THAT string), so the command is left exactly as
+     * written and the caller reports no rewrite: appending at the end would hand the flag to the
+     * shell, outside the quotes.
      */
     const addToRun = (flag) => {
         const pipeline = lastSuitePipeline(out);
         const runner = pipeline ? pipeline.located[pipeline.at] : undefined;
-        out = runner
-            ? `${out.slice(0, runner.end)} ${flag}${out.slice(runner.end)}`
-            : `${out.trimEnd()} ${flag}`;
+        if (runner && runner.end === null)
+            return false;
+        const at = runner?.end ?? out.trimEnd().length;
+        out = `${out.slice(0, at)} ${flag}${out.slice(at)}`;
+        return true;
     };
     // A diagnosis or a re-run (capped, last-failed, grepped, or named files) walks each failure
     // once: the suite's own `retries` doubled every failure of X1 flash-m71's first whole run,
@@ -493,8 +500,7 @@ export function streamingBackgroundCommand(command) {
                     'write every result into the log twice (X1 flash-m83).');
         }
     }
-    else if (finalPlaywrightRun) {
-        addToRun('--reporter=list');
+    else if (finalPlaywrightRun && addToRun('--reporter=list')) {
         changes.push('Added `--reporter=list` so each test result is written to the log as it finishes ' +
             '(the config reporter may print nothing until the end).');
     }
@@ -513,8 +519,8 @@ export function streamingBackgroundCommand(command) {
             'and you need not wait for it to end to start on them.');
     }
     if (finalPlaywrightRun && diagnosis && !/--retries\b/.test(lastStep)) {
-        addToRun('--retries=0');
-        changes.push('Added `--retries=0`: a diagnosis or re-run walks each failure once; keep the suite’s retries for the proof run.');
+        if (addToRun('--retries=0'))
+            changes.push('Added `--retries=0`: a diagnosis or re-run walks each failure once; keep the suite’s retries for the proof run.');
     }
     return { command: out, changes };
 }
@@ -604,32 +610,34 @@ const OUTPUT_ONLY_FILTERS = new Set([
 /** A word that sends output to a file (`> f`, `>> f`, `2> f`); `2>&1` only joins stderr, so it is not one. */
 const OUTPUT_REDIRECT = /^(?:\d*|&)>>?(?!&)/;
 /**
- * The shell parse's segments with their offsets in the command, or null when one cannot be placed.
+ * The shell parse's segments with their offsets in the command.
+ *
+ * {@link commandSegments} answers which program each stage runs; this answers where it is. The
+ * offsets come from the parse's own token positions ({@link locatedCommandSegments}), never from
+ * searching the command for the re-joined text: the words are joined back with single spaces for
+ * matching, so `command.indexOf(segment.text)` comes up empty on irregular spacing, on a grouping
+ * brace, or on anything a heredoc body shifts — and the caller then cut at a guess or refused to
+ * cut at all (xr-molecule-flash-m105 +08:12, where a heredoc body turned a finished run into
+ * "piped" for the rest of the session).
  *
- * {@link commandSegments} answers which program each stage runs, but re-joins the words with single
- * spaces — so a segment written with irregular whitespace, or a program spelled with a directory,
- * has no offset a caller can cut at. Null is the honest answer there: every caller then leaves the
- * command exactly as written rather than cutting into a guess.
+ * A statement inside a nested `sh -c '<command>'` string is listed with null offsets: its
+ * positions are positions in THAT string, so nothing may be spliced at them — but its separator
+ * is known, which is all a pipeline question needs.
  *
  * @param command - The shell command.
- * @returns The located segments, in order, or null.
+ * @returns The located segments, in order.
  */
 function locatedSegments(command) {
     const out = [];
-    let cursor = 0;
-    let previousEnd = null;
-    for (const segment of commandSegments(command)) {
-        const at = command.indexOf(segment.text, cursor);
-        if (at < 0)
-            return null;
+    for (const located of locatedCommandSegments(command)) {
+        if (located.segment === null)
+            continue;
         out.push({
-            segment,
-            start: at,
-            end: at + segment.text.length,
-            between: previousEnd === null ? '' : command.slice(previousEnd, at),
+            segment: located.segment,
+            start: located.start,
+            end: located.end,
+            between: located.separator,
         });
-        cursor = at + segment.text.length;
-        previousEnd = cursor;
     }
     return out;
 }
@@ -673,8 +681,6 @@ function lastSuitePipeline(command) {
     if (commandRunsNoTests(command))
         return null;
     const located = locatedSegments(command);
-    if (located === null)
-        return null;
     let at = -1;
     for (let i = 0; i < located.length; i += 1) {
         const segment = located[i]?.segment;
@@ -724,33 +730,59 @@ export function stripTrailingSuiteFilters(command) {
     const stage = located[first];
     if (!previous || !stage)
         return { command, dropped: '' };
+    // A stage inside a nested `sh -c` string has no offsets in this command: nothing can be cut.
+    if (previous.end === null || stage.start === null)
+        return { command, dropped: '' };
     const pipe = stage.between.indexOf('|');
     if (pipe < 0)
         return { command, dropped: '' };
     const cut = previous.end + pipe;
     return { command: command.slice(0, cut).trimEnd(), dropped: command.slice(cut).trim() };
 }
+/**
+ * Where the suite runner's exit code comes from: the runner itself, or a stage piped after it.
+ *
+ * {@link suiteRunPipedAfterRunner}'s one question, with the honest third answer kept apart. The
+ * code a finished run reports is its LAST pipeline stage's, so a stage after the runner makes the
+ * code the stage's — but only when such a stage EXISTS. The platform used to report "piped" for
+ * any run whose statements it could not place in the text, which one heredoc body was enough to
+ * cause: on X1 xr-molecule-flash-m105 (+08:12) a config written in the same `exec_command` made
+ * the run come back with no exit code at all, and the note under it claimed a stage after the
+ * runner that was not there. The parse now places every statement (`locatedCommandSegments`), so
+ * "unplaced" is the rare, named case rather than a guess dressed as an answer.
+ *
+ * @param command - The shell command, after the streaming rewrite when one was applied.
+ * @returns Whether a stage follows the runner, and whether the run could be placed at all.
+ */
+export function suiteRunPipelinePlacement(command) {
+    const located = locatedSegments(command);
+    const pipeline = lastSuitePipeline(command);
+    if (pipeline !== null) {
+        const stages = pipeline.located.slice(pipeline.at);
+        // Every stage of the pipeline has to sit somewhere in THIS command to be read as a pipeline
+        // of it: a suite inside a `sh -c '<command>'` string has no offsets here.
+        const unplaced = stages.some((stage) => stage.start === null);
+        return { piped: pipeline.located.length > pipeline.at + 1, unplaced };
+    }
+    if (commandRunsNoTests(command))
+        return { piped: false, unplaced: false };
+    const runner = located.find((stage) => SUITE_RUN_COMMANDS.some((re) => re.test(stage.segment.text)));
+    // No suite at all, or a suite that is not the command's last step (a `; echo done` follows it):
+    // either way no stage after the RUNNER produces this command's code.
+    if (!runner)
+        return { piped: false, unplaced: false };
+    return { piped: false, unplaced: runner.start === null };
+}
 /**
  * Whether the command's last step runs a suite whose output still passes through a stage after
  * the runner — one {@link stripTrailingSuiteFilters} could not prove is output-only (`| tee log`,
  * `| xargs …`). The pipeline's exit status is that stage's, not the run's.
  *
- * A command whose stages cannot be placed in the text (irregular whitespace inside the run) is
- * reported as piped too: whether a pipe follows the runner is then UNKNOWN, and an unknown exit
- * code that gets trusted is a failing run read as a pass — the failure this rule exists to stop.
- *
  * @param command - The shell command, after the streaming rewrite when one was applied.
- * @returns True when a pipe this tool must not drop still follows the suite runner, or when the
- *   command runs a suite the parse cannot place.
+ * @returns True when a pipe this tool must not drop still follows the suite runner.
  */
 export function suiteRunPipedAfterRunner(command) {
-    const pipeline = lastSuitePipeline(command);
-    if (pipeline !== null)
-        return pipeline.located.length > pipeline.at + 1;
-    // No placed pipeline: either there is no suite at all, or its stages cannot be located.
-    if (commandRunsNoTests(command) || locatedSegments(command) !== null)
-        return false;
-    return commandSegments(command).some((segment) => SUITE_RUN_COMMANDS.some((re) => re.test(segment.text)));
+    return suiteRunPipelinePlacement(command).piped;
 }
 /**
  * Start a background suite run at lower CPU and IO priority, so the sandbox it
@@ -2124,17 +2156,63 @@ export function failuresByCause(log, excluded = []) {
     return groupFailures(log, excluded).causes;
 }
 /**
- * The causes a run's log names, and the failures the request excludes out of them.
+ * A finished run's own count of tests that failed their first attempt and passed on the retry:
+ * Playwright's `  1 flaky`, printed in its closing tally.
+ */
+const FLAKY_TALLY_LINE = /^\s*[1-9]\d*\s+flaky\b/;
+/**
+ * The tests a finished run's tally declares FLAKY (`  1 flaky` followed by their headings), keyed
+ * the way a failure block is.
+ *
+ * Playwright prints a numbered failure block for the FIRST attempt of a test that then passes on
+ * its retry, and also declares the test under `N flaky` — so a reader that only looks at the
+ * blocks counts a flake as a cause to fix. xr-molecule-flash-m105's proof run against the deployed
+ * URL reported ten `waitForURL` timing flakes as "causes" of a red run (+24:54), and the executor
+ * spent its next minutes re-running them one by one until three passed untouched. The
+ * declaration under the count is the runner's own answer, and its heading carries the same words
+ * as the failure block's ({@link splitTitlePath} reads both the same way).
+ *
+ * @param text - The run's output, ANSI already stripped.
+ * @returns Each flaky test, first seen first.
+ */
+function flakyTestsDeclared(text) {
+    const tests = [];
+    let underFlakyCount = false;
+    for (const line of text.split('\n')) {
+        if (FLAKY_TALLY_LINE.test(line)) {
+            underFlakyCount = true;
+            continue;
+        }
+        if (!underFlakyCount)
+            continue;
+        // The declaration lines are the reporter's own headings (`    [chromium] › a.spec.ts:5:1 › …`);
+        // the first line that is not one ends them (the next tally line, or the end of the report).
+        const heading = /^\s+\[[^\]\n]+\]\s*›\s*(.+)$/.exec(line)?.[1];
+        if (heading === undefined) {
+            underFlakyCount = false;
+            continue;
+        }
+        const { where, title } = splitTitlePath(heading.replace(/[\s─]+$/, ''));
+        tests.push({ where, title, seconds: null });
+    }
+    return distinctTests(tests);
+}
+/**
+ * The causes a run's log names, the failures the request excludes, and the failures the runner
+ * itself counted as flaky out of them.
  *
  * One grouping pass, because a note that lists the causes must know what it left out to say so
  * ({@link failureCausesNote}).
  *
  * @param log - The log of a finished or running run.
  * @param excluded - The test titles the request carves out.
- * @returns The causes to fix, and the distinct tests dropped as excluded.
+ * @returns The causes to fix, the distinct tests dropped as excluded, and the distinct tests the
+ *   runner counted as flaky (a retried pass is not a cause to fix).
  */
 function groupFailures(log, excluded) {
     const text = log.replace(ANSI_SGR, '');
+    const flakyTests = flakyTestsDeclared(text);
+    const flaky = new Set(flakyTests.map(testKey));
     const byMessage = new Map();
     const named = [];
     for (const block of failureBlocks(text)) {
@@ -2144,6 +2222,10 @@ function groupFailures(log, excluded) {
         const m = FAILURE_BLOCK_HEADER.exec(block.split('\n')[0] ?? '');
         const { where, title } = splitTitlePath(m?.[1] ?? '');
         const test = { where, title, seconds: null };
+        // The runner declared this test flaky: the block above is its first attempt, which it
+        // passed on the retry, so it is neither a cause nor a failure to re-run.
+        if (flaky.has(testKey(test)))
+            continue;
         named.push(test);
         if (matchingExcludedTitles(title, excluded).length > 0)
             continue;
@@ -2173,6 +2255,9 @@ function groupFailures(log, excluded) {
     const claimed = new Set(causes.flatMap((c) => c.tests.map(testKey)));
     const unclaimed = distinctTests(listed).filter((t) => t.seconds !== null &&
         !claimed.has(testKey(t)) &&
+        // A flaky test's `✘` row is its first attempt; its `✓` retry follows it in the same log,
+        // and the runner's tally already said the test passed.
+        !flaky.has(testKey(t)) &&
         matchingExcludedTitles(t.title, excluded).length === 0);
     const byDuration = [];
     for (const t of unclaimed) {
@@ -2186,7 +2271,11 @@ function groupFailures(log, excluded) {
     for (const g of byDuration)
         causes.push({ message: null, seconds: g.seconds, tests: g.tests, evidence: [] });
     const ignored = distinctTests(named).filter((t) => matchingExcludedTitles(t.title, excluded).length > 0);
-    return { causes: causes.sort((a, b) => b.tests.length - a.tests.length), ignored };
+    return {
+        causes: causes.sort((a, b) => b.tests.length - a.tests.length),
+        ignored,
+        flaky: flakyTests,
+    };
 }
 /**
  * The one-line-per-cause summary of a finished run's failures, or null when the run named fewer
@@ -2197,9 +2286,12 @@ function groupFailures(log, excluded) {
  * stopped early happened to reach.
  *
  * A test the request excludes is not one of the causes — it is dropped and named once, at the
- * end, so a result never asks to fix a test it also says to ignore. Where the caller knows how
- * the run was started, the note also hands over the narrowed re-run of exactly those tests
- * ({@link rerunOfRunningSuite}) instead of leaving the executor to re-run the whole suite.
+ * end, so a result never asks to fix a test it also says to ignore. A test the runner itself
+ * declared `flaky` (it failed once and passed on its config retry) is not a cause either: it is
+ * named apart from them, once, as what the tally called it ({@link flakyTestsDeclared}). Where
+ * the caller knows how the run was started, the note also hands over the narrowed re-run of
+ * exactly those tests ({@link rerunOfRunningSuite}) instead of leaving the executor to re-run the
+ * whole suite.
  *
  * @param log - The finished run's output.
  * @param excluded - The test titles the request carves out, if the caller knows them.
@@ -2209,7 +2301,7 @@ function groupFailures(log, excluded) {
  * @returns The note, or null.
  */
 export function failureCausesNote(log, excluded = [], run) {
-    const { causes, ignored } = groupFailures(log, excluded);
+    const { causes, ignored, flaky } = groupFailures(log, excluded);
     const total = causes.reduce((n, c) => n + c.tests.length, 0);
     if (total < 2)
         return null;
@@ -2221,9 +2313,16 @@ export function failureCausesNote(log, excluded = [], run) {
     const locations = [...new Set(causes.flatMap((c) => c.tests.map((t) => t.where)).filter(Boolean))];
     const rerun = run ? rerunOfRunningSuite(run, locations, excluded) : null;
     const ignoredTitles = [...new Set(ignored.map((t) => t.title || t.where).filter(Boolean))];
+    const flakyTitles = [...new Set(flaky.map((t) => t.where || t.title).filter(Boolean))];
     const header = `${total} failure${total === 1 ? '' : 's'} in this run, grouped by cause — fix every cause ` +
         `below before the next deploy:\n`;
+    // The flaky sentence sits before the ignored one: the ignored sentence is the LAST thing the
+    // note says, and callers assert on that ending.
     const tail = (rerun ? ` Re-run just these once they are fixed: \`${rerun}\`` : '') +
+        (flakyTitles.length
+            ? ' Flaky (failed once, passed on the config retry — the runner counts these as flaky, not ' +
+                `as failures): ${flakyTitles.join(', ')}.`
+            : '') +
         (ignoredTitles.length ? ` Ignored (excluded by the request): ${ignoredTitles.join(', ')}.` : '');
     // This list is the part of the result that SURVIVES the platform's tool-output cut: the stdout
     // above it is cut in the MIDDLE at {@link TOOL_RESULT_CHARS}, which is why the recap must fit

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@molecule/api-ai-tools",
-  "version": "1.8.1",
+  "version": "1.8.3",
   "description": "Shared AI agent tools with backend abstraction for sandbox and local execution",
   "type": "module",
   "main": "dist/index.js",