@molecule/api-ai-tools 1.8.3 → 1.9.2

package/dist/pipeline-exit-note.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The exit code a hand-run check's result carries is the pipeline's LAST stage's, and a weak
+ * executor reads the number as the check's verdict.
+ *
+ * `npx tsc --noEmit 2>&1 | head -40` reports `head`'s 0 while the output above it carries a type
+ * error, and `… | head -40 && tail -30 missing.log` reports `tail`'s 1 while the checker was clean —
+ * both measured in xr-molecule-flash-m117 (+04:06, +08:05). A model that trusts the code concludes
+ * "clean" and ships a build that does not compile, or hunts an error that is not there. This module
+ * says which stage produced the code, and what the output actually carries, in one sentence beside
+ * `exitCode`.
+ *
+ * The parse is the package's own shell reader ({@link locatedCommandSegments}), so a `|` inside
+ * quotes or a heredoc is not a stage, and `set -o pipefail` (where it really runs) turns the note
+ * off: then the code IS the check's.
+ *
+ * @module
+ */
+/**
+ * The sentence an `exec_command` result carries beside `exitCode` when the code belongs to a
+ * pipeline's last stage rather than to the check that printed the output.
+ *
+ * Two shapes, both from a hand-run check with an unguarded pipe:
+ *
+ * - the code says 0 and the output carries failures (`tsc | head` reports `head`'s 0);
+ * - the code is non-zero and the checker printed no failures (`tsc | head && tail missing.log`
+ *   reports `tail`'s 1, and the checker was clean).
+ *
+ * A command with no pipe, a pipe guarded by `pipefail`, a pipeline where no checker runs, or a
+ * code and an output that agree all return null.
+ *
+ * @param command - The command as the executor sent it.
+ * @param exitCode - The code the shell reported (the pipeline's last stage's).
+ * @param output - The command's raw stdout and stderr, for the checker's own text.
+ * @returns One sentence naming the stage the code came from, or null.
+ */
+export declare function pipelineExitCodeNote(command: string, exitCode: number, output: string): string | null;
+//# sourceMappingURL=pipeline-exit-note.d.ts.map

package/dist/pipeline-exit-note.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline-exit-note.d.ts","sourceRoot":"","sources":["../src/pipeline-exit-note.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AA2GH;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,GACb,MAAM,GAAG,IAAI,CAsCf"}

package/dist/pipeline-exit-note.js

