@molecule/api-ai-tools 1.14.4 → 1.14.5

package/dist/browser-probe.d.ts

@@ -2,7 +2,7 @@
  * A standalone Playwright probe that launches a browser and never closes it — the
  * resource-lifecycle hang `exec_command` did not yet classify.
  *
- * X1 xr-molecule-flash-m257 (+10:44 → +15:34) ran
+ * A real probe ran
  * `cd /workspace/my-app/app && node /workspace/.mol-scratch/fav-probe.mjs 2>&1 | tail -5`. The
  * 30-line script binds `const browser = await chromium.launch()`, walks a real page, reaches its
  * last `console.log`, and ends without `browser.close()`, `disconnect()`, a disposal scope or
@@ -28,8 +28,8 @@
  *   `import`), or a persistent-process intent (`launchServer`, `connect`, a server `.listen`, a
  *   timer or signal handler).
  *
- * Anything ambiguous is left alone. A wrong refusal costs a valid probe — the review that found
- * the m257 leak also proved five harmless scripts a raw substring match would refuse (a local
+ * Anything ambiguous is left alone. A wrong refusal costs a valid probe — a raw substring match
+ * would also refuse five harmless scripts (a local
  * engine stub, the launch text in a string, in a comment, in a template literal, and inside a
  * function that is never called) — and a missed leak costs the same budget the tool already had.
  * This is a lifecycle diagnostic, never an egress or security gate.
@@ -38,7 +38,7 @@
  */
 /** A browser launch bound to a variable, proven to have no cleanup path. */
 export interface BrowserProbeLeak {
-    /** The variable the launched browser is bound to (`browser` in the m257 probe). */
+    /** The variable the launched browser is bound to (`browser` in the probe above). */
     readonly variable: string;
 }
 /** A foreground command that directly executes such a script. */

package/dist/browser-probe.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"browser-probe.d.ts","sourceRoot":"","sources":["../src/browser-probe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,4EAA4E;AAC5E,MAAM,WAAW,gBAAgB;IAC/B,mFAAmF;IACnF,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAC1B;AAED,iEAAiE;AACjE,MAAM,WAAW,sBAAuB,SAAQ,gBAAgB;IAC9D,+CAA+C;IAC/C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AA6aD;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAyB7E;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,sBAAsB,EAC7B,aAAa,EAAE,MAAM,EACrB,KAAK,UAAQ,GACZ,MAAM,CAaR;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,sBAAsB,GAAG,MAAM,CASlF"}
+{"version":3,"file":"browser-probe.d.ts","sourceRoot":"","sources":["../src/browser-probe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,4EAA4E;AAC5E,MAAM,WAAW,gBAAgB;IAC/B,oFAAoF;IACpF,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAC1B;AAED,iEAAiE;AACjE,MAAM,WAAW,sBAAuB,SAAQ,gBAAgB;IAC9D,+CAA+C;IAC/C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AA6aD;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAyB7E;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,sBAAsB,EAC7B,aAAa,EAAE,MAAM,EACrB,KAAK,UAAQ,GACZ,MAAM,CAaR;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,sBAAsB,GAAG,MAAM,CASlF"}

package/dist/browser-probe.js

@@ -2,7 +2,7 @@
  * A standalone Playwright probe that launches a browser and never closes it — the
  * resource-lifecycle hang `exec_command` did not yet classify.
  *
- * X1 xr-molecule-flash-m257 (+10:44 → +15:34) ran
+ * A real probe ran
  * `cd /workspace/my-app/app && node /workspace/.mol-scratch/fav-probe.mjs 2>&1 | tail -5`. The
  * 30-line script binds `const browser = await chromium.launch()`, walks a real page, reaches its
  * last `console.log`, and ends without `browser.close()`, `disconnect()`, a disposal scope or
@@ -28,8 +28,8 @@
  *   `import`), or a persistent-process intent (`launchServer`, `connect`, a server `.listen`, a
  *   timer or signal handler).
  *
- * Anything ambiguous is left alone. A wrong refusal costs a valid probe — the review that found
- * the m257 leak also proved five harmless scripts a raw substring match would refuse (a local
+ * Anything ambiguous is left alone. A wrong refusal costs a valid probe — a raw substring match
+ * would also refuse five harmless scripts (a local
  * engine stub, the launch text in a string, in a comment, in a template literal, and inside a
  * function that is never called) — and a missed leak costs the same budget the tool already had.
  * This is a lifecycle diagnostic, never an egress or security gate.
@@ -85,7 +85,7 @@ const REGEX_AFTER = new Set([
  * A source with every comment and every string, template and regex literal blanked to spaces,
  * preserving offsets and newlines so a match's position still indexes the original source.
  *
- * A launch mentioned in prose is not a launch: the m257 review proved scripts that only PRINT
+ * A launch mentioned in prose is not a launch: a review proved scripts that only PRINT
  * `const browser = await chromium.launch()` — in a string, a comment and a template literal — and
  * a raw substring match refused all of them. Template `${…}` substitutions stay code (a `close()`
  * written there is a real cleanup path), nested braces are tracked so the substitution's end is
@@ -308,7 +308,7 @@ function topLevelThrow(code) {
  * This is the conservative guard for the one shape the lexer cannot read: a regex literal whose
  * opening `/` follows a `)` (`if (x) /…/.test(s)`) reads as division, so the launch text inside it
  * survives blanking. A mid-line top-level launch is a deliberate false negative; every positive
- * shape (the m257 probe, `import * as pw` + `pw.chromium.launch`, a destructured require) declares
+ * shape (the probe above, `import * as pw` + `pw.chromium.launch`, a destructured require) declares
  * at line start.
  *
  * @param code - The {@link codeOnly} text.

package/dist/command-position.d.ts

@@ -3,12 +3,11 @@
  * arguments to something else.
  *
  * Every classifier that read a command as "this runs the suite" matched the runner's NAME
- * anywhere in the text, so a runner named in an argument was read as an invocation: X1
- * xr-molecule-flash-m81 (+20:03) sent
+ * anywhere in the text, so a runner named in an argument was read as an invocation:
  * `cd /workspace/fixtures/realworld/specs/api && ls && head -30 run-api-tests-hurl.sh` — two
  * reads of a file that was already there — and the suite-overlap hold answered "a Playwright
- * suite is already running against this app and database … wait for it", costing a minute of
- * forced idling on a command that writes nothing and runs nothing. `cat`, `grep`, `sed -n`,
+ * suite is already running against this app and database … wait for it", idling a command that
+ * writes nothing and runs nothing. `cat`, `grep`, `sed -n`,
  * `wc`, `ls` and `git show` of a runner script are the same shape.
  *
  * So this parser answers it in one place, for every caller: split the command at its pipeline
@@ -28,7 +27,7 @@
  * `end`, `programOffset` and `assignmentOffset` are the offsets a caller splices at. They are
  * token positions from this walk, never a search for re-joined text — the words are joined back
  * with single spaces for matching, so `command.indexOf(segment.text)` fails on irregular spacing,
- * on grouping braces, and on anything a heredoc body shifts (xr-molecule-flash-m105 +08:12).
+ * on grouping braces, and on anything a heredoc body shifts.
  *
  * @module
  */
@@ -110,8 +109,8 @@ export declare function commandSubstitutions(command: string): string[];
  * not a text match. The command-position parser already knows what runs and what is only quoted
  * data ({@link commandSegments}), so a pattern never reads a `|` inside a quoted grep alternation
  * as a pipeline: `grep -E "USER CALLS|ENV|BUTTON" app.log` prints log lines, and the `ENV` in
- * its pattern started nothing (X0 xr-molecule-flash-m331 blocked exactly that call as an
- * environment dump). What the shell DOES run stays visible through the same walk: a bare
+ * its pattern starts nothing — a text match would block exactly that call as an environment
+ * dump. What the shell DOES run stays visible through the same walk: a bare
  * launcher (`ls | env`), a shell string (`bash -c 'env'`), a substitution
  * (`echo "$(printenv)"`) and a nested one (`sh -c 'x; env'`) are all commands here.
  *
@@ -131,7 +130,7 @@ export declare function executedCommands(command: string): ExecutedCommand[];
  * executor's own command in more than one place, and a value written for the runner belongs in
  * the runner's own statement: `APP_BASE=https://… cd app && npx playwright test` sets the variable
  * for `cd` alone, so the Playwright config falls back to the local app while the command line
- * still names the deployed host (xr-molecule-flash-m103 +28:08).
+ * still names the deployed host.
  */
 export interface LocatedCommandSegment {
     /**
@@ -196,7 +195,7 @@ export interface LocatedCommandSegment {
      * The file this statement sends its own output to (`> out.log`, `>> log`, `&> run.log`,
      * `| tee file`), or null. Only a redirect written at the command's own level counts: one
      * inside a `( … )` / `{ … }` group writes through that group, and one that feeds a heredoc's
-     * file (`cat > cfg.ts <<'EOF'`) is writing a config (X1 flash-m44, flash-m136).
+     * file (`cat > cfg.ts <<'EOF'`) is writing a config.
      */
     redirectTarget: string | null;
 }
@@ -216,8 +215,8 @@ export declare function locatedCommandSegments(command: string): LocatedCommandS
  * redirection (`… 2>&1`), and a statement can sit inside a group whose closer belongs to the
  * shell, not to the words (`( … )`, `{ …; }`). Appending after that closer is a different shell
  * word that the group has already closed — `… --config=x 2>&1) --reporter=list` is
- * `sh: Syntax error: word unexpected`, which killed a backgrounded walk at once and pushed the
- * model off the platform's runner shape (xr-molecule-flash-m129 +34:29). Write the option where
+ * `sh: Syntax error: word unexpected`, which kills a backgrounded walk at once and pushes the
+ * model off the platform's runner shape. Write the option where
  * the program's own arguments end and the rest of the statement still parses:
  * `… --config=x --reporter=list 2>&1)`.
  *
@@ -239,8 +238,8 @@ export declare function statementArgumentEnd(command: string, start: number | nu
  * parses its last stage as `tail` with the argument `-25)`. {@link LocatedCommandSegment.end}
  * therefore says one past the `)`, and a caller cutting that stage out of the command takes the
  * group's closer with it — the rewritten command is then `( … 2>&1`, which no shell parses
- * (xr-molecule-flash-m418 +23:31: a heredoc config plus a parenthesized Playwright pipeline came
- * back as `end of file unexpected` from the background runner).
+ * (a heredoc config plus a parenthesized Playwright pipeline came back as `end of file
+ * unexpected` from the background runner).
  *
  * The parse's own group depths answer which closers belong to an enclosing group: the depth a
  * statement was written at is its first character's depth (an opener is recorded at the depth
@@ -285,9 +284,9 @@ export declare function commandTimeoutSeconds(command: string): number | null;
  * The platform moves a run to the background precisely because its own bound cannot fit this
  * tool's ceiling, and a background task has no ceiling — its wait is bounded by `wait_for_task`
  * and the turn's deadline. The `timeout N` an executor wrote to fit the ceiling therefore keeps
- * killing the run at N in the background, where nothing needed it: X1 xr-molecule-flash-m143
- * (+24:45) wrote `timeout 280` for a 31-test walk, the tool backgrounded it, and the prefix stopped
- * the walk with no tally — then the cut sentence told the executor to "run it in the background",
+ * killing the run at N in the background, where nothing needed it: an executor wrote
+ * `timeout 280` for a 31-test walk, the tool backgrounded it, and the prefix stopped the walk
+ * with no tally — then the cut sentence told the executor to "run it in the background",
  * which is where it already was.
  *
  * The wrapper is found by the same parse every other command reader uses ({@link commandStart}):

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

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

package/dist/command-position.js

@@ -3,12 +3,11 @@
  * arguments to something else.
  *
  * Every classifier that read a command as "this runs the suite" matched the runner's NAME
- * anywhere in the text, so a runner named in an argument was read as an invocation: X1
- * xr-molecule-flash-m81 (+20:03) sent
+ * anywhere in the text, so a runner named in an argument was read as an invocation:
  * `cd /workspace/fixtures/realworld/specs/api && ls && head -30 run-api-tests-hurl.sh` — two
  * reads of a file that was already there — and the suite-overlap hold answered "a Playwright
- * suite is already running against this app and database … wait for it", costing a minute of
- * forced idling on a command that writes nothing and runs nothing. `cat`, `grep`, `sed -n`,
+ * suite is already running against this app and database … wait for it", idling a command that
+ * writes nothing and runs nothing. `cat`, `grep`, `sed -n`,
  * `wc`, `ls` and `git show` of a runner script are the same shape.
  *
  * So this parser answers it in one place, for every caller: split the command at its pipeline
@@ -28,7 +27,7 @@
  * `end`, `programOffset` and `assignmentOffset` are the offsets a caller splices at. They are
  * token positions from this walk, never a search for re-joined text — the words are joined back
  * with single spaces for matching, so `command.indexOf(segment.text)` fails on irregular spacing,
- * on grouping braces, and on anything a heredoc body shifts (xr-molecule-flash-m105 +08:12).
+ * on grouping braces, and on anything a heredoc body shifts.
  *
  * @module
  */
@@ -310,11 +309,11 @@ const SHELLS = new Set(['ash', 'bash', 'dash', 'ksh', 'sh', 'zsh']);
  * `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
+ * the `.bin` shim: a run that sent
  * `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.
+ * earlier call got no `--trace`, no suite-budget pin and no proof credit, because no reader
+ * recognised it — and the platform then spent the rest of the turn re-walking a suite it had
+ * already walked green.
  */
 const NODE = new Set(['node']);
 /**
@@ -653,8 +652,7 @@ function nestedCommand(words, from) {
  * program: the leading words, and the ones behind an `env` wrapper (`env -i PATH=$PATH
  * BASE_URL=https://… npx playwright test`). A shell passes those to the program in exactly the
  * same way — `env` is the POSIX form of the leading-word form — so a reader that only saw the
- * leading ones called a deployed walk local (X0 xr-molecule-flash-m204 +38:15: two green deployed
- * walks were refused, 5.2 min).
+ * leading ones called a deployed walk local (two green deployed walks were refused, 5.2 min).
  *
  * @param words - The segment's words, quotes kept.
  * @returns The index of the word in command position (one past the end when the segment runs
@@ -798,8 +796,8 @@ function commentStartsAt(command, at) {
  * <<'EOF' … import { defineConfig, devices } from '@playwright/test' … EOF` writes a file and runs
  * `cat`. Read as shell, though, every line of the body is a statement — and the words joined back
  * for matching are not the words written, so a caller that placed a statement by searching for
- * them found nothing, in a command whose real statements sat all along. On X1
- * xr-molecule-flash-m105 (+08:12) the body's `import { defineConfig, devices } …` alone made
+ * them found nothing, in a command whose real statements sat all along. A heredoc body's
+ * `import { defineConfig, devices } …` alone made
  * `suiteRunPipedAfterRunner` answer "piped" for a run with no pipe left, and the run's exit code
  * was dropped for the rest of the session.
  *
@@ -925,7 +923,7 @@ function blankHeredocBodies(command) {
  * A flat walk read that first inner `"` as the CLOSE of the outer one, so the `)` that ends the
  * outer substitution landed inside a quote that was never opened, the depth was left standing at
  * 1, and every newline in the rest of the script was swallowed: the script's own `hurl --test`
- * never reached command position, and X1 xr-molecule-flash-m89 saw seven passing Hurl runs the
+ * never reached command position, and seven passing Hurl runs were invisible to the
  * platform could not see (the runner is read from the tree's own script TEXT —
  * `molecule-dev/api/src/ai/supplied-tree-guard.ts` — so a script that does not classify records
  * no runner, and every run of it reads as nothing).
@@ -1391,8 +1389,8 @@ export function commandSubstitutions(command) {
  * not a text match. The command-position parser already knows what runs and what is only quoted
  * data ({@link commandSegments}), so a pattern never reads a `|` inside a quoted grep alternation
  * as a pipeline: `grep -E "USER CALLS|ENV|BUTTON" app.log` prints log lines, and the `ENV` in
- * its pattern started nothing (X0 xr-molecule-flash-m331 blocked exactly that call as an
- * environment dump). What the shell DOES run stays visible through the same walk: a bare
+ * its pattern starts nothing — a text match would block exactly that call as an environment
+ * dump. What the shell DOES run stays visible through the same walk: a bare
  * launcher (`ls | env`), a shell string (`bash -c 'env'`), a substitution
  * (`echo "$(printenv)"`) and a nested one (`sh -c 'x; env'`) are all commands here.
  *
@@ -1491,8 +1489,8 @@ function substitutionDepth(text) {
  * redirection (`… 2>&1`), and a statement can sit inside a group whose closer belongs to the
  * shell, not to the words (`( … )`, `{ …; }`). Appending after that closer is a different shell
  * word that the group has already closed — `… --config=x 2>&1) --reporter=list` is
- * `sh: Syntax error: word unexpected`, which killed a backgrounded walk at once and pushed the
- * model off the platform's runner shape (xr-molecule-flash-m129 +34:29). Write the option where
+ * `sh: Syntax error: word unexpected`, which kills a backgrounded walk at once and pushes the
+ * model off the platform's runner shape. Write the option where
  * the program's own arguments end and the rest of the statement still parses:
  * `… --config=x --reporter=list 2>&1)`.
  *
@@ -1577,8 +1575,8 @@ export function statementArgumentEnd(command, start, end) {
  * parses its last stage as `tail` with the argument `-25)`. {@link LocatedCommandSegment.end}
  * therefore says one past the `)`, and a caller cutting that stage out of the command takes the
  * group's closer with it — the rewritten command is then `( … 2>&1`, which no shell parses
- * (xr-molecule-flash-m418 +23:31: a heredoc config plus a parenthesized Playwright pipeline came
- * back as `end of file unexpected` from the background runner).
+ * (a heredoc config plus a parenthesized Playwright pipeline came back as `end of file
+ * unexpected` from the background runner).
  *
  * The parse's own group depths answer which closers belong to an enclosing group: the depth a
  * statement was written at is its first character's depth (an opener is recorded at the depth
@@ -1781,9 +1779,9 @@ export function commandTimeoutSeconds(command) {
  * The platform moves a run to the background precisely because its own bound cannot fit this
  * tool's ceiling, and a background task has no ceiling — its wait is bounded by `wait_for_task`
  * and the turn's deadline. The `timeout N` an executor wrote to fit the ceiling therefore keeps
- * killing the run at N in the background, where nothing needed it: X1 xr-molecule-flash-m143
- * (+24:45) wrote `timeout 280` for a 31-test walk, the tool backgrounded it, and the prefix stopped
- * the walk with no tally — then the cut sentence told the executor to "run it in the background",
+ * killing the run at N in the background, where nothing needed it: an executor wrote
+ * `timeout 280` for a 31-test walk, the tool backgrounded it, and the prefix stopped the walk
+ * with no tally — then the cut sentence told the executor to "run it in the background",
  * which is where it already was.
  *
  * The wrapper is found by the same parse every other command reader uses ({@link commandStart}):

package/dist/cut-run.d.ts

@@ -2,13 +2,13 @@
  * A command that a budget stopped before it finished, and the state its result carries so no
  * reader can mistake it for a run that ended.
  *
- * X1 xr-molecule-flash-m93 (2026-10-16, +12:37) sent the supplied RealWorld suite as
- * `timeout 280 hurl --test --continue-on-error --jobs 1 … hurl/*.hurl 2>&1 | tail -60` and got
+ * A command such as
+ * `timeout 280 hurl --test --continue-on-error --jobs 1 … hurl/*.hurl 2>&1 | tail -60` came
  * back `exitCode: 0`, four finished files' lines and nothing else. Two lies in one result: the
  * `timeout 280` killed the run at 280 s, and the `| tail` made the pipeline's status the status —
  * so the executor read a suite that stopped at its fifth file as a suite that ran and nearly
- * passed, fixed one message, and immediately sent the same 280-second command again (the run's
- * third, ~14 minutes of a 60-minute cap across three of them).
+ * passed, fixed one message, and immediately sent the same 280-second command again (~14 minutes
+ * of a 60-minute cap across three of them).
  *
  * So the tool never reports a stopped run as `exitCode: 0`. Such a result carries
  * `status: 'cut_at_budget'` and an exit code that is `null` whenever the number the pipeline
@@ -19,7 +19,7 @@
  *
  * 1. **Its own bound** — a `timeout <N>` the command carries ({@link commandTimeoutSeconds}). The
  *    run used it, so the run was killed at it; with no closing tally in the output, the run did
- *    not finish. This is m93's shape.
+ *    not finish. This is the first shape.
  * 2. **This tool's budget** — the backend runs the command under `timeout` (see
  *    `backends/sandbox.ts`), which reports 124 whatever the pipeline did, and returns everything
  *    printed until then. The budget is the tool's own, so its number belongs to the tool.
@@ -104,7 +104,7 @@ export declare function suiteTally(text: string): boolean;
  * The code in a background result is the code of the command's LAST pipeline stage. When a stage
  * after the suite runner still consumes its output (`| tee run.log`, or a filter the platform could
  * not prove output-only), that stage produced the code, not the run — and `… | grep … | tail -20`
- * exited 0 for a run with a failure in it (xr-molecule-flash-m101 +25:54). No code is reported
+ * can exit 0 for a run with a failure in it. No code is reported
  * then: the log's own tally decides.
  *
  * The same reading covers a code of 0 beside a tally that names a failure: whatever ended the
@@ -139,7 +139,7 @@ export interface CutRun {
      * ({@link commandCutRun}'s `budgetSeconds` is 0). A background run is bounded by what its own
      * command carries — so a `command-timeout` cut there is that prefix killing the walk, and the
      * executor must be told to drop the prefix, never to start the run in the background it is
-     * already in (X1 xr-molecule-flash-m143 +24:45).
+     * already in.
      */
     background: boolean;
     /**
@@ -164,12 +164,12 @@ export interface CutRun {
     /**
      * The interpreter of an inline program that only touches local files (`python3`, `node`, …), or
      * null. Such a program is stopped by its short budget because it is stuck, never because the work
-     * is slow, so the sentence must not send it to the background (xr-molecule-flash-m200 +03:45).
+     * is slow, so the sentence must not send it to the background.
      */
     inlineScript?: string | null;
     /**
      * The variable a leaked standalone browser launch is bound to, when the command ran such a probe
-     * and the cut reader could only classify it after the run (xr-molecule-flash-m257). A leaked
+     * and the cut reader could only classify it after the run. A leaked
      * handle is not a slow workload: the background is the one place it must not be sent, so the
      * sentence names the close instead.
      */

package/dist/cut-run.js

@@ -2,13 +2,13 @@
  * A command that a budget stopped before it finished, and the state its result carries so no
  * reader can mistake it for a run that ended.
  *
- * X1 xr-molecule-flash-m93 (2026-10-16, +12:37) sent the supplied RealWorld suite as
- * `timeout 280 hurl --test --continue-on-error --jobs 1 … hurl/*.hurl 2>&1 | tail -60` and got
+ * A command such as
+ * `timeout 280 hurl --test --continue-on-error --jobs 1 … hurl/*.hurl 2>&1 | tail -60` came
  * back `exitCode: 0`, four finished files' lines and nothing else. Two lies in one result: the
  * `timeout 280` killed the run at 280 s, and the `| tail` made the pipeline's status the status —
  * so the executor read a suite that stopped at its fifth file as a suite that ran and nearly
- * passed, fixed one message, and immediately sent the same 280-second command again (the run's
- * third, ~14 minutes of a 60-minute cap across three of them).
+ * passed, fixed one message, and immediately sent the same 280-second command again (~14 minutes
+ * of a 60-minute cap across three of them).
  *
  * So the tool never reports a stopped run as `exitCode: 0`. Such a result carries
  * `status: 'cut_at_budget'` and an exit code that is `null` whenever the number the pipeline
@@ -19,7 +19,7 @@
  *
  * 1. **Its own bound** — a `timeout <N>` the command carries ({@link commandTimeoutSeconds}). The
  *    run used it, so the run was killed at it; with no closing tally in the output, the run did
- *    not finish. This is m93's shape.
+ *    not finish. This is the first shape.
  * 2. **This tool's budget** — the backend runs the command under `timeout` (see
  *    `backends/sandbox.ts`), which reports 124 whatever the pipeline did, and returns everything
  *    printed until then. The budget is the tool's own, so its number belongs to the tool.
@@ -173,7 +173,7 @@ const FAILED_TALLY = /\b[1-9]\d*\s+failed\b/;
  * The code in a background result is the code of the command's LAST pipeline stage. When a stage
  * after the suite runner still consumes its output (`| tee run.log`, or a filter the platform could
  * not prove output-only), that stage produced the code, not the run — and `… | grep … | tail -20`
- * exited 0 for a run with a failure in it (xr-molecule-flash-m101 +25:54). No code is reported
+ * can exit 0 for a run with a failure in it. No code is reported
  * then: the log's own tally decides.
  *
  * The same reading covers a code of 0 beside a tally that names a failure: whatever ended the

package/dist/failure-kind.d.ts

@@ -10,12 +10,12 @@
  * - **status** — a response arrived and the HTTP status disagreed with what the suite asserts.
  * - **assertion** — a response arrived and an assertion over its body failed.
  *
- * X0 xr-molecule-flash-m110 (+18:42 → +20:09) is the case this exists for: one Hurl file on the
- * freshly deployed URL failed with `(28) Operation timed out … 0 bytes received` while the other
- * twelve passed and 138 requests executed, and every note on the result read it as an assertion.
- * The executor rewrote a CORS middleware, bisected a second server and latency-compared the two,
- * then re-ran the same file — which passed in 3 s. A single re-run was the whole fix, and the one
- * fact that would have said so is the failure's LAYER.
+ * The case this exists for: one Hurl file on the freshly deployed URL failed with
+ * `(28) Operation timed out … 0 bytes received` while the other twelve passed and 138 requests
+ * executed, and every note on the result read it as an assertion. The executor rewrote a CORS
+ * middleware, bisected a second server and latency-compared the two, then re-ran the same file —
+ * which passed in 3 s. A single re-run was the whole fix, and the one fact that would have said
+ * so is the failure's LAYER.
  *
  * ONE classifier, used by the causes note ({@link ./utilities.ts} `failureCausesNote`) and by the
  * platform's own proof result (`molecule-dev` `suite-proof.ts`), so the two can never disagree

package/dist/failure-kind.js

@@ -10,12 +10,12 @@
  * - **status** — a response arrived and the HTTP status disagreed with what the suite asserts.
  * - **assertion** — a response arrived and an assertion over its body failed.
  *
- * X0 xr-molecule-flash-m110 (+18:42 → +20:09) is the case this exists for: one Hurl file on the
- * freshly deployed URL failed with `(28) Operation timed out … 0 bytes received` while the other
- * twelve passed and 138 requests executed, and every note on the result read it as an assertion.
- * The executor rewrote a CORS middleware, bisected a second server and latency-compared the two,
- * then re-ran the same file — which passed in 3 s. A single re-run was the whole fix, and the one
- * fact that would have said so is the failure's LAYER.
+ * The case this exists for: one Hurl file on the freshly deployed URL failed with
+ * `(28) Operation timed out … 0 bytes received` while the other twelve passed and 138 requests
+ * executed, and every note on the result read it as an assertion. The executor rewrote a CORS
+ * middleware, bisected a second server and latency-compared the two, then re-ran the same file —
+ * which passed in 3 s. A single re-run was the whole fix, and the one fact that would have said
+ * so is the failure's LAYER.
  *
  * ONE classifier, used by the causes note ({@link ./utilities.ts} `failureCausesNote`) and by the
  * platform's own proof result (`molecule-dev` `suite-proof.ts`), so the two can never disagree

package/dist/index.d.ts

@@ -31,7 +31,7 @@
  *   ceiling the request side puts on a single tool result: whole files are
  *   returned up to it and every path past that is named in `note` and listed as
  *   `not returned`, so a file is never handed back in part — the shape that lost
- *   the middle of a ten-file batch to the request-side cut (X0 flash-m81). Each
+ *   the middle of a ten-file batch to the request-side cut. Each
  *   entry carries its own content or its own error, so one bad path never fails
  *   the batch.
  * - **`edit_file` shows the result, so the model need not re-read.** A
@@ -57,7 +57,7 @@
  *   added or removed and nothing else, the edit can only move text across lines —
  *   joining the next line onto the replaced text, or pushing the rest of the line
  *   down — which is what a weak model does by accident when it repeats a line it
- *   means to keep (flash-m28, m55, m62, m89, five times in the m89 run alone). The
+ *   means to keep. The
  *   replacement is skipped, the rest of the batch is applied, and the result
  *   carries `skippedNote`: one line naming the replacement, what applying it would
  *   have done, and how to say it on purpose (include the next line in `old_string`).

package/dist/index.js

@@ -31,7 +31,7 @@
  *   ceiling the request side puts on a single tool result: whole files are
  *   returned up to it and every path past that is named in `note` and listed as
  *   `not returned`, so a file is never handed back in part — the shape that lost
- *   the middle of a ten-file batch to the request-side cut (X0 flash-m81). Each
+ *   the middle of a ten-file batch to the request-side cut. Each
  *   entry carries its own content or its own error, so one bad path never fails
  *   the batch.
  * - **`edit_file` shows the result, so the model need not re-read.** A
@@ -57,7 +57,7 @@
  *   added or removed and nothing else, the edit can only move text across lines —
  *   joining the next line onto the replaced text, or pushing the rest of the line
  *   down — which is what a weak model does by accident when it repeats a line it
- *   means to keep (flash-m28, m55, m62, m89, five times in the m89 run alone). The
+ *   means to keep. The
  *   replacement is skipped, the rest of the batch is applied, and the result
  *   carries `skippedNote`: one line naming the replacement, what applying it would
  *   have done, and how to say it on purpose (include the next line in `old_string`).

package/dist/inline-script.d.ts

@@ -2,7 +2,7 @@
  * An inline interpreter program (`python3 -c`, `python3 - <<EOF`, `node -e`) that only touches local
  * files — work that takes milliseconds or never ends, never minutes of honest progress.
  *
- * xr-molecule-flash-m200 (+03:45, 2026-10-19) spent 291 s of a 60-minute cap on
+ * One such step spent 291 s of a 60-minute cap on
  * `python3 - <<'EOF' … re.findall(r'([^{}]*:before[^{}]*)\{content:"[^"]*"\}', s) … EOF` rewriting a
  * minified CSS file whose first rule is one ~25 KB selector list: the pattern's two unbounded
  * `[^{}]*` around a literal backtrack cubically, printed nothing, and was stopped by the tool's
@@ -15,10 +15,10 @@
  * a short budget ({@link INLINE_SCRIPT_BUDGET_MS}), and a cut says what happened: a runaway
  * transform, not slow work ({@link inlineScriptRunawaySentence}).
  *
- * The short budget needs the WHOLE command to be that shape. xr-molecule-flash-m254 (+12:48)
- * chained the m200 heredoc with `node …/smoke.mjs | tail -25` — a Playwright walk whose import
- * lives inside the file — and the walk was stopped after 20 s while the result blamed the python
- * transform. Every statement must be proven local ({@link LOCAL_UTILITY}) before the budget applies.
+ * The short budget needs the WHOLE command to be that shape. A command that chained such a
+ * heredoc with `node …/smoke.mjs | tail -25` — a Playwright walk whose import lives inside the
+ * file — had the walk stopped after 20 s while the result blamed the python transform. Every
+ * statement must be proven local ({@link LOCAL_UTILITY}) before the budget applies.
  *
  * @module
  */

package/dist/inline-script.js

@@ -2,7 +2,7 @@
  * An inline interpreter program (`python3 -c`, `python3 - <<EOF`, `node -e`) that only touches local
  * files — work that takes milliseconds or never ends, never minutes of honest progress.
  *
- * xr-molecule-flash-m200 (+03:45, 2026-10-19) spent 291 s of a 60-minute cap on
+ * One such step spent 291 s of a 60-minute cap on
  * `python3 - <<'EOF' … re.findall(r'([^{}]*:before[^{}]*)\{content:"[^"]*"\}', s) … EOF` rewriting a
  * minified CSS file whose first rule is one ~25 KB selector list: the pattern's two unbounded
  * `[^{}]*` around a literal backtrack cubically, printed nothing, and was stopped by the tool's
@@ -15,10 +15,10 @@
  * a short budget ({@link INLINE_SCRIPT_BUDGET_MS}), and a cut says what happened: a runaway
  * transform, not slow work ({@link inlineScriptRunawaySentence}).
  *
- * The short budget needs the WHOLE command to be that shape. xr-molecule-flash-m254 (+12:48)
- * chained the m200 heredoc with `node …/smoke.mjs | tail -25` — a Playwright walk whose import
- * lives inside the file — and the walk was stopped after 20 s while the result blamed the python
- * transform. Every statement must be proven local ({@link LOCAL_UTILITY}) before the budget applies.
+ * The short budget needs the WHOLE command to be that shape. A command that chained such a
+ * heredoc with `node …/smoke.mjs | tail -25` — a Playwright walk whose import lives inside the
+ * file — had the walk stopped after 20 s while the result blamed the python transform. Every
+ * statement must be proven local ({@link LOCAL_UTILITY}) before the budget applies.
  *
  * @module
  */
@@ -66,7 +66,7 @@ const EXTERNAL_EFFECT = /\b(?:curl|wget|aria2c|rsync|scp|sftp|ftp|ssh|urllib3?|h
  * The only OTHER programs a proven-local inline program may share its command with: plain file
  * utilities (`cd app && python3 - <<'EOF' … EOF`, `… EOF | tail -25`).
  *
- * xr-molecule-flash-m254 (+12:48) ran `python3 - <<'EOF' … EOF` and then, in the same command,
+ * A command ran `python3 - <<'EOF' … EOF` and then, in the same command,
  * `node /workspace/.mol-scratch/smoke.mjs | tail -25` — the agent's Playwright UI walk. The
  * heredoc alone is local, so the whole chain got the 20 s budget, the walk was stopped, and the
  * result blamed the python transform. A script FILE can do anything (the `playwright` import is

package/dist/line-diff.d.ts

@@ -4,9 +4,8 @@
  * The count is a diff, not an arithmetic delta: replacing one line with another
  * leaves the line count unchanged, so `new.length - old.length` is 0 for the
  * edit that changed the file — a result that reads to the model as "your write
- * did nothing" (X0 xr-molecule-flash-m141 +09:56: `write_file` rewrote
- * `ArticlePreview.tsx`'s favorite label and reported
- * `"linesAdded":0,"linesRemoved":0`). The lines an edit actually changed are
+ * did nothing" — `write_file` rewrote `ArticlePreview.tsx`'s favorite label and reported
+ * `"linesAdded":0,"linesRemoved":0`. The lines an edit actually changed are
  * found with the same longest-common-subsequence line diff the IDE's tool cards
  * use (`@molecule/app-ide-react`'s `diffLineCount`); it is mirrored here because
  * the API and App halves of the workspace cannot import each other (AGENTS.md

package/dist/line-diff.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"line-diff.d.ts","sourceRoot":"","sources":["../src/line-diff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAmGH;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,SAAS,MAAM,EAAE,EAC3B,QAAQ,EAAE,SAAS,MAAM,EAAE,GAC1B;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAuBpC"}
+{"version":3,"file":"line-diff.d.ts","sourceRoot":"","sources":["../src/line-diff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAmGH;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,SAAS,MAAM,EAAE,EAC3B,QAAQ,EAAE,SAAS,MAAM,EAAE,GAC1B;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAuBpC"}

package/dist/line-diff.js

@@ -4,9 +4,8 @@
  * The count is a diff, not an arithmetic delta: replacing one line with another
  * leaves the line count unchanged, so `new.length - old.length` is 0 for the
  * edit that changed the file — a result that reads to the model as "your write
- * did nothing" (X0 xr-molecule-flash-m141 +09:56: `write_file` rewrote
- * `ArticlePreview.tsx`'s favorite label and reported
- * `"linesAdded":0,"linesRemoved":0`). The lines an edit actually changed are
+ * did nothing" — `write_file` rewrote `ArticlePreview.tsx`'s favorite label and reported
+ * `"linesAdded":0,"linesRemoved":0`. The lines an edit actually changed are
  * found with the same longest-common-subsequence line diff the IDE's tool cards
  * use (`@molecule/app-ide-react`'s `diffLineCount`); it is mirrored here because
  * the API and App halves of the workspace cannot import each other (AGENTS.md

package/dist/no-test-run.d.ts

@@ -9,13 +9,13 @@
  * prints with `--help`/`--version`, the same way.
  *
  * Every check in the platform read such a command as a whole-suite run, because each one
- * matched the runner's NAME. X1 xr-molecule-flash-m79's first Playwright command was a config
+ * matched the runner's NAME. A first Playwright command that was a config
  * check — a config written to `/tmp`, `cp`'d beside the suite and used with `--list` — and it
  * came back HELD, `status: not_run`, with a ~4 KB `suiteNote` telling it to send the same
  * command with `--max-failures=15` ("uncapped it walks every test … 8–13 minutes"), beside an
  * environment block saying the run "ran on their defaults" and an import note about a path the
  * `cp` had already fixed. Nothing ran. The model gave up on the approach, wrote a second
- * config, and its next command was held again (flash-m74's "same command three times" shape):
+ * config, and its next command was held again ("same command three times" shape):
  * two holds, zero tests, and the config check it asked for never answered.
  *
  * So the classifiers live here, in one place, and callers ask them instead of their own
@@ -27,8 +27,8 @@
  * What counts as an invocation is COMMAND POSITION, read by `@molecule/api-ai-tools`'
  * `commandSegments`: `npx playwright test --list`, `hurl --help` and `bash run.sh` invoke the
  * runner, while a runner named as an argument (`grep -n playwright e2e/README.md`,
- * `head -30 run-api-tests-hurl.sh`) invokes nothing at all. X1 xr-molecule-flash-m81 (+20:03)
- * read a runner script with `head -30` and the suite-overlap hold answered "a Playwright suite is
+ * `head -30 run-api-tests-hurl.sh`) invokes nothing at all. Reading a runner script with
+ * `head -30` has had the suite-overlap hold answer "a Playwright suite is
  * already running … wait for it", for a command that runs nothing.
  *
  * @module
@@ -41,7 +41,7 @@
  * position of a segment, after its wrapper prefixes. A runner named in an argument is not an
  * invocation — `head -30 run-api-tests-hurl.sh` and `grep -n playwright e2e/README.md` name a
  * file to read, and a `--list` written inside a file the command writes is not a flag anyone runs
- * with (flash-m81).
+ * with.
  *
  * A command that invokes no runner is NOT one of these (false): "the command runs no test" is
  * then true for `ls`, which is not the question any caller is asking. The question is whether

package/dist/no-test-run.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-test-run.d.ts","sourceRoot":"","sources":["../src/no-test-run.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAiLH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAiB3D"}
+{"version":3,"file":"no-test-run.d.ts","sourceRoot":"","sources":["../src/no-test-run.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAkLH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAiB3D"}