@molecule/api-ai-tools 1.13.1 → 1.14.1

package/dist/utilities.js

@@ -536,9 +536,25 @@ const PRINTING_REPORTERS = new Set(['list', 'line', 'dot', 'basic', 'spec']);
  * edited `app/src` while the run was still walking — which voids the run.
  */
 export const PLAYWRIGHT_FAILURES_INLINE_ENV = 'PLAYWRIGHT_LIST_PRINT_FAILURES_INLINE';
+/**
+ * A step that stores the status of the step before it in a variable: `__proof_slow=$?`.
+ *
+ * The variable name is the shell's own (`[A-Za-z_][A-Za-z0-9_]*`) and the value is EXACTLY the
+ * special parameter, bare or double-quoted, so nothing else can be running here. A capture whose
+ * value is anything else — `x=$(rebuild)`, `x=$?; rm -rf …` (a separate statement anyway) — is a
+ * program, not a status, and is not one of these.
+ */
+const STATUS_CAPTURE_STEP = /^[A-Za-z_][A-Za-z0-9_]*=(?:\$\?|"\$\?"|\$\{\?\})$/;
+/**
+ * The arithmetic body `exit $((…))` may carry and still run nothing: variable names, numbers and
+ * arithmetic operators only. No `$`, backtick, `;` or comma is allowed, so no command substitution
+ * and no expansion of a variable into something that runs can hide in it.
+ */
+const STATUS_EXIT_ARITHMETIC = /^[A-Za-z0-9_|&+\-*/%^<>=!~() \t]*$/;
 /**
  * Whether a command step only reports or discards the status of the steps before it: `echo EXIT
- * $?`, `echo $?`, `printf …`, `true`, `exit 0`.
+ * $?`, `echo $?`, `printf …`, `true`, `exit 0`, a status capture (`__proof_slow=$?`), or an
+ * `exit $((a | b))` over statuses already captured.
  *
  * The shape models and the platform's own re-run notes send routinely ends on one of these —
  * `npx playwright test … > /tmp/pw.log 2>&1; echo EXIT $?` — and reading the split's last part as
@@ -548,12 +564,33 @@ export const PLAYWRIGHT_FAILURES_INLINE_ENV = 'PLAYWRIGHT_LIST_PRINT_FAILURES_IN
  * punctuation are not part of the step; {@link streamingBackgroundCommand} strips those before
  * asking, and strips them here too for the split it is given.
  *
+ * A status CAPTURE is the same kind of step, and the platform's own chained proof walks end on a
+ * run of them: `… <browser run>; __proof_slow=$?; echo __PROOF_EXIT__ …; exit $((__proof_fast |
+ * __proof_slow))` (`chainedProofCommand`, molecule-dev `post-deploy-proof-run.ts`). Reading the
+ * browser half as a status step is what lets the run keep its reporter, its machine report and the
+ * inline-failure switch — without it, every platform proof ran its browser suite on the request's
+ * own `line` reporter, which writes no ✓/✘ mark and no per-failure error into the log the wait
+ * reads (xr-molecule-flash-x03 +27:44).
+ *
+ * Only the two shapes whose whole value is the shell's own status are read this way; anything that
+ * could run — a command substitution, a backticked word, a suffix after the status — stays a step.
+ *
  * @param step - One statement of the command, as the `&&`/`||`/`;` split left it.
  * @returns True when the step runs nothing but a status report.
  */
 function isStatusOnlyStep(step) {
-    const text = step.replace(/[\s)}]+$/, '').trim();
-    return /^(?:echo|printf)\b/.test(text) || /^true$/.test(text) || /^exit(?:\s+\S+)?$/.test(text);
+    const text = step.trim();
+    // An enclosing group's closer is punctuation, not part of the step — but the `))` that closes an
+    // arithmetic expansion is part of the statement, so that shape is read off the text as written.
+    const withoutCloser = text.replace(/[\s)}]+$/, '');
+    if (/^(?:echo|printf)\b/.test(withoutCloser) || /^true$/.test(withoutCloser))
+        return true;
+    if (/^exit(?:\s+\S+)?$/.test(withoutCloser))
+        return true;
+    if (STATUS_CAPTURE_STEP.test(withoutCloser))
+        return true;
+    const arithmetic = /^exit\s+\$\(\((.*)\)\)$/.exec(text);
+    return arithmetic !== null && STATUS_EXIT_ARITHMETIC.test(arithmetic[1] ?? '');
 }
 /**
  * Rewrite a command about to run in the background so its log grows while it
@@ -565,13 +602,15 @@ function isStatusOnlyStep(step) {
  *   It is dropped: `wait_for_task` already returns the end of the log.
  * - any output-only filter piped after a SUITE runner (`| grep … | tail -20`), which hides the
  *   failing test's own error and leaves the pipeline's exit status — the filter's — as the run's.
- *   Every such stage is dropped ({@link stripTrailingSuiteFilters}); `wait_for_task` already
- *   returns the end of the full log, and a run whose tally shows a failure must never report 0
- *   (xr-molecule-flash-m101 +25:54).
+ *   Every such stage is dropped from EVERY suite run in the command, not only the last
+ *   ({@link stripTrailingSuiteFilters}); `wait_for_task` already returns the end of the full log,
+ *   and a run whose tally shows a failure must never report 0 (xr-molecule-flash-m101 +25:54).
  * - `playwright test` with no `--reporter`, which runs the config's reporter —
  *   often `html`, which prints nothing per test. `--reporter=list` is added
  *   when the playwright run is the command's last step, piped or not: it writes each result as
- *   it finishes, and it is the shape the platform reads a background suite back in.
+ *   it finishes, and it is the shape the platform reads a background suite back in. Every EARLIER
+ *   Playwright invocation gets the same reporter, so its log is readable while it walks; the
+ *   machine `json` report stays on the last invocation.
  *
  * The run ends up with exactly ONE reporter that prints each failure — `list`. A run that names
  * any other printing reporter has it REPLACED, never joined: two of them write every test result
@@ -634,20 +673,22 @@ export function streamingBackgroundCommand(command, context, reportPath) {
     // A filter after the suite runner is not output the platform can read: it hides the failing
     // test's own error, and its exit status replaces the run's with the filter's — m101's
     // `… | grep -E "✘|passed|failed|skipped" | tail -20` reported `exitCode: 0` for a run with a
-    // failure in it. Every stage the parse proves is output-only is dropped; the end of the FULL
-    // log comes back anyway.
-    const filtered = stripTrailingSuiteFilters(out);
-    if (filtered.dropped) {
+    // failure in it. Every stage the parse proves is output-only is dropped from EVERY run, earlier
+    // walks included; the end of the FULL log comes back anyway.
+    const filtered = suiteFilterDrops(out);
+    if (filtered.drops.length > 0) {
         out = filtered.command;
-        // A lone trailing `| tail -N` keeps its own sentence: the reason it goes is that it holds all
-        // output back until the command ends, not that a filter cannot be read back.
-        const tailOnly = TRAILING_TAIL.exec(filtered.dropped);
-        changes.push(tailOnly && tailOnly[0].trim() === filtered.dropped
-            ? `Dropped the trailing \`${filtered.dropped}\`: it holds all output back until the command ends, ` +
-                'and wait_for_task returns the end of the log anyway.'
-            : `Dropped \`${filtered.dropped}\` from after the test runner: a filtered log cannot be ` +
-                'diagnosed — the failing test’s own error is not in it — and wait_for_task returns the ' +
-                'end of the full log anyway.');
+        for (const dropped of filtered.drops) {
+            // A lone trailing `| tail -N` keeps its own sentence: the reason it goes is that it holds all
+            // output back until the command ends, not that a filter cannot be read back.
+            const tailOnly = TRAILING_TAIL.exec(dropped);
+            changes.push(tailOnly && tailOnly[0].trim() === dropped
+                ? `Dropped the trailing \`${dropped}\`: it holds all output back until the command ends, ` +
+                    'and wait_for_task returns the end of the log anyway.'
+                : `Dropped \`${dropped}\` from after the test runner: a filtered log cannot be ` +
+                    'diagnosed — the failing test’s own error is not in it — and wait_for_task returns the ' +
+                    'end of the full log anyway.');
+        }
     }
     const tail = TRAILING_TAIL.exec(out);
     if (tail) {
@@ -863,8 +904,116 @@ export function streamingBackgroundCommand(command, context, reportPath) {
         if (addToRun('--retries=0'))
             changes.push(`Added \`--retries=0\`: ${why}.`);
     }
+    // Every EARLIER Playwright invocation writes the same log, so it is put on the progressive
+    // reporter too — not only the invocation this launcher measures (see
+    // {@link earlierPlaywrightReporters}).
+    const earlier = earlierPlaywrightReporters(out);
+    if (earlier.changes.length > 0) {
+        out = earlier.command;
+        changes.push(...earlier.changes);
+    }
     return { command: out, changes, ...(report === null ? {} : { reportPath: report }) };
 }
+/**
+ * Put every Playwright invocation BEFORE the command's last one on the progressive `list`
+ * reporter.
+ *
+ * A compound command's earlier walk is not a preview: it writes the same log the executor reads,
+ * and on X1 xr-molecule-flash-l21 (+21:27) the first 3.6-minute walk kept its own
+ * `--reporter=line`, which prints `[n/N] <title>` rows with no ✓/✘ mark and no per-failure error.
+ * What came back was `72 passed` and two failure NAMES; the error bodies existed only in the walk's
+ * discarded log, and diagnosing them needed another run.
+ *
+ * Only the reporter SET is touched, and only printing reporters in it ({@link PRINTING_REPORTERS})
+ * are replaced by ONE `list` — the same rule the last invocation gets. A run that names no
+ * reporter has the config reporter, which may print nothing until the end, so `--reporter=list` is
+ * added where the parse can place it. Every other flag (`--grep`, `--project`, `--config`,
+ * `--workers`, `--timeout`, selections, exclusions, retries) and every non-printing reporter
+ * (`json`, `html`, `junit`, or one this build does not know) is left exactly as written.
+ *
+ * The LAST invocation is deliberately not this function's: {@link streamingBackgroundCommand}
+ * already decides its reporters, and it alone owns the machine `json` report, which must never be
+ * claimed for an earlier walk. A statement the parse cannot place (inside a nested `sh -c` string)
+ * is left as written — there is no offset in this command to splice at.
+ *
+ * @param command - The command after every other rewrite.
+ * @returns The rewritten command, and one sentence per reporter change made.
+ */
+function earlierPlaywrightReporters(command) {
+    const located = locatedSegments(command);
+    const runs = [];
+    for (let i = 0; i < located.length; i += 1) {
+        const segment = located[i]?.segment;
+        if (segment && SUITE_RUN_COMMANDS.some((re) => re.test(segment.text)))
+            runs.push(i);
+    }
+    const rewrites = [];
+    let out = command;
+    // Right to left, so each site's offsets still describe the text they were measured on.
+    for (const at of runs.slice(0, -1).reverse()) {
+        const site = located[at];
+        if (!site || site.start === null || site.end === null)
+            continue;
+        const raw = out.slice(site.start, site.end);
+        // A statement that only lists or prints tests is not a run (`--list`, `--help`).
+        if (!isPlaywrightRunCommand(raw))
+            continue;
+        const reporters = lastReporterFlag(raw);
+        if (reporters === null) {
+            const insertAt = statementArgumentEnd(out, site.start, site.end);
+            if (insertAt === null)
+                continue;
+            out = `${out.slice(0, insertAt)} --reporter=list${out.slice(insertAt)}`;
+            rewrites.push({ kind: 'added', from: '' });
+            continue;
+        }
+        const printing = reporters.values.filter((value) => PRINTING_REPORTERS.has(value));
+        // A set with no printing reporter is the executor's own artifact (`json`, `html`, `junit`, or
+        // a reporter this build does not know) and is left exactly as it was.
+        if (printing.length === 0)
+            continue;
+        if (printing.length === 1 && printing[0] === 'list')
+            continue;
+        let placed = false;
+        const kept = reporters.values
+            .map((value) => {
+            if (!PRINTING_REPORTERS.has(value))
+                return value;
+            if (placed)
+                return null;
+            placed = true;
+            return 'list';
+        })
+            .filter((value) => value !== null);
+        out =
+            out.slice(0, site.start + reporters.start) +
+                `--reporter${reporters.separator}${kept.join(',')}` +
+                out.slice(site.start + reporters.end);
+        rewrites.push({
+            kind: printing.includes('list') ? 'dropped' : 'switched',
+            from: reporters.values.join(','),
+        });
+    }
+    const changes = [];
+    const count = (kind) => rewrites.filter((rewrite) => rewrite.kind === kind).length;
+    if (count('added') > 0)
+        changes.push(`Added \`--reporter=list\` to ${count('added') === 1 ? 'the earlier test run' : 'each earlier test run'} ` +
+            'so each test result is written to the log as it finishes (a config reporter may print ' +
+            'nothing until the end).');
+    const switched = rewrites.find((rewrite) => rewrite.kind === 'switched');
+    if (switched)
+        changes.push(`Switched ${count('switched') === 1 ? 'the earlier test run’s' : 'each earlier test run’s'} ` +
+            `reporters to \`--reporter=list\`: \`list\` writes each test result as it finishes and is ` +
+            'the shape the platform reads back, and it is the only printing reporter — two of them ' +
+            'write every result into the log twice (X1 flash-m83).');
+    const dropped = rewrites.find((rewrite) => rewrite.kind === 'dropped');
+    if (dropped)
+        changes.push(`Dropped a second printing reporter from ` +
+            `${count('dropped') === 1 ? 'the earlier test run’s' : 'each earlier test run’s'} ` +
+            `\`--reporter=${dropped.from}\`: two reporters that both print each failure write every ` +
+            'test result into the log twice, so this run keeps `list` alone.');
+    return { command: out, changes };
+}
 /**
  * Put Playwright's standard `json` report on a FOREGROUND run that already names its own reporters.
  *
@@ -1306,50 +1455,48 @@ function lastSuitePipeline(command) {
  * @returns The located segments and the last suite stage's index among them, or null.
  */
 function lastSuiteRun(command) {
+    return suiteRunSites(command).at(-1) ?? null;
+}
+/**
+ * Every suite-run statement of a command, in command order, each with the parse's segments.
+ *
+ * A command may start the suite more than once — a whole-directory walk followed by a single
+ * spec, or a Hurl run followed by a browser walk — and every one of them writes the log the
+ * executor reads. Reading only the last one left the earlier walk's failing test's own error
+ * behind a `| tail -5` while the LAST invocation was rewritten normally
+ * (xr-molecule-flash-l21 +21:27: a 3.6-minute walk returned `72 passed` with no error body when
+ * the driver ran `… specs 2>&1 | tail -5; echo START; … auth.spec.ts`).
+ *
+ * A command that runs no test at all is not a set of runs ({@link commandRunsNoTests}); nor is a
+ * statement that only lists tests, which the reporter pass asks about per statement
+ * ({@link isPlaywrightRunCommand}).
+ *
+ * @param command - The shell command.
+ * @returns One entry per suite-running statement, all sharing the parse's segments.
+ */
+function suiteRunSites(command) {
     if (commandRunsNoTests(command))
-        return null;
+        return [];
     const located = locatedSegments(command);
-    let at = -1;
+    const sites = [];
     for (let i = 0; i < located.length; i += 1) {
         const segment = located[i]?.segment;
         if (segment && SUITE_RUN_COMMANDS.some((re) => re.test(segment.text)))
-            at = i;
+            sites.push({ located, at: i });
     }
-    return at < 0 ? null : { located, at };
+    return sites;
 }
 /**
- * Drop the output-only filters piped after the command's suite runner.
- *
- * A filter after the runner is not "the end of the log" the executor asked for: it hides the
- * failing test's own error (it usually matches none of `✘|passed|failed`), and the pipeline's exit
- * status becomes the FILTER's, so `… 2>&1 | grep -E "✘|passed|failed|skipped" | tail -20` came back
- * `exitCode: 0` for a run with a failure in it (xr-molecule-flash-m101 +25:54). The tool returns
- * the end of the full log anyway, so the filter only costs diagnosability.
- *
- * Only a contiguous suffix of the stages after the runner is cut, and only stages the parse proves
- * are output-only ({@link isOutputOnlyFilter}): a `| tee` or `| xargs` keeps its place, and a
- * caller that reports the run's exit code must then treat it as unknown
- * ({@link suiteRunPipedAfterRunner}).
- *
- * A statement after the run's own pipeline (`; echo done`, `&& echo ok`) does not protect the
- * filters before it: the filter is thrown away and the trailing statement is kept, so the log the
- * run writes still holds every failure (xr-molecule-flash-m121 — a `| tail -5; echo done` kept its
- * tail, and a 95-second walk's log held only the tally while the platform's own hold had handed
- * that command back).
- *
- * The command around the dropped stages is left as written: a group they sit in keeps its closer
- * (`( … | tail -25)` → `( … )`, never `( …` — xr-molecule-flash-m418 +23:31), and a stage the cut
- * would leave a closer dangling inside is not dropped at all.
+ * The output-only filters piped after ONE suite runner, as a slice to remove — or null when this
+ * runner has none this reader can prove output-only.
  *
  * @param command - The shell command.
- * @returns The rewritten command and the stages dropped.
+ * @param located - The parse's located segments ({@link locatedSegments}).
+ * @param at - The runner's index among them.
+ * @returns The slice to drop, or null.
  */
