@molecule/api-ai-tools 1.9.5 → 1.9.7

package/README.md

@@ -3,7 +3,7 @@ AUTO-GENERATED — DO NOT EDIT THIS FILE.
 Generated by `mlcl sync-docs` from the package's src/index.ts JSDoc + mlcl/registry.json.
 Edits here are overwritten on the next commit (molecule's pre-commit hook regenerates).
 To change this document, edit the module-level JSDoc in src/index.ts.
-Generated: 2026-10-17T20:38:26.582Z
+Generated: 2026-10-18T00:28:51.925Z
 -->
 
 # @molecule/api-ai-tools
@@ -133,6 +133,18 @@ interface LocatedCommandSegment {
    * statements are one pipeline (`|`, never `;`) asks it instead of reading the text between them.
    */
   separator: string
+  /**
+   * The separator that ENDED this statement — `&` when the shell backgrounds it (so the process
+   * writes its own output, not the command's), '' for the last statement of a command.
+   */
+  terminator: string
+  /**
+   * The file this statement sends its own output to (`> out.log`, `>> log`, `&> run.log`,
+   * `| tee file`), or null. Only a redirect written at the command's own level counts: one
+   * inside a `( … )` / `{ … }` group writes through that group, and one that feeds a heredoc's
+   * file (`cat > cfg.ts <<'EOF'`) is writing a config (X1 flash-m44, flash-m136).
+   */
+  redirectTarget: string | null
 }
 ```
 
@@ -388,6 +400,16 @@ interface TraceArtifact {
   line: number
   /** The requests the page made, the interesting ones first ({@link traceArtifactsScript}). */
   requests: TraceRequest[]
+  /**
+   * The request the failing step itself sent: the trace's LAST `fetch`/`xhr` in recording order
+   * (a click's own call), else its document request. It leads the note's row, because a click that
+   * changed nothing is explained by the request the click sent and what came back — xr-molecule-
+   * flash-m135's Follow click sent `DELETE /api/profiles/x/follow → 200` (its `following` state was
+   * stale) and the note listed only the test's earlier, answered requests.
+   *
+   * Absent when the trace recorded neither, and on traces read before this field existed.
+   */
+  lead?: TraceRequest
   /** The console errors and page errors the page raised. */
   console: string[]
   /**
@@ -728,6 +750,21 @@ interface UniversalCause {
   count: number
   /** The distinct spec files they live in, in the order the log named them. */
   files: string[]
+  /**
+   * The cause is that the page rendered NOTHING: every failure so far is a wait for an element
+   * the page never painted, whatever the selector asked for ({@link emptyPageCause}). One cause
+   * is failing every test even though no two failures share an error signature, so the note says
+   * so in the page's terms instead of naming one locator as the signature.
+   */
+  pageRendersNothing?: true
+  /** The page's own uncaught error, when the run printed one. */
+  pageError?: string
+  /**
+   * The distinct failures this cause covers, in log order — the rows a note lists for
+   * {@link pageRendersNothing}. Absent for a signature cause, whose rows are the repeating
+   * failure's own tests.
+   */
+  tests?: FailedTest[]
 }
 ```
 
@@ -1721,6 +1758,28 @@ function unansweredRequest(request: TraceRequest): boolean
 
 **Returns:** True when the request is still in flight and worth naming.
 
+#### `stalledDocumentSubresource(request)`
+
+Whether a trace recorded a DOCUMENT SUBRESOURCE that never finished: a stylesheet, script or
+other asset the page itself loads, with no response and no error text — still in flight when
+the navigation timed out.
+
+The page shell's own incidental requests (`/sw.js`, the manifest, a favicon, a font) are
+excepted for the reason {@link isStaticAssetRequest} documents: m125's run was sent to write a
+caching service worker by an aborted `/sw.js`. A pending `/assets/*.css` is different — the
+navigation blocks on it, so it is the reason `page.goto` ran out of time rather than one of the
+app's API calls (xr-molecule-flash-m135 +34:10: three deployed `page.goto` timeouts on tests that
+pass locally, one 88 KB stylesheet fetch measured at 27 s, and the failing tests' traces each
+held the never-answered CSS while the note said "the cause is in the page").
+
+```typescript
+function stalledDocumentSubresource(request: TraceRequest): boolean
+```
+
+- `request` — One request a trace recorded.
+
+**Returns:** True when the request is a document subresource that never finished.
+
 #### `failureTraceNote(items, target, earlierFailures)`
 
 The note a failed suite run's result carries: what each failing test's page actually sent, and
