@molecule/api-ai-tools 1.9.16 → 1.9.18

package/dist/server-command.js

@@ -0,0 +1,180 @@
+/**
+ * "This command starts a server, and a server never exits" — ONE reading of a server launch,
+ * shared by the `exec_command` refusal, the over-budget advice, and the platform's own-server note
+ * (`molecule-dev/api/src/ai/own-server-note.ts` imports {@link SERVER_PROGRAM} and
+ * {@link BACKGROUNDED} from here), so every surface that names a server names the same commands.
+ *
+ * X1 xr-molecule-flash-m167 (+19:16 → +24:04) wrote `/tmp/probe.mts` whose body imports the app's
+ * `api/src/server.ts` and calls its `create(0)`, then ran it in the FOREGROUND:
+ * `npx tsx --env-file=.env /tmp/probe.mts 2>&1 | tail -15`. The scaffold's `create()` calls
+ * `server.listen(port)` and returns the server, so the process never exits — and behind `| tail`
+ * it printed nothing until it did. The tool waited its whole 290 s budget and answered with "run
+ * a smaller unit", advice about the wrong axis for a process that was never going to return.
+ *
+ * A server started in the background is a different thing: it is the launch the platform records
+ * and hands a task id for, and the over-budget advice below keeps it off the foreground budget.
+ *
+ * @module
+ */
+import { commandSegments } from './command-position.js';
+import { withoutHeredocs } from './suite-overlap.js';
+/**
+ * A background launch: a single `&` (not `&&`, not a `2>&1`) or an explicit detacher. A
+ * backgrounded launch never holds the tool, so every reading here stops at it.
+ */
+export const BACKGROUNDED = /(?:^|[^&>])&(?!&|>)|\b(?:nohup|setsid)\b/;
+/**
+ * A program that SERVES: the scaffold's entry (`server.ts`/`server.js`), a package manager's
+ * `start`/`dev`/`serve`/`preview` script, a Vite dev or preview server, `next start|dev`, or a
+ * Python WSGI server. Matched against a command segment's own text, and against a script's SOURCE
+ * when the command only names the script file.
+ */
+export const SERVER_PROGRAM = /\bserver\.[cm]?[jt]s\b|\b(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:start|dev|serve|preview)\b|\bvite\s+(?:preview|dev|serve)\b|\bvite(?![.\w-])(?!\s+(?:build|optimize)\b)|\bnext\s+(?:start|dev)\b|\b(?:uvicorn|gunicorn)\b|\bflask\s+run\b|\bpython\d?\s+-m\s+http\.server\b/;
+/** Programs that run a script FILE, so the file's own source decides whether it serves. */
+const SCRIPT_RUNNERS = new Set([
+    'bun',
+    'deno',
+    'node',
+    'nodejs',
+    'tsx',
+    'ts-node',
+]);
+/** Programs that serve by themselves, read against {@link SERVER_PROGRAM}. */
+const SERVER_PROGRAMS = new Set([
+    'bun',
+    'deno',
+    'flask',
+    'gunicorn',
+    'next',
+    'node',
+    'nodejs',
+    'python',
+    'python3',
+    'tsx',
+    'ts-node',
+    'uvicorn',
+    'vite',
+]);
+/** A file a script runner executes. */
+const SCRIPT_FILE = /\.(?:[cm]?[jt]s|tsx)$/;
+/** A test file is a test, even when it imports the server to exercise it. */
+const TEST_FILE = /(?:^|\/)__tests__\/|\.(?:test|spec)\.[cm]?[jt]sx?$/;
+/** Package-manager scripts that keep serving instead of finishing. */
+const SERVE_SCRIPTS = /^(?:start|dev|serve|preview)$/;
+/** Test runners: their command line names a suite, never a server to leave running. */
+const TEST_RUNNERS = /^(?:hurl|jest|mocha|playwright|vitest)$/;
+/** A script's SOURCE that binds a listener even when it does not name a server file. */
+const STARTS_LISTENING = /\b(?:server|app)\.listen\s*\(/;
+/** A word with its shell quotes taken off (`'src/server.ts'` → `src/server.ts`). */
+function bare(word) {
+    const match = /^(['"])(.*)\1$/s.exec(word);
+    return match?.[2] ?? word;
+}
+/**
+ * Whether one parsed statement starts a server: a package manager's serving script, or a program
+ * that IS a server, named in command position (so `cat server.ts` is a read, not a launch).
+ *
+ * @param segment - One statement of the command.
+ * @returns True when the statement starts a server that does not exit.
+ */
+function runsServerProgram(segment) {
+    if (TEST_RUNNERS.test(segment.program))
+        return false;
+    if (/^(?:npm|pnpm|yarn|bun)$/.test(segment.program)) {
+        const words = segment.args.map(bare);
+        const script = words[0] === 'run' ? words[1] : words[0];
+        if (script !== undefined && SERVE_SCRIPTS.test(script))
+            return true;
+    }
+    return SERVER_PROGRAMS.has(segment.program) && SERVER_PROGRAM.test(segment.text);
+}
+/**
+ * The script file a runner statement executes, when it names one.
+ *
+ * @param segment - One statement of the command.
+ * @returns The script's path as written, or null when the statement runs no script file.
+ */
+function scriptPath(segment) {
+    if (!SCRIPT_RUNNERS.has(segment.program))
+        return null;
+    for (const arg of segment.args) {
+        const word = bare(arg);
+        if (word.startsWith('-'))
+            continue;
+        if (SCRIPT_FILE.test(word) && !TEST_FILE.test(word))
+            return word;
+    }
+    return null;
+}
+/**
+ * Whether a command, read from its TEXT alone, starts a server that stays up in the foreground.
+ *
+ * The over-budget reader's shape: at that point the command has already run, and only its text is
+ * left to say whether "run a smaller unit" was ever the right advice.
+ *
+ * @param command - The command as the executor sent it.
+ * @returns True when a foreground statement of the command starts a server.
+ */
+export function startsServerProgram(command) {
+    const text = withoutHeredocs(command);
+    if (BACKGROUNDED.test(text))
+        return false;
+    return commandSegments(text).some((segment) => runsServerProgram(segment));
+}
+/**
+ * A FOREGROUND command that starts a server, including one that only names a script whose SOURCE
+ * imports the app's server and calls its `create()`/`listen()`.
+ *
+ * The script read is best-effort: a path the backend will not answer for is a command this reading
+ * cannot classify, never a refusal. A backgrounded launch, a test runner and a test file are all
+ * left alone.
+ *
+ * @param command - The command as the executor sent it.
+ * @param readScript - Reads a script file the command names (`backend.readFile`).
+ * @returns The serving program, or null when the command starts no server in the foreground.
+ */
+export async function foregroundServerCommand(command, readScript) {
+    const text = withoutHeredocs(command);
+    if (BACKGROUNDED.test(text))
+        return null;
+    for (const segment of commandSegments(text)) {
+        if (runsServerProgram(segment))
+            return { program: segment.program };
+        const script = scriptPath(segment);
+        if (script === null)
+            continue;
+        let source;
+        try {
+            source = await readScript(script);
+        }
+        catch (_error) {
+            // A script the backend cannot read is not classified: the refusal must never be a guess.
+            continue;
+        }
+        if (SERVER_PROGRAM.test(source) || STARTS_LISTENING.test(source)) {
+            return { program: `${segment.program} ${script}` };
+        }
+    }
+    return null;
+}
+/**
+ * The refusal for a foreground command that starts a server: why it would never return, and the
+ * two shapes that do work — a background launch, or a probe of the API already running.
+ *
+ * @param server - The serving program, from {@link foregroundServerCommand}.
+ * @param budgetSeconds - The tool's budget, which a foreground server would consume whole.
+ * @returns The refusal sentence.
+ */
+export function serverCommandRefusal(server, budgetSeconds) {
+    return (`\`${server.program}\` starts a server, and a server never exits: run in the foreground it ` +
+        `would hold this tool for its whole ${budgetSeconds} s budget and return nothing. Start it ` +
+        'with `run_in_background: true` and collect it with `wait_for_task`, or probe the API already ' +
+        'running on :4000 with a command that finishes.');
+}
+/**
+ * The closing advice on an over-budget message for a command recognised as a server start: there
+ * is no tally to split, and the run has to leave the foreground budget to keep serving.
+ */
+export const SERVER_OVER_BUDGET_ADVICE = 'A server is not a bigger unit to split: it never exits, so stopped here it reports nothing. ' +
+    'Start it with `run_in_background: true` (it keeps serving and hands back a task id to ' +
+    '`wait_for_task`), or probe the API already running on :4000.';

package/dist/suite-overlap.d.ts

@@ -139,6 +139,16 @@ export interface SuiteRunInFlight {
 export declare function suiteRunInTheWay<T extends SuiteRunInFlight>(candidate: {
     target: string;
 }, inFlight: readonly T[]): T | null;
+/**
+ * What a caller knows about the run being judged beyond its command text.
+ */
+export interface DiagnosisRunContext {
+    /**
+     * The test titles the person's request excludes by name — the same reading molecule-dev's
+     * `excludedTestTitles` gives the rest of the platform.
+     */
+    approvedExclusions?: readonly string[];
+}
 /**
  * Whether a command walks a PART of a suite instead of all of it: a cap that stops it at a failure
  * count, the failures the last run printed (`--last-failed`, `--only-changed`), a title filter, or
@@ -166,8 +176,17 @@ export declare function suiteRunInTheWay<T extends SuiteRunInFlight>(candidate:
  * 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 declare function isDiagnosisRun(command: string): boolean;
+export declare function isDiagnosisRun(command: string, context?: DiagnosisRunContext): boolean;
 //# sourceMappingURL=suite-overlap.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"suite-overlap.d.ts","sourceRoot":"","sources":["../src/suite-overlap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAQH;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAoB1D;AAKD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAc1F;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,QAAQ,GAAE,SAAS,MAAM,EAAO,EAChC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,EACtB,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,GAClB,MAAM,CA0CR;AAgHD;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,+FAA+F;IAC/F,SAAS,EAAE,OAAO,CAAA;IAClB,oFAAoF;IACpF,MAAM,EAAE,MAAM,CAAA;IACd;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC3B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,gBAAgB,EACzD,SAAS,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,EAC7B,QAAQ,EAAE,SAAS,CAAC,EAAE,GACrB,CAAC,GAAG,IAAI,CAMV;AAqDD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAQvD"}
+{"version":3,"file":"suite-overlap.d.ts","sourceRoot":"","sources":["../src/suite-overlap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAQH;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAoB1D;AAKD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAc1F;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,QAAQ,GAAE,SAAS,MAAM,EAAO,EAChC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,EACtB,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,GAClB,MAAM,CA0CR;AAgHD;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,+FAA+F;IAC/F,SAAS,EAAE,OAAO,CAAA;IAClB,oFAAoF;IACpF,MAAM,EAAE,MAAM,CAAA;IACd;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC3B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,gBAAgB,EACzD,SAAS,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,EAC7B,QAAQ,EAAE,SAAS,CAAC,EAAE,GACrB,CAAC,GAAG,IAAI,CAMV;AAqDD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,kBAAkB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CACvC;AAmCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAYtF"}

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.
@@ -325,6 +325,36 @@ const PLAYWRIGHT_RUN = /^(?:@playwright\/test|playwright)(?:@\S+)?\s+test(?=\s|$
  * 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 +413,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 +435,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;AAwJ9C;;;;;;;;;;;;;;;;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;AAoFnE;;;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,CA8pFxF"}

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
@@ -421,12 +422,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, 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 +2270,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 +2329,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 +2411,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 `;`).
@@ -2428,6 +2498,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 +2525,7 @@ export function buildTools(backend, config) {
                                     : pipelineExitCodeNote(streaming.command, reported, output);
                                 const notes = [
                                     ...(sleepNote ? [sleepNote] : []),
+                                    ...(budgetNote ? [budgetNote] : []),
                                     ...streaming.changes,
                                     ...(exitNote === null ? [] : [exitNote]),
                                 ];
@@ -2464,6 +2536,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 +2547,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 +2650,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 +2659,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 +2677,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(' '),
                         }
                         : {}),
                 };

package/dist/trace-artifacts.d.ts

@@ -159,6 +159,26 @@ export interface TraceContextEvidence {
      */
     requests: TraceRequest[];
 }
+/**
+ * The text a failing assertion waited for that a same-page API response carried and the page never
+ * rendered.
+ *
+ * The assertion's own error names the text (a `has-text(…)` / `getByText(…)` / `toContainText(…)`
+ * argument), and the trace's network log holds the response that contained it. That pair is the
+ * whole diagnosis: the API returned the value and the page dropped it before rendering, so the cut
+ * is in the component that maps the response onto the list — not in the API, the route or the
+ * selector. xr-molecule-flash-m169 (+13:09) spent its fix rounds on the wrong component and on a
+ * markup detail while `GET /api/tags` was returning the missing "trending" and `PopularTags`
+ * sliced the response to its first 20 entries (the m99 top-N class, in the frontend).
+ */
+export interface TraceMissingText {
+    /** The text the assertion waited for (`trending`). */
+    text: string;
+    /** The method of the response that carried it (`GET`). */
+    method: string;
+    /** The path of the response that carried it (`/api/tags`). */
+    path: string;
+}
 /** 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. */
@@ -224,6 +244,17 @@ export interface TraceArtifact {
      * and on traces read before this field existed.
      */
     otherContexts?: TraceContextEvidence[];
+    /**
+     * The text the failing assertion waited for and a same-page API response carried, when the trace
+     * recorded both. The note leads with it: the value reached the browser and the page did not
+     * render it, so the next read is where that response is mapped — never the API or the selector
+     * (xr-molecule-flash-m169).
+     *
+     * Absent when the assertion waited for no text (a text-free selector, a strict-mode violation),
+     * when no page-scoped `fetch`/`xhr` answered 2xx/3xx with the text in its body, and on traces
+     * read before this field existed.
+     */
+    missingText?: TraceMissingText;
 }
 /** How many traces one read reports, newest first. */
 export declare const MAX_TRACE_ARTIFACTS = 12;
@@ -379,6 +410,14 @@ export interface TraceRunReport {
      * contradicts it.
      */
     productionBuildAdvised?: boolean;
+    /**
+     * The endpoints the app's own auth config names for a credential exchange — a login, a
+     * registration, a token endpoint (`loginEndpoint: '/users/login'`, resolved from the app's
+     * source). A 401/403 there answers credentials the app was ASKED to check, never a token the
+     * client failed to attach, so the note says so even when the path is mounted somewhere unusual.
+     * Empty when the caller could not read the app's config.
+     */
+    authEndpoints?: readonly string[];
 }
 /**
  * The note a failed suite run's result carries: what each failing test's page actually sent, and
@@ -457,6 +496,13 @@ export interface TraceRunReport {
  * xr-molecule-flash-m148 (+29:18) hit this exactly: six local walks read
  * `POST …/favorite → 401 {"errors":{"token":["is missing"]}}` as a handler bug.
  *
+ * A credential EXCHANGE (a login/registration/token endpoint, read from the app's auth config, the
+ * path or the body) is never that shape: the request's purpose is to obtain a token, so an absent
+ * header is not a client omission ({@link isCredentialExchange}). xr-molecule-flash-m165's login
+ * 401 was answered as one for 40 minutes; the trace also showed the suite's SET-UP traffic going
+ * to `https://api.realworld.show/api` instead of this app, which is what the note leads with
+ * ({@link foreignOriginApiRequests}).
+ *
  * @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
@@ -497,15 +543,21 @@ export interface DiagnosisTraceRewrite {
     change: string | null;
 }
 /**
- * The command a DIAGNOSIS run needs to leave a readable trace behind, when the suite's config
+ * The command a Playwright run needs to leave a readable trace behind, when the suite's config
  * would record none.
  *
  * The failing tests' requests are only readable if the run wrote them down (see the module doc),
  * and the config is where the decision about that lives — the platform does not edit the suite's
- * config, so it passes the flag instead, and only where it can do no harm: on a run narrowed to a
- * part of the suite or capped ({@link isDiagnosisRun}), never on the whole-suite proof run, and
- * never over a `--trace` the executor wrote itself. A capped walk is exactly the run whose
- * failures someone is about to work on; the proof run is graded as it is.
+ * config, so it passes the flag instead, on every Playwright run that starts tests and does not
+ * already decide its own `--trace`. That includes the whole-suite proof run, which an earlier
+ * version of this function skipped on the reasoning that its flags are graded: the flag changes
+ * what is RETAINED, not what passes. `retain-on-failure` keeps the trace only of a test that
+ * fails — Playwright records it and deletes it when the test passes (playwright's
+ * `_shouldAbandonTrace` unlinks the temporary trace files of a passing test) — so a green proof
+ * run keeps nothing extra. A failing one keeps the network log its failures need.
+ * xr-molecule-flash-m163 (+24:58) is why the proof run is no longer skipped: its one deployed
+ * failure left only an `error-context.md`, the executor spent the next calls hunting a `trace.zip`
+ * that could not exist, and then shipped a guessed fix.
  *
  * @param args - The command, the directory it starts in, and the backend's file read.
  * @returns The command to run and the sentence to report, or the command unchanged.

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