@@ -0,0 +1,154 @@
+/**
+ * The exit code a hand-run check's result carries is the pipeline's LAST stage's, and a weak
+ * executor reads the number as the check's verdict.
+ *
+ * `npx tsc --noEmit 2>&1 | head -40` reports `head`'s 0 while the output above it carries a type
+ * error, and `… | head -40 && tail -30 missing.log` reports `tail`'s 1 while the checker was clean —
+ * both measured in xr-molecule-flash-m117 (+04:06, +08:05). A model that trusts the code concludes
+ * "clean" and ships a build that does not compile, or hunts an error that is not there. This module
+ * says which stage produced the code, and what the output actually carries, in one sentence beside
+ * `exitCode`.
+ *
+ * The parse is the package's own shell reader ({@link locatedCommandSegments}), so a `|` inside
+ * quotes or a heredoc is not a stage, and `set -o pipefail` (where it really runs) turns the note
+ * off: then the code IS the check's.
+ *
+ * @module
+ */
+import { locatedCommandSegments } from './command-position.js';
+/** The shells whose `-o pipefail` makes a pipeline report its first failing stage. */
+const PIPEFAIL_SHELLS = new Set(['ash', 'bash', 'dash', 'ksh', 'sh', 'zsh']);
+/**
+ * The programs a pipeline may end with when all they do is read what was printed and print it
+ * again — the stages that hand back their own status in place of the check's.
+ */
+const OUTPUT_ONLY_FILTERS = new Set([
+    'awk',
+    'cat',
+    'column',
+    'cut',
+    'egrep',
+    'fgrep',
+    'fmt',
+    'fold',
+    'grep',
+    'head',
+    'jq',
+    'nl',
+    'rg',
+    'sed',
+    'sort',
+    'tail',
+    'tr',
+    'uniq',
+    'wc',
+]);
+/** `1 type error` / `2 type errors`. */
+const plural = (count, one, many) => `${count} ${count === 1 ? one : many}`;
+/**
+ * The failure count a runner's tally names. Vitest prints two tallies — `Test Files  1 failed`
+ * above `Tests  2 failed` — and the last one is the tests, which is the number the note means.
+ *
+ * @param output - The runner's output.
+ * @returns The count in the last `N failed` tally, or 0.
+ */
+const failedTally = (output) => {
+    const tallies = [...output.matchAll(/\b(\d+) failed\b/g)];
+    return Number(tallies.at(-1)?.[1] ?? 0);
+};
+/** The checkers whose output says pass or fail in text of its own. */
+const CHECKERS = [
+    {
+        name: 'tsc',
+        runs: (program) => program === 'tsc' || program === 'vue-tsc',
+        failures: (output) => {
+            const errors = output.match(/\berror TS\d+/g)?.length ?? 0;
+            if (errors > 0)
+                return errors;
+            const found = /\bFound (\d+) errors?/.exec(output);
+            return found ? Number(found[1]) : 0;
+        },
+        label: (count) => plural(count, 'type error', 'type errors'),
+    },
+    {
+        name: 'eslint',
+        runs: (program) => program === 'eslint',
+        failures: (output) => {
+            const problems = /✖\s*(\d+)\s+problems?/.exec(output);
+            return problems ? Number(problems[1]) : 0;
+        },
+        label: (count) => plural(count, 'lint problem', 'lint problems'),
+    },
+    {
+        name: 'vitest',
+        runs: (program) => program === 'vitest',
+        failures: failedTally,
+        label: (count) => plural(count, 'failing test', 'failing tests'),
+    },
+    {
+        name: 'playwright',
+        runs: (_program, text) => /^playwright\s+test\b/.test(text),
+        failures: failedTally,
+        label: (count) => plural(count, 'failing test', 'failing tests'),
+    },
+];
+/** Whether the command turns on `pipefail`, so a pipeline reports the check's own status. */
+function guardedByPipefail(segments) {
+    return segments.some(({ program, args }) => (program === 'set' || PIPEFAIL_SHELLS.has(program)) && args.includes('pipefail'));
+}
+/**
+ * The sentence an `exec_command` result carries beside `exitCode` when the code belongs to a
+ * pipeline's last stage rather than to the check that printed the output.
+ *
+ * Two shapes, both from a hand-run check with an unguarded pipe:
+ *
+ * - the code says 0 and the output carries failures (`tsc | head` reports `head`'s 0);
+ * - the code is non-zero and the checker printed no failures (`tsc | head && tail missing.log`
+ *   reports `tail`'s 1, and the checker was clean).
+ *
+ * A command with no pipe, a pipe guarded by `pipefail`, a pipeline where no checker runs, or a
+ * code and an output that agree all return null.
+ *
+ * @param command - The command as the executor sent it.
+ * @param exitCode - The code the shell reported (the pipeline's last stage's).
+ * @param output - The command's raw stdout and stderr, for the checker's own text.
+ * @returns One sentence naming the stage the code came from, or null.
+ */
+export function pipelineExitCodeNote(command, exitCode, output) {
+    const running = locatedCommandSegments(command).filter((entry) => entry.segment !== null);
+    if (running.length < 2)
+        return null;
+    if (!running.some((entry) => entry.separator.trim() === '|'))
+        return null;
+    const segments = running.map((entry) => entry.segment);
+    if (guardedByPipefail(segments))
+        return null;
+    let checkerAt = -1;
+    for (let i = segments.length - 1; i >= 0; i -= 1) {
+        const segment = segments[i];
+        if (CHECKERS.some((checker) => checker.runs(segment.program, segment.text))) {
+            checkerAt = i;
+            break;
+        }
+    }
+    if (checkerAt < 0)
+        return null;
+    // The check's own status is lost only when a stage of the SAME pipeline follows it; a `&&` after
+    // the check already reports a real failure of its own, and a check followed by nothing reports
+    // its own code.
+    if (running[checkerAt + 1]?.separator.trim() !== '|')
+        return null;
+    const checkerSegment = segments[checkerAt];
+    const checker = CHECKERS.find((candidate) => candidate.runs(checkerSegment.program, checkerSegment.text));
+    const last = segments[segments.length - 1];
+    const failures = checker.failures(output);
+    if (exitCode === 0 && failures > 0) {
+        return (`the exit code 0 is the last stage's (${last.program}), not ${checker.name}'s — ` +
+            `the output carries ${checker.label(failures)}`);
+    }
+    if (exitCode !== 0 && failures === 0 && OUTPUT_ONLY_FILTERS.has(last.program)) {
+        return (`the exit code ${exitCode} is the last stage's (${last.program}), not ${checker.name}'s — ` +
+            'the checker printed no errors');
+    }
+    return null;
+}

