@molecule/api-ai-tools 1.9.18 → 1.10.0

package/dist/tools.js

@@ -7,7 +7,7 @@
  * @module
  */
 import { posix } from 'path';
-import { commandCutRun, CUT_AT_BUDGET, cutRunSentence, suiteRunExitCode } from './cut-run.js';
+import { commandCutRun, CUT_AT_BUDGET, cutRunSentence, suiteRunExitCode, suiteSummary, } from './cut-run.js';
 import { addChangeSpan, changedSpan, countLines, renderEditExcerpt, renderSmallFile, } from './edit-excerpt.js';
 import { guardToolExecute, missingParamError, ToolInputError } from './input-normalizer.js';
 import { diffLineCount } from './line-diff.js';
@@ -31,6 +31,19 @@ const waitedByTask = new Map();
 const logBytesByTask = new Map();
 /** The file a background command writes its own output to, when it redirects it. */
 const outputFileByTask = new Map();
+/**
+ * Task ids whose launch put the suite on {@link PLAYWRIGHT_FAILURES_INLINE_ENV} — the inline
+ * failure switch, announced by the launch's own change list and written as an `export` at the
+ * head of the command.
+ *
+ * The wait note may promise that each failure's own error sits under its ✘ line only when the run
+ * was actually given the switch: a run whose shape withheld the rewrite prints its failures only
+ * in the end-of-run summary, and the note that promised inline reports sent the model grepping a
+ * file they were not in (the m99 class, recurring at xr-molecule-flash-m173 +17:07, +39:14).
+ * Process memory, like {@link outputFileByTask}: a task this process did not launch recovers it
+ * from the script on disk, which carries the rewritten command.
+ */
+const inlineFailuresByTask = new Set();
 /**
  * How each background task was started: the command as it was actually run (after
  * {@link streamingBackgroundCommand} rewrote it) and the directory it ran in.
@@ -158,6 +171,105 @@ export async function taskStopCommand(backend, taskId) {
         return fallback;
     }
 }
+/**
+ * How often a wait re-asks whether a task whose exit file has not appeared has ended. The exit
+ * file is read every tick; this probe is a process test plus the task's own output, and 3 s is
+ * close enough that a run which ended is never waited out (m182: 281 s on a walk that ended in 20).
+ */
+const TASK_END_LOOK_MS = 3_000;
+/** How much of a task's own output the end test reads — a runner's tally is its last lines. */
+const TASK_OUTPUT_END_BYTES = 4_000;
+/**
+ * The shell probe behind {@link taskEndState}: the pid the launcher wrote, and the end of the
+ * file the command redirects its own output to.
+ *
+ * The pid test is the one `molecule-dev/api/src/ai/background-tasks.ts` applies in `liveness` —
+ * a written exit code ends the task, a live pid keeps it running, and a handle the sandbox cannot
+ * account for stays unknown — so this package and that one cannot disagree about whether a task
+ * is still walking.
+ *
+ * @param taskId - The task's `mol-bg-…` handle (format already checked by the caller).
+ * @param own - The file the command redirects its own output to, when the launch could tell.
+ * @returns The command; its first line is `MOL_TASK_STATE <alive|gone|unknown>`, the rest the tail.
+ */
+const taskStateCommand = (taskId, own) => `P=$(cat /tmp/${taskId}.pid 2>/dev/null); ` +
+    `if [ -z "$P" ] || [ ! -f /tmp/${taskId}.sh ]; then echo MOL_TASK_STATE unknown; ` +
+    `elif kill -0 "$P" 2>/dev/null; then echo MOL_TASK_STATE alive; ` +
+    `else echo MOL_TASK_STATE gone; fi; ` +
+    (own ? `tail -c ${TASK_OUTPUT_END_BYTES} ${shellQuote(own)} 2>/dev/null` : 'true');
+/**
+ * The ending a task's own output already records, read from the file its command redirects to.
+ *
+ * A command can put its real work in a subshell and leave the platform's wrapper waiting on
+ * something else — `( runner > /tmp/full-run.log; echo EXIT=$? >> /tmp/full-run.log ) &` — so
+ * the task log stays empty and the exit file may never appear while the run itself is over. The
+ * run's own file is where its outcome is: an `EXIT=<n>` line the command appended, or the
+ * runner's closing tally (Playwright's status lines, Vitest's `Tests …` line, Hurl's
+ * `Executed files:`), which is the last thing a finished run prints.
+ *
+ * @param text - The tail of the task's own output file.
+ * @returns Whether the output records an ending, and the code when it recorded one.
+ */
+function outputEnding(text) {
+    const trimmed = text.trimEnd();
+    if (!trimmed)
+        return { ended: false, exitCode: null };
+    // An explicit marker the command appended is the run's own verdict, whatever precedes it.
+    const marker = /(?:^|\n)EXIT=(\d+)\s*$/.exec(trimmed);
+    if (marker)
+        return { ended: true, exitCode: Number(marker[1]) };
+    const lastLine = trimmed.slice(trimmed.lastIndexOf('\n') + 1).trim();
+    // A tally is an ending only as the LAST line: a second walk starts by printing its own header,
+    // so a file whose last line is still the first walk's tally is between the two.
+    const tallyLine = /^\d+\s+(?:passed|failed|flaky|skipped|interrupted|timed out|did not run)\b/.test(lastLine) ||
+        /^Tests\s+.+\(\d+\)$/.test(lastLine) ||
+        /\bExecuted files:\s*\d+/.test(lastLine);
+    if (!tallyLine)
+        return { ended: false, exitCode: null };
+    return { ended: suiteSummary(trimmed)?.finished ?? false, exitCode: null };
+}
+/**
+ * Whether a background task has ENDED, asked of the task itself rather than of a note about it.
+ *
+ * A missing exit file alone is not "running": the launcher writes that file from the wrapper it
+ * started, and a command that backgrounds its real work leaves the file missing after the run is
+ * over. X1 xr-molecule-flash-m182 (+30:25) waited 281 s — its whole remaining ceiling — on a walk
+ * that had ended in 20 s, and a `sleep 240; tail` on the same handle was answered "is live". The
+ * end is read the way `molecule-dev/api/src/ai/background-tasks.ts` reads it — exit file, then
+ * the pid — plus the one signal this package has and that tracker does not: the task's own output
+ * file already holding its ending.
+ *
+ * @param backend - The execution backend the task runs on.
+ * @param taskId - The task's `mol-bg-…` handle.
+ * @returns Whether it has ended, and the code its own output recorded when it recorded one.
+ */
+async function taskEndState(backend, taskId) {
+    const own = outputFileByTask.get(taskId);
+    let stdout;
+    try {
+        const r = await backend.run(taskStateCommand(taskId, own), { timeout: 5_000 });
+        stdout = String(r.stdout ?? '');
+    }
+    catch (_error) {
+        // A sandbox that cannot answer is not evidence of an ending: the quiet failure (a wait) beats
+        // the loud one (a result handed back for a run that is still walking).
+        return { ended: false, exitCode: null };
+    }
+    const [stateLine = '', ...rest] = stdout.split('\n');
+    const state = /MOL_TASK_STATE (alive|gone|unknown)/.exec(stateLine)?.[1] ?? 'unknown';
+    const ownEnding = outputEnding(rest.join('\n'));
+    // The run's own output can end the task while its wrapper is still alive: the wrapper may be
+    // waiting on the wrong thing (m182's was blocked) while the run it started is over. An explicit
+    // `EXIT=<n>` is that verdict; a bare tally is trusted only once the pid is gone, because the
+    // instant between a walk's tally and its next walk's header reads the same.
+    if (ownEnding.ended && (ownEnding.exitCode !== null || state === 'gone'))
+        return ownEnding;
+    // A pid this sandbox can account for and that is gone, with no exit file: the wrapper that
+    // writes the exit code was killed or exited, so the task ended and has no verdict to invent.
+    if (state === 'gone')
+        return { ended: true, exitCode: null };
+    return { ended: false, exitCode: null };
+}
 /** A millisecond span the way a model reads it: seconds under 90, else minutes. */
 function durationText(ms) {
     const s = Math.max(0, Math.round(ms / 1000));
@@ -369,17 +481,27 @@ async function backgroundTaskState(backend, command, seconds, ceilingMs) {
         const own = outputFileByTask.get(id);
         return own !== undefined && command.includes(own);
     };
+    // A task is only a candidate to WAIT on while it is still walking: the exit file and the same
+    // end test `wait_for_task` applies both say when it ended, so a sleep is never held for a handle
+    // whose run is already over (m182 +30:25: `sleep 240; tail /tmp/full-run.log` was answered "is
+    // live" for a task that had ended 20 s after it started).
+    const stateOf = async (id) => {
+        const exitCode = await exitCodeOf(id);
+        if (exitCode !== null)
+            return { id, ended: true, exitCode };
+        return { id, ...(await taskEndState(backend, id)) };
+    };
     const newestFirst = [...ids].reverse();
     const namedId = newestFirst.find(names);
     let target = namedId
-        ? { id: namedId, exitCode: await exitCodeOf(namedId) }
+        ? await stateOf(namedId)
         : null;
     if (!target) {
         // Bounded: a long session can leave many finished tasks behind, and each look costs a read.
         for (const id of newestFirst.slice(0, 8)) {
-            const exitCode = await exitCodeOf(id);
-            if (exitCode === null) {
-                target = { id, exitCode };
+            const state = await stateOf(id);
+            if (!state.ended) {
+                target = state;
                 break;
             }
         }
@@ -395,7 +517,7 @@ async function backgroundTaskState(backend, command, seconds, ceilingMs) {
         // No slice: the note still says the task's state and how to get its result.
     }
     const secondsText = `Did not sleep ${Math.round(seconds)} s: background task \`${target.id}\``;
-    if (target.exitCode === null) {
+    if (!target.ended) {
         const facts = waitProgressClauses({
             taskId: target.id,
             slice,
@@ -414,15 +536,19 @@ async function backgroundTaskState(backend, command, seconds, ceilingMs) {
     const counter = logProgress(slice);
     const progress = counter ? `, at ${counter.done} of ${counter.total} in its log` : '';
     const failures = slice.trim() ? '; the failures in its log are in outputSoFar' : '';
+    // No exit file and no code in the run's own output: it ended and there is no verdict to invent.
+    const verdict = target.exitCode === null
+        ? 'no exit code — its process is gone and its output recorded none'
+        : `exit code ${target.exitCode}`;
     return {
-        note: `${secondsText} had already ended (exit code ${target.exitCode})${progress}${failures} — ` +
+        note: `${secondsText} had already ended (${verdict})${progress}${failures} — ` +
             `\`wait_for_task ${target.id}\` returns its result now.`,
         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, repeatedSuiteRunError, repeatingFailure, repeatingFailureNote, resolvePath, RUNNING_FAILURE_LINES, runningCauseCommand, runningOutputSliceCommand, searchTimeoutError, serializedChars, shellQuote, sliceLines, SMALL_FILE_WHOLE_CHARS, streamingBackgroundCommand, stripControlChars, suiteRunBudgetCommand, suiteRunPipelinePlacement, suiteRunPriorityLaunch, TOOL_RESULT_CHARS, truncateMiddle, universalCause, whitespaceTolerantReplace, withoutSuiteTimeout, } from './utilities.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, PLAYWRIGHT_FAILURES_INLINE_ENV, printsOnlySource, READ_RESULT_ENVELOPE_CHARS, redactSecrets, redactSecretsInCode, repeatedSuiteRunError, repeatingFailure, repeatingFailureNote, resolvePath, RUNNING_FAILURE_LINES, runningCauseCommand, runningOutputSliceCommand, searchTimeoutError, serializedChars, shellQuote, sliceLines, SMALL_FILE_WHOLE_CHARS, streamingBackgroundCommand, stripControlChars, suiteRunBudgetCommand, suiteRunPipelinePlacement, suiteRunPriorityLaunch, TOOL_RESULT_CHARS, truncateMiddle, universalCause, whitespaceTolerantReplace, withoutSuiteTimeout, } from './utilities.js';
 /**
  * How long exec_command waits for a command it backgrounded only because the
  * command asked for more than the tool's ceiling, before handing back a task id.
@@ -715,7 +841,7 @@ function packageCatalog(path) {
  * @returns Array of AITool objects ready to pass to an AI provider
  */
 export function buildTools(backend, config) {
-    const { include, exclude, pathGuards = true, symlinkGuards = false, redactSecrets: doRedact = true, blockDangerousCommands = false, blockCommand, execTimeoutMs = 120_000, commandBudgetMs, overCeilingGraceMs = OVER_CEILING_GRACE_MS, searchExcludedDirs, outlineLargeHtml, excludedTestTitles, onAfterWrite, onFileDiff, onFileChange, } = config ?? {};
+    const { include, exclude, pathGuards = true, symlinkGuards = false, redactSecrets: doRedact = true, blockDangerousCommands = false, blockCommand, execTimeoutMs = 120_000, commandBudgetMs, overCeilingGraceMs = OVER_CEILING_GRACE_MS, searchExcludedDirs, outlineLargeHtml, excludedTestTitles, requiredSuiteEnv, onAfterWrite, onFileDiff, onFileChange, } = config ?? {};
     const root = backend.projectRoot;
     // A host-filesystem backend with escape guards off is the combination the
     // audit flagged: `pathGuards` off lets `..` paths out of the workspace,
@@ -2445,6 +2571,10 @@ export function buildTools(backend, config) {
                     const ownFile = ownTarget === null ? null : posix.resolve(cwd, ownTarget);
                     if (ownFile)
                         outputFileByTask.set(id, ownFile);
+                    // Whether the run's failures print as they fail, so a wait can promise that only when
+                    // it is true (see inlineFailuresByTask).
+                    if (streaming.command.startsWith(`export ${PLAYWRIGHT_FAILURES_INLINE_ENV}=1; `))
+                        inlineFailuresByTask.add(id);
                     runByTask.set(id, { command: streaming.command, cwd });
                     await backend.writeFile(script, `${streaming.command}\n`);
                     // The clock the grace return below reports a stopped run against: the command is
@@ -2760,13 +2890,19 @@ export function buildTools(backend, config) {
                 /^mol-bg-[a-z0-9]+-[a-z0-9]+$/.test(taskId)) {
                 outputFileProbed.add(taskId);
                 try {
-                    const target = outputRedirectTarget(await backend.readFile(`/tmp/${taskId}.sh`));
+                    const script = await backend.readFile(`/tmp/${taskId}.sh`);
+                    const target = outputRedirectTarget(script);
                     // A relative target was written against the command's own cwd, which
                     // the handle does not carry; the project root is where a background
                     // command runs unless the caller passed one. An absolute target is
                     // already resolved and stays as written.
                     if (target)
                         outputFileByTask.set(taskId, posix.resolve(root, target));
+                    // The rewritten command is on disk with the `export` head it was given: a task this
+                    // process did not launch still says whether its failures print as they fail
+                    // (see inlineFailuresByTask).
+                    if (script.startsWith(`export ${PLAYWRIGHT_FAILURES_INLINE_ENV}=1; `))
+                        inlineFailuresByTask.add(taskId);
                 }
                 catch (_error) {
                     // No script under that id: this process did not start the task, so
@@ -2824,6 +2960,13 @@ export function buildTools(backend, config) {
                 };
             }
             const log = `/tmp/${taskId}.log`;
+            // The file every note below must point the executor at: the one its own reads and
+            // `outputSoFar` come from. A command that redirects its output (`> /tmp/pw-full.log`) leaves
+            // the task log holding a word, so a grep composed against THAT prints nothing — xr-molecule-
+            // flash-m173 (+17:07) obeyed the +12:18 note's `grep … /tmp/mol-bg-….log`, every grep
+            // printed empty, and the whole mid-run diagnosis window was lost. The task's own wrapper log
+            // stays `log` wherever something is read from both (the size probe and the slice do).
+            const readLog = outputFileByTask.get(taskId) ?? log;
             const exitFile = `/tmp/${taskId}.exit`;
             // Leave the outer tool ceiling a margin so this returns a result rather
             // than being killed by it.
@@ -2870,6 +3013,8 @@ export function buildTools(backend, config) {
             const started = runByTask.get(taskId);
             let midRunNote = null;
             let lastCauseLookAt = startedAt - repeatingCauseLookMs();
+            let lastEndLookAt = startedAt - TASK_END_LOOK_MS;
+            let endedWithoutCode = false;
             let exitCode = await readExit();
             while (exitCode === null && Date.now() - startedAt < budgetMs) {
                 await new Promise((r) => setTimeout(r, Math.min(2_000, budgetMs - (Date.now() - startedAt))));
@@ -2878,6 +3023,19 @@ export function buildTools(backend, config) {
                 // its real result instead of a note about it.
                 if (exitCode !== null)
                     break;
+                // A missing exit file is not "running": the launcher writes that file from its wrapper,
+                // and a command that backgrounds its real work leaves it missing after the run is over.
+                // The same end test the sleep peek uses answers here, before a cause look can `continue`
+                // past it — m182 (+30:25) waited 281 s on a walk that had ended in 20 s.
+                if (Date.now() - lastEndLookAt >= TASK_END_LOOK_MS) {
+                    lastEndLookAt = Date.now();
+                    const state = await taskEndState(backend, taskId);
+                    if (state.ended) {
+                        exitCode = state.exitCode;
+                        endedWithoutCode = state.exitCode === null;
+                        break;
+                    }
+                }
                 if (repeatingCauseNoted.has(taskId))
                     continue;
                 if (Date.now() - lastCauseLookAt < repeatingCauseLookMs())
@@ -2923,7 +3081,7 @@ export function buildTools(backend, config) {
                         waitedMs: earlyMs,
                         note: repeatingFailureNote(noted, {
                             taskId,
-                            log,
+                            log: readLog,
                             stop: await taskStopCommand(backend, taskId),
                             universal: stopCause,
                             ...(started ? { run: started } : {}),
@@ -2947,7 +3105,7 @@ export function buildTools(backend, config) {
                     const editsInvalidateRun = started === undefined || suiteCommandTarget(started.command) === 'local';
                     midRunNote = repeatingFailureNote(found, {
                         taskId,
-                        log,
+                        log: readLog,
                         stop: '',
                         universal: null,
                         ...(started ? { run: started } : {}),
@@ -2957,7 +3115,10 @@ export function buildTools(backend, config) {
             }
             const waitedMs = Date.now() - startedAt;
             waitedByTask.set(taskId, waitedBefore + waitedMs);
-            if (exitCode === null) {
+            // A task the end test found over with no exit code is FINISHED, not still walking: its
+            // result is read below from its own output. Only a task still alive (or a sandbox that
+            // could not answer) reaches the running/stuck answers.
+            if (exitCode === null && !endedWithoutCode) {
                 const grownTo = await logBytes();
                 const lastSize = logBytesByTask.get(taskId);
                 if (grownTo !== null)
@@ -3009,7 +3170,7 @@ export function buildTools(backend, config) {
                 const secondWalk = secondSuiteWalk(soFar) !== null;
                 const stopInstead = secondWalk
                     ? ` Stop it (\`exec_command: ${await taskStopCommand(backend, taskId)}\`) and read the ` +
-                        `first walk's tally in ${log} — the second walk measures nothing new.`
+                        `first walk's tally in ${readLog} — the second walk measures nothing new.`
                     : null;
                 if (stillWriting && waitedBefore + waitedMs >= stuckAfterMs()) {
                     waitedByTask.set(taskId, 0);
@@ -3031,7 +3192,7 @@ export function buildTools(backend, config) {
                         status: 'stuck',
                         waitedMs: waitedBefore + waitedMs,
                         note: `${Math.round((waitedBefore + waitedMs) / 1000)}s of waiting and it has not exited — it is ` +
-                            `stuck, not slow. See what it printed with exec_command (tail /tmp/${taskId}.log — ` +
+                            `stuck, not slow. See what it printed with exec_command (tail ${readLog} — ` +
                             `read_file cannot reach /tmp), kill it (\`exec_command: ` +
                             `${await taskStopCommand(backend, taskId)}\`) and move on; do not wait on it again.`,
                     };
@@ -3050,11 +3211,19 @@ export function buildTools(backend, config) {
                                 `keep waiting — its result carries the log output. ` +
                                 (soFar.trim()
                                     ? `outputSoFar is the failure lines so far (up to ${RUNNING_FAILURE_LINES}) and then the end of ` +
-                                        `the log, not the whole run — \`grep -n '✘' ${log} | head -40\` lists every failure, ` +
-                                        `\`grep -n -A 20 '<test name>' ${log}\` reads one failure's error: this run writes ` +
-                                        `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. `) +
+                                        `the log, not the whole run — \`grep -n '✘' ${readLog} | head -40\` lists every failure, ` +
+                                        `\`grep -n -A 20 '<test name>' ${readLog}\` reads one failure's error: ` +
+                                        // The promise is made only when the launch actually set the inline switch
+                                        // (inlineFailuresByTask). A run whose shape withheld it prints each failure's
+                                        // error in the end-of-run summary alone, and telling the model to grep under
+                                        // the ✘ row sent it through greps that could not match (xr-molecule-flash-m173
+                                        // +17:07, +39:14 — the m99 class, recurring).
+                                        (inlineFailuresByTask.has(taskId)
+                                            ? `this run writes each failure's own report into the log as that test fails, ` +
+                                                `right under its ✘ line, not only in the summary at the end. `
+                                            : `this run prints each failure's error only in the summary at the end; until ` +
+                                                `then the ✘ rows are all there is. `)
+                                    : `Nothing has been printed yet — \`grep -n '✘' ${readLog} | head -40\` lists failures as they appear. `) +
                                 // 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
@@ -3100,12 +3269,20 @@ export function buildTools(backend, config) {
             // failing tests instead of leaving the executor to re-run the whole suite (xr-molecule-
             // flash-m101 +12:13: 139 tests, ~4 minutes, to check two fixes).
             const run = runByTask.get(taskId);
+            // What the REQUEST requires of this suite and the run left out: the narrowed re-run below
+            // is composed from the run's own command, so without these it would measure the same wrong
+            // configuration again (m182: the request names `TEST_MODE=fullstack`, the run and its
+            // re-run both omitted it, and the walk measured the `spa` suite). The consumer's reading,
+            // asked once per finished run; a failure to read answers "nothing required".
+            const requiredEnv = run && requiredSuiteEnv
+                ? ((await requiredSuiteEnv(run.command, run.cwd).catch(() => [])) ?? [])
+                : [];
             // The tests the request excludes are not causes to fix, and the re-run below inverts them
             // out — a result must never ask the executor to fix a test it also says does not count.
             // The log's own path rides along so a recap that leaves causes out can hand over the ONE
             // grep that prints their bodies: the stdout above is cut in the middle, so the log is where
             // they still are whole.
-            const causes = failureCausesNote(output, excludedTestTitles?.() ?? [], run ? { ...run, log: ownFile ?? log } : undefined);
+            const causes = failureCausesNote(output, excludedTestTitles?.() ?? [], run ? { ...run, log: ownFile ?? log, env: requiredEnv } : undefined);
             // A backgrounded run is under no tool budget, and the exit file hands back the PIPELINE's
             // code — so a suite killed at a `timeout 280` the command carried behind a `| tail` reports
             // 0 here too. The run's start is in its own id ({@link taskStartedAt}), so the bound it used
@@ -3139,7 +3316,16 @@ export function buildTools(backend, config) {
                 ? suiteRunPipelinePlacement(run.command)
                 : { piped: false, unplaced: false };
             const reported = suiteRunExitCode(exitCode, output, placement.piped);
-            const noCodeNote = suiteExitCodeNote(placement, reported);
+            // A run that ended with no code at all is not a filtered pipeline: the sentence below says
+            // where its result came from, and claiming a stage after the runner would contradict it.
+            const noCodeNote = endedWithoutCode ? null : suiteExitCodeNote(placement, reported);
+            // The task ended and no exit file recorded a verdict: say so, and say where the result came
+            // from, so the executor reads it instead of waiting on a handle that can never answer.
+            const endedNote = endedWithoutCode
+                ? 'It ended without writing an exit code — its process is gone' +
+                    (ownFile ? `, and its own output (${ownFile}) is the result below` : '') +
+                    '. Read that result; do not wait on this task again.'
+                : null;
             // A FINISHED result says so, even when the code it would report is withheld: a filtered
             // pipeline's code is not the run's verdict ({@link FILTERED_EXIT_NOTE}), so `exitCode` alone
             // cannot tell a caller this is the delivered result rather than a progress return — and a
@@ -3149,8 +3335,12 @@ export function buildTools(backend, config) {
                 status: 'completed',
                 exitCode: reported,
                 waitedMs,
-                ...(causes || noCodeNote
-                    ? { note: [causes, noCodeNote].filter((n) => Boolean(n)).join(' ') }
+                ...(causes || noCodeNote || endedNote
+                    ? {
+                        note: [causes, noCodeNote, endedNote]
+                            .filter((n) => Boolean(n))
+                            .join(' '),
+                    }
                     : {}),
                 stdout: sanitizeOutput(truncateMiddle(output, MAX_OUTPUT_SIZE)),
                 ...(output.length > MAX_OUTPUT_SIZE ? { truncated: true, fullOutput: log } : {}),

package/dist/trace-artifacts.d.ts

@@ -139,6 +139,17 @@ export interface TraceAction {
     pageId?: string;
     /** The frame the action ran in, from the same snapshot. */
     frameId?: string;
+    /**
+     * The selector a `fill`/`type`/`selectOption` acted on (`textarea[name="bio"]`), from the
+     * trace's own params. Kept so the note can compare what the test typed with what the page
+     * submitted (m173: the field it typed into was sent empty).
+     */
+    selector?: string;
+    /**
+     * The value a `fill`/`type`/`selectOption` typed or chose, from the trace's own params —
+     * absent when the action carried none (a `selectOption` by label only).
+     */
+    value?: string;
 }
 /**
  * What a browser context OTHER than the failing page's recorded — the second context a
@@ -179,6 +190,29 @@ export interface TraceMissingText {
     /** The path of the response that carried it (`/api/tags`). */
     path: string;
 }
+/**
+ * A write the trace recorded answering a boolean field, and a LATER GET of the same resource
+ * answering the opposite for that field.
+ *
+ * This is the pair that reads as a frontend race and is not one: xr-molecule-flash-m181's follow
+ * test sent `POST /api/profiles/:username/follow` and the API answered
+ * `{"profile":{…,"following":true}}`, then a `GET /api/profiles/:username` answered
+ * `{"profile":{…,"following":false}}` — the READ route never saw the viewer, so it hydrated
+ * `following` from nobody. The run rewrote the profile component twice, the API client once, and
+ * added optimistic state before anyone read the route's middleware; the write itself was fine.
+ */
+export interface TraceReadContradiction {
+    /** The boolean field both answered (`following`, `favorited`). */
+    field: string;
+    /** What the write's response said it is. */
+    writeValue: boolean;
+    /** What the later read's response said it is. */
+    readValue: boolean;
+    /** The write that answered it (`POST /api/profiles/x/follow`). */
+    write: TraceRequest;
+    /** The later GET of the same resource (`GET /api/profiles/x`). */
+    read: TraceRequest;
+}
 /** What one trace says: the test it belongs to, the requests it made, and its console lines. */
 export interface TraceArtifact {
     /** The failure's spec file, relative to the run's directory, when the trace names one. */
@@ -255,6 +289,15 @@ export interface TraceArtifact {
      * read before this field existed.
      */
     missingText?: TraceMissingText;
+    /**
+     * A write's answer a later GET of the same resource contradicted — the read route does not see
+     * the viewer (xr-molecule-flash-m181's `following`). The note leads with it and sends the run at
+     * the route's middleware, not the page's state handling.
+     *
+     * Absent when no write and later read in the trace answered the same boolean field differently,
+     * and on traces read before this field existed.
+     */
+    readContradiction?: TraceReadContradiction;
 }
 /** How many traces one read reports, newest first. */
 export declare const MAX_TRACE_ARTIFACTS = 12;
@@ -419,6 +462,20 @@ export interface TraceRunReport {
      */
     authEndpoints?: readonly string[];
 }
+/**
+ * Whether a request PATH asks the app to mint a credential — a login, a registration, a token
+ * endpoint — as opposed to a protected resource that presents one.
+ *
+ * This is the path half of {@link isCredentialExchange}, exported so a caller holding only a
+ * `METHOD path` reads the same classification: a Hurl failing entry says
+ * `POST /api/users/login` and nothing about the body, and the whole-suite note must not explain
+ * a wrong-password login that answered 200 as a cookie-jar effect (xr-molecule-flash-m176).
+ *
+ * @param path - The request path (`/api/users/login`); a query or fragment is ignored.
+ * @param authEndpoints - The endpoints the app's auth config names (`/users/login`).
+ * @returns True when the path names a credential exchange.
+ */
+export declare function isCredentialExchangePath(path: string, authEndpoints?: readonly string[]): boolean;
 /**
  * The note a failed suite run's result carries: what each failing test's page actually sent, and
  * what came back.
@@ -458,6 +515,20 @@ export interface TraceRunReport {
  * context and the assertion's page cannot be identified, the note lists the requests and makes NO
  * causal claim — no "the test's last action", no "the page stayed at …" — instead of merging them.
  *
+ * A field the test filled and the page submitted EMPTY ({@link formResetOf}) leads the note: the
+ * trace holds both facts — the value typed into `textarea[name="bio"]` and the `PUT /api/user`
+ * whose body carried `"bio": ""` — so the form's state was reset between the typing and the
+ * submit. The note names the effect that re-seeds a form from data whose identity changed and the
+ * fix at the source (seed the form once). xr-molecule-flash-m173 lost a deploy-and-walk cycle to
+ * this on the deployed URL only, where the background session verification lands later than it
+ * does locally.
+ *
+ * A write whose response said a boolean field is true and a LATER GET of the same resource that
+ * said it is false leads the note first ({@link readContradictionSentence}): the read route never
+ * saw the viewer, so the fix is on that route's middleware, not in the page. xr-molecule-flash-m181
+ * spent ~8 minutes rewriting the profile component over exactly that pair — the write answered
+ * `{"following":true}` and the next profile GET answered `false`.
+ *
  * 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 line ({@link traceRowEvidence}), rows are
  * deduplicated by the test's location, and they are ordered real failure → repeated from an

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

@@ -1 +1 @@
-{"version":3,"file":"trace-artifacts.d.ts","sourceRoot":"","sources":["../src/trace-artifacts.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"trace-artifacts.d.ts","sourceRoot":"","sources":["../src/trace-artifacts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAKH,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;IACZ;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAA;IACb;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;;;;;;;;OAQG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,iFAAiF;IACjF,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,eAAe;IAC9B,yFAAyF;IACzF,GAAG,EAAE,MAAM,CAAA;IACX,oEAAoE;IACpE,KAAK,EAAE,MAAM,CAAA;IACb,kEAAkE;IAClE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;IAClB;;;;OAIG;IACH,QAAQ,EAAE,YAAY,EAAE,CAAA;IACxB,yFAAyF;IACzF,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,4EAA4E;IAC5E,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;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;IAClB,2FAA2F;IAC3F,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,oFAAoF;IACpF,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,2DAA2D;IAC3D,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,oBAAoB;IACnC,2CAA2C;IAC3C,OAAO,EAAE,MAAM,CAAA;IACf;;;OAGG;IACH,QAAQ,EAAE,YAAY,EAAE,CAAA;CACzB;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,gBAAgB;IAC/B,sDAAsD;IACtD,IAAI,EAAE,MAAM,CAAA;IACZ,0DAA0D;IAC1D,MAAM,EAAE,MAAM,CAAA;IACd,8DAA8D;IAC9D,IAAI,EAAE,MAAM,CAAA;CACb;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,sBAAsB;IACrC,kEAAkE;IAClE,KAAK,EAAE,MAAM,CAAA;IACb,4CAA4C;IAC5C,UAAU,EAAE,OAAO,CAAA;IACnB,iDAAiD;IACjD,SAAS,EAAE,OAAO,CAAA;IAClB,kEAAkE;IAClE,KAAK,EAAE,YAAY,CAAA;IACnB,kEAAkE;IAClE,IAAI,EAAE,YAAY,CAAA;CACnB;AAED,gGAAgG;AAChG,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;;;;;;;;;;OAUG;IACH,IAAI,CAAC,EAAE,YAAY,CAAA;IACnB;;;;OAIG;IACH,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB;;;;;;;;;;;;;;OAcG;IACH,UAAU,CAAC,EAAE,eAAe,CAAA;IAC5B;;;;;OAKG;IACH,OAAO,EAAE,WAAW,EAAE,CAAA;IACtB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,IAAI,CAAA;IACnB;;;;;;;OAOG;IACH,aAAa,CAAC,EAAE,oBAAoB,EAAE,CAAA;IACtC;;;;;;;;;OASG;IACH,WAAW,CAAC,EAAE,gBAAgB,CAAA;IAC9B;;;;;;;OAOG;IACH,iBAAiB,CAAC,EAAE,sBAAsB,CAAA;CAC3C;AAED,sDAAsD;AACtD,eAAO,MAAM,mBAAmB,KAAK,CAAA;AAErC,sDAAsD;AACtD,eAAO,MAAM,mBAAmB,IAAI,CAAA;AAEpC;;;GAGG;AACH,eAAO,MAAM,kBAAkB,IAAI,CAAA;AAEnC,sFAAsF;AACtF,eAAO,MAAM,kBAAkB,KAAK,CAAA;AAEpC,yFAAyF;AACzF,eAAO,MAAM,qBAAqB,MAAM,CAAA;AAUxC,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;AAEvC;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,MAAM,CAAA;AAK5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,oBAAoB,QAAO,MAy6BvC,CAAA;AAyFD;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,EAAE,CAwDnE;AA2KD;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAKnE;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAG5D;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAGhE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAMzE;AAkDD;;;;;;;;;;GAUG;AACH,MAAM,WAAW,eAAe;IAC9B,+EAA+E;IAC/E,IAAI,EAAE,MAAM,CAAA;IACZ,mEAAmE;IACnE,IAAI,EAAE,MAAM,CAAA;IACZ,4FAA4F;IAC5F,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,4FAA4F;IAC5F,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;CACxB;AAED,2DAA2D;AAC3D,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,QAAQ,CAAC,EAAE,SAAS,eAAe,EAAE,CAAA;IACrC;;;;;OAKG;IACH,sBAAsB,CAAC,EAAE,OAAO,CAAA;IAChC;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAClC;AA4SD;;;;;;;;;;;;GAYG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,MAAM,EACZ,aAAa,GAAE,SAAS,MAAM,EAAO,GACpC,OAAO,CAcT;AAipBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgHG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,SAAS,aAAa,EAAE,EAC/B,MAAM,EAAE,MAAM,EACd,eAAe,GAAE,SAAS,MAAM,EAAO,EACvC,WAAW,GAAE,SAAS,MAAM,EAAO,EACnC,MAAM,GAAE,cAAmB,GAC1B,MAAM,GAAG,IAAI,CAocf;AAaD;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAG9D;AAED,iFAAiF;AACjF,eAAO,MAAM,oBAAoB,8BAA8B,CAAA;AAwG/D,oGAAoG;AACpG,MAAM,WAAW,qBAAqB;IACpC,0BAA0B;IAC1B,OAAO,EAAE,MAAM,CAAA;IACf,4EAA4E;IAC5E,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CACtB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;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,CA0BjC"}