@molecule/api-ai-tools 1.9.16 → 1.9.19

package/dist/command-position.js

@@ -68,6 +68,75 @@ const LAUNCHERS = new Set([
 ]);
 /** The shells whose `-c '<command>'` argument is a command of its own. */
 const SHELLS = new Set(['ash', 'bash', 'dash', 'ksh', 'sh', 'zsh']);
+/**
+ * Node, which is a wrapper only when the script it runs IS a tool's own CLI — never in general:
+ * `node script.mjs` RUNS that script, so the parser's answer for it stays `node`.
+ *
+ * The Playwright runner is spelled this way whenever a project reaches it by file instead of by
+ * the `.bin` shim: xr-molecule-flash-m179 (+17:51) ran
+ * `node /workspace/node_modules/.bin/playwright test` after `npx playwright test` in every
+ * earlier call, and no reader recognised it — the run got no `--trace`, no suite-budget pin and
+ * no proof credit, and the platform spent the rest of the turn re-walking a suite it had already
+ * walked green.
+ */
+const NODE = new Set(['node']);
+/**
+ * The Playwright CLI, as the path operand of a `node` invocation: the package's `.bin` shim, or
+ * the `cli.js` a package installs (`playwright/cli.js`, `@playwright/test/cli.js`).
+ */
+const PLAYWRIGHT_CLI = /(?:^|\/)node_modules\/(?:\.bin\/playwright|(?:playwright|@playwright\/test)\/cli\.(?:js|mjs|cjs))$/;
+/**
+ * The runner a `node` script operand IS, or null when the operand is any other script.
+ *
+ * @param word - The script operand, as written.
+ * @returns The runner's name (`playwright`), or null.
+ */
+function nodeScriptRunner(word) {
+    return PLAYWRIGHT_CLI.test(unquoted(word)) ? 'playwright' : null;
+}
+/**
+ * Node's own value-taking options: the ones that consume the word after them, so the script
+ * operand is not mistaken for a value (`node -r tsx/cli.js …`). Node also accepts `--flag=value`.
+ */
+const NODE_VALUE_FLAGS = new Set([
+    '-e',
+    '--eval',
+    '-p',
+    '--print',
+    '-r',
+    '--require',
+    '--import',
+    '--loader',
+    '--experimental-loader',
+    '--input-type',
+    '--conditions',
+    '--title',
+]);
+/**
+ * The word a `node` invocation runs as its script: the first operand after node's own options,
+ * with `--` ending the options. Null when node runs no file (`node --test`, `node -e '<code>'`).
+ *
+ * A wrong guess here is harmless: the operand is then checked against {@link PLAYWRIGHT_CLI}, so
+ * an ordinary script (`node probe.mjs`) is never read as a runner.
+ *
+ * @param words - The segment's words.
+ * @param from - The index just after `node`.
+ * @returns The script operand's index, or null.
+ */
+function nodeScriptIndex(words, from) {
+    let at = from;
+    for (let guard = 0; guard < MAX_WRAPPERS && at < words.length; guard++) {
+        const word = words[at] ?? '';
+        if (!word.startsWith('-'))
+            return at;
+        const flag = unquoted(word);
+        // `--` ends node's options; the script is the next word.
+        if (flag === '--')
+            return at + 1 < words.length ? at + 1 : null;
+        at += flag.includes('=') || !NODE_VALUE_FLAGS.has(flag) ? 1 : 2;
+    }
+    return null;
+}
 /** Package runners that run the program named after them (`npx playwright test`). */
 const PACKAGE_RUNNERS = new Set(['bunx', 'npx', 'pnpx']);
 /** Package managers whose sub-command runs a package's binary (`bun x`, `pnpm dlx`, `npm exec`). */