package/dist/suite-overlap.d.ts

@@ -50,12 +50,44 @@ export declare function withoutHeredocs(command: string): string;
  * @returns The target key.
  */
 export declare function suiteCommandTarget(command: string): string;
+/**
+ * Whether a Playwright statement names its own config — the reading {@link withSuiteConfig} and
+ * {@link scopedRerunCommand} share, so neither adds a second `--config` to a command that has one.
+ *
+ * @param command - A command, or the Playwright statement inside it.
+ * @returns True when the statement loads a config of its own.
+ */
+export declare function namesSuiteConfig(command: string): boolean;
+/**
+ * The command with a `--config` added to the Playwright invocation it starts — or unchanged when
+ * it already names one, or starts no Playwright run.
+ *
+ * The flag rides the same statement the runner does: a `cd`, an env prefix and a `timeout` before
+ * it are left exactly as they were, and so is everything chained after the run (`| tail -50`).
+ *
+ * xr-molecule-flash-m113 (+19:09): the model's fix-round re-run dropped the
+ * `--config playwright.conduit.config.ts` both earlier runs had carried, so Playwright started with
+ * NO base URL and all 10 failures were `page.goto: Cannot navigate to invalid URL` — a failure list
+ * that says nothing about the app. The platform composes commands back to the executor too (the
+ * narrowed re-run of a finished run's failures), and a command it hands back has to carry the
+ * config the run was measured under, never the shape that caused that finding.
+ *
+ * @param command - The command as the executor sent it.
+ * @param config - The config the run loads, when the caller knows it.
+ * @returns The command with the flag, or the command unchanged.
+ */
+export declare function withSuiteConfig(command: string, config: string | null | undefined): string;
 /**
  * The whole-suite command made scoped to the tests it should re-run instead: the same
  * invocation — same directory, same settings — with the named `file:line`s in place of the whole
  * suite, `--last-failed` dropped (it re-runs the tests that never ran too, X1 flash-m60) and
  * `--retries=0` set (a re-run of a known failure does not need to pay for retries).
  *
+ * `config` is the config the run was measured under ({@link withSuiteConfig}): the narrowed re-run
+ * carries it whenever the command itself does not, so a run that dropped `--config` cannot be
+ * handed back a command with the same defect (xr-molecule-flash-m113: every failing test was
+ * `Cannot navigate to invalid URL` because the re-run loaded no base URL).
+ *
  * @param command - The whole-suite run's command.
  * @param locations - The failing `file:line`s to re-run, as the run's own log printed them — or,
  *   for a run that started outside the suite, the absolute form Playwright matches each file
@@ -64,9 +96,11 @@ export declare function suiteCommandTarget(command: string): string;
  *   (`--grep-invert`) so a re-run of the failing locations cannot report one of them again —
  *   xr-molecule-flash-m101 re-ran the whole 139-test suite and spent ~4 minutes to be told about
  *   a test the request had already said does not count.
+ * @param config - The config the run loaded, when the caller knows it; added when the command
+ *   does not name one.
  * @returns The scoped command, or the command unchanged when it runs no Playwright suite.
  */
