@molecule/api-ai-tools 1.6.6 → 1.7.0

package/dist/utilities.js

@@ -327,6 +327,20 @@ function lastReporterFlag(step) {
  * carries every result twice.
  */
 const PRINTING_REPORTERS = new Set(['list', 'line', 'dot', 'basic', 'spec']);
+/**
+ * Playwright's switch for printing each failure's own error as that test fails, instead of only in
+ * the summary at the end: `list` reads it in its constructor (`ListReporterOptions.printFailuresInline`,
+ * `playwright/lib/reporters/list.js` — 1.63, the version the toolchain pins), and when it prints
+ * inline the end-of-run repeat is suppressed with it (`epilogue(!printFailuresInline)`), so one
+ * reporter still prints each failure exactly once.
+ *
+ * A background suite is put on `list` (see {@link streamingBackgroundCommand}) and this with it, so
+ * the log names its causes WHILE it walks. Without it the log's only failure lines are `✘` rows:
+ * X1 xr-molecule-flash-m99 (+19:27 → +21:00, 2026-10-16) was told to `grep -n -A 20 '<test name>'`
+ * the log, got nothing back through four greps, inferred causes from the spec prose instead, and
+ * edited `app/src` while the run was still walking — which voids the run.
+ */
+export const PLAYWRIGHT_FAILURES_INLINE_ENV = 'PLAYWRIGHT_LIST_PRINT_FAILURES_INLINE';
 /**
  * Rewrite a command about to run in the background so its log grows while it
  * runs. Two shapes left the log empty until exit, and an empty log is what
@@ -352,6 +366,11 @@ const PRINTING_REPORTERS = new Set(['list', 'line', 'dot', 'basic', 'spec']);
  * `junit`) is the
  * executor's own and is left exactly as it is — so is any reporter this build does not know.
  *
+ * A run put on `list` is also given {@link PLAYWRIGHT_FAILURES_INLINE_ENV}, so each failure's own
+ * error is in the log as that test fails rather than only at the end: a suite that is still walking
+ * is exactly when the executor reads the log, and without it a running log carries `✘` rows and
+ * nothing else (xr-molecule-flash-m99 spent ~90 s on greps of one, then fixed what it guessed).
+ *
  * Only the command's last step is touched, and only its reporter, and only when that step runs
  * something: `npx playwright test --list` takes two seconds and writes nothing per test, so
  * neither reporter nor `--retries=0` is added to it ({@link isPlaywrightRunCommand}).
@@ -441,6 +460,20 @@ export function streamingBackgroundCommand(command) {
         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).');
     }
+    // The run's failures, in the log as they fail (see PLAYWRIGHT_FAILURES_INLINE_ENV). Only for a
+    // run that ends on `list` — a run whose only reporters are machine formats has no failure lines
+    // to make inline, and this is inert for one — and set as an `export` at the head of the whole
+    // command, never mid-command: the last step may be a wrapper (`timeout 280 npx playwright test`)
+    // or start a line of its own (a multi-line command's last line), and an assignment written in
+    // front of either would be read as the program to run.
+    const endsOnListReporter = finalPlaywrightRun &&
+        (reporters === null || reporters.values.some((v) => PRINTING_REPORTERS.has(v)));
+    if (endsOnListReporter) {
+        out = `export ${PLAYWRIGHT_FAILURES_INLINE_ENV}=1; ${out}`;
+        changes.push('Each failure’s own error is now written into the log as that test fails, not only in the ' +
+            'summary at the end — so a run that is still walking already says what its failures are, ' +
+            'and you need not wait for it to end to start on them.');
+    }
     if (finalPlaywrightRun && diagnosis && !/--retries\b/.test(lastStep)) {
         out = `${out.trimEnd()} --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.');
@@ -1280,10 +1313,12 @@ export const RUNNING_FAILURE_LINE_RE = '^[[:space:]]*(✘|✗|×|✖|✕|[0-9]+\
  * The shell command whose stdout is the interesting part of a log that is still being written:
  * the failure lines so far (capped at {@link RUNNING_FAILURE_LINES}), then the end of the log.
  *
- * A Playwright `list` run prints one line per test as it finishes and its error blocks only at
- * the end, so the LAST bytes of a running log are its least informative part — in X1 flash-m61
- * the last 3 000 bytes of a 139-test walk were the skip list, and all 61 failures were above
- * them, which cost the run the grep it had to make anyway.
+ * A Playwright `list` run prints one line per test as it finishes, so the LAST bytes of a running
+ * log are its least informative part — in X1 flash-m61 the last 3 000 bytes of a 139-test walk
+ * were the skip list, and all 61 failures were above them, which cost the run the grep it had to
+ * make anyway. A background run also carries each failure's own error as it fails
+ * ({@link PLAYWRIGHT_FAILURES_INLINE_ENV}), and {@link RUNNING_FAILURE_LINE_RE} already matches
+ * those blocks' headers and their `Error:` lines, so this slice shows the causes too.
  *
  * @param log - The task log path.
  * @param own - A file the command redirects its own output to, if any.
@@ -1529,9 +1564,11 @@ function distinctTests(tests) {
  * The cause repeating among a running suite's failures, or null.
  *
  * Playwright's `list` reporter prints one line per test as it finishes — its mark, its title
- * path and how long it ran — and defers each failure's error to the summary at the end, so
- * mid-run the only signature those lines carry is the duration. Where the log carries the
- * failure bodies (a `line` reporter's output, or a finished run's summary) the signature is the
+ * path and how long it ran — and, on a run the platform started in the background, each failure's
+ * own error with it ({@link PLAYWRIGHT_FAILURES_INLINE_ENV}); a `list` run with no error bodies in
+ * its log (an older Playwright, a log the bodies have been cut from) carries only the duration as
+ * a signature. Where the log carries the failure bodies (either inline, or in a finished run's
+ * summary) the signature is the
  * error itself — {@link failureMessage}: the error class plus the locator or the values that
  * differ — which is stronger (it needs no assumption about how long a failure should take), so
  * the message is looked for first and the duration is then left with the tests whose bodies the
@@ -1714,6 +1751,42 @@ export function universalCause(log, found) {
         return null;
     return { count: found.count, files };
 }
+/**
+ * The ONE finding that ends a wait early, and the only one a note may hand a stop command over
+ * for: a PROVEN cause that is failing the whole run.
+ *
+ * Both halves are load-bearing, each of them learned from a run that lost minutes to the other.
+ *
+ * - **Failing the WHOLE run** is {@link universalCause}: every failure the log names, across
+ *   {@link UNIVERSAL_CAUSE_FILES} spec files or more, with nothing passing since the first — the
+ *   dont-stop-runs rule. X1 flash-m83 (2026-10-16) stopped eight local runs at their first
+ *   repeating cause in 14.5 minutes and never finished one, and a run that still has other causes
+ *   left to name is the only thing that will name them.
+ * - **A PROVEN cause** is an error repeated VERBATIM. A shared DURATION is a LEAD, never a cause:
+ *   a suite whose config sets a timeout spends that timeout on every failure that waits for
+ *   anything, so three unrelated tests timing out together look exactly like one broken run
+ *   (`~7 s` is a property of the CONFIG, not of the cause — {@link normalizedSignature}). X1
+ *   xr-molecule-flash-m99 (2026-10-16) was told `status: 'repeating_failure'` twice on that
+ *   shape — three `url-navigation.spec.ts` tests at ~16.2 s, one `timeout: 15_000` plus teardown
+ *   — read the early return as "stop waiting, edit now", and voided a run that was still walking;
+ *   the second cost a 224 s wait that ended with no result at all.
+ *
+ * Neither half alone is enough, and {@link repeatingFailure} finding a signature is not either:
+ * that answers "is a cause repeating among this run's failures", which is worth telling the
+ * executor mid-run as a NOTE while the wait goes on. This answers the narrower question the wait
+ * needs — is the run over as a measuring instrument — and it is THE one predicate behind both
+ * that decision and the note's wording, so the two cannot come to different verdicts.
+ *
+ * @param found - What {@link repeatingFailure} found mid-run.
+ * @param 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.
+ */
+export function earlyReturnCause(found, universal) {
+    if (found.message === null)
+        return null;
+    return universal ?? null;
+}
 /**
  * Every failure a run names, grouped by the cause behind it — one group per cause, with the
  * tests it hit.
@@ -1723,11 +1796,11 @@ export function universalCause(log, found) {
  * bodies to read; X1 flash-m83 (2026-10-16) spent three deploys (6.7 minutes) each fixing a
  * single cause, two of them found by runs stopped before they walked the rest.
  *
- * The signature is the cause itself where the log carries the failures' bodies (a finished run,
- * or a `line` reporter) — {@link failureMessage}: the error class plus the locator or the values
- * that differ — and how long they took where it does not (a still-running `list` log, which is
- * why a duration group is labelled as a duration and not as a proven cause). A test the log
- * printed twice, or failed twice, is one test.
+ * The signature is the cause itself where the log carries the failures' bodies (a finished run, a
+ * background `list` run — whose failures print as they fail — or a `line` reporter) —
+ * {@link failureMessage}: the error class plus the locator or the values that differ — and how long
+ * they took where it does not, which is why a duration group is labelled as a duration and not as a
+ * proven cause. A test the log printed twice, or failed twice, is one test.
  *
  * @param log - The log of a finished or running run.
  * @returns The causes, the one with the most tests first.
@@ -1753,8 +1826,9 @@ export function failuresByCause(log) {
         if (tests.length > 0)
             causes.push({ message, seconds: null, tests });
     }
-    // The failures with no body of their own — every failure of a still-running `list` log — are
-    // grouped by how long they took: a band is opened by its first test and takes the ones that
+    // The failures with no body of their own — a `list` log with no error blocks in it, from a run
+    // not started in the background — are grouped by how long they took: a band is opened by its
+    // first test and takes the ones that
     // then ran the same length, the same band {@link repeatingFailure} uses.
     const claimed = new Set(causes.flatMap((c) => c.tests.map(testKey)));
     const unclaimed = distinctTests(failedTests(text)).filter((t) => t.seconds !== null && !claimed.has(testKey(t)));
@@ -1841,11 +1915,15 @@ export function rerunOfRunningSuite(run, locations) {
  * tests, so the note never names one or two tests as a cause.
  *
  * The note names the cause early so the executor can START FIXING while the run keeps walking,
- * and it asks for the run to be stopped only when {@link universalCause} says the cause is
- * failing the whole run. X1 flash-m76 (2026-10-16) spent 4.0 minutes walking 15 tests whose one
- * cause was certain at the third, 47 s in, and the note answers exactly that; X1 flash-m83 then
- * stopped eight runs at their first repeating cause in 14.5 minutes and never finished one, so
- * the note must not say to stop when the run still has other causes to name.
+ * and it hands a stop command over only when {@link earlyReturnCause} says so — the SAME
+ * predicate the wait uses to decide whether to return early, so a finding the wait keeps waiting
+ * on is a finding this note never asks to stop for. X1 flash-m76 (2026-10-16) spent 4.0 minutes
+ * walking 15 tests whose one cause was certain at the third, 47 s in, and the note answers
+ * exactly that; X1 flash-m83 then stopped eight runs at their first repeating cause in 14.5
+ * minutes and never finished one, so the note must not say to stop when the run still has other
+ * causes to name. X1 xr-molecule-flash-m99 (2026-10-16) is the third shape: a shared duration is
+ * not a cause at all, so a lead reaches the executor as a note on a result it is still waiting
+ * for — never as a verdict with a stop command in it.
  *
  * The run is STILL WALKING while this note is written — both callers produce it mid-run — so a
  * re-run of one of its tests is a second run against the same app and database, and the platform
@@ -1859,7 +1937,7 @@ export function rerunOfRunningSuite(run, locations) {
  *
  * @param found - What {@link repeatingFailure} found.
  * @param o - The run's facts: its `taskId`, its `log` path, `stop` — the shell command that
- *   stops it, printed only for a {@link UniversalCause} — `universal`, what
+ *   stops it, printed only for an {@link earlyReturnCause} — `universal`, what
  *   {@link universalCause} found (absent means the run is not failing whole), and `run`, how the
  *   run was started ({@link rerunOfRunningSuite}) when the caller knows it.
  * @returns The note.
@@ -1917,8 +1995,11 @@ export function repeatingFailureNote(found, o) {
     // directory the run started in. Without that record it says the timing and nothing more.
     const thenRun = aRunIsInTheWay && rerun ? `\nSend this once the run ends:\n  ${rerun}` : '';
     const where = `task ${o.taskId}, log ${o.log}`;
-    if (o.universal) {
-        const files = o.universal.files.map(shortFile);
+    // The ONE predicate behind this wording and the wait's own early return (`earlyReturnCause`), so
+    // a finding the wait keeps waiting on can never be handed a stop command here.
+    const stop = earlyReturnCause(found, o.universal);
+    if (stop) {
+        const files = stop.files.map(shortFile);
         const shown = files.slice(0, 4).join(', ');
         const moreFiles = files.length > 4 ? `, … and ${files.length - 4} more` : '';
         return (`Every test this run has walked so far has failed the same way — all ${found.count} of ` +
@@ -1928,15 +2009,20 @@ export function repeatingFailureNote(found, o) {
             `repeats this one cause. Stop it and fix that cause first: \`exec_command: ${o.stop}\`, ` +
             `then run the whole suite again. It is still going (${where}).${reproduce}`);
     }
+    // Everything else is a note on a run the wait is still waiting for, and both its shapes end the
+    // same way: the run finishes, because it is the only thing that names the causes this finding is
+    // not. What it does NOT carry is the "Stop it if every test fails this way" clause — that one
+    // belongs to a PROVEN cause the run is still walking (the sentence below), never to a lead:
+    // xr-molecule-flash-m99's executor read it on a shared duration and voided the run.
     const keepGoing = `Let the rest of the run finish — it is the only thing that will name the causes that are NOT ` +
         `this one, and a run stopped at its first repeating cause costs a second whole run to find ` +
-        `them. Stop it only if every test it walks fails this same way (the app unreachable, a 5xx on ` +
-        `every request, the same selector timing out on every test of every file so far). ` +
-        `It is still going (${where}).`;
+        `them. It is still going (${where}).`;
     if (isCause)
         return (`${found.count} different tests in this run have already failed the same way — ${signature} — ` +
             `so one cause is repeating:\n${rows}${more}\n` +
-            `Start fixing it now, while the run keeps walking.${reproduce} ${keepGoing}${thenRun}`);
+            `Start fixing it now, while the run keeps walking. Stop it only if every test it walks ` +
+            `fails this same way (the app unreachable, a 5xx on every request, the same selector timing ` +
+            `out on every test of every file so far).${reproduce} ${keepGoing}${thenRun}`);
     return (`${found.count} different tests in this run each failed after ~${found.seconds}s — the same ` +
         `duration to within half a second. A shared duration is a lead, not a cause: a suite whose ` +
         `config sets a timeout spends that timeout on every failure that waits for anything, so ` +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@molecule/api-ai-tools",
-  "version": "1.6.6",
+  "version": "1.7.0",
   "description": "Shared AI agent tools with backend abstraction for sandbox and local execution",
   "type": "module",
   "main": "dist/index.js",
@@ -31,7 +31,7 @@
     "@molecule/api-ai": "^1.0.1"
   },
   "devDependencies": {
-    "@molecule/api-ai": "1.3.3",
+    "@molecule/api-ai": "1.3.4",
     "@types/node": "26.1.2",
     "esbuild": "0.28.2",
     "typescript": "6.0.3",