@molecule/api-ai-tools 1.9.1 → 1.9.3

package/dist/suite-overlap.js

@@ -28,7 +28,8 @@
  *
  * @module
  */
-import { commandSegments } from './command-position.js';
+import { posix } from 'node:path';
+import { commandSegments, locatedCommandSegments } from './command-position.js';
 import { commandRunsNoTests } from './no-test-run.js';
 import { shellQuote } from './utilities.js';
 /**
@@ -131,18 +132,21 @@ export function withSuiteConfig(command, config) {
  * `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
- *   argument against.
+ * @param locations - The failing `file:line`s to re-run, as the run's own log printed them. A
+ *   location the reporter printed relative to the runner's own directory (`../../fixtures/…`,
+ *   which no absolute path contains) is resolved here ({@link playwrightLocations}), so the
+ *   command this returns is one Playwright can match.
  * @param excluded - The test titles the request carves out. They are inverted out
  *   (`--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.
+ * @param cwd - The directory `exec_command` was given, when it was; the base a location is
+ *   resolved against when the command does not `cd` anywhere.
  * @returns The scoped command, or the command unchanged when it runs no Playwright suite.
  */
-export function scopedRerunCommand(command, locations, excluded = [], config) {
+export function scopedRerunCommand(command, locations, excluded = [], config, cwd) {
     const at = command.search(/\bplaywright\s+test\b/);
     if (at === -1)
         return command;
@@ -165,12 +169,155 @@ export function scopedRerunCommand(command, locations, excluded = [], config) {
     // 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
+    // Playwright matches each positional argument as a regex against the ABSOLUTE path of every test
+    // file it collects (`playwright test --help`: "Each argument is treated as a regular expression.
+    // Matching is performed against the absolute file paths."), while the reporter prints a failure
+    // relative to the runner's own directory. A `../../fixtures/…` location therefore matches
+    // nothing — "No tests found" — so every location is rendered in a form Playwright can match
+    // ({@link playwrightLocations}).
+    const narrowed = playwrightLocations(locations, command, cwd);
+    const scoped = dropSupersededSpecFiles(statement, narrowed)
         .replace(/\s*--last-failed\b/g, '')
         .replace(/\s*--retries(?:[= ]\d+)?/g, '')
-        .replace(/^(playwright\s+test)\b/, `$1 ${locations.join(' ')} --retries=0${carry}${invert}`);
+        .replace(/^(playwright\s+test)\b/, `$1 ${narrowed.join(' ')} --retries=0${carry}${invert}`);
     return `${head}${scoped}${tail}`;
 }
+/** A directory a `cd` can name literally: no `~`, no variable, no glob. */
+const LITERAL_DIR = /^[A-Za-z0-9_./+-]+$/;
+/** A word without its shell quotes. */
+const unquoted = (word) => word.replace(/^['"]|['"]$/g, '');
+/**
+ * The absolute directory the Playwright statement in a command runs in, or null when the command
+ * does not say.
+ *
+ * The reporter prints a failing test's file relative to the process directory the runner started
+ * in (`../fixtures/…` from a run whose suite lives outside its own tree), so the directory has to
+ * come from the command itself: `exec_command`'s `cwd` when it was given, then each `cd` before
+ * the runner. Only a literal `cd` is followed — a target holding a variable, a glob or `~`
+ * resolves nowhere useful, and a guessed absolute path is worse than the relative one the
+ * reporter printed.
+ *
+ * @param command - The shell command.
+ * @param cwd - The `cwd` the tool was given, when it was.
+ * @returns The absolute directory, or null.
+ */
+function suiteRunDirectory(command, cwd) {
+    let dir = typeof cwd === 'string' && cwd.startsWith('/') ? posix.normalize(cwd) : null;
+    for (const { segment } of locatedCommandSegments(command)) {
+        if (segment === null)
+            continue;
+        if (segment.program === 'cd') {
+            const target = unquoted(segment.args[0] ?? '').replace(/\/+$/, '');
+            if (!target || target.startsWith('-') || target.startsWith('~') || !LITERAL_DIR.test(target))
+                return null;
+            // A shell `cd /abs` DISCARDS the directory before it; only a relative target resolves
+            // against the one the run started in.
+            if (target.startsWith('/'))
+                dir = posix.normalize(target);
+            else if (dir === null)
+                return null;
+            else
+                dir = posix.normalize(posix.join(dir, target));
+            continue;
+        }
+        if (segment.program === 'playwright' && segment.args[0] === 'test')
+            break;
+    }
+    return dir;
+}
+/** A failure location's path and its `:line[:column]` suffix, split the way Playwright does. */
+const LOCATION_LINE = /^(.*?)(:\d+(?::\d+)?)$/;
+/**
+ * Each location in a form Playwright matches, so a re-run composed from a run's own report can
+ * actually run.
+ *
+ * Playwright compiles every positional file argument into a regex and tests it against the
+ * absolute path of each collected test file (`playwright test --help`; `createFiltersFromArguments`
+ * → `forceRegExp` → `createFileMatcher`, verified against Playwright 1.63 with `--list`: the
+ * reporter's `../../fixtures/…/articles.spec.ts:3` lists 0 tests, the absolute path lists 1). A
+ * location the reporter printed relative to the runner's directory is resolved against it; where
+ * that directory cannot be known, only the leading `./`/`../` segments are dropped, which leaves a
+ * suffix the absolute path still contains (`fixtures/…/articles.spec.ts:3` matches).
+ *
+ * A location without a leading dot is left alone: it is either absolute or already a suffix of the
+ * absolute path, and rewriting it against a mis-guessed base could only break it
+ * (xr-molecule-flash-m118 +16:34 "No tests found"; m124 +18:38 the platform's own "Re-run just
+ * these" command).
+ *
+ * @param locations - The failing `file:line`s as the run's log printed them.
+ * @param command - The run's command, for its own `cd`s.
+ * @param cwd - The `cwd` the tool was given, when it was.
+ * @returns The locations, matchable by Playwright.
+ */
+function playwrightLocations(locations, command, cwd) {
+    const base = suiteRunDirectory(command, cwd);
+    return locations.map((location) => {
+        const [, file = '', suffix = ''] = LOCATION_LINE.exec(location) ?? [];
+        if (!file.startsWith('./') && !file.startsWith('../'))
+            return location;
+        const resolved = base === null ? file.replace(/^(?:\.{1,2}\/)+/, '') : posix.resolve(base, file);
+        return `${resolved}${suffix}`;
+    });
+}
+/** 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.
+ *
+ * @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.
+ *
+ * @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.
+ */
+function dropSupersededSpecFiles(statement, locations) {
+    if (locations.length === 0)
+        return statement;
+    const runner = /^(playwright\s+test)\b/.exec(statement);
+    if (runner === null)
+        return statement;
+    const head = runner[1];
+    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 `${head}${kept}`;
+}
 /**
  * The run in flight that makes a second run a hazard, or null when nothing is in the way.
  *

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;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"}

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';
 /**
@@ -358,6 +359,7 @@ async function backgroundTaskState(backend, command, seconds, ceilingMs) {
         slice,
     };
 }
+import { suiteCommandTarget } from './suite-overlap.js';
 import { diagnosisTraceCommand } from './trace-artifacts.js';
 import { checkBlockedCommand, declaredBudgetSeconds, DEFAULT_SEARCH_EXCLUDED_DIRS, directoryReadHint, earlyReturnCause, emptyCallError, failureCausesNote, findPathArgs, findPatternArgs, fusedLine, htmlOutline, isCommandTimeout, isEnvFilePath, isOutsideRoot, isPlaywrightRunCommand, isSuiteRunCommand, isValidGlob, linesWithinSerialized, literalDirPrefix, MAX_BATCH_READ_FILES, MAX_FIND_RESULTS, MAX_HTML_INLINE_CHARS, MAX_OUTPUT_SIZE, MAX_READ_CALL_CHARS, MAX_READ_RETURN_CHARS, MAX_READ_SIZE, MAX_SEARCH_CONTEXT_LINES, MAX_SEARCH_RESULTS, MAX_WRITE_SIZE, outputIsWithheldUntilExit, outputRedirectTarget, parseCheckCommand, parseCheckProblem, pathArgError, printsOnlySource, READ_RESULT_ENVELOPE_CHARS, redactSecrets, redactSecretsInCode, repeatingFailure, repeatingFailureNote, resolvePath, RUNNING_FAILURE_LINES, runningCauseCommand, runningOutputSliceCommand, searchTimeoutError, serializedChars, shellQuote, sliceLines, SMALL_FILE_WHOLE_CHARS, streamingBackgroundCommand, stripControlChars, suiteRunPipelinePlacement, suiteRunPriorityLaunch, truncateMiddle, universalCause, whitespaceTolerantReplace, } from './utilities.js';
 /**
@@ -577,6 +579,35 @@ function batchFailureError(path, total, failures) {
             ? `\n\n(${omitted} more replacement${omitted === 1 ? '' : 's'} also failed and are not shown.)`
             : ''));
 }
+/**
+ * Delays between retries of the symlink guard while a sandbox's command channel is
+ * still attaching: four attempts over roughly 2.6 s (plus the commands' own time),
+ * which covers the span a freshly claimed E2B sandbox answers `SandboxNotFoundError`
+ * before its exec channel is usable (xr-molecule-flash-m120 +00:29). A plain slow
+ * answer keeps the single 300 ms retry instead — a sandbox that is gone does not
+ * come back inside five seconds.
+ */
+const SANDBOX_STARTING_BACKOFF_MS = [300, 800, 1_500];
+/**
+ * Whether an error from the sandbox's command channel says the sandbox is still
+ * STARTING rather than gone for good.
+ *
+ * A sandbox created seconds earlier answers `SandboxNotFoundError` ("Sandbox is
+ * probably not running anymore") until its channel attaches, and that message names
+ * the worse of the two causes — so a file tool refused it as if the sandbox were
+ * dead. These shapes are retried; anything else keeps the one quick retry.
+ *
+ * @param error - The error thrown by `backend.run`.
+ * @returns True when the sandbox looks like it is still coming up.
+ */
+function sandboxStillStarting(error) {
+    const err = error;
+    const name = typeof err?.name === 'string' ? err.name : '';
+    const message = typeof err?.message === 'string' ? err.message : '';
+    if (/^SandboxNotFound(?:Error)?$/i.test(name))
+        return true;
+    return /not (?:found|running)|notfound|not attached|still starting/i.test(`${name} ${message}`);
+}
 /**
  * Build a complete set of AI agent tools bound to an execution backend.
  *
@@ -710,10 +741,18 @@ export function buildTools(backend, config) {
     async function checkSymlink(path) {
         if (!symlinkGuards)
             return null;
-        // One retry: the first commands on a just-attached sandbox can fail at once (X1
-        // flash-m44: three paths refused in 332 ms, the same check passing a beat later).
+        // The retry budget is failure-aware. A plain slow answer gets ONE quick retry
+        // (X1 flash-m44: three paths refused in 332 ms, the same check passing a beat
+        // later). A channel that is still ATTACHING gets longer: a sandbox created
+        // seconds earlier answers `SandboxNotFoundError` for well over 600 ms, so the
+        // fixed 2 × 300 ms budget ran out and the run's FIRST file tool was refused with
+        // "probably not running anymore" 300 ms before the same tool answered
+        // (xr-molecule-flash-m120 +00:29). Those errors are about a sandbox that is
+        // still starting, not one that is gone, so they are retried up to ~5 s.
         let lastError;
-        for (let attempt = 0; attempt < 2; attempt++) {
+        let attempts = 0;
+        for (;;) {
+            attempts++;
             const started = Date.now();
             try {
                 const result = await backend.run(`readlink -f ${shellQuote(path)} 2>/dev/null || echo ${shellQuote(path)}`, { timeout: 5000 });
@@ -727,20 +766,29 @@ export function buildTools(backend, config) {
                 lastError = Object.assign(error instanceof Error ? error : new Error(String(error)), {
                     elapsedMs: Date.now() - started,
                 });
-                if (attempt === 0)
-                    await new Promise((resolve) => setTimeout(resolve, 300));
+                const backoff = sandboxStillStarting(lastError) ? SANDBOX_STARTING_BACKOFF_MS : [];
+                const wait = backoff[attempts - 1] ?? (attempts === 1 ? 300 : undefined);
+                if (wait === undefined)
+                    break;
+                await new Promise((resolve) => setTimeout(resolve, wait));
             }
         }
         // Deny conservatively, and say what failed: "access denied" read as a forbidden path,
         // and a fixed "did not answer within 5 s" hid an error that took 332 ms.
         const err = lastError;
         const timedOut = err?.name === 'TimeoutError' || (err?.elapsedMs ?? 0) >= 4900;
-        return timedOut
-            ? 'Unable to verify path safety: the sandbox did not answer the check within 5 s (it may be ' +
+        if (timedOut) {
+            return ('Unable to verify path safety: the sandbox did not answer the check within 5 s (it may be ' +
                 'restarting or out of memory), so the path was refused to stay safe. Retry in a moment; if ' +
-                'every file tool fails this way, the sandbox needs a restart.'
-            : `Unable to verify path safety: the sandbox's command channel failed (${err?.name ?? 'Error'}: ${String(err?.message ?? err).slice(0, 160)}), ` +
-                'so the path was refused to stay safe. Retry the call; if every file tool fails this way, the sandbox needs a restart.';
+                'every file tool fails this way, the sandbox needs a restart.');
+        }
+        if (sandboxStillStarting(err)) {
+            return ('Unable to verify path safety: the sandbox is still starting (its command channel is not ' +
+                'attached yet), so the path was refused to stay safe. Retry in a few seconds — a freshly ' +
+                'created sandbox can take a moment to attach.');
+        }
+        return (`Unable to verify path safety: the sandbox's command channel failed (${err?.name ?? 'Error'}: ${String(err?.message ?? err).slice(0, 160)}), ` +
+            'so the path was refused to stay safe. Retry the call; if every file tool fails this way, the sandbox needs a restart.');
     }
     /**
      * Strip control characters and optionally redact secrets from tool output.
@@ -2172,6 +2220,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 +2235,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 +2360,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
                         ? {
@@ -2492,6 +2553,13 @@ export function buildTools(backend, config) {
             // note it printed called "a lead, not a cause" — and read the early return as "stop waiting,
             // edit now", voiding a run that was still walking both times (the second wait, 224 s of a
             // 280 s budget, ended with nothing at all).
+            // How this run was started, so the note can hand over the re-run to send once it ends
+            // instead of one for now — the platform refuses a second run against the same app and
+            // database while this one walks (xr-molecule-flash-m89: the +19:59 note named a re-run
+            // and its overlap hold refused that exact run 23 s later) — and so a run narrowed to a
+            // file or two is judged against what it selected (xr-molecule-flash-m119 +42:08). Read
+            // BEFORE the loop: the running answers below are built after it closes and still need it.
+            const started = runByTask.get(taskId);
             let midRunNote = null;
             let lastCauseLookAt = startedAt - repeatingCauseLookMs();
             let exitCode = await readExit();
@@ -2523,12 +2591,7 @@ export function buildTools(backend, config) {
                     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));
-                // How this run was started, so the note can hand over the re-run to send once it ends
-                // instead of one for now — the platform refuses a second run against the same app and
-                // database while this one walks (xr-molecule-flash-m89: the +19:59 note named a re-run
-                // and its overlap hold refused that exact run 23 s later).
-                const started = runByTask.get(taskId);
+                const stopCause = earlyReturnCause(found, universalCause(causeLog, found, started?.command));
                 if (stopCause) {
                     // …and only now is the pid walk paid for.
                     repeatingCauseNoted.add(taskId);
@@ -2553,12 +2616,18 @@ export function buildTools(backend, config) {
                 // duration into a proven whole-run cause, and that one is worth returning early for.
                 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
+                    // instructions the note and the wait's own sentence give must agree (xr-molecule-flash-
+                    // m122 +19:00: one result said editing app/src "changes the code the run is testing" and
+                    // "Start fixing it now"). The target is read off the command the task was started with.
+                    const editsInvalidateRun = started === undefined || suiteCommandTarget(started.command) === 'local';
                     midRunNote = repeatingFailureNote(found, {
                         taskId,
                         log,
                         stop: '',
                         universal: null,
                         ...(started ? { run: started } : {}),
+                        ...(editsInvalidateRun ? { editsInvalidateRun: true } : {}),
                     });
                 }
             }
@@ -2649,7 +2718,16 @@ export function buildTools(backend, config) {
                                 `each failure's own report into the log as that test fails, right under its ✘ line, ` +
                                 `not only in the summary at the end. `
                             : `Nothing has been printed yet — \`grep -n '✘' ${log} | head -40\` lists failures as they appear. `) +
-                        `Meanwhile do work that leaves the code under test alone (read the failures so far, plan the fixes): editing app/src or api/src now changes the code the run is testing, and its result no longer counts.${midRun}`,
+                        // What an edit does to this run depends on what the run MEASURES: the sandbox's own
+                        // app is re-served from app/src as it is edited, so the run's result stops counting; a
+                        // run against the deployed build is untouched by a local edit, and the executor can
+                        // spend the rest of the run fixing (xr-molecule-flash-m122 +19:00: a deployed run was
+                        // told editing changes what it tests, then handed "Start fixing it now" in the same
+                        // result — it waited out 1 min 11 s of free fixing time).
+                        (started !== undefined && suiteCommandTarget(started.command) !== 'local'
+                            ? `Meanwhile fix what it has already named: this run tests the deployed build, so editing app/src or api/src now does not change what it tests — fix the causes it has already named while it walks, run nothing against the app until it ends, then deploy once.`
+                            : `Meanwhile do work that leaves the code under test alone (read the failures so far, plan the fixes): editing app/src or api/src now changes the code the run is testing, and its result no longer counts.`) +
+                        `${midRun}`,
                 };
             }
             let output;

package/dist/trace-artifacts.d.ts

@@ -54,6 +54,12 @@ export interface TraceRequest {
     sent?: string;
     /** What came back for that 4xx, bounded the same way — the API's own error body. */
     got?: string;
+    /**
+     * The browser's own resource type (`document`, `fetch`, `xhr`, `font`, `image`, `stylesheet`,
+     * `script`, …). `document` when the request was the page load itself; when it ended in a
+     * `net::ERR_*`, nothing rendered and no selector or app request was measured.
+     */
+    type?: string;
 }
 /** One action the traced page performed, with the trace's own timing for it. */
 export interface TraceAction {
@@ -137,6 +143,36 @@ export declare const traceArtifactsScript: () => string;
  * @returns One entry per trace it printed.
  */
 export declare function parseTraceArtifacts(stdout: string): TraceArtifact[];
+/**
+ * Whether a request is one of the page shell's, not the test's (`STATIC_ASSET_PATH`).
+ *
+ * The document itself is never incidental — a page that never loaded IS the failure — and a
+ * request whose type is the app's own API (`fetch`/`xhr`) is judged by its path alone.
+ *
+ * @param request - One request a trace recorded.
+ * @returns True when the request is incidental to the step under test.
+ */
+export declare function isStaticAssetRequest(request: TraceRequest): boolean;
+/**
+ * Whether a trace recorded a request the server actually failed: a 4xx/5xx, or a network error.
+ *
+ * A 404 on a static asset is excepted: `/sw.js` and `/fonts/*` 404 on an app that never shipped
+ * them, and naming one as a failure sent m125 into writing the caching worker it had asked about.
+ * A 5xx on an asset, or a network error, still counts — the server did fail.
+ *
+ * @param request - One request a trace recorded.
+ * @returns True when the request failed in a way the note should name.
+ */
+export declare function failedRequest(request: TraceRequest): boolean;
+/**
+ * Whether a trace recorded NO response and no reason for it — a request that was aborted or still
+ * in flight when the test ended. It is not evidence that the server failed (m112 +30:45), and one
+ * the page shell made is not evidence about the step at all (m125 +29:33).
+ *
+ * @param request - One request a trace recorded.
+ * @returns True when the request is still in flight and worth naming.
+ */
+export declare function unansweredRequest(request: TraceRequest): boolean;
 /**
  * The note a failed suite run's result carries: what each failing test's page actually sent, and
  * what came back.
@@ -164,6 +200,10 @@ export declare function parseTraceArtifacts(stdout: string): TraceArtifact[];
  * 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".
  *
+ * A run whose every traced page never finished its navigation leads with the browser's own
+ * transport error (`net::ERR_CONTENT_DECODING_FAILED` and friends) and the document it hit: nothing
+ * rendered, so no row below is app evidence (xr-molecule-flash-m118 +37:09).
+ *
  * @param items - The traces {@link parseTraceArtifacts} read.
  * @param target - Where the run went — the deployed host, as the note names it.
  * @param earlierFailures - The failing `file:line`s earlier walks of this suite left, so a repeat

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;;;;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"}
+{"version":3,"file":"trace-artifacts.d.ts","sourceRoot":"","sources":["../src/trace-artifacts.ts"],"names":[],"mappings":"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"}