-export declare function scopedRerunCommand(command: string, locations: readonly string[], excluded?: readonly string[]): string;
+export declare function scopedRerunCommand(command: string, locations: readonly string[], excluded?: readonly string[], config?: string | null): string;
 /**
  * One suite run, as the rule that decides whether a second may start beside it reads it.
  *

package/dist/suite-overlap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"suite-overlap.d.ts","sourceRoot":"","sources":["../src/suite-overlap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAMH;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAoB1D;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,QAAQ,GAAE,SAAS,MAAM,EAAO,GAC/B,MAAM,CA2BR;AAED;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,+FAA+F;IAC/F,SAAS,EAAE,OAAO,CAAA;IAClB,oFAAoF;IACpF,MAAM,EAAE,MAAM,CAAA;IACd;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC3B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,gBAAgB,EACzD,SAAS,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,EAC7B,QAAQ,EAAE,SAAS,CAAC,EAAE,GACrB,CAAC,GAAG,IAAI,CAMV;AAqDD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAQvD"}
+{"version":3,"file":"suite-overlap.d.ts","sourceRoot":"","sources":["../src/suite-overlap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAMH;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAoB1D;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;;;;;;;;;;;;;;;;;;;;;;GAsBG;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,GACrB,MAAM,CA8BR;AAED;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,+FAA+F;IAC/F,SAAS,EAAE,OAAO,CAAA;IAClB,oFAAoF;IACpF,MAAM,EAAE,MAAM,CAAA;IACd;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC3B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,gBAAgB,EACzD,SAAS,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,EAC7B,QAAQ,EAAE,SAAS,CAAC,EAAE,GACrB,CAAC,GAAG,IAAI,CAMV;AAqDD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAQvD"}

package/dist/suite-overlap.js

@@ -74,12 +74,62 @@ export function suiteCommandTarget(command) {
     }
     return 'local';
 }
+/** Whether a Playwright statement already names its own config (`-c`, `--config`, `--config=`). */
+const NAMES_CONFIG = /(?:^|\s)(?:-c|--config)(?:\s+|=)/;
+/**
+ * Whether a Playwright statement names its own config — the reading {@link withSuiteConfig} and
+ * {@link scopedRerunCommand} share, so neither adds a second `--config` to a command that has one.
+ *
+ * @param command - A command, or the Playwright statement inside it.
+ * @returns True when the statement loads a config of its own.
+ */
+export function namesSuiteConfig(command) {
+    return NAMES_CONFIG.test(command);
+}
+/**
+ * The command with a `--config` added to the Playwright invocation it starts — or unchanged when
+ * it already names one, or starts no Playwright run.
+ *
+ * The flag rides the same statement the runner does: a `cd`, an env prefix and a `timeout` before
+ * it are left exactly as they were, and so is everything chained after the run (`| tail -50`).
+ *
+ * xr-molecule-flash-m113 (+19:09): the model's fix-round re-run dropped the
+ * `--config playwright.conduit.config.ts` both earlier runs had carried, so Playwright started with
+ * NO base URL and all 10 failures were `page.goto: Cannot navigate to invalid URL` — a failure list
+ * that says nothing about the app. The platform composes commands back to the executor too (the
+ * narrowed re-run of a finished run's failures), and a command it hands back has to carry the
+ * config the run was measured under, never the shape that caused that finding.
+ *
+ * @param command - The command as the executor sent it.
+ * @param config - The config the run loads, when the caller knows it.
+ * @returns The command with the flag, or the command unchanged.
+ */
+export function withSuiteConfig(command, config) {
+    if (!config)
+        return command;
+    const at = command.search(/\bplaywright\s+test\b/);
+    if (at === -1)
+        return command;
+    const head = command.slice(0, at);
+    const rest = command.slice(at);
+    const end = rest.search(/&&|\|\||;|\|/);
+    const statement = end === -1 ? rest : rest.slice(0, end);
+    const tail = end === -1 ? '' : rest.slice(end);
+    if (namesSuiteConfig(statement))
+        return command;
+    return `${head}${statement.replace(/^(playwright\s+test)\b/, `$1 --config ${shellQuote(config)}`)}${tail}`;
+}
 /**
  * The whole-suite command made scoped to the tests it should re-run instead: the same
  * invocation — same directory, same settings — with the named `file:line`s in place of the whole
  * suite, `--last-failed` dropped (it re-runs the tests that never ran too, X1 flash-m60) and
  * `--retries=0` set (a re-run of a known failure does not need to pay for retries).
  *
+ * `config` is the config the run was measured under ({@link withSuiteConfig}): the narrowed re-run
+ * carries it whenever the command itself does not, so a run that dropped `--config` cannot be
+ * handed back a command with the same defect (xr-molecule-flash-m113: every failing test was
+ * `Cannot navigate to invalid URL` because the re-run loaded no base URL).
+ *
  * @param command - The whole-suite run's command.
  * @param locations - The failing `file:line`s to re-run, as the run's own log printed them — or,
  *   for a run that started outside the suite, the absolute form Playwright matches each file
@@ -88,9 +138,11 @@ export function suiteCommandTarget(command) {
  *   (`--grep-invert`) so a re-run of the failing locations cannot report one of them again —
  *   xr-molecule-flash-m101 re-ran the whole 139-test suite and spent ~4 minutes to be told about
  *   a test the request had already said does not count.
+ * @param config - The config the run loaded, when the caller knows it; added when the command
+ *   does not name one.
  * @returns The scoped command, or the command unchanged when it runs no Playwright suite.
  */
