@molecule/api-ai-tools 1.9.16 → 1.9.19

package/dist/suite-overlap.js

@@ -31,7 +31,7 @@
 import { posix } from 'node:path';
 import { commandSegments, locatedCommandSegments } from './command-position.js';
 import { commandRunsNoTests } from './no-test-run.js';
-import { shellQuote, suiteRunStatements } from './utilities.js';
+import { matchingExcludedTitles, shellQuote, suiteRunStatements } from './utilities.js';
 /**
  * A command with its heredoc bodies removed: the runs, kills and hosts it names in a file it
  * WRITES are not what the command itself does.
@@ -108,17 +108,48 @@ export function namesSuiteConfig(command) {
 export function withSuiteConfig(command, config) {
     if (!config)
         return command;
-    const at = command.search(/\bplaywright\s+test\b/);
-    if (at === -1)
+    const run = playwrightStatement(command);
+    if (run === null)
         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))
+    if (namesSuiteConfig(command.slice(run.start, run.end)))
         return command;
-    return `${head}${statement.replace(/^(playwright\s+test)\b/, `$1 --config ${shellQuote(config)}`)}${tail}`;
+    // Right after the runner's own words (`playwright test <here>`), so a launcher in front of
+    // them — `npx --no-install`, `node <path>/playwright` — is untouched and the flag is the
+    // runner's own argument wherever it sits.
+    return `${command.slice(0, run.afterRunner)} --config ${shellQuote(config)}${command.slice(run.afterRunner)}`;
+}
+/**
+ * A redirect that names a FILE for a stream whose target a re-run would destroy: `> f`, `>> f`,
+ * `1> f`, `&> f`. `2>` is stderr and deliberately not matched; a descriptor duplication
+ * (`2>&1`, `>&2`) has no file target and does not match either, because `&` cannot start one.
+ */
+const FILE_REDIRECT = /(^|\s)(&>>?|1?>>?)(\s*)(?:'([^']+)'|"([^"]+)"|([^\s;&|]+))/g;
+/** A target that is not a log anyone could lose: rewriting it would CREATE a file. */
+const DEVICE_TARGET = /^\/dev\//;
+/**
+ * The command with every file redirect pointed at a fresh file beside its original target
+ * (`/tmp/pw-full.log` → `/tmp/pw-full.rerun.log`), and nothing else changed.
+ *
+ * A re-run composed from a run's own command keeps the run's redirect by construction, and the
+ * run wrote the walk's only report to that file: xr-molecule-flash-m173 handed over *"Send this
+ * once the run ends: … npx playwright test …/articles.spec.ts:32 --retries=0 … > /tmp/pw-full.log
+ * 2>&1"* — the ONE narrowed re-run that was about to check the fixes would have overwritten the
+ * full walk's log, destroying the other 11 failures' error reports. Following the platform's own
+ * advice must never destroy the evidence it was based on.
+ *
+ * @param command - A shell command.
+ * @returns The command whose file redirects write to a fresh target.
+ */
+function redirectToFreshFile(command) {
+    return command.replace(FILE_REDIRECT, (whole, before, op, space, single, double, bare) => {
+        const target = single ?? double ?? bare ?? '';
+        // `/dev/null` and friends are not a report to preserve; leaving them keeps the re-run silent
+        // the way the run was, where rewriting them would create a file nobody asked for.
+        if (!target || DEVICE_TARGET.test(target))
+            return whole;
+        const quote = single !== undefined ? "'" : double !== undefined ? '"' : '';
+        return `${before}${op}${space}${quote}${target}.rerun.log${quote}`;
+    });
 }
 /**
  * The whole-suite command made scoped to the tests it should re-run instead: the same
@@ -126,6 +157,10 @@ export function withSuiteConfig(command, config) {
  * 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).
  *
+ * The re-run keeps the run's `> <file>` redirect only in the sense of keeping its OUTPUT there:
+ * the target is rewritten to a fresh sibling ({@link redirectToFreshFile}), so a re-run never
+ * overwrites the log the run itself is the evidence for (xr-molecule-flash-m173).
+ *
  * `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
@@ -147,16 +182,17 @@ export function withSuiteConfig(command, config) {
  * @returns The scoped command, or the command unchanged when it runs no Playwright suite.
  */
 export function scopedRerunCommand(command, locations, excluded = [], config, cwd) {
-    const at = command.search(/\bplaywright\s+test\b/);
-    if (at === -1)
+    const run = playwrightStatement(command);
+    if (run === null)
         return command;
-    const head = command.slice(0, at);
-    const rest = command.slice(at);
     // Only the first statement runs the suite; the rest (`| tail -50`, `&& echo done`)
     // is left exactly as it was.
-    const end = rest.search(/&&|\|\||;|\|/);
-    const statement = end === -1 ? rest : rest.slice(0, end);
-    const tail = end === -1 ? '' : rest.slice(end);
+    const statement = command.slice(run.start, run.end);
+    const tail = command.slice(run.end);
+    // The arguments after the runner's own words (`playwright test`), where the narrowed re-run
+    // writes its locations — the launcher in front of them (`npx --no-install`, `node
+    // <path>/playwright`) is not part of the arguments.
+    const args = command.slice(run.afterRunner, run.end);
     // One literal alternation, regex-escaped and shell-quoted: a title carries parentheses and
     // quotes (`should only allow comment author to delete`) that are regex and shell syntax alike.
     const invert = excluded.length > 0 && !/--grep-invert\b/.test(command)
@@ -176,16 +212,18 @@ export function scopedRerunCommand(command, locations, excluded = [], config, cw
     // 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)
+    const dropped = dropSupersededSpecFiles(args, narrowed)
         .replace(/\s*--last-failed\b/g, '')
-        .replace(/\s*--retries(?:[= ]\d+)?/g, '')
-        .replace(/^(playwright\s+test)\b/, `$1 ${narrowed.join(' ')} --retries=0${carry}${invert}`);
+        .replace(/\s*--retries(?:[= ]\d+)?/g, '');
+    const scoped = command.slice(0, run.afterRunner) +
+        ` ${narrowed.join(' ')} --retries=0${carry}${invert}` +
+        dropped;
     // A command that starts the suite AGAIN after this statement is a chain of walks, not a re-run:
     // everything from the next suite runner on is dropped, so the composed command carries ONE walk.
     // X1 xr-molecule-flash-m157 (+14:02) was handed a re-run that still carried the chain's second
     // whole walk — 4.5 minutes measuring code it had not changed.
     const rerunTail = suiteRunStatements(tail).length > 0 ? '' : tail;
-    return `${head}${scoped}${rerunTail}`;
+    return `${redirectToFreshFile(scoped)}${redirectToFreshFile(rerunTail)}`;
 }
 /** A directory a `cd` can name literally: no `~`, no variable, no glob. */
 const LITERAL_DIR = /^[A-Za-z0-9_./+-]+$/;
@@ -267,7 +305,8 @@ function playwrightLocations(locations, command, cwd) {
 /** 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+)?)?$/;
 /**
- * The statement with every bare spec-file argument taken out once the re-run names failure locations.
+ * The runner's own arguments with every bare spec-file argument taken out once the re-run names
+ * failure locations.
  *
  * The re-run is "just these": Playwright matches each positional argument against every collected
  * file's path, so a bare file left beside the `file:line`s re-admits ALL of that file's tests.
@@ -276,23 +315,20 @@ const SPEC_FILE_ARGUMENT = /^(?!-)[^\s]*\.(?:spec|test)\.[cm]?[jt]sx?(?::\d+(?::
  * failures sat in two of them — 32 tests, ~3 min, instead of the 8 failures' ~30 s. A file with no
  * failure in it has nothing to re-run, so it goes too.
  *
- * @param statement - The Playwright statement, starting at its own `playwright test`.
+ * The launcher's words are not arguments and are not here: the caller passes what follows
+ * `playwright test` ({@link playwrightStatement}'s `afterRunner`), so `node <path>/playwright
+ * test` and `npx playwright test` lose the same spec files.
+ *
+ * @param args - The run's own arguments, after `playwright test`.
  * @param locations - The failing `file:line`s the re-run names.
- * @returns The statement without its bare spec-file arguments.
+ * @returns The arguments without their bare spec-file arguments.
  */
-function dropSupersededSpecFiles(statement, locations) {
+function dropSupersededSpecFiles(args, 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) => {
+        return args;
+    return args.replace(/(^|\s+)([^\s]+)(?=\s|$)/g, (whole, _space, token) => {
         return SPEC_FILE_ARGUMENT.test(token) ? '' : whole;
     });
-    return `${head}${kept}`;
 }
 /**
  * The run in flight that makes a second run a hazard, or null when nothing is in the way.
@@ -320,11 +356,78 @@ export function suiteRunInTheWay(candidate, inFlight) {
  * closing quote is that echo. A version-pinned `playwright@1.44.0 test` is the same run.
  */
 const PLAYWRIGHT_RUN = /^(?:@playwright\/test|playwright)(?:@\S+)?\s+test(?=\s|$)/;
+/**
+ * The statement of a command that runs `playwright test`, and where its own arguments begin.
+ *
+ * Both rewrites that compose a command ({@link withSuiteConfig}, {@link scopedRerunCommand}) read
+ * the run through the shared shell parse — the same answer every classifier gets — instead of
+ * searching the text for `playwright test`. The search missed the runner reached by file (`node
+ * <path>/@playwright/test/cli.js test`, xr-molecule-flash-m179), so a narrowed re-run of that run
+ * silently stayed the whole suite.
+ *
+ * `afterRunner` is the offset just past the runner's own words (`playwright test`): the
+ * sub-command is the word after the program word, wherever the program word is (the script path
+ * behind `node`, the name itself otherwise), so an option written there is the run's own.
+ *
+ * @param command - The shell command.
+ * @returns The statement's span and its argument offset, or null when no statement runs the suite.
+ */
+function playwrightStatement(command) {
+    for (const located of locatedCommandSegments(command)) {
+        const segment = located.segment;
+        if (!segment || !PLAYWRIGHT_RUN.test(segment.text))
+            continue;
+        // A statement inside a nested `sh -c '<command>'` has no offsets here: its positions are
+        // positions in that string, so nothing may be spliced at them.
+        if (located.start === null || located.end === null || located.programOffset === null)
+            return null;
+        const words = [...command.slice(located.programOffset).matchAll(/\S+/g)];
+        const subcommand = words[1];
+        if (subcommand === undefined)
+            return null;
+        return {
+            start: located.start,
+            end: located.end,
+            afterRunner: located.programOffset + (subcommand.index ?? 0) + subcommand[0].length,
+        };
+    }
+    return null;
+}
 /**
  * What narrows a Playwright run to a part of the suite: a named file or line, a title filter, or
  * the tests the run before it printed (`--last-failed`, `--only-changed`).
  */
 const NARROWED_RUN = /\.(?:spec|test)\.[cm]?[jt]sx?\b|\.[cm]?[jt]sx?:\d+|(?:^|\s)(?:-g|--grep(?:-invert)?|--last-failed|--only-changed)\b/;
+/**
+ * A `--grep-invert` (or its `-G` alias) with the pattern Playwright takes: quoted or bare, `=` or
+ * whitespace between flag and value, the last occurrence winning as it does on the runner's own
+ * command line. The flag's own name has to be followed by `=` or whitespace, so `--grep` never
+ * matches `--grep-invert`; and a value never crosses a shell separator, so a flag written last
+ * cannot eat the statement after it.
+ */
+const GREP_INVERT_VALUE = /(?:^|[\s;&|(])(?:--grep-invert|-G)(?:=|\s+)(?:'([^']*)'|"([^"]*)"|([^\s;&|]+))/g;
+/**
+ * The `--grep-invert` pattern a Playwright invocation carries, or null when it carries none.
+ *
+ * @param run - The Playwright invocation's command-position text.
+ * @returns The pattern as the command wrote it, or null.
+ */
+function grepInvertPattern(run) {
+    const last = [...run.matchAll(GREP_INVERT_VALUE)].at(-1);
+    if (!last)
+        return null;
+    return last[1] ?? last[2] ?? last[3] ?? null;
+}
+/**
+ * The invocation without its `--grep-invert` flags, so the OTHER narrowers can be read on their
+ * own: a run that greps AND names a file is still a diagnosis whatever its inversion excludes.
+ *
+ * @param run - The Playwright invocation's command-position text.
+ * @returns The same text with every `--grep-invert`/`-G` flag and value taken out.
+ */
+function withoutGrepInvert(run) {
+    return run.replace(GREP_INVERT_VALUE, ' ');
+}
 /**
  * The Playwright invocation's text when the command starts one, or null.
  *
@@ -383,10 +486,19 @@ function boundsFailures(command) {
  * diagnosis. A command that starts no Playwright run is not one either (false): the question is
  * about a run already read as a Playwright suite.
  *
+ * A `--grep-invert` is only a narrowing when it excludes MORE than the request already excludes.
+ * When the caller passes those approved titles ({@link DiagnosisRunContext}) and the inverted
+ * pattern names one of them — the request's own "except …" scope written as the flag, which
+ * molecule-dev's `invertDecision` reads the same way — the run still walks the whole proof scope,
+ * and it is not a diagnosis. xr-molecule-flash-m170 (+33:16): the deployed proof carried exactly
+ * that exclusion, the rewriter added `--retries=0` to it, and the run lost the suite's retries on
+ * the one walk where a network blip is likeliest.
+ *
  * @param command - The command as the executor sent it.
+ * @param context - The request's approved exclusions, when the caller knows them.
  * @returns True when the run is a diagnosis or a re-run, not the whole suite.
  */
-export function isDiagnosisRun(command) {
+export function isDiagnosisRun(command, context) {
     if (boundsFailures(command))
         return true;
     const run = playwrightRun(command);
@@ -396,5 +508,11 @@ export function isDiagnosisRun(command) {
     // the suite either, and is not the whole-suite run the retries belong on.
     if (commandRunsNoTests(run))
         return true;
-    return NARROWED_RUN.test(run);
+    const inverted = grepInvertPattern(run);
+    if (inverted === null)
+        return NARROWED_RUN.test(run);
+    // A file, a line, a `-g`, `--last-failed` … narrows the run whatever the inversion also drops.
+    if (NARROWED_RUN.test(withoutGrepInvert(run)))
+        return true;
+    return matchingExcludedTitles(inverted, context?.approvedExclusions ?? []).length === 0;
 }

package/dist/tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAkJ9C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAahG;AAiSD,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAsEnE;;;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;AA2GD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,CAAC,EAAE,eAAe,GAAG,MAAM,EAAE,CAqlFxF"}
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAsK9C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAahG;AAiSD,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAqFnE;;;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;AA2GD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,CAAC,EAAE,eAAe,GAAG,MAAM,EAAE,CAurFxF"}

package/dist/tools.js

@@ -13,6 +13,7 @@ import { guardToolExecute, missingParamError, ToolInputError } from './input-nor
 import { diffLineCount } from './line-diff.js';
 import { pipelineExitCodeNote } from './pipeline-exit-note.js';
 import { TOOL_SCHEMAS } from './schemas.js';
+import { foregroundServerCommand, SERVER_OVER_BUDGET_ADVICE, serverCommandRefusal, startsServerProgram, } from './server-command.js';
 import { leadingSleepPeek } from './sleep-peek.js';
 /**
  * Total waiting, per background task, after which wait_for_task reports it
@@ -30,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.
@@ -421,12 +435,23 @@ async function backgroundTaskState(backend, command, seconds, ceilingMs) {
 }
 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, 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.
  */
 const OVER_CEILING_GRACE_MS = 45_000;
+/**
+ * The machine-readable mark on a result whose run carried the supplied suite's own settings
+ * ({@link ToolBuildConfig.suiteBudget}) — the flags actually written, so a consumer's notes can
+ * treat those settings as equal to the suite's instead of re-reading the config.
+ *
+ * @param pinned - The flags put on the command.
+ * @returns The result field, or nothing when no flag was placed.
+ */
+function suiteBudgetField(pinned) {
+    return pinned.length === 0 ? {} : { suiteBudget: { pinned: [...pinned] } };
+}
 /**
  * The closing advice on an over-budget message for a command that is not a test
  * suite: the work it was chaining is what to split.
@@ -2258,11 +2283,38 @@ export function buildTools(backend, config) {
                 if (blocked)
                     return { error: blocked };
             }
-            // A diagnosis run of a suite whose config records no trace gets one recorded anyway
+            // A command that starts the suite more than once is refused BEFORE anything runs, in the
+            // foreground as well as in the background: each walk measures the same code, and only the
+            // last one is rewritten here. The background launcher already refused it; a foreground
+            // command ran both, and the platform's note read the first walk's tally beside the second
+            // walk's host (X1 xr-molecule-flash-m170 +06:02). ONE reading — {@link repeatedSuiteRunError}
+            // — so every launch site refuses the same commands.
+            const repeatedSuiteRun = repeatedSuiteRunError(rawCommand);
+            if (repeatedSuiteRun)
+                return { error: repeatedSuiteRun };
+            // A FOREGROUND command that starts a server never returns: it holds this tool for its whole
+            // budget and — behind `| tail`, the way these probes are usually written — prints nothing
+            // until it does. X1 xr-molecule-flash-m167 (+19:16 → +24:04) sent
+            // `npx tsx --env-file=.env /tmp/probe.mts | tail -15` where the script imports the app's
+            // `api/src/server.ts` and calls `create(0)`, whose `listen()` keeps the process alive; the
+            // run waited 290 s and was then told to "run a smaller unit". Refused BEFORE anything runs,
+            // with the two shapes that work: a background launch (which the platform tracks and hands a
+            // task id for) or a probe of the API already on :4000.
+            if (input.run_in_background !== true) {
+                const server = await foregroundServerCommand(rawCommand, (path) => backend.readFile(path));
+                if (server) {
+                    return {
+                        error: serverCommandRefusal(server, Math.max(1, Math.round((commandBudgetMs ?? 290_000) / 1000))),
+                    };
+                }
+            }
+            // A Playwright run of a suite whose config records no trace gets one recorded anyway
             // (`diagnosisTraceCommand`, trace-artifacts.ts): the failing tests' own network log is what
             // tells a swallowed request error from a selector, and X1 xr-molecule-flash-m100 spent the
             // last minutes of its run hand-writing Chromium probes for what the trace it never wrote
-            // down would have said. The whole rule is that function's; the proof run is never touched.
+            // down would have said. The whole rule is that function's; the whole-suite proof run gets it
+            // too, since a trace is retained only for a failing test (m163's proof run left none and the
+            // executor hunted one that did not exist).
             const traced = await diagnosisTraceCommand({
                 command: rawCommand,
                 cwd,
@@ -2290,6 +2342,32 @@ export function buildTools(backend, config) {
                     };
                 }
             }
+            // The supplied suite's own budget. A run whose runner config sets a different per-test
+            // timeout or worker count measures a run the grader never sees: xr-molecule-flash-m169 wrote
+            // a 60 s wrapper config, the platform proved the suite on it, and the official 15 s grader
+            // then failed five tests the proof could never show. The suite's values are put back on the
+            // runner's own arguments — the one place Playwright lets them win over every config — and the
+            // result carries the sentence. The consumer reads the configs (it knows where the suite and
+            // its base live); this tool only writes the flags where they belong. Before the background
+            // branch, so a task launch and a foreground run carry them alike.
+            let budgetNote = null;
+            let budgetPinned = [];
+            if (config?.suiteBudget !== undefined && isPlaywrightRunCommand(command)) {
+                try {
+                    const pin = await config.suiteBudget(command, cwd);
+                    if (pin !== null && pin !== undefined) {
+                        budgetNote = pin.note;
+                        if (pin.flags.length > 0) {
+                            const pinned = suiteRunBudgetCommand(command, pin.flags);
+                            command = pinned.command;
+                            budgetPinned = pinned.placed;
+                        }
+                    }
+                }
+                catch (_error) {
+                    // A consumer's scan that fails changes nothing: the command runs exactly as asked.
+                }
+            }
             // Detached: start it, hand back a handle, let the turn continue. A
             // command that outlives the tool's ceiling is otherwise simply lost —
             // measured across six agent runs, ten of them were killed at the
@@ -2346,7 +2424,12 @@ export function buildTools(backend, config) {
                         command = lifted.command;
                     // Keep the log growing while it runs (see streamingBackgroundCommand):
                     // an empty log is what wait_for_task reads as stuck.
-                    const streaming = streamingBackgroundCommand(command);
+                    // The request's own exclusions ride along: a `--grep-invert` that names one of them is
+                    // the proof scope written as a flag, not a diagnosis, so it keeps the suite's retries
+                    // (xr-molecule-flash-m170 +33:16). The getter is the host's, read here at launch time.
+                    const streaming = streamingBackgroundCommand(command, {
+                        approvedExclusions: excludedTestTitles?.() ?? [],
+                    });
                     // A command that starts the suite more than once is refused here, before anything is
                     // written or launched: each walk measures the same code, and only the last is rewritten
                     // (X1 xr-molecule-flash-m157 +14:02 — two whole walks chained with `;`).
@@ -2375,6 +2458,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
@@ -2428,6 +2515,7 @@ export function buildTools(backend, config) {
                                             ? { truncated: true, fullOutput: log }
                                             : {}),
                                         error: (sleepNote ? `${sleepNote} ` : '') +
+                                            (budgetNote ? `${budgetNote} ` : '') +
                                             cutRunSentence(cut) +
                                             // A suite stopped in the background is never sent to the background again:
                                             // the sentence says what to do, and the advice's reason (it “takes the run
@@ -2454,6 +2542,7 @@ export function buildTools(backend, config) {
                                     : pipelineExitCodeNote(streaming.command, reported, output);
                                 const notes = [
                                     ...(sleepNote ? [sleepNote] : []),
+                                    ...(budgetNote ? [budgetNote] : []),
                                     ...streaming.changes,
                                     ...(exitNote === null ? [] : [exitNote]),
                                 ];
@@ -2464,6 +2553,7 @@ export function buildTools(backend, config) {
                                     ...(pipeNote === null ? {} : { exitCodeNote: pipeNote }),
                                     ...(output.length > MAX_OUTPUT_SIZE ? { truncated: true, fullOutput: log } : {}),
                                     ...(notes.length ? { note: notes.join(' ') } : {}),
+                                    ...suiteBudgetField(budgetPinned),
                                 };
                             }
                             await new Promise((r) => setTimeout(r, 1_500));
@@ -2474,7 +2564,9 @@ export function buildTools(backend, config) {
                         log,
                         exitFile,
                         ...(peekedTask?.slice.trim() ? { outputSoFar: sanitizeOutput(peekedTask.slice) } : {}),
+                        ...suiteBudgetField(budgetPinned),
                         note: (sleepNote ? `${sleepNote} ` : '') +
+                            (budgetNote ? `${budgetNote} ` : '') +
                             (overCeiling
                                 ? declaredSeconds > ceilingSeconds
                                     ? `This command asks for ${declaredSeconds}s, more than this tool's ${ceilingSeconds}s, and its ` +
@@ -2575,6 +2667,7 @@ export function buildTools(backend, config) {
                         // count) says the same sentence with the total the output alone cannot give.
                         cutRun: cut,
                         error: (sleepNote ? `${sleepNote} ` : '') +
+                            (budgetNote ? `${budgetNote} ` : '') +
                             `${cutLead} ` +
                             // The tool's own budget stopping a run that printed nothing: keep the sentence that
                             // says why the output is empty, since nothing else in the result can say it.
@@ -2583,7 +2676,11 @@ export function buildTools(backend, config) {
                                     ? ' — and a pipe through tail/head holds everything back until the command ends, so it printed nothing: run it without the pipe (use a line reporter and let the output stream)'
                                     : ''}. `
                                 : '') +
-                            (isSuiteRunCommand(command) ? SUITE_OVER_BUDGET_ADVICE : SPLIT_WORK_ADVICE),
+                            (startsServerProgram(command)
+                                ? SERVER_OVER_BUDGET_ADVICE
+                                : 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
@@ -2597,9 +2694,10 @@ export function buildTools(backend, config) {
                     exitCode: result.exitCode,
                     ...(exitCodeNote === null ? {} : { exitCodeNote }),
                     ...(peekedTask?.slice.trim() ? { outputSoFar: sanitizeOutput(peekedTask.slice) } : {}),
-                    ...(sleepNote || ceilingNote || traced.change
+                    ...suiteBudgetField(budgetPinned),
+                    ...(sleepNote || ceilingNote || traced.change || budgetNote
                         ? {
-                            note: [sleepNote, ceilingNote, traced.change].filter(Boolean).join(' '),
+                            note: [sleepNote, ceilingNote, traced.change, budgetNote].filter(Boolean).join(' '),
                         }
                         : {}),
                 };
@@ -2679,13 +2777,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
@@ -2743,6 +2847,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.
@@ -2842,7 +2953,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 } : {}),
@@ -2866,7 +2977,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 } : {}),
@@ -2928,7 +3039,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);
@@ -2950,7 +3061,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.`,
                     };
@@ -2969,11 +3080,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