@@ -345,6 +414,8 @@ function nestedCommand(words, from) {
  * @returns The index of the word in command position (one past the end when the segment runs
  *   nothing), the command string of a `sh -c '<command>'` this segment turns out to be, and the
  *   seconds its own `timeout` wrapper allows that command (`timeout 280 hurl …` → 280) or null.
+ *   `program` names what runs when that is not the word itself's name — `node <path>/playwright`
+ *   is a `playwright` invocation, not a `node` one ({@link nodeScriptRunner}).
  */
 function commandStart(words) {
     let at = 0;
@@ -364,14 +435,14 @@ function commandStart(words) {
         if (SHELLS.has(name)) {
             const nested = nestedCommand(words, at + 1);
             if (nested !== null)
-                return { at, nested, timeoutSeconds };
+                return { at, nested, timeoutSeconds, program: null };
             at += 1 + flagWords(words, at + 1, name);
             continue;
         }
         if (PACKAGE_RUNNERS.has(name)) {
             const runner = packageRunnerOptions(words, at + 1, name);
             if (runner.nested !== null)
-                return { at, nested: runner.nested, timeoutSeconds };
+                return { at, nested: runner.nested, timeoutSeconds, program: null };
             at += 1 + runner.count;
             continue;
         }
@@ -380,19 +451,35 @@ function commandStart(words) {
             const subcommand = unquoted(words[at + 1] ?? '');
             const runner = packageRunnerOptions(words, at + 2, `${name} ${subcommand}`);
             if (runner.nested !== null)
-                return { at, nested: runner.nested, timeoutSeconds };
+                return { at, nested: runner.nested, timeoutSeconds, program: null };
             at += 2 + runner.count;
             continue;
         }
+        if (name === 'yarn' && unquoted(words[at + 1] ?? '') === 'playwright') {
+            // Yarn classic runs the binary named after it (`yarn playwright test`); Yarn 2+ spells the
+            // same thing `yarn exec`/`yarn dlx` ({@link PACKAGE_RUNNER_SUBCOMMANDS}). Only the runner's
+            // own name is read through it — `yarn test` is the project's own script, not a binary.
+            at += 1;
+            continue;
+        }
+        if (NODE.has(name)) {
+            // `node <path>/playwright test` is a Playwright invocation; `node probe.mjs` runs the
+            // project's own script and stays a `node` statement (`program: null`).
+            const script = nodeScriptIndex(words, at + 1);
+            const runner = script === null ? null : nodeScriptRunner(words[script] ?? '');
+            return runner === null
+                ? { at, nested: null, timeoutSeconds, program: null }
+                : { at: script ?? at, nested: null, timeoutSeconds, program: runner };
+        }
         if (!LAUNCHERS.has(name))
-            return { at, nested: null, timeoutSeconds };
+            return { at, nested: null, timeoutSeconds, program: null };
         at += 1 + flagWords(words, at + 1, name);
         if (name === 'timeout' && DURATION.test(words[at] ?? '')) {
             timeoutSeconds = durationSeconds(words[at] ?? '');
             at += 1;
         }
     }
-    return { at, nested: null, timeoutSeconds };
+    return { at, nested: null, timeoutSeconds, program: null };
 }
 /**
  * A command with every heredoc BODY blanked to spaces, so its length and every offset in it are
@@ -993,7 +1080,9 @@ function locatedSegmentsOf(command, depth) {
             assignmentOffset: part.start + leading.end,
             programOffset: words[start.at] === undefined ? null : part.start + (wordOffset(part.text, start.at) ?? 0),
         };
-        const program = words[start.at] === undefined ? '' : programName(words[start.at] ?? '');
+        // The runner the word RUNS names, when that is not the word's own name (`node <path>/playwright`
+        // is a `playwright` invocation, xr-molecule-flash-m179).
+        const program = words[start.at] === undefined ? '' : (start.program ?? programName(words[start.at] ?? ''));
         const args = words.slice(start.at + 1);
         const redirectTarget = redirectTargetOf(part.text, part.depths, program, args);
         if (start.nested !== null) {

package/dist/index.d.ts

@@ -141,6 +141,7 @@ export * from './no-test-run.js';
 export * from './output-filter.js';
 export * from './pipeline-exit-note.js';
 export * from './schemas.js';
+export * from './server-command.js';
 export * from './sleep-peek.js';
 export * from './suite-overlap.js';
 export * from './system-prompt.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkIG;AAEH,cAAc,qBAAqB,CAAA;AACnC,cAAc,uBAAuB,CAAA;AACrC,cAAc,oBAAoB,CAAA;AAClC,cAAc,uBAAuB,CAAA;AACrC,cAAc,cAAc,CAAA;AAC5B,cAAc,mBAAmB,CAAA;AACjC,cAAc,uBAAuB,CAAA;AACrC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,kBAAkB,CAAA;AAChC,cAAc,oBAAoB,CAAA;AAClC,cAAc,yBAAyB,CAAA;AACvC,cAAc,cAAc,CAAA;AAC5B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,cAAc,YAAY,CAAA;AAC1B,cAAc,sBAAsB,CAAA;AACpC,cAAc,YAAY,CAAA;AAC1B,cAAc,gBAAgB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkIG;AAEH,cAAc,qBAAqB,CAAA;AACnC,cAAc,uBAAuB,CAAA;AACrC,cAAc,oBAAoB,CAAA;AAClC,cAAc,uBAAuB,CAAA;AACrC,cAAc,cAAc,CAAA;AAC5B,cAAc,mBAAmB,CAAA;AACjC,cAAc,uBAAuB,CAAA;AACrC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,kBAAkB,CAAA;AAChC,cAAc,oBAAoB,CAAA;AAClC,cAAc,yBAAyB,CAAA;AACvC,cAAc,cAAc,CAAA;AAC5B,cAAc,qBAAqB,CAAA;AACnC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,cAAc,YAAY,CAAA;AAC1B,cAAc,sBAAsB,CAAA;AACpC,cAAc,YAAY,CAAA;AAC1B,cAAc,gBAAgB,CAAA"}

package/dist/index.js

@@ -141,6 +141,7 @@ export * from './no-test-run.js';
 export * from './output-filter.js';
 export * from './pipeline-exit-note.js';
 export * from './schemas.js';
+export * from './server-command.js';
 export * from './sleep-peek.js';
 export * from './suite-overlap.js';
 export * from './system-prompt.js';

package/dist/output-filter.d.ts

@@ -19,9 +19,13 @@
 import { type CommandSegment } from './command-position.js';
 /** A cutting stage that follows the runner, and the command with the whole pipe removed. */
 export interface RunnerOutputFilter {
-    /** The stage exactly as the runner's command wrote it — `tail -6`. */
+    /**
+     * The stage exactly as the runner's command wrote it — `tail -6`. When several cutting filters
+     * follow the runner, this is the whole trailing chain as written, pipes included:
+     * `grep -E "Failure|actual" | head -40`.
+     */
     stage: string;
-    /** The pipe as a sentence names it — `| tail -6`. */
+    /** The pipe as a sentence names it — `| tail -6`, or the whole chain `| grep … | head -40`. */
     pipe: string;
     /**
      * The command with the pipe and the stage removed — `hurl --variable uid=… --test /tmp/t.hurl
@@ -33,16 +37,23 @@ export interface RunnerOutputFilter {
 /**
  * The output filter that follows the runner in `command`, or null when there is none.
  *
- * Only a stage of the runner's OWN pipeline counts (its separator is `|`), and only when it is the
- * LAST stage of that pipeline: a `| grep … | wc -l` chain would leave a dangling pipe if the
- * middle stage were cut out, so a chain is not answered here at all. A filter before the runner
- * (`cat run.log | tail -20 && hurl …`) reads something else's output and is not this.
+ * Only stages of the runner's OWN pipeline count (their separator is `|`), and they are read as
+ * one trailing CHAIN: `| grep … | head -40` is two cuts, and removing only the first would leave
+ * the run piped into the second. Every stage after the runner must be a cutting filter and the
+ * chain must run to the pipeline's end — a pipeline that continues into `wc -l` is not answered
+ * here, because removing the cutting stages alone would still leave the failure hidden. A filter
+ * before the runner (`cat run.log | tail -20 && hurl …`) reads something else's output and is not
+ * this.
  *
  * @param command - The command as the executor sent it.
  * @param runs - Whether a segment is the runner this run is about (the caller knows its own kind:
  *   {@link CommandSegment.program} is the program, once wrapper words like `timeout 280` and
  *   `npx` are taken away).
+ * @param occurrence - Which runner invocation the output belongs to, 1-based. A command can run
+ *   the same runner more than once (xr-molecule-flash-m170: the suite bare, then with `HOST=…`),
+ *   and each invocation carries its OWN pipe; a reader judging the second walk must name the
+ *   second walk's cut, never the first's.
  * @returns The filter and the unfiltered command, or null.
  */
-export declare function outputFilterAfterRunner(command: string, runs: (segment: CommandSegment) => boolean): RunnerOutputFilter | null;
+export declare function outputFilterAfterRunner(command: string, runs: (segment: CommandSegment) => boolean, occurrence?: number): RunnerOutputFilter | null;
 //# sourceMappingURL=output-filter.d.ts.map

package/dist/output-filter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"output-filter.d.ts","sourceRoot":"","sources":["../src/output-filter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,KAAK,cAAc,EAA0B,MAAM,uBAAuB,CAAA;AASnF,4FAA4F;AAC5F,MAAM,WAAW,kBAAkB;IACjC,sEAAsE;IACtE,KAAK,EAAE,MAAM,CAAA;IACb,qDAAqD;IACrD,IAAI,EAAE,MAAM,CAAA;IACZ;;;;OAIG;IACH,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,OAAO,GACzC,kBAAkB,GAAG,IAAI,CAkB3B"}
+{"version":3,"file":"output-filter.d.ts","sourceRoot":"","sources":["../src/output-filter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EACL,KAAK,cAAc,EAGpB,MAAM,uBAAuB,CAAA;AAS9B,4FAA4F;AAC5F,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAA;IACb,+FAA+F;IAC/F,IAAI,EAAE,MAAM,CAAA;IACZ;;;;OAIG;IACH,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,OAAO,EAC1C,UAAU,SAAI,GACb,kBAAkB,GAAG,IAAI,CAmC3B"}

package/dist/output-filter.js

@@ -16,7 +16,7 @@
  *
  * @module
  */
-import { locatedCommandSegments } from './command-position.js';
+import { locatedCommandSegments, } from './command-position.js';
 /**
  * The programs whose job is to re-shape what an earlier stage printed and that can DROP lines —
  * the reader's own cut, never part of the run. `tee`, `sort` and `wc` are output plumbing too, but
@@ -26,39 +26,67 @@ const CUTTING_FILTERS = new Set(['awk', 'cut', 'grep', 'head', 'sed', 'tail']);
 /**
  * The output filter that follows the runner in `command`, or null when there is none.
  *
- * Only a stage of the runner's OWN pipeline counts (its separator is `|`), and only when it is the
- * LAST stage of that pipeline: a `| grep … | wc -l` chain would leave a dangling pipe if the
- * middle stage were cut out, so a chain is not answered here at all. A filter before the runner
- * (`cat run.log | tail -20 && hurl …`) reads something else's output and is not this.
+ * Only stages of the runner's OWN pipeline count (their separator is `|`), and they are read as
+ * one trailing CHAIN: `| grep … | head -40` is two cuts, and removing only the first would leave
+ * the run piped into the second. Every stage after the runner must be a cutting filter and the
+ * chain must run to the pipeline's end — a pipeline that continues into `wc -l` is not answered
+ * here, because removing the cutting stages alone would still leave the failure hidden. A filter
+ * before the runner (`cat run.log | tail -20 && hurl …`) reads something else's output and is not
+ * this.
  *
  * @param command - The command as the executor sent it.
  * @param runs - Whether a segment is the runner this run is about (the caller knows its own kind:
  *   {@link CommandSegment.program} is the program, once wrapper words like `timeout 280` and
  *   `npx` are taken away).
+ * @param occurrence - Which runner invocation the output belongs to, 1-based. A command can run
+ *   the same runner more than once (xr-molecule-flash-m170: the suite bare, then with `HOST=…`),
+ *   and each invocation carries its OWN pipe; a reader judging the second walk must name the
+ *   second walk's cut, never the first's.
  * @returns The filter and the unfiltered command, or null.
  */
-export function outputFilterAfterRunner(command, runs) {
+export function outputFilterAfterRunner(command, runs, occurrence = 1) {
     if (typeof command !== 'string' || command.trim() === '')
         return null;
     const entries = locatedCommandSegments(command);
-    const runnerAt = entries.findIndex((entry) => entry.segment !== null && runs(entry.segment));
-    if (runnerAt < 0 || runnerAt + 1 >= entries.length)
+    const runners = [];
+    entries.forEach((entry, index) => {
+        if (entry.segment !== null && runs(entry.segment))
+            runners.push(index);
+    });
+    const runnerAt = runners[occurrence - 1];
+    if (runnerAt === undefined)
         return null;
     const runner = entries[runnerAt];
-    const filter = entries[runnerAt + 1];
-    // The stage must be fed by the runner's own pipe, and nothing may be piped out of the filter:
-    // those are the two positions where cutting it out leaves a command that still runs the run.
-    if (!runner || !filter || filter.separator.trim() !== '|')
+    if (!runner || runner.end === null)
         return null;
-    if (!filter.segment || !CUTTING_FILTERS.has(filter.segment.program))
+    // The chain is every stage fed by the runner's own pipe, until the pipeline ends. Each one has
+    // to be a cutting filter: a stage that does not drop lines ends the chain, and the chain then
+    // stops before the pipeline's end — which is not answerable (`| grep … | wc -l` would still
+    // hide the assertion in a count).
+    const chain = [];
+    for (let index = runnerAt + 1; index < entries.length; index++) {
+        const entry = entries[index];
+        if (!entry || entry.separator.trim() !== '|')
+            break;
+        if (!entry.segment || !CUTTING_FILTERS.has(entry.segment.program))
+            break;
+        chain.push(entry);
+        if (entry.terminator.trim() !== '|')
+            break;
+    }
+    const first = chain[0];
+    const last = chain[chain.length - 1];
+    if (!first || !last)
         return null;
-    if (filter.terminator.trim() === '|')
+    // A pipeline that continues past the chain means a non-cutting stage sits after it.
+    if (last.terminator.trim() === '|')
         return null;
-    if (runner.end === null || filter.start === null || filter.end === null)
+    if (first.start === null || last.end === null)
         return null;
+    const stage = command.slice(first.start, last.end);
     return {
-        stage: command.slice(filter.start, filter.end),
-        pipe: `| ${command.slice(filter.start, filter.end)}`,
-        command: `${command.slice(0, runner.end)}${command.slice(filter.end)}`,
+        stage,
+        pipe: `| ${stage}`,
+        command: `${command.slice(0, runner.end)}${command.slice(last.end)}`,
     };
 }

package/dist/server-command.d.ts

@@ -0,0 +1,73 @@
+/**
+ * "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
+ */
+/**
+ * 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 declare const BACKGROUNDED: RegExp;
+/**
+ * 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 declare const SERVER_PROGRAM: RegExp;
+/**
+ * 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 declare function startsServerProgram(command: string): boolean;
+/** A foreground command that starts a server, as the refusal names it. */
+export interface ForegroundServer {
+    /** The program (and script, when there is one) that serves. */
+    readonly program: string;
+}
+/**
+ * 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 declare function foregroundServerCommand(command: string, readScript: (path: string) => Promise<string>): Promise<ForegroundServer | 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 declare function serverCommandRefusal(server: ForegroundServer, budgetSeconds: number): string;
+/**
+ * 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 declare const SERVER_OVER_BUDGET_ADVICE: string;
+//# sourceMappingURL=server-command.d.ts.map

package/dist/server-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-command.d.ts","sourceRoot":"","sources":["../src/server-command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAMH;;;GAGG;AACH,eAAO,MAAM,YAAY,QAA6C,CAAA;AAEtE;;;;;GAKG;AACH,eAAO,MAAM,cAAc,QACmP,CAAA;AAmF9Q;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAI5D;AAED,0EAA0E;AAC1E,MAAM,WAAW,gBAAgB;IAC/B,+DAA+D;IAC/D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAC5C,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAmBlC;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CAO5F;AAED;;;GAGG;AACH,eAAO,MAAM,yBAAyB,QAG0B,CAAA"}

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

@@ -83,6 +83,10 @@ export declare function withSuiteConfig(command: string, config: string | null |
  * 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
@@ -139,6 +143,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 +180,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,CAS1F;AAqCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;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,CA8CR;AAkHD;;;;;;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;AA2FD;;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"}