-export function scopedRerunCommand(command, locations, excluded = []) {
+export function scopedRerunCommand(command, locations, excluded = [], config) {
     const at = command.search(/\bplaywright\s+test\b/);
     if (at === -1)
         return command;
@@ -110,10 +162,13 @@ export function scopedRerunCommand(command, locations, excluded = []) {
             .map((t) => t.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
             .join('|'))}`
         : '';
+    // The run's own config: the command's `--config` when it has one, else the config the caller
+    // recorded for the run. A re-run without it measures nothing (m113).
+    const carry = config && !namesSuiteConfig(statement) ? ` --config ${shellQuote(config)}` : '';
     const scoped = statement
         .replace(/\s*--last-failed\b/g, '')
         .replace(/\s*--retries(?:[= ]\d+)?/g, '')
-        .replace(/^(playwright\s+test)\b/, `$1 ${locations.join(' ')} --retries=0${invert}`);
+        .replace(/^(playwright\s+test)\b/, `$1 ${locations.join(' ')} --retries=0${carry}${invert}`);
     return `${head}${scoped}${tail}`;
 }
 /**

package/dist/tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAgJ9C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAahG;AAiOD,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;AAgDD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,CAAC,EAAE,eAAe,GAAG,MAAM,EAAE,CAu2ExF"}
+{"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;AAiOD,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;AAgDD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,CAAC,EAAE,eAAe,GAAG,MAAM,EAAE,CAy3ExF"}

package/dist/tools.js

@@ -9,6 +9,7 @@
 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';
+import { pipelineExitCodeNote } from './pipeline-exit-note.js';
 import { TOOL_SCHEMAS } from './schemas.js';
 import { leadingSleepPeek } from './sleep-peek.js';
 /**
@@ -2172,6 +2173,12 @@ export function buildTools(backend, config) {
                                 const placement = suiteRunPipelinePlacement(streaming.command);
                                 const reported = suiteRunExitCode(code, output, placement.piped);
                                 const exitNote = suiteExitCodeNote(placement, reported);
+                                // The same question the foreground path asks: when the code is a filter's, say
+                                // which stage produced it (and what the output carries) rather than leaving a
+                                // 0 beside a printed error.
+                                const pipeNote = reported === null
+                                    ? null
+                                    : pipelineExitCodeNote(streaming.command, reported, output);
                                 const notes = [
                                     ...(sleepNote ? [sleepNote] : []),
                                     ...streaming.changes,
@@ -2181,6 +2188,7 @@ export function buildTools(backend, config) {
                                     stdout,
                                     stderr: '',
                                     exitCode: reported,
+                                    ...(pipeNote === null ? {} : { exitCodeNote: pipeNote }),
                                     ...(output.length > MAX_OUTPUT_SIZE ? { truncated: true, fullOutput: log } : {}),
                                     ...(notes.length ? { note: notes.join(' ') } : {}),
                                 };
@@ -2305,10 +2313,16 @@ export function buildTools(backend, config) {
                             (isSuiteRunCommand(command) ? SUITE_OVER_BUDGET_ADVICE : SPLIT_WORK_ADVICE),
                     };
                 }
+                // A pipeline reports its LAST stage's code: `tsc | head` says 0 beside a printed type
+                // error, and `tsc | head && tail missing.log` says 1 beside a clean check. Name the
+                // stage the number came from (pipeline-exit-note.ts) — the field the executor trusts
+                // most must not contradict the text it can read.
+                const exitCodeNote = pipelineExitCodeNote(command, result.exitCode, `${result.stdout}\n${result.stderr}`);
                 return {
                     stdout,
                     stderr,
                     exitCode: result.exitCode,
+                    ...(exitCodeNote === null ? {} : { exitCodeNote }),
                     ...(peekedTask?.slice.trim() ? { outputSoFar: sanitizeOutput(peekedTask.slice) } : {}),
                     ...(sleepNote || ceilingNote || traced.change
                         ? {

package/dist/trace-artifacts.d.ts

@@ -32,8 +32,37 @@ export interface TraceRequest {
     method: string;
     /** The request's path (`/api/articles/x/favorite`), or the whole URL when it is cross-origin. */
     path: string;
-    /** The response status, or 0 when the request never got a response. */
+    /**
+     * The response status as the trace recorded it. Playwright writes `-1` when a request was never
+     * answered (its HAR entry starts at `-1` and only a response event overwrites it); `0` is the
+     * same absence when the snapshot carried no response at all. Neither is a server failure.
+     */
     status: number;
+    /**
+     * Playwright's own error text for a request that failed WITHOUT a response
+     * (`net::ERR_CONNECTION_REFUSED`) — a real failure. A request that got no response and recorded
+     * no text was aborted or still in flight when the test ended (the page closed under it), so it
+     * says nothing about the server (xr-molecule-flash-m112 +30:45).
+     */
+    failure?: string;
+    /**
+     * What the page SENT, for a 4xx answered by the app's own API — bounded (see
+     * {@link MAX_TRACED_BODY_CHARS}). A body wrapped as `{"data":{…}}` is visible here in one line:
+     * app-http's verbs take the body as their second argument, so a helper that passes
+     * `{ data: body }` there ships the wrapper (xr-molecule-flash-m111 +11:36).
+     */
+    sent?: string;
+    /** What came back for that 4xx, bounded the same way — the API's own error body. */
+    got?: string;
+}
+/** One action the traced page performed, with the trace's own timing for it. */
+export interface TraceAction {
+    /** The Playwright API the entry names: `Frame.goto`, `Locator.fill`, `Locator.click`. */
+    api: string;
+    /** When the action started, on the trace's own monotonic clock (ms). */
+    start: number;
+    /** When it finished, or null when the run ended before it did. */
+    end: number | null;
 }
 /** What one trace says: the test it belongs to, the requests it made, and its console errors. */
 export interface TraceArtifact {
@@ -45,6 +74,12 @@ export interface TraceArtifact {
     requests: TraceRequest[];
     /** The console errors and page errors the page raised. */
     console: string[];
+    /**
+     * The page's own actions in the order the trace recorded them, bounded — what a test that ran
+     * out of a per-test budget spends its time on. A test that repeats one action prints it once per
+     * repeat, so the gap between two starts is one repeat's measured cost.
+     */
+    actions: TraceAction[];
 }
 /** How many traces one read reports, newest first. */
 export declare const MAX_TRACE_ARTIFACTS = 12;
@@ -52,12 +87,20 @@ export declare const MAX_TRACE_ARTIFACTS = 12;
 export declare const MAX_TRACED_REQUESTS = 6;
 /** How many console errors one test's trace contributes. */
 export declare const MAX_TRACED_CONSOLE = 4;
+/** How many of the page's own actions one test's trace contributes, the LAST ones. */
+export declare const MAX_TRACED_ACTIONS = 40;
+/** How much of a 4xx request's sent body (or its response body) the trace read keeps. */
+export declare const MAX_TRACED_BODY_CHARS = 300;
 /** How many tests the note in a run's result names. */
 export declare const MAX_TRACE_NOTE_TESTS = 5;
 /** How many requests the note names per test. */
 export declare const MAX_TRACE_NOTE_REQUESTS = 4;
 /** How long a URL the note prints, before the middle is cut. */
 export declare const TRACE_NOTE_URL_CHARS = 96;
+/** How much of the sent body the note prints — enough to see a `{"data":…}` wrapper. */
+export declare const TRACE_NOTE_SENT_CHARS = 160;
+/** How much of the response body the note prints — the API's first error line. */
+export declare const TRACE_NOTE_GOT_CHARS = 120;
 /**
  * The Node program the sandbox runs to read a failed run's traces: `node <script> <dir>` prints one
  * `TRACE <json>` line per `trace.zip` under `<dir>` (newest first, {@link MAX_TRACE_ARTIFACTS} of
@@ -69,10 +112,17 @@ export declare const TRACE_NOTE_URL_CHARS = 96;
  * central directory and `zlib.inflateRawSync` — about forty lines, and the only thing that has to
  * be true of a `trace.zip` is that it IS one.
  *
- * A request is kept over a static asset when it failed (`status >= 400`) or never answered
- * (`status === 0`), and over anything else when it is the page talking to the app
- * (`fetch`/`xhr`/`document`): a failing test's trace holds the whole page load, and the answer is
- * always at the end of it.
+ * A request is kept over a static asset when it failed — a `status >= 400`, or no response at all
+ * together with Playwright's own error text (`-1` plus `_failureText`, a refused connection) — and
+ * over anything else when it is the page talking to the app (`fetch`/`xhr`/`document`): a failing
+ * test's trace holds the whole page load. A request with no response and NO error text was aborted
+ * or still in flight when the test ended; it is kept too, but as what it is, not as a failure.
+ *
+ * A request answered 4xx by the app's OWN API also keeps what the page SENT and the first of what
+ * came back: Playwright stores either inline (`text`) or in a resource entry (`_file`), and both
+ * are read. That is where a wrapped body shows: xr-molecule-flash-m111's helper passed
+ * `{ data: body }` as app-http's second argument, so every POST/PUT was `{"data":{…}}` and the API
+ * validated `{}`. Status alone said only "422".
  *
  * @returns The program's source, to write to a file and run.
  */
@@ -97,11 +147,31 @@ export declare function parseTraceArtifacts(stdout: string): TraceArtifact[];
  * {@link MAX_TRACE_NOTE_TESTS} tests with {@link MAX_TRACE_NOTE_REQUESTS} requests each, because it
  * rides in a result the model pays for.
  *
+ * The three kinds are kept apart, because they mean different things. A FAILED request (4xx/5xx, or
+ * a network error with Playwright's own text) is a cause. A request with NO RESPONSE RECORDED —
+ * Playwright's `-1`, no error text — was still in flight when the test ended (the page closed under
+ * it); listing it as a failure sent a run hunting an API that never answered anything wrong
+ * (xr-molecule-flash-m112 +30:45). The rest are the page's last answered requests.
+ *
+ * A 4xx request carries what the page SENT beside its status, so a wrapped body is visible in one
+ * 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
+ * deduplicated by the test's location, and they are ordered real failure → repeated from an
+ * earlier walk → the rest ({@link traceRowTier}). Without that the note spent all five rows on four
+ * traces of one `afterEach` line whose every request was `-1`, and left the favorite cause — the
+ * one failure that repeated in every walk — in its "… and N more".
+ *
  * @param items - The traces {@link parseTraceArtifacts} read.
  * @param target - Where the run went — the deployed host, as the note names it.
- * @returns The note, or null when no trace held a request or a console error.
+ * @param earlierFailures - The failing `file:line`s earlier walks of this suite left, so a repeat
+ *   is ranked above a one-off. Empty when the caller knows of no earlier walk.
+ * @returns The note, or null when no trace held a recorded response, a real failure or a console
+ *   error.
  */
-export declare function failureTraceNote(items: readonly TraceArtifact[], target: string): string | null;
+export declare function failureTraceNote(items: readonly TraceArtifact[], target: string, earlierFailures?: readonly string[]): string | null;
 /**
  * Whether a Playwright config records traces for the tests that fail.
  *

package/dist/trace-artifacts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trace-artifacts.d.ts","sourceRoot":"","sources":["../src/trace-artifacts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAMH,iEAAiE;AACjE,MAAM,WAAW,YAAY;IAC3B,gCAAgC;IAChC,MAAM,EAAE,MAAM,CAAA;IACd,iGAAiG;IACjG,IAAI,EAAE,MAAM,CAAA;IACZ,uEAAuE;IACvE,MAAM,EAAE,MAAM,CAAA;CACf;AAED,iGAAiG;AACjG,MAAM,WAAW,aAAa;IAC5B,0FAA0F;IAC1F,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACnB,+EAA+E;IAC/E,IAAI,EAAE,MAAM,CAAA;IACZ,6FAA6F;IAC7F,QAAQ,EAAE,YAAY,EAAE,CAAA;IACxB,0DAA0D;IAC1D,OAAO,EAAE,MAAM,EAAE,CAAA;CAClB;AAED,sDAAsD;AACtD,eAAO,MAAM,mBAAmB,KAAK,CAAA;AAErC,sDAAsD;AACtD,eAAO,MAAM,mBAAmB,IAAI,CAAA;AAEpC,4DAA4D;AAC5D,eAAO,MAAM,kBAAkB,IAAI,CAAA;AAEnC,uDAAuD;AACvD,eAAO,MAAM,oBAAoB,IAAI,CAAA;AAErC,iDAAiD;AACjD,eAAO,MAAM,uBAAuB,IAAI,CAAA;AAExC,gEAAgE;AAChE,eAAO,MAAM,oBAAoB,KAAK,CAAA;AAEtC;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,oBAAoB,QAAO,MA+LvC,CAAA;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,EAAE,CAyBnE;AAiBD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,aAAa,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CA4B/F;AAaD;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAG9D;AAED,iFAAiF;AACjF,eAAO,MAAM,oBAAoB,8BAA8B,CAAA;AA2G/D,oGAAoG;AACpG,MAAM,WAAW,qBAAqB;IACpC,0BAA0B;IAC1B,OAAO,EAAE,MAAM,CAAA;IACf,4EAA4E;IAC5E,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CACtB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,qBAAqB,CAAC,IAAI,EAAE;IAChD,OAAO,EAAE,MAAM,CAAA;IACf,GAAG,EAAE,MAAM,CAAA;IACX,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;CAC5C,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAyBjC"}
+{"version":3,"file":"trace-artifacts.d.ts","sourceRoot":"","sources":["../src/trace-artifacts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAMH,iEAAiE;AACjE,MAAM,WAAW,YAAY;IAC3B,gCAAgC;IAChC,MAAM,EAAE,MAAM,CAAA;IACd,iGAAiG;IACjG,IAAI,EAAE,MAAM,CAAA;IACZ;;;;OAIG;IACH,MAAM,EAAE,MAAM,CAAA;IACd;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;;;;;OAKG;IACH,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,oFAAoF;IACpF,GAAG,CAAC,EAAE,MAAM,CAAA;CACb;AAED,gFAAgF;AAChF,MAAM,WAAW,WAAW;IAC1B,yFAAyF;IACzF,GAAG,EAAE,MAAM,CAAA;IACX,wEAAwE;IACxE,KAAK,EAAE,MAAM,CAAA;IACb,kEAAkE;IAClE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;CACnB;AAED,iGAAiG;AACjG,MAAM,WAAW,aAAa;IAC5B,0FAA0F;IAC1F,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACnB,+EAA+E;IAC/E,IAAI,EAAE,MAAM,CAAA;IACZ,6FAA6F;IAC7F,QAAQ,EAAE,YAAY,EAAE,CAAA;IACxB,0DAA0D;IAC1D,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB;;;;OAIG;IACH,OAAO,EAAE,WAAW,EAAE,CAAA;CACvB;AAED,sDAAsD;AACtD,eAAO,MAAM,mBAAmB,KAAK,CAAA;AAErC,sDAAsD;AACtD,eAAO,MAAM,mBAAmB,IAAI,CAAA;AAEpC,4DAA4D;AAC5D,eAAO,MAAM,kBAAkB,IAAI,CAAA;AAEnC,sFAAsF;AACtF,eAAO,MAAM,kBAAkB,KAAK,CAAA;AAEpC,yFAAyF;AACzF,eAAO,MAAM,qBAAqB,MAAM,CAAA;AAExC,uDAAuD;AACvD,eAAO,MAAM,oBAAoB,IAAI,CAAA;AAErC,iDAAiD;AACjD,eAAO,MAAM,uBAAuB,IAAI,CAAA;AAExC,gEAAgE;AAChE,eAAO,MAAM,oBAAoB,KAAK,CAAA;AAEtC,wFAAwF;AACxF,eAAO,MAAM,qBAAqB,MAAM,CAAA;AAExC,kFAAkF;AAClF,eAAO,MAAM,oBAAoB,MAAM,CAAA;AAKvC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,oBAAoB,QAAO,MAiQvC,CAAA;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,EAAE,CAqCnE;AAwJD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,SAAS,aAAa,EAAE,EAC/B,MAAM,EAAE,MAAM,EACd,eAAe,GAAE,SAAS,MAAM,EAAO,GACtC,MAAM,GAAG,IAAI,CAmFf;AAaD;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAG9D;AAED,iFAAiF;AACjF,eAAO,MAAM,oBAAoB,8BAA8B,CAAA;AA2G/D,oGAAoG;AACpG,MAAM,WAAW,qBAAqB;IACpC,0BAA0B;IAC1B,OAAO,EAAE,MAAM,CAAA;IACf,4EAA4E;IAC5E,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CACtB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,qBAAqB,CAAC,IAAI,EAAE;IAChD,OAAO,EAAE,MAAM,CAAA;IACf,GAAG,EAAE,MAAM,CAAA;IACX,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;CAC5C,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAyBjC"}