@@ -1742,8 +1801,8 @@ A 4xx request carries what the page SENT beside its status, so a wrapped body is
 line rather than inferred from the status; when one of those bodies is an object whose only key
 is `data`, the note names the call shape that produces it (xr-molecule-flash-m111 +11:36).
 
-WHICH rows it spends is evidence, not artifact order (xr-molecule-flash-m112 +53:46): a row
-needs a recorded response, a real failure or a console error ({@link traceRowEvidence}), rows are
+Every row opens with the request the failing step ITSELF sent ({@link TraceArtifact.lead}) and
+its response — whatever its status — because the question a `waiting for locator` failure asks
 
 _(description truncated — read the full text in `node_modules/@molecule/api-ai-tools/dist/trace-artifacts.d.ts`.)_
 
@@ -1947,13 +2006,24 @@ The file a command sends its own output to, when it redirects it (`> out.txt`,
 this leaves its task log empty, so the log is the wrong place to look and an empty
 log proves nothing (X1 flash-m29).
 
+Which redirect counts is decided by the command's own shell structure, from the same
+parse every other command reader uses: a redirect written in a BACKGROUNDED statement
+(`… &`) or inside a `( … )` / `{ … }` group writes that process's or group's output, not
+the command's. The platform's own preview launch is exactly that — the preview server is
+started with `>/tmp/mol-preview-4173.log 2>&1 &` inside the build/serve prelude, and the
+suite's foreground command follows it — so a reader that took the last `>` in the whole
+text told a run its output went to the PREVIEW's log (X1 flash-m136 +18:31).
+
+The target comes back without its shell quotes: `> '/tmp/x.log'` is `/tmp/x.log`, and
+the callers resolve a relative one against the command's cwd.
+
 ```typescript
 function outputRedirectTarget(command: string): string | null
 ```
 
 - `command` — The shell command.
 
-**Returns:** The target as written, or null (`/dev/null` and `&1`/`&2` are not files).
+**Returns:** The target, or null (`/dev/null` and `&1`/`&2` are not files).
 
 #### `streamingBackgroundCommand(command)`
 
@@ -2624,13 +2694,13 @@ alongside the others.
 ```typescript
 function universalCause(
   log: string,
-  found: RepeatingFailure,
+  found: RepeatingFailure | null,
   command?: string | null,
 ): UniversalCause | null
 ```
 
 - `log` — The log so far.
-- `found` — The repeating cause {@link repeatingFailure} found in it.
+- `found` — The repeating cause {@link repeatingFailure} found in it, or null when no two failures share a signature (a page that renders nothing fails each spec at its own first locator — {@link emptyPageCause} still reads that run).
 - `command` — How the run was started, when the caller knows it: its spec-file selection scales the file threshold ({@link specFilesSelected}).
 
 **Returns:** The cause's count and files, or null when the run is not failing whole.
@@ -2661,12 +2731,12 @@ _(description truncated — read the full text in `node_modules/@molecule/api-ai
 
 ```typescript
 function earlyReturnCause(
-  found: RepeatingFailure,
+  found: RepeatingFailure | null,
   universal: UniversalCause | null | undefined,
 ): UniversalCause | null
 ```
 
-- `found` — What {@link repeatingFailure} found mid-run.
+- `found` — What {@link repeatingFailure} found mid-run, or null when no signature repeats.
 - `universal` — What {@link universalCause} found for it, if anything.
 
 **Returns:** The cause to stop the run over, or null — in which case nothing may be stopped, the wait keeps going, and the finding rides the run's result as a note.
@@ -3046,6 +3116,16 @@ How much of the response body the note prints — the API's first error line.
 const TRACE_NOTE_GOT_CHARS: 120
 ```
 
+#### `TRACE_NOTE_LEAD_GOT_CHARS`
+
+How much of the FAILING STEP's response body the note prints. Longer than
+{@link TRACE_NOTE_GOT_CHARS}: it is the one line that answers "what did the click actually get
+back", and an app's own body (`{"profile":{…}}`) can carry the answer past its first clause.
+
+```typescript
+const TRACE_NOTE_LEAD_GOT_CHARS: 200
+```
+
 #### `DIAGNOSIS_TRACE_FLAG`
 
 The `--trace` flag this platform adds, and the only value it adds it with.
@@ -3363,6 +3443,16 @@ property of the run rather than of a page.
 const UNIVERSAL_CAUSE_FILES: 3
 ```
 
+#### `EMPTY_PAGE_CAUSE_TESTS`
+
+How many tests a run must have walked — with nothing passing since its first failure — before
+"the page renders nothing" can be its one cause. A handful of failures is a handful of bugs;
+a page that never painted fails every spec that reaches it, and m141's walk had 36 by +20:30.
+
+```typescript
+const EMPTY_PAGE_CAUSE_TESTS: 15
+```
+
 #### `CONNECTION_CAUSE_TESTS`
 
 How many tests a connection-class cause must cover before the run is stopped even when they

package/dist/command-position.d.ts

@@ -114,6 +114,18 @@ export interface LocatedCommandSegment {
      * statements are one pipeline (`|`, never `;`) asks it instead of reading the text between them.
      */
     separator: string;
+    /**
+     * The separator that ENDED this statement — `&` when the shell backgrounds it (so the process
+     * writes its own output, not the command's), '' for the last statement of a command.
+     */
+    terminator: string;
+    /**
+     * The file this statement sends its own output to (`> out.log`, `>> log`, `&> run.log`,
+     * `| tee file`), or null. Only a redirect written at the command's own level counts: one
+     * inside a `( … )` / `{ … }` group writes through that group, and one that feeds a heredoc's
+     * file (`cat > cfg.ts <<'EOF'`) is writing a config (X1 flash-m44, flash-m136).
+     */
+    redirectTarget: string | null;
 }
 /**
  * Every statement of a command, with its own assignments and where it sits — assignment-only

package/dist/command-position.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"command-position.d.ts","sourceRoot":"","sources":["../src/command-position.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,uFAAuF;AACvF,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAA;IACf,qFAAqF;IACrF,IAAI,EAAE,SAAS,MAAM,EAAE,CAAA;IACvB,4FAA4F;IAC5F,IAAI,EAAE,MAAM,CAAA;IACZ;;;OAGG;IACH,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;CAC9B;AAqND;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAM3D;AA+cD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,EAAE,CAIjE;AAmCD;;;;;;;;;GASG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;OAIG;IACH,OAAO,EAAE,cAAc,GAAG,IAAI,CAAA;IAC9B,0FAA0F;IAC1F,WAAW,EAAE,SAAS,MAAM,EAAE,CAAA;IAC9B;;;;OAIG;IACH,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB;;;;;OAKG;IACH,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAA;IAC/B;;;OAGG;IACH,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;IAClB;;;;OAIG;IACH,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B;;;;;OAKG;IACH,SAAS,EAAE,MAAM,CAAA;CAClB;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,qBAAqB,EAAE,CAE/E;AAmDD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,GAAG,IAAI,EACpB,GAAG,EAAE,MAAM,GAAG,IAAI,GACjB,MAAM,GAAG,IAAI,CAyDf;AA4ED;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAOpE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAK/E"}
+{"version":3,"file":"command-position.d.ts","sourceRoot":"","sources":["../src/command-position.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,uFAAuF;AACvF,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAA;IACf,qFAAqF;IACrF,IAAI,EAAE,SAAS,MAAM,EAAE,CAAA;IACvB,4FAA4F;IAC5F,IAAI,EAAE,MAAM,CAAA;IACZ;;;OAGG;IACH,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;CAC9B;AAqND;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAM3D;AAmjBD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,EAAE,CAIjE;AAmCD;;;;;;;;;GASG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;OAIG;IACH,OAAO,EAAE,cAAc,GAAG,IAAI,CAAA;IAC9B,0FAA0F;IAC1F,WAAW,EAAE,SAAS,MAAM,EAAE,CAAA;IAC9B;;;;OAIG;IACH,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB;;;;;OAKG;IACH,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAA;IAC/B;;;OAGG;IACH,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;IAClB;;;;OAIG;IACH,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B;;;;;OAKG;IACH,SAAS,EAAE,MAAM,CAAA;IACjB;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAA;IAClB;;;;;OAKG;IACH,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;CAC9B;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,qBAAqB,EAAE,CAE/E;AAmDD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,GAAG,IAAI,EACpB,GAAG,EAAE,MAAM,GAAG,IAAI,GACjB,MAAM,GAAG,IAAI,CAyDf;AAwFD;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAOpE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAK/E"}

package/dist/command-position.js

@@ -541,6 +541,26 @@ function splitSegments(command) {
     let buffer = '';
     /** The offset in the command of the current buffer's first character. */
     let bufferStart = 0;
+    /** How many `( … )` / `{ … }` groups are open at the current position. */
+    let groupDepth = 0;
+    /** The depth each character of `buffer` was written at, aligned with it (-1 when quoted). */
+    let depths = [];
+    /**
+     * Append shell text to the statement being read, recording the depth it was written at.
+     * Text inside a quote or a command substitution is recorded as -1: a `>` there is a literal
+     * character or a nested command's business, never the outer command's redirect.
+     */
+    const put = (text, depth = groupDepth) => {
+        for (let n = 0; n < text.length; n++)
+            depths.push(depth);
+        buffer += text;
+    };
+    /** Close the statement being read at `after`. */
+    const end = (after) => {
+        parts.push({ text: buffer, start: bufferStart, after, depths });
+        buffer = '';
+        depths = [];
+    };
     /** The nestings this position sits inside, outermost first. */
     const stack = [];
     for (let i = 0; i < source.length; i++) {
@@ -550,7 +570,7 @@ function splitSegments(command) {
         // A single-quoted string expands nothing at all: no escape, no substitution, and no quote
         // but its own ends it.
         if (top === 'single') {
-            buffer += char;
+            put(char, -1);
             if (char === "'")
                 stack.pop();
             continue;
@@ -559,7 +579,7 @@ function splitSegments(command) {
         // inside single quotes (handled above). The `(` is consumed here so the depth is counted once.
         if (char === '$' && next === '(') {
             stack.push('sub');
-            buffer += '$(';
+            put('$(', -1);
             i += 1;
             continue;
         }
@@ -569,21 +589,21 @@ function splitSegments(command) {
             if (char === '"')
                 stack.pop();
             else if (char === '\\' && next !== undefined) {
-                buffer += char + next;
+                put(char + next, -1);
                 i += 1;
                 continue;
             }
-            buffer += char;
+            put(char, -1);
             continue;
         }
         if (char === '"') {
             stack.push('double');
-            buffer += char;
+            put(char, -1);
             continue;
         }
         if (char === "'") {
             stack.push('single');
-            buffer += char;
+            put(char, -1);
             continue;
         }
         // Inside a substitution or a subshell of one: its own parentheses nest, its `|`/`;`/`&&`
@@ -593,41 +613,53 @@ function splitSegments(command) {
                 stack.push('sub');
             else if (char === ')')
                 stack.pop();
-            buffer += char;
+            put(char, -1);
             continue;
         }
         if (char === '\\' && next !== undefined) {
-            buffer += char + next;
+            // An escaped character is a literal (`\>` writes no file).
+            put(char + next, -1);
             i += 1;
             continue;
         }
+        // Grouping belongs to the shell, not to a word: a statement written inside `( … )` or
+        // `{ … }` writes through that group, so the depth travels with every character a caller
+        // reading a redirect may ask about.
+        if (char === '(' || char === '{') {
+            put(char);
+            groupDepth += 1;
+            continue;
+        }
+        if (char === ')' || char === '}') {
+            groupDepth = Math.max(0, groupDepth - 1);
+            put(char);
+            continue;
+        }
         if ((char === '&' && next === '&') || (char === '|' && next === '|')) {
-            parts.push({ text: buffer, start: bufferStart, after: char + next });
-            buffer = '';
+            end(char + next);
             i += 1;
             bufferStart = i + 1;
             continue;
         }
         if (char === ';' || char === '|' || char === '\n') {
-            parts.push({ text: buffer, start: bufferStart, after: char });
-            buffer = '';
+            end(char);
             bufferStart = i + 1;
             continue;
         }
         if (char === '&' && source[i - 1] !== '>' && next !== '>') {
-            parts.push({ text: buffer, start: bufferStart, after: '&' });
-            buffer = '';
+            end('&');
             bufferStart = i + 1;
             continue;
         }
-        buffer += char;
+        put(char);
     }
-    parts.push({ text: buffer, start: bufferStart, after: '' });
+    end('');
     const out = [];
     // The separator of the last part, kept across the empty ones so a statement's own separator
     // survives the blank lines around it (`a &&\n b` and a heredoc's blanked body alike).
     let lastAfter = null;
     for (const part of parts) {
+        const trimStart = part.text.length - part.text.trimStart().length;
         const text = part.text.trim();
         if (text === '') {
             lastAfter = part.after;
@@ -635,14 +667,63 @@ function splitSegments(command) {
         }
         out.push({
             text,
-            start: part.start + (part.text.length - part.text.trimStart().length),
+            start: part.start + trimStart,
             after: part.after,
             before: lastAfter ?? '',
+            depths: part.depths.slice(trimStart),
         });
         lastAfter = part.after;
     }
     return out;
 }
+/** A redirect's target word: a quoted one keeps its spaces (`tee 'out file.txt'`). */
+const REDIRECT_TARGET_WORD = String.raw `(?:'[^']*'|"[^"]*"|[^\s;&|]+)`;
+/**
+ * A `>`, `>>` or `&>` redirect written at a statement's own level, with the word it writes to.
+ * The lookbehind is what keeps `2>&1` out: the `>` of a descriptor redirect follows a digit.
+ */
+const REDIRECT_AND_TARGET = new RegExp(String.raw `(?<![0-9&>])(?:&>|1?>>?)\s*(${REDIRECT_TARGET_WORD})`, 'g');
+/** A word with one layer of MATCHING shell quotes removed (`'out file.txt'` → `out file.txt`). */
+function unquotedWord(word) {
+    return word.replace(/^(['"])(.*)\1$/, '$2');
+}
+/**
+ * The file a statement sends its own output to, when it redirects it at the command's own level.
+ *
+ * Three shapes are deliberately not one: a redirect inside a `( … )` / `{ … }` group (it writes
+ * through that group, not through the command's own shell), a statement that feeds a heredoc's
+ * file (`cat > cfg.ts <<'EOF'` writes a config), and `/dev/null` or a descriptor (`2>&1`).
+ *
+ * @param text - The statement's text, as the tokenizer split it.
+ * @param depths - The depth each character of `text` was written at: the open-group count, 0 at
+ *   the command's own level, -1 inside a quote or a command substitution.
+ * @param program - The word in command position (`tee` writes through its own file argument).
+ * @param args - The statement's words after the program.
+ * @returns The target with one layer of quotes removed, or null.
+ */
+function redirectTargetOf(text, depths, program, args) {
+    // A heredoc's own file is a config the command WRITES, never where the run's output goes
+    // (X1 flash-m44).
+    if (/(?:^|\s)<<(?![<])-?/.test(text))
+        return null;
+    // `| tee file` is a statement of its own: the pipe is a statement separator here.
+    if (program === 'tee') {
+        const target = args.find((arg) => !arg.startsWith('-'));
+        return target === undefined ? null : unquotedWord(target);
+    }
+    let last = null;
+    for (const match of text.matchAll(REDIRECT_AND_TARGET)) {
+        const word = unquotedWord(match[1] ?? '');
+        // Only the command's own level counts: not a group's redirect (depth > 0), and not one
+        // written inside a quote or a command substitution (depth -1).
+        if ((depths[match.index ?? 0] ?? 0) !== 0)
+            continue;
+        if (word === '/dev/null' || word.startsWith('&'))
+            continue;
+        last = word;
+    }
+    return last;
+}
 /**
  * One segment's words: quotes kept whole, grouping parentheses dropped, and a `(` written
  * against the first word taken off it (`(npx playwright test)`).
@@ -912,6 +993,9 @@ function locatedSegmentsOf(command, depth) {
             assignmentOffset: part.start + leading.end,
             programOffset: words[start.at] === undefined ? null : part.start + (wordOffset(part.text, start.at) ?? 0),
         };
+        const program = words[start.at] === undefined ? '' : programName(words[start.at] ?? '');
+        const args = words.slice(start.at + 1);
+        const redirectTarget = redirectTargetOf(part.text, part.depths, program, args);
         if (start.nested !== null) {
             const inner = locatedSegmentsOf(start.nested, depth + 1);
             for (let i = 0; i < inner.length; i += 1) {
@@ -927,6 +1011,12 @@ function locatedSegmentsOf(command, depth) {
                     end: null,
                     assignmentOffset: null,
                     programOffset: null,
+                    // `sh -c '…' &` backgrounds the command inside the string too.
+                    terminator: part.after === '&' ? '&' : entry.terminator,
+                    // A redirect written OUTSIDE the string (`sh -c '…' > run.log`) carries the nested
+                    // command's output, so the first nested statement holds it — unless that statement
+                    // redirects on its own, which takes the output away from the outer file.
+                    redirectTarget: i === 0 && entry.redirectTarget === null ? redirectTarget : entry.redirectTarget,
                     separator: i === 0 ? part.before : entry.separator,
                 });
             }
@@ -943,11 +1033,11 @@ function locatedSegmentsOf(command, depth) {
                     ...placed,
                     programOffset: null,
                     separator: part.before,
+                    terminator: part.after,
+                    redirectTarget,
                 });
             continue;
         }
-        const program = programName(word);
-        const args = words.slice(start.at + 1);
         out.push({
             segment: {
                 program,
@@ -958,6 +1048,8 @@ function locatedSegmentsOf(command, depth) {
             assignments: leading.words,
             ...placed,
             separator: part.before,
+            terminator: part.after,
+            redirectTarget,
         });
     }
     return out;

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;AAQH;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAoB1D;AAKD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAc1F;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,QAAQ,GAAE,SAAS,MAAM,EAAO,EAChC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,EACtB,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,GAClB,MAAM,CAqCR;AA8ID;;;;;;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;AAQH;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAoB1D;AAKD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAc1F;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,QAAQ,GAAE,SAAS,MAAM,EAAO,EAChC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,EACtB,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,GAClB,MAAM,CAqCR;AAgHD;;;;;;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

@@ -262,45 +262,18 @@ function playwrightLocations(locations, command, cwd) {
 /** A spec-file argument Playwright accepts as its positional filter — never a flag. */
 const SPEC_FILE_ARGUMENT = /^(?!-)[^\s]*\.(?:spec|test)\.[cm]?[jt]sx?(?::\d+(?::\d+)?)?$/;
 /**
- * A `file:line` location's own file part: Playwright prints failures as
- * `url-navigation.spec.ts:13:7`, and the file is the argument that supersedes.
+ * The statement with every bare spec-file argument taken out once the re-run names failure locations.
  *
- * @param location - A location (`file.spec.ts:13`, `file.spec.ts:13:7`) or a spec-file argument.
- * @returns The path without its line numbers.
- */
-function locationFile(location) {
-    return location.replace(/:\d+(?::\d+)?$/, '');
-}
-/**
- * Whether two spellings name the same spec file: equal, or one the absolute (or longer) form of
- * the other. The command and the reporter routinely spell the same file differently — the model
- * names `url-navigation.spec.ts`, the summary prints `specs/e2e/url-navigation.spec.ts:13`, and a
- * hold hands back `/workspace/fixtures/realworld/specs/e2e/url-navigation.spec.ts:13`.
- *
- * @param argument - The spec-file argument as the command wrote it.
- * @param location - The failing location.
- * @returns True when the location is inside that file.
- */
-function sameSpecFile(argument, location) {
-    const a = locationFile(argument)
-        .replace(/^['"]|['"]$/g, '')
-        .replace(/^\.\//, '');
-    const l = locationFile(location)
-        .replace(/^['"]|['"]$/g, '')
-        .replace(/^\.\//, '');
-    return a === l || a.endsWith(`/${l}`) || l.endsWith(`/${a}`);
-}
-/**
- * The statement with every spec-file argument its OWN failure locations already name taken out.
- *
- * A `file:line` inside a named file supersedes the whole file, so keeping both runs the file plus
- * the locations — the whole suite again, with the failures duplicated inside it. xr-molecule-flash-m118
- * (+45:24) composed just that: the model's `npx playwright test … url-navigation.spec.ts` was
- * narrowed to the 14 `file:line`s AND the bare file, "~297s" for a file and fourteen duplicates.
+ * The re-run is "just these": Playwright matches each positional argument against every collected
+ * file's path, so a bare file left beside the `file:line`s re-admits ALL of that file's tests.
+ * xr-molecule-flash-m118 (+45:24) kept the one file its 14 failures were in ("~297s" for a file and
+ * fourteen duplicates); xr-molecule-flash-m134 (+20:0x) kept all four files of a run whose 8
+ * failures sat in two of them — 32 tests, ~3 min, instead of the 8 failures' ~30 s. A file with no
+ * failure in it has nothing to re-run, so it goes too.
  *
  * @param statement - The Playwright statement, starting at its own `playwright test`.
  * @param locations - The failing `file:line`s the re-run names.
- * @returns The statement without those superseded file arguments.
+ * @returns The statement without its bare spec-file arguments.
  */
 function dropSupersededSpecFiles(statement, locations) {
     if (locations.length === 0)
@@ -312,9 +285,7 @@ function dropSupersededSpecFiles(statement, locations) {
     const kept = statement
         .slice(head.length)
         .replace(/(^|\s+)([^\s]+)(?=\s|$)/g, (whole, _space, token) => {
-        if (!SPEC_FILE_ARGUMENT.test(token))
-            return whole;
-        return locations.every((location) => sameSpecFile(token, location)) ? '' : whole;
+        return SPEC_FILE_ARGUMENT.test(token) ? '' : whole;
     });
     return `${head}${kept}`;
 }

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;AAiJ9C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAahG;AAkOD,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAmEnE;;;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;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,qBAAqB;IACpC,iFAAiF;IACjF,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,8FAA8F;IAC9F,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;CAC5B;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,qBAAqB,CAAC,CAAA;AAoBpF;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,CAAC,GACxE,qBAAqB,CAkBvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAsB,4BAA4B,CAChD,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,qBAAqB,GAC5B,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAiCxB;AA8ED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,CAAC,EAAE,eAAe,GAAG,MAAM,EAAE,CAk6ExF"}
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAiJ9C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAahG;AAkOD,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAoEnE;;;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;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,qBAAqB;IACpC,iFAAiF;IACjF,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,8FAA8F;IAC9F,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;CAC5B;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,qBAAqB,CAAC,CAAA;AAoBpF;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,CAAC,GACxE,qBAAqB,CAkBvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAsB,4BAA4B,CAChD,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,qBAAqB,GAC5B,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAiCxB;AA8ED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,CAAC,EAAE,eAAe,GAAG,MAAM,EAAE,CAi7ExF"}

package/dist/tools.js

@@ -6,6 +6,7 @@
  *
  * @module
  */
+import { posix } from 'path';
 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';
@@ -2148,12 +2149,12 @@ export function buildTools(backend, config) {
                     // IO priority (see suiteRunPriorityLaunch). Foreground runs are never
                     // touched, and a sandbox without the tools runs it unchanged.
                     const prioritized = suiteRunPriorityLaunch(streaming.command, `sh ${script} > ${log} 2>&1; echo $? > ${exitFile}`);
+                    // The target comes back without its shell quotes (`> '/tmp/x.log'` is `/tmp/x.log`);
+                    // `posix.resolve` leaves an absolute one absolute and places a relative one under the
+                    // cwd the command ran in (X1 flash-m134 +31:20: `${cwd}/${target}` produced
+                    // `/workspace/'/tmp/…'`, a path nothing writes).
                     const ownTarget = outputRedirectTarget(streaming.command);
-                    const ownFile = ownTarget
-                        ? ownTarget.startsWith('/')
-                            ? ownTarget
-                            : `${cwd}/${ownTarget}`
-                        : null;
+                    const ownFile = ownTarget === null ? null : posix.resolve(cwd, ownTarget);
                     if (ownFile)
                         outputFileByTask.set(id, ownFile);
                     runByTask.set(id, { command: streaming.command, cwd });
@@ -2456,9 +2457,10 @@ export function buildTools(backend, config) {
                     const target = outputRedirectTarget(await backend.readFile(`/tmp/${taskId}.sh`));
                     // A relative target was written against the command's own cwd, which
                     // the handle does not carry; the project root is where a background
-                    // command runs unless the caller passed one.
+                    // command runs unless the caller passed one. An absolute target is
+                    // already resolved and stays as written.
                     if (target)
-                        outputFileByTask.set(taskId, target.startsWith('/') ? target : `${root}/${target}`);
+                        outputFileByTask.set(taskId, posix.resolve(root, target));
                 }
                 catch (_error) {
                     // No script under that id: this process did not start the task, so
@@ -2587,12 +2589,24 @@ export function buildTools(backend, config) {
                     continue;
                 }
                 const found = repeatingFailure(causeLog);
-                if (!found)
+                // The page-renders-nothing cause needs no repeated signature: every spec waits for its
+                // own first element, so the failures differ while the cause does not (m141).
+                const universal = universalCause(causeLog, found, started?.command);
+                if (!found && !universal)
                     continue;
                 // The ONE predicate behind this decision and `repeatingFailureNote`'s wording, so the two
                 // cannot come to different verdicts.
-                const stopCause = earlyReturnCause(found, universalCause(causeLog, found, started?.command));
+                const stopCause = earlyReturnCause(found, universal);
                 if (stopCause) {
+                    // The note's rows and re-run hint are about the failures the cause covers; an
+                    // empty-page cause carries its own list, and a run with no repeated signature has no
+                    // other one.
+                    const noted = found ?? {
+                        count: stopCause.count,
+                        message: null,
+                        seconds: null,
+                        tests: stopCause.tests ?? [],
+                    };
                     // …and only now is the pid walk paid for.
                     repeatingCauseNoted.add(taskId);
                     const earlyMs = Date.now() - startedAt;
@@ -2601,7 +2615,7 @@ export function buildTools(backend, config) {
                         taskId,
                         status: 'repeating_failure',
                         waitedMs: earlyMs,
-                        note: repeatingFailureNote(found, {
+                        note: repeatingFailureNote(noted, {
                             taskId,
                             log,
                             stop: await taskStopCommand(backend, taskId),
@@ -2614,6 +2628,10 @@ export function buildTools(backend, config) {
                 // to keep waiting for the run's own result, so it must not be told one in the status. The
                 // look keeps running for the same reason: an app that goes down mid-run turns a shared
                 // duration into a proven whole-run cause, and that one is worth returning early for.
+                // Without a repeated signature there is no lead to note (the empty-page cause above is
+                // the only reading that needs none).
+                if (!found)
+                    continue;
                 if (!midRunLeadNoted.has(taskId)) {
                     midRunLeadNoted.add(taskId);
                     // A run against the sandbox's own app is changed by an edit while it walks — the two