-export function stripTrailingSuiteFilters(command) {
-    const run = lastSuiteRun(command);
-    if (run === null)
-        return { command, dropped: '' };
-    const { located, at } = run;
-    // Where the suite's own pipeline ends: the first stage after the runner that is not joined to
+function suiteFilterCut(command, located, at) {
+    // Where this suite's own pipeline ends: the first stage after the runner that is not joined to
     // its predecessor by a single `|`. Everything from there on is another statement, kept as it is.
     let end = at;
     for (let i = at + 1; i < located.length; i += 1) {
@@ -1365,15 +1512,15 @@ export function stripTrailingSuiteFilters(command) {
         first = i;
     }
     if (first === end + 1)
-        return { command, dropped: '' };
+        return null;
     const previous = located[first - 1];
     const stage = located[first];
     const lastDropped = located[end];
     if (!previous || !stage || !lastDropped)
-        return { command, dropped: '' };
+        return null;
     // 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 || lastDropped.end === null)
-        return { command, dropped: '' };
+        return null;
     // Every stage dropped must be provably whole inside the command's own structure. A group
     // closer attached to one of them closes a group the pipeline below still runs in
     // (`( … | tail -5) | cat`), and a stage that OPENS a group it does not close (`| { cat; }`) has
@@ -1383,17 +1530,17 @@ export function stripTrailingSuiteFilters(command) {
     for (let i = first; i <= end; i += 1) {
         const droppedStage = located[i];
         if (!droppedStage || droppedStage.end === null)
-            return { command, dropped: '' };
+            return null;
         const boundary = statementBoundary(command, droppedStage.start, droppedStage.end);
         if (boundary === null || boundary.leavesGroupOpen)
-            return { command, dropped: '' };
+            return null;
         if (i < end && boundary.textEnd !== droppedStage.end)
-            return { command, dropped: '' };
+            return null;
         boundaries.push(boundary);
     }
     const lastBoundary = boundaries[boundaries.length - 1];
     if (lastBoundary === undefined)
-        return { command, dropped: '' };
+        return null;
     // Where the dropped stages' own text ends. The tokenizer attaches the closer of an enclosing
     // group to the stage's last word (`tail -25)`), so cutting at {@link LocatedSegment.end} deleted
     // the `)` and left `( … 2>&1` — a command no shell parses, which the background runner rejected
@@ -1401,14 +1548,71 @@ export function stripTrailingSuiteFilters(command) {
     const dropEnd = lastBoundary.textEnd;
     const pipe = stage.between.indexOf('|');
     if (pipe < 0)
-        return { command, dropped: '' };
+        return null;
     const cut = previous.end + pipe;
-    // The stages dropped are a middle slice when a statement follows, so the text after them is
-    // kept — `; echo done` still runs, and so does the punctuation closing the group they sat in.
-    return {
-        command: `${command.slice(0, cut).trimEnd()}${command.slice(dropEnd)}`,
-        dropped: command.slice(cut, dropEnd).trim(),
-    };
+    return { cut, dropEnd, dropped: command.slice(cut, dropEnd).trim() };
+}
+/**
+ * Drop the output-only filters piped after EVERY suite runner in the command.
+ *
+ * A filter after a runner is not "the end of the log" the executor asked for: it hides the
+ * failing test's own error (it usually matches none of `✘|passed|failed`), and the pipeline's exit
+ * status becomes the FILTER's, so `… 2>&1 | grep -E "✘|passed|failed|skipped" | tail -20` came back
+ * `exitCode: 0` for a run with a failure in it (xr-molecule-flash-m101 +25:54). The tool returns
+ * the end of the full log anyway, so the filter only costs diagnosability.
+ *
+ * EVERY run is stripped, not only the command's last: a compound command's earlier walk writes
+ * the same log, and its `| tail -5` threw away the error body of a 3.6-minute Playwright walk
+ * whose two failure names were all the executor got back (xr-molecule-flash-l21 +21:27). Only a
+ * run the parse places is touched, and only its own pipeline — a later statement's filters belong
+ * to it.
+ *
+ * Only a contiguous suffix of the stages after the runner is cut, and only stages the parse proves
+ * are output-only ({@link isOutputOnlyFilter}): a `| tee` or `| xargs` keeps its place, and a
+ * caller that reports the run's exit code must then treat it as unknown
+ * ({@link suiteRunPipedAfterRunner}).
+ *
+ * A statement after the run's own pipeline (`; echo done`, `&& echo ok`) does not protect the
+ * filters before it: the filter is thrown away and the trailing statement is kept, so the log the
+ * run writes still holds every failure (xr-molecule-flash-m121 — a `| tail -5; echo done` kept its
+ * tail, and a 95-second walk's log held only the tally while the platform's own hold had handed
+ * that command back).
+ *
+ * The command around the dropped stages is left as written: a group they sit in keeps its closer
+ * (`( … | tail -25)` → `( … )`, never `( …` — xr-molecule-flash-m418 +23:31), and a stage the cut
+ * would leave a closer dangling inside is not dropped at all.
+ *
+ * @param command - The shell command.
+ * @returns The rewritten command and the stages dropped, one entry per suite run, in command order.
+ */
+function suiteFilterDrops(command) {
+    const cuts = [];
+    for (const site of suiteRunSites(command)) {
+        const cut = suiteFilterCut(command, site.located, site.at);
+        if (cut !== null)
+            cuts.push(cut);
+    }
+    if (cuts.length === 0)
+        return { command, drops: [] };
+    // Right to left, so every cut's offsets still describe the text it was measured on.
+    let out = command;
+    for (const cut of [...cuts].sort((a, b) => b.cut - a.cut)) {
+        // The stages dropped are a middle slice when a statement follows, so the text after them is
+        // kept — `; echo done` still runs, and so does the punctuation closing the group they sat in.
+        out = `${out.slice(0, cut.cut).trimEnd()}${out.slice(cut.dropEnd)}`;
+    }
+    return { command: out, drops: cuts.map((cut) => cut.dropped) };
+}
+/**
+ * Drop the output-only filters piped after the command's suite runners
+ * ({@link suiteFilterDrops}).
+ *
+ * @param command - The shell command.
+ * @returns The rewritten command, and the stages dropped in command order (`''` when none were).
+ */
+export function stripTrailingSuiteFilters(command) {
+    const { command: out, drops } = suiteFilterDrops(command);
+    return { command: out, dropped: drops.join(' ') };
 }
 /**
  * Where the suite runner's exit code comes from: the runner itself, or a stage piped after it.
@@ -2423,6 +2627,43 @@ export function runningCauseCommand(log, own) {
     const read = `cat ${log}${own ? ` ${shellQuote(own)}` : ''} 2>/dev/null`;
     return `${read} | tail -c ${REPEATING_CAUSE_TAIL_BYTES}`;
 }
+/** Bytes of a running log a diagnostic note reads back: one {@link REPEATING_CAUSE_TAIL_BYTES} window. */
+export const RUNNING_LOG_READ_BYTES = REPEATING_CAUSE_TAIL_BYTES;
+/**
+ * The shell command whose stdout is a bounded CONTIGUOUS read of a running task's own log: the
+ * log's byte size, then its last {@link RUNNING_LOG_READ_BYTES} bytes.
+ *
+ * {@link runningOutputSliceCommand} is the wrong read for a diagnosis, and l07 is the finding: it
+ * stitches the first 40 grep-selected failure lines to the last 1 000 bytes with a blank line
+ * between, so the tail is DISJOINT from the headers above it. Read as one log, the last numbered
+ * header absorbs whatever the tail starts with — a clipped skipped-test title became the cause of
+ * a genuine failure (xr-molecule-flash-l07). A contiguous window can only ever hold real
+ * neighbouring lines of one log.
+ *
+ * The size rides along so a caller can say when the window is only the log's end
+ * ({@link parseRunningLogRead}); without it a tail reads as the whole run.
+ *
+ * @param log - The task log path.
+ * @param own - A file the command redirects its own output to, if any.
+ * @returns The shell command, safe to hand to the execution backend as-is.
+ */
+export function runningLogReadCommand(log, own) {
+    const read = `cat ${log}${own ? ` ${shellQuote(own)}` : ''} 2>/dev/null`;
+    return `{ ${read} | wc -c; ${read} | tail -c ${RUNNING_LOG_READ_BYTES}; }`;
+}
+/**
+ * The two parts of {@link runningLogReadCommand}'s answer.
+ *
+ * @param stdout - The command's stdout.
+ * @returns The window and the whole log's byte size, or null when the size line is absent (the
+ *   read did not run, so nothing may be said about the log).
+ */
+export function parseRunningLogRead(stdout) {
+    const sized = /^\s*(\d+)\s*\n/.exec(stdout);
+    if (sized === null)
+        return null;
+    return { text: stdout.slice(sized[0].length), bytes: Number(sized[1]) };
+}
 /**
  * DISTINCT tests that must share one signature before a running suite's repeating cause is named.
  * A test the log prints twice, or a test that failed twice, is still one test.
@@ -2513,6 +2754,12 @@ function failureBody(block) {
         .map((l) => l.replace(ANSI_SGR, '').trim())
         .filter((l) => l &&
         !LIST_RESULT_LINE.test(l) &&
+        // A SKIPPED test's own row (`  -  41 [chromium] › user-fetch-errors.spec.ts:88:3 › …`) is
+        // a progress line, never a failure's body: a block with no body of its own is followed by
+        // whatever the reporter printed next, and that row became the failure's "cause" when the
+        // wait's stitched display was read as one log (xr-molecule-flash-l07). A `- waiting for`
+        // call-log line stays — it names the locator, and the dash carries no index.
+        !/^\s*-\s+\d+\s+/.test(l) &&
         !/^(?:at\s|\d+ \||>\s*\d+ \||\|)/.test(l) &&
         !/^Error Context:/.test(l));
 }
@@ -3870,14 +4117,14 @@ regressedSpecs = []) {
             'handler shape, a header or CORS.');
     }
     // A text that is the TAIL of a longer log says so in its first line (`…(N earlier characters
-    // omitted)`, the shape `background-tasks` writes when a log is capped): what it holds is not
+    // omitted)`, or bytes for a byte-bounded read): what it holds is not
     // the run's list of failures, only the part that survived the cut. Saying "N failures in this
     // run" over it reads as complete, and did: xr-molecule-flash-m123's collected 42 KB diagnosis
     // log was clipped to its last 8 KB, and this note grouped 2 of the run's 14 failures under
     // "fix every cause below" while the 11 that shared the run's one real cause were gone
     // (2026-10-17). The root fix is to hand this function the whole log; this says so when a
     // caller cannot.
-    const clipped = /^…\((\d+) earlier characters omitted\)/.exec(log);
+    const clipped = /^…\((\d+) earlier (characters|bytes) omitted\)/.exec(log);
     // The missing-header reading leads the list: four unrelated locators failing while every
     // snapshot shows the page painted and un-navigated is ONE fact about the route, and the list
     // below would otherwise read as four separate defects (xr-molecule-flash-m193 rewrote the
@@ -3887,7 +4134,7 @@ regressedSpecs = []) {
     const header = (missingHeader === null ? '' : `${missingHeader}\n`) +
         (clipped !== null
             ? `${total} failure${total === 1 ? '' : 's'} in the LAST part of this run’s log — its ` +
-                `first ${clipped[1]} characters were clipped, so a cause that failed earlier is ` +
+                `first ${clipped[1]} ${clipped[2]} were clipped, so a cause that failed earlier is ` +
                 `missing here. Fix every cause below${connections.length > 0 ? ' the app’s code can produce, and re-send the connection error once as it is' : ''}, ` +
                 `and read the whole run log before concluding:\n`
             : `${total} failure${total === 1 ? '' : 's'} in this run, grouped by cause — fix every cause ` +

package/package.json

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