@molecule/api-ai-tools 1.14.3 → 1.14.5

package/README.md

@@ -3,7 +3,7 @@ AUTO-GENERATED — DO NOT EDIT THIS FILE.
 Generated by `mlcl sync-docs` from the package's src/index.ts JSDoc + mlcl/registry.json.
 Edits here are overwritten on the next commit (molecule's pre-commit hook regenerates).
 To change this document, edit the module-level JSDoc in src/index.ts.
-Generated: 2026-10-24T07:21:35.435Z
+Generated: 2026-10-25T20:03:24.838Z
 -->
 
 # @molecule/api-ai-tools
@@ -64,7 +64,7 @@ A browser launch bound to a variable, proven to have no cleanup path.
 
 ```typescript
 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
 }
 ```
@@ -136,7 +136,7 @@ two things a caller that WRITES into a command needs. The platform composes a ru
 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.
 
 ```typescript
 interface LocatedCommandSegment {
@@ -202,7 +202,7 @@ 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
 }
@@ -252,7 +252,7 @@ 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
   /**
@@ -277,12 +277,12 @@ 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.
    */
@@ -532,8 +532,7 @@ interface SuiteRunInFlight {
   target: string
   /**
    * Whether the command being judged STOPS this run before starting its own — a kill comes first,
-   * so a run the command itself stops is not in the way (xr-molecule-flash-m87's
-   * `kill 19408 … ; npx playwright test …`).
+   * so a run the command itself stops is not in the way (`kill 19408 … ; npx playwright test …`).
    */
   stoppedByCommand?: boolean
 }
@@ -638,7 +637,7 @@ interface TraceRequest {
    * What the page SENT, for a 4xx answered by the app's own API — bounded (see
    * {@link MAX_TRACED_BODY_CHARS}). A body wrapped as `{"data":{…}}` is visible here in one line:
    * app-http's verbs take the body as their second argument, so a helper that passes
-   * `{ data: body }` there ships the wrapper (xr-molecule-flash-m111 +11:36).
+   * `{ data: body }` there ships the wrapper.
    */
   sent?: string
   /** What came back for that 4xx, bounded the same way — the API's own error body. */
@@ -662,7 +661,7 @@ interface TraceRequest {
    * A 401 cannot be read without this: the API's own body said
    * `{"errors":{"token":["is missing"]}}` while the note told the run to read the API handler,
    * when the header's absence proved the CLIENT never attached the token
-   * (xr-molecule-flash-m148 +29:18). A header present moves the answer to the server: the API
+   * A header present moves the answer to the server: the API
    * refused a token it was sent.
    */
   sentAuthorization?: boolean
@@ -681,7 +680,7 @@ interface TraceRequest {
   /**
    * The trace member this request came from — the browser context Playwright numbered (`1`, `3`).
    * A test that opens a second browser context writes one trace member per context, and a test's
-   * request is only evidence about the page it was made on (xr-molecule-flash-m160).
+   * request is only evidence about the page it was made on.
    */
   context?: string
   /** The page the request was made on, as the HAR entry's `pageref` records it. */
@@ -695,7 +694,7 @@ The test's LAST user action before the failing assertion, and the requests it ca
 
 An assertion after a navigation is not explained by the page's last call (`GET /api/tags` on
 whatever page the app redirected to); it is explained by what the action the test took sent and
-what came back (xr-molecule-flash-m148: 13 then 12 failing tests, every trace row leading with
+what came back (13 then 12 failing tests, every trace row leading with
 `GET /api/tags → 200`, while the register `POST /api/users` and its answer — the fact that
 explains the signed-out page — was never shown).
 
@@ -741,7 +740,7 @@ interface TraceAction {
   /**
    * The selector a `fill`/`type`/`selectOption` acted on (`textarea[name="bio"]`), from the
    * trace's own params. Kept so the note can compare what the test typed with what the page
-   * submitted (m173: the field it typed into was sent empty).
+   * submitted (a field typed into and sent empty).
    */
   selector?: string
   /**
@@ -759,7 +758,7 @@ two-context test opens for its own setup.
 
 Its actions and requests belong to a different page: a request it sent is not the failing
 action's effect, and the URL it left the page on is not where the assertion's page went
-(xr-molecule-flash-m160: the helper context created an article in an editor page while the
+(the helper context created an article in an editor page while the
 primary page moved to the profile the assertion then failed on, and the note called the
 editor page the failing page).
 
@@ -784,13 +783,13 @@ The assertion's own error names the text (a `has-text(…)` / `getByText(…)` /
 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
+selector. One run 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).
+sliced the response to its first 20 entries (a top-N cut, in the frontend).
 
 The text must be a value the response held, never a substring of one: a whole JSON string or
 number value, or a word bounded by non-alphanumerics. A text of 2 characters or fewer, or one
-made of digits only, must be a whole JSON value. xr-molecule-flash-m208's pagination assertion
+made of digits only, must be a whole JSON value. A pagination assertion
 waited for "2" and the raw substring hit `pag1792394785820` in a tags response, so the note led
 with a response that had nothing to do with the failure; when no response holds the text that
 way, the field is absent and the note leads with its next finding.
@@ -808,7 +807,7 @@ interface TraceMissingText {
    * of the collection that started after the last navigation, and the text is absent from the
    * page's own failure snapshot ({@link traceArtifactsScript}).
    *
-   * Absent when the evidence is weaker — a creation POST carried the text (m194's button failure
+   * Absent when the evidence is weaker — a creation POST carried the text (a button failure
    * was not a missing article), the snapshot still showed it, or the trace recorded no clock —
    * and the note then says only that a response contained the text.
    */
@@ -821,7 +820,7 @@ interface TraceMissingText {
 A write the trace recorded answering a boolean field, and a LATER GET of the same resource
 answering the opposite for that field.
 
-This is the pair that reads as a frontend race and is not one: xr-molecule-flash-m181's follow
+This is the pair that reads as a frontend race and is not one: a follow
 test sent `POST /api/profiles/:username/follow` and the API answered
 `{"profile":{…,"following":true}}`, then a `GET /api/profiles/:username` answered
 `{"profile":{…,"following":false}}` — the READ route never saw the viewer, so it hydrated
@@ -900,7 +899,7 @@ interface TraceCountMatch {
   text?: string
   /** Its ancestors, outermost first (`body > div.comment-form > div.card`), bounded. */
   path?: string
-  /** True when a `<form>` is one of its ancestors — the m321 extra match's shape. */
+  /** True when a `<form>` is one of its ancestors — the shape of an extra form-internal match. */
   inForm?: true
 }
 ```
@@ -911,7 +910,7 @@ A failing assertion that compared a LOCATOR COUNT (`expect(await locator.count()
 `expect(locator).toHaveCount(n)`), with the locator the trace recorded and, when the failure
 snapshot can supply them, the elements it matched.
 
-xr-molecule-flash-m321's `comments.spec.ts:86` sat on `Expected: 3 / Received: 4` for ~30
+A `comments.spec.ts:86` assertion sat on `Expected: 3 / Received: 4` for ~30
 minutes and three whole suite walks: the helper counted `.card:not(.comment-form) .card-block`,
 the app's comment form was a `.comment-form` wrapper around a plain `.card`, and the form's own
 `.card-block` made the fourth. The trace had the selector (its `Frame.queryCount` entry) and the
@@ -972,7 +971,7 @@ interface TraceArtifact {
    * action caused ({@link TraceArtifact.lastAction}), else — on a trace with no action clock — the
    * trace's LAST `fetch`/`xhr` in recording order, else its document. It leads the note's row when
    * {@link lastAction} is absent, because a click that changed nothing is explained by the request
-   * the click sent and what came back — xr-molecule-flash-m135's Follow click sent
+   * the click sent and what came back — a Follow click sent
    * `DELETE /api/profiles/x/follow → 200` (its `following` state was stale) and the note listed only
    * the test's earlier, answered requests.
    *
@@ -992,7 +991,7 @@ interface TraceArtifact {
    *
    * A test that opens a second browser context writes one trace member per context, and the
    * archive does not order them by time: the last action of the concatenation may belong to the
-   * helper's page while the assertion failed on another (xr-molecule-flash-m160). The action is
+   * helper's page while the assertion failed on another. The action is
    * therefore the failing page's own, and its `pageAfter` is that page's last frame snapshot.
    *
    * Absent on traces read before this field existed, on traces whose network entries recorded no
@@ -1012,13 +1011,13 @@ interface TraceArtifact {
    * True when the trace held more than one browser context and none of them could be tied to the
    * failing assertion's page. The note then makes no causal claim — no "the test's last action",
    * no "the page stayed at …" — rather than attributing one context's click and URL to another
-   * context's assertion (xr-molecule-flash-m160).
+   * context's assertion.
    */
   unattributed?: true
   /**
    * The browser contexts the test opened BESIDES the failing assertion's page, with the app
    * requests each made. Kept apart so the note can name them as set-up work instead of printing
-   * their requests as the failing action's effects (xr-molecule-flash-m160).
+   * their requests as the failing action's effects.
    *
    * Absent when the trace recorded one context only, when every other context made no request,
    * and on traces read before this field existed.
@@ -1027,8 +1026,7 @@ interface TraceArtifact {
   /**
    * 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).
+   * render it, so the next read is where that response is mapped — never the API or the selector.
    *
    * 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
@@ -1037,7 +1035,8 @@ interface TraceArtifact {
   missingText?: TraceMissingText
   /**
    * A write's answer a later GET of the same resource contradicted — the read route does not see
-   * the viewer (xr-molecule-flash-m181's `following`). The note leads with it and sends the run at
+   * the viewer (a `following` flag that reads as `false`). The note leads with it and sends the
+   * run at
    * the route's middleware, not the page's state handling.
    *
    * Absent when no write and later read in the trace answered the same boolean field differently,
@@ -1048,19 +1047,19 @@ interface TraceArtifact {
    * A visibility failure whose locator RESOLVED into an empty box — Playwright's "hidden" — with
    * the element's children read from the failure snapshot ({@link TraceHiddenBox}). The note uses
    * it to name why the box is empty (an `<img>` with no CSS size, a textless element) instead of
-   * leaving the run to probe computed styles (xr-molecule-flash-m197).
+   * leaving the run to probe computed styles.
    */
   hiddenBox?: TraceHiddenBox
   /**
    * A failing assertion that compared a locator count, with the locator the trace recorded and the
    * elements its failure snapshot matched ({@link TraceCountMismatch}). The row prints them, so a
    * count that is off by one names the extra element instead of leaving the run to probe for it
-   * (xr-molecule-flash-m321's 30-minute `Expected: 3 / Received: 4`).
+   * (a 30-minute `Expected: 3 / Received: 4` hunt).
    */
   countMismatch?: TraceCountMismatch
   /**
    * The method+path groups this test's page sent {@link TRACE_NOTE_LOOP_REPEATS} times or more,
-   * most-repeated first — a render loop the note leads with (xr-molecule-flash-m215: 2,106
+   * most-repeated first — a render loop the note leads with (2,106
    * `GET /api/articles/<slug>` in one test, printed as four identical `→ 200` lines). Counted over
    * every network entry of the failing page, not the capped {@link TraceArtifact.requests} list.
    *
@@ -1087,8 +1086,8 @@ interface TraceArtifact {
 What the runner's own report says about ONE failing test: where the test is declared, which
 Playwright call its failure names, and the per-test deadline the failure measured against.
 
-A trace cannot tell a navigation that ran out of budget from a selector wait that did. On
-xr-molecule-flash-m153 a 15 s `page.waitForSelector` timeout left a trace whose `Frame.goto`
+A trace cannot tell a navigation that ran out of budget from a selector wait that did. A 15 s
+`page.waitForSelector` timeout can leave a trace whose `Frame.goto`
 never finished (the test was cut off mid-navigation) with a `/src/components/*.tsx` module still
 pending when the context closed — and the note read that as an asset hang, then sent the run to
 re-run the same tests unchanged against the same dev server while the same result's
@@ -1136,7 +1135,7 @@ interface TraceRunReport {
   /**
    * The app source files whose code sends a repeated request, read by the caller from the
    * project (`app/src/**`) before this note is written. A loop's sentence names the component to
-   * read instead of leaving the run to search for it (xr-molecule-flash-m215's `Editor.tsx`).
+   * read instead of leaving the run to search for it (the component's own file).
    * Empty when the caller could not read the app or no file states the path.
    */
   callSites?: readonly { method: string; path: string; file: string }[]
@@ -1357,8 +1356,8 @@ interface ToolBuildConfig {
    * The test titles the person's request EXCLUDES by name (molecule-dev's `excludedTestTitles`),
    * asked when a finished suite run's cause note is built. Their failures are not causes to fix:
    * the note drops them, says so at the end, and inverts them out of the narrowed re-run it hands
-   * over — a result must never name a test beside "it does not count" (xr-molecule-flash-m101
-   * +12:00, where the executor spent a turn and an edit on the excluded test).
+   * over — a result must never name a test beside "it does not count" (an executor once spent a
+   * turn and an edit on the excluded test).
    *
    * A getter, not an array, because the request is read per turn while the tool set is built
    * once. Unset means no test is excluded.
@@ -1372,8 +1371,8 @@ interface ToolBuildConfig {
    * `requiredRunSettings` — its mode, say), asked when the cause note composes a narrowed re-run
    * of a finished run's failures. A re-run composed from the executor's own command inherits what
    * that command set — and nothing it left out, so a run that measured the suite in `spa` handed
-   * back a re-run that would measure `spa` again (xr-molecule-flash-m182 +12:06: the request names
-   * `TEST_MODE=fullstack`, the run and its re-run both omitted it).
+   * back a re-run that would measure `spa` again (the request names `TEST_MODE=fullstack`, and
+   * both the run and its re-run omitted it).
    *
    * A getter, not an array: the request is read per turn while the tool set is built once, and
    * what the suite's own files read is the consumer's reading. Unset answers "nothing required".
@@ -1407,7 +1406,7 @@ interface ToolBuildConfig {
 
   /**
    * A whole walk's duration in ms, as the consumer measured it. A suite run the executor detached
-   * whose own `timeout` is shorter than this is lifted (m200); unset lifts only a bound no longer
+   * whose own `timeout` is shorter than this is lifted; unset lifts only a bound no longer
    * than this tool's ceiling.
    *
    * @param command - The suite command.
@@ -1415,6 +1414,8 @@ interface ToolBuildConfig {
    * @returns The duration in ms, or null.
    */
   suiteRunMs?: (command: string, cwd: string) => Promise<number | null | undefined>
+
+  /** Post-write hook (e.g. auto-format via Prettier/ESLint). Called after every write_file/edit_file. */
 // … truncated — the full declaration is in node_modules/@molecule/api-ai-tools/dist/types.d.ts
 ```
 
@@ -1620,21 +1621,21 @@ interface FailureCause {
    * The suite's own per-test budget in ms, when the cause is the test-budget kill
    * (`Test timeout of 15000ms exceeded`). The signature normalizes the number away
    * ({@link normalizedSignature}) so equal causes group, and that number is the one fact that
-   * predicts a test spending its budget on a repeated action (xr-molecule-flash-m110 +20:44).
+   * predicts a test spending its budget on a repeated action.
    */
   budgetMs?: number
   /**
    * The layer the failure came from ({@link classifyRunFailure}). A `connection` cause never
    * reached the app, so it is NOT a cause the app's code can fix: the note says to re-run it
    * once and read the app's log on a repeat, instead of sending a fix at a handler
-   * (xr-molecule-flash-m110 +18:42 rewrote a CORS middleware for a 20 s connection timeout).
+   * (a CORS middleware was rewritten for a 20 s connection timeout).
    */
   kind: RunFailureKind
   /**
    * What the page itself showed at the moment of the failure, when the caller read it from
    * Playwright's `error-context.md` (the alert / error list). The failure's own error line names
-   * the symptom — `waitForURL` timed out — and never what the page was saying: xr-molecule-flash-
-   * m122 +23:39 grouped eight `waitForURL` timeouts under one line while the page snapshots named
+   * the symptom — `waitForURL` timed out — and never what the page was saying: eight
+   * `waitForURL` timeouts were grouped under one line while the page snapshots named
    * the cause (`email can't be blank`, `username can't be blank` — the settings form submitted
    * before its values had loaded). Attached to the cause so the fix needs no `cat` of the file.
    */
@@ -1915,8 +1916,8 @@ This is the reading a policy that asks "does this command run X" needs, and it i
 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.
 
@@ -1954,8 +1955,8 @@ A flag written "at the end of the command" is not the runner's: a statement can
 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)`.
 
@@ -1986,8 +1987,8 @@ adjacent closer to its last word because no separator comes between them: `( …
 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
@@ -2041,9 +2042,9 @@ largest bound that was lifted.
 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}):
@@ -2136,7 +2137,7 @@ The exit code a finished suite run may report.
 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
@@ -2407,7 +2408,7 @@ A runner counts only where a shell would RUN it ({@link commandSegments}): the w
 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
@@ -2449,7 +2450,7 @@ function outputFilterAfterRunner(
 
 - `command` — The command as the executor sent it.
 - `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).
-- `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.
+- `occurrence` — Which runner invocation the output belongs to, 1-based. A command can run the same runner more than once (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.
 
@@ -2725,7 +2726,7 @@ it already names one, or starts no Playwright run.
 The flag rides the same statement the runner does: a `cd`, an env prefix and a `timeout` before
 it are left exactly as they were, and so is everything chained after the run (`| tail -50`).
 
-xr-molecule-flash-m113 (+19:09): the model's fix-round re-run dropped the
+A fix-round re-run dropped the
 `--config playwright.conduit.config.ts` both earlier runs had carried, so Playwright started with
 NO base URL and all 10 failures were `page.goto: Cannot navigate to invalid URL` — a failure list
 that says nothing about the app. The platform composes commands back to the executor too (the
@@ -2746,21 +2747,21 @@ function withSuiteConfig(command: string, config: string | null | undefined): st
 The whole-suite command made scoped to the tests it should re-run instead: the same
 invocation — same launcher, same settings — with the named `file:line`s in place of every
 positional selection the run carried (a spec file, a suite directory or a regex filter),
-`--last-failed` dropped (it re-runs the tests that never ran too, X1 flash-m60) and
+`--last-failed` dropped (it re-runs the tests that never ran too) and
 `--retries=0` set (a re-run of a known failure does not need to pay for retries) — except the
 re-run of a run against a DEPLOYED URL, which keeps the suite's own retries and tracing
 (`options.suiteSettings`).
 
 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 redirectRunnerOutputsToFreshFiles}), so a
-re-run never overwrites the log the run itself is the evidence for (xr-molecule-flash-m173) —
-and the setup around the run keeps its own file writes untouched (xr-molecule-flash-m429). A
+re-run never overwrites the log the run itself is the evidence for —
+and the setup around the run keeps its own file writes untouched. A
 `tail`/`head`/`cat`/`grep` chained after the run that reads that exact log is shown the fresh
-sibling instead, so the re-run displays the run it performed (xr-molecule-flash-o03).
+sibling instead, so the re-run displays the run it performed.
 
 `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
+handed back a command with the same defect (every failing test was
 `Cannot navigate to invalid URL` because the re-run loaded no base URL).
 
 ```typescript
@@ -2777,23 +2778,23 @@ function scopedRerunCommand(
 
 - `command` — The whole-suite run's command.
 - `locations` — The failing `file:line`s to re-run, as the run's own log printed them. A location the reporter printed relative to the runner's own directory (`../../fixtures/…`, which no absolute path contains) is resolved here ({@link playwrightLocations}), so the command this returns is one Playwright can match.
-- `excluded` — The test titles the request carves out. They are inverted out (`--grep-invert`) so a re-run of the failing locations cannot report one of them again — xr-molecule-flash-m101 re-ran the whole 139-test suite and spent ~4 minutes to be told about a test the request had already said does not count.
+- `excluded` — The test titles the request carves out. They are inverted out (`--grep-invert`) so a re-run of the failing locations cannot report one of them again — a re-run of the whole 139-test suite spends ~4 minutes to be told about a test the request had already said does not count.
 - `config` — The config the run loaded, when the caller knows it; added when the command does not name one.
 - `cwd` — The directory `exec_command` was given, when it was; the base a location is resolved against when the command does not `cd` anywhere.
-- `env` — The settings the REQUEST requires of the suite and this run left out ({@link withRunEnv}): the re-run carries them, so a re-run of a run measured in the wrong mode is not measured in that mode again (xr-molecule-flash-m182 +12:06).
-- `options` — `suiteSettings` for the re-run of a run against a DEPLOYED URL: it keeps the suite's own retries and tracing instead of the diagnosis ones. The graded measurement is the suite's own settings, and a retry is what leaves a failing test's trace there; the platform's `--retries=0` and its `--trace=retain-on-failure` are both a stricter measurement than the one that was graded, and on X1 xr-molecule-flash-h15 the recording alone turned three budget-bound deployed tests into timeouts.
+- `env` — The settings the REQUEST requires of the suite and this run left out ({@link withRunEnv}): the re-run carries them, so a re-run of a run measured in the wrong mode is not measured in that mode again.
+- `options` — `suiteSettings` for the re-run of a run against a DEPLOYED URL: it keeps the suite's own retries and tracing instead of the diagnosis ones. The graded measurement is the suite's own settings, and a retry is what leaves a failing test's trace there; the platform's `--retries=0` and its `--trace=retain-on-failure` are both a stricter measurement than the one that was graded, and the recording alone turned three budget-bound deployed tests into timeouts.
 
 **Returns:** The scoped command, or the command unchanged when it runs no Playwright suite.
 
 #### `withRunEnv(command, settings)`
 
 The command with the request's required settings put in front of its RUN statement — the ONE
-place every composed re-run gets them (xr-molecule-flash-m182).
+place every composed re-run gets them.
 
 The settings are written at the statement's own assignment offset, never in front of the whole
 command: a shell binds an assignment there to the statement's program, while one in front of the
 whole command is the environment of its FIRST statement alone (`APP_BASE=… cd app && npx
-playwright test` sets the variable for `cd`; xr-molecule-flash-m103 +28:08). A name the command
+playwright test` sets the variable for `cd`). A name the command
 gives a different value is replaced, and one it already gives the required value is left as
 written. When the parse cannot place the statement (a run inside a nested `sh -c '…'`), the
 settings become `export`s, which no statement boundary can swallow.
@@ -2850,10 +2851,10 @@ disagree:
   ({@link ./utilities.js} `streamingBackgroundCommand`) — a diagnosis walks each failure once,
   while the run the suite is judged by keeps the suite's own retries; and
 - the platform's own notes (molecule-dev's `suite-cli-override.ts`), which must not tell the
-  executor to drop the `--retries=0` the platform itself has just added — the contradiction X1
-  flash-m74 and m75 filed, and m76 filed a third time.
+  executor to drop the `--retries=0` the platform itself has just added — a contradiction
+  filed three times.
 
-Until xr-molecule-flash-m89 they were a regex and a predicate that only LOOKED alike, and the
+Until then they were a regex and a predicate that only LOOKED alike, and the
 gap was exactly the run the platform had asked for: its `testRunNote` says "run the whole suite
 once with `--max-failures=0`", and the rewriter read that cap flag as a capped diagnosis and
 stripped the suite's retries from the uncapped proof run that follows a deploy — the one run the
@@ -2936,11 +2937,10 @@ The command that stops a running background task, read from the sandbox's own pi
 
 THE one builder for it, so every note that hands the executor a way to stop a run hands over the
 same pid-only form: a `pkill -f <something>` matches the shell running it (its argv IS the
-command), and `molecule-dev/api/src/ai/pattern-kill-guard.ts` holds exactly that — X1
-xr-molecule-flash-m87's stuck note suggested `kill $(cat /tmp/<id>.pid) 2>/dev/null; pkill -f
-<id>.sh`, which the platform's own guard then refused, and the same shape cost a refused call at
-+21:57. The pid tree is the whole of what the pattern was for: the detached shell and every
-process under it.
+command), and `molecule-dev/api/src/ai/pattern-kill-guard.ts` holds exactly that — a stuck note
+that suggested `kill $(cat /tmp/<id>.pid) 2>/dev/null; pkill -f <id>.sh` was refused by the
+platform's own guard, and the same shape costs a refused call every time. The pid tree is the
+whole of what the pattern was for: the detached shell and every process under it.
 
 ```typescript
 function taskStopCommand(backend: ExecutionBackend, taskId: string): Promise<string>
@@ -2956,8 +2956,8 @@ function taskStopCommand(backend: ExecutionBackend, taskId: string): Promise<str
 The steer attached to a SUCCESSFUL read of a package's built output. The ENOENT
 redirect below fires only when the read FAILS, so a model that knows the hoisted
 layout reads `node_modules/@molecule/<pkg>/dist/*.js` happily and never learns the
-documented API is one call away (X0 flash-m70: 24 such reads in 57 s, no note on
-any of them). Carried as `distNote` rather than merged into `note` so a host that
+documented API is one call away (24 such reads in 57 s, with no note on any of
+them). Carried as `distNote` rather than merged into `note` so a host that
 has read_molecule_doc (molecule-dev's cadence note, which also names the functions)
 can supersede it without string-matching.
 
@@ -2979,7 +2979,7 @@ The task id is the ownership: it is the handle `wait_for_task` returned, `/tmp/$
 the log this platform's launcher writes for it, and the redirect target is the file this
 process's own launch registered for that id — never a path parsed out of a command by the
 caller. A diagnosis that reads a running walk must not build a `/tmp` path of its own
-(xr-molecule-flash-l07: the wait's DISPLAY was diagnosed as if it were the log).
+(a wait's DISPLAY gets diagnosed as if it were the log).
 
 ```typescript
 function registeredTaskLogCommand(taskId: string): string | null
@@ -3012,17 +3012,17 @@ when the path is not under `node_modules` or nothing is installed there.
 
 `node_modules` is not the project's code: nothing written there survives the
 next install, no deploy carries it, and a sandbox whose dependency tree is
-shared (the pre-installed superset) breaks every other run through it. X0
-xr-molecule-flash-m91 (+04:43) called `write_file` on
-`node_modules/@molecule/api-resource-comment/dist/numbers.d.ts` while reading
-the package's declarations and clobbered its runtime module a call later
+shared (the pre-installed superset) breaks every other run through it. A
+`write_file` on
+`node_modules/@molecule/api-resource-comment/dist/numbers.d.ts`, made while
+reading the package's declarations, clobbered its runtime module a call later
 (`module.exports = {}` over the ESM handler its own code imports) — the write
 answered `ok: true`, and 18 s went to noticing, `npm pack`-ing the package and
 putting the file back. Reading these files stays allowed (that is how the
 declarations above are read at all).
 
 What is protected is the INSTALL, not the spelling: the decision comes from
-{@link InstalledPackageFacts}, never from the path alone (m106 above). Three
+{@link InstalledPackageFacts}, never from the path alone (see the symlink case above). Three
 things are the run's own to remove or replace —
 
 - a `node_modules` that is a SYMLINK: `rm`/`unlink` removes the link, never the
@@ -3032,6 +3032,7 @@ things are the run's own to remove or replace —
 
 A path INSIDE the link is still decided by what resolves there: a link into a
 real tree is refused, because removing or writing through it reaches the
+install.
 
 _(description truncated — read the full text in `node_modules/@molecule/api-ai-tools/dist/tools.d.ts`.)_
 
@@ -3125,7 +3126,7 @@ function isStaticAssetRequest(request: TraceRequest): boolean
 Whether a trace recorded a failed response or a request error other than cancellation.
 
 A 404 on a static asset is excepted: `/sw.js` and `/fonts/*` 404 on an app that never shipped
-them, and naming one as a failure sent m125 into writing the caching worker it had asked about.
+them, and naming one as a failure sent a run into writing the caching worker it had asked about.
 A 5xx on an asset, or a network error, still counts. A request error alone does not locate
 the cause in the server: the browser or network may have rejected the request.
 
@@ -3141,7 +3142,7 @@ function failedRequest(request: TraceRequest): boolean
 
 Whether a trace recorded no response and no error other than cancellation. The request may
 have been pending or cancelled when recording ended; the trace does not establish whether
-the endpoint stalled. A shell request is not evidence about the step (m125 +29:33).
+the endpoint stalled. A shell request is not evidence about the step.
 
 ```typescript
 function unansweredRequest(request: TraceRequest): boolean
@@ -3158,12 +3159,12 @@ other asset the page itself loads, with no response and no error text — still
 the navigation timed out.
 
 The page shell's own incidental requests (`/sw.js`, the manifest, a favicon, a font) are
-excepted for the reason {@link isStaticAssetRequest} documents: m125's run was sent to write a
-caching service worker by an aborted `/sw.js`. A pending `/assets/*.css` is different — the
-navigation blocks on it, so it is the reason `page.goto` ran out of time rather than one of the
-app's API calls (xr-molecule-flash-m135 +34:10: three deployed `page.goto` timeouts on tests that
-pass locally, one 88 KB stylesheet fetch measured at 27 s, and the failing tests' traces each
-held the never-answered CSS while the note said "the cause is in the page").
+excepted for the reason {@link isStaticAssetRequest} documents: an aborted `/sw.js` once sent a
+run to write a caching service worker. A pending `/assets/*.css` is different — the navigation
+blocks on it, so it is the reason `page.goto` ran out of time rather than one of the app's API
+calls (three deployed `page.goto` timeouts on tests that pass locally, one 88 KB stylesheet
+fetch measured at 27 s, and the failing tests' traces each holding the never-answered CSS while
+the note said "the cause is in the page").
 
 ```typescript
 function stalledDocumentSubresource(request: TraceRequest): boolean
@@ -3181,7 +3182,7 @@ endpoint — as opposed to a protected resource that presents one.
 This is the path half of {@link isCredentialExchange}, exported so a caller holding only a
 `METHOD path` reads the same classification: a Hurl failing entry says
 `POST /api/users/login` and nothing about the body, and the whole-suite note must not explain
-a wrong-password login that answered 200 as a cookie-jar effect (xr-molecule-flash-m176).
+a wrong-password login that answered 200 as a cookie-jar effect.
 
 ```typescript
 function isCredentialExchangePath(path: string, authEndpoints?: readonly string[]): boolean
@@ -3197,7 +3198,7 @@ function isCredentialExchangePath(path: string, authEndpoints?: readonly string[
 The sentence a "hidden" visibility failure earns when the trace proved WHY the box is empty.
 
 Playwright calls an element with a zero-size box hidden even when it is painted, so the answer
-is in the element's children. `a.navbar-brand` on xr-molecule-flash-m197 was 0×4 px because its
+is in the element's children. An `a.navbar-brand` was 0×4 px because its
 only child was `<img src="/conduit-logo.svg" height="26">`: an SVG with a `viewBox` and no
 width/height has no intrinsic size, and the `height` attribute loses to Tailwind's preflight
 (`img { max-width: 100%; height: auto }`), which the scaffold's own `index.css` imports. The
@@ -3217,7 +3218,7 @@ function hiddenBoxNote(items: readonly TraceArtifact[]): string | null
 The row's sentence for a failing count assertion: the locator, both numbers, and the elements
 the failure snapshot held.
 
-xr-molecule-flash-m321's `comments.spec.ts:86` printed only `Expected: 3 / Received: 4`. The
+A `comments.spec.ts:86` row printed only `Expected: 3 / Received: 4`. The
 helper counted `.card:not(.comment-form) .card-block`, and the app's comment form was a
 `.comment-form` wrapper around a plain `.card`, so the form's own `.card-block` was the fourth
 match. The trace held the selector and the four elements; the note held neither.
@@ -3258,14 +3259,15 @@ The three kinds are kept apart, because they mean different things. A FAILED req
 a network error with Playwright's own text) is a cause. A request with NO RESPONSE RECORDED —
 Playwright's `-1`, no error text — was still in flight when the test ended (the page closed under
 it); listing it as a failure sent a run hunting an API that never answered anything wrong
-(xr-molecule-flash-m112 +30:45). The rest are the page's last answered requests.
+The rest are the page's last answered requests.
 
 A 4xx request carries what the page SENT beside its status, so a wrapped body is visible in one
 line rather than inferred from the status; when one of those bodies is an object whose only key
-is `data`, the note names the call shape that produces it (xr-molecule-flash-m111 +11:36).
+is `data`, the note names the call shape that produces it.
 
 Every row opens with the test's LAST user action before the failing assertion and the requests
 that action caused ({@link TraceArtifact.lastAction}) — started after it, before the assertion,
+the app's own API calls first, each with its status and the first 200 characters of its response,
 
 _(description truncated — read the full text in `node_modules/@molecule/api-ai-tools/dist/trace-artifacts.d.ts`.)_
 
@@ -3293,7 +3295,7 @@ Whether a Playwright config records traces for the tests that fail.
 
 Only `on` and `retain-on-failure` keep a `trace.zip` for a failure whatever the retries do: the
 two retry modes need a retry to happen at all, and a diagnosis run is given `--retries=0`
-(`streamingBackgroundCommand`), so on X1 xr-molecule-flash-m100 the run's own
+(`streamingBackgroundCommand`), so a run's own
 `trace: 'on-first-retry'` recorded nothing — which is what left the failing tests' network log
 unreadable. A config that sets no `trace:` at all records nothing either (Playwright's default
 is off); so does one that cannot be read.
@@ -3306,6 +3308,20 @@ function suiteRecordsTraces(configText: string): boolean
 
 **Returns:** True when the config records traces for failures.
 
+#### `namesNoRetries(command)`
+
+Whether the run itself pins `--retries=0` (either spelling): a run that cannot retry records no
+retry trace, so it still needs one recorded for it. A running wait reads the same proof to know
+a first failure's body is already final (`wait_for_task`'s diagnostic yield).
+
+```typescript
+function namesNoRetries(command: string): boolean
+```
+
+- `command` — The shell command.
+
+**Returns:** True when the run allows no retry.
+
 #### `diagnosisTraceCommand(args)`
 
 The command a Playwright run needs to leave a readable trace behind, when the suite's config
@@ -3318,14 +3334,15 @@ decide its own `--trace`, and whose config keeps no trace for its failures.
 
 A run that can serve as PROOF is the exception: the graded measurement is the suite's own
 settings, so it keeps its own tracing and retries. That was measured, not assumed — on one
-sandbox in X1 xr-molecule-flash-h15 (+46:53 → +49:30) the same build ran a three-test deployed
+sandbox the same build ran a three-test deployed
 subset 3/3 timed out under this flag (17.6–17.9 s against a 15 s per-test budget) and the whole
 file passed 14/14 without it (10.9–12.1 s). `retain-on-failure` RETAINS only a failing test's
 trace (Playwright's `_shouldAbandonTrace` unlinks a passing test's), but it RECORDS every
 action of every test, and for a test near its per-test budget that recording is the difference
-between passing and timing out. m163 (+24:58) is the failure this flag was added for: its
+between passing and timing out. This flag was added for exactly that failure: its
 deployed proof run left only an `error-context.md` because the suite traces
 `on-first-retry` and the run had no retries. That need is met without the flag — the graded
+deployed run keeps the suite's own retries, so a failing test leaves its retry's trace — and
 
 _(description truncated — read the full text in `node_modules/@molecule/api-ai-tools/dist/trace-artifacts.d.ts`.)_
 
@@ -3529,7 +3546,7 @@ function outputIsWithheldUntilExit(command: string): boolean
 The file a command sends its own output to, when it redirects it (`> out.txt`,
 `>> log`, `&> run.log`, `| tee [-a] file`), or null. A background command that does
 this leaves its task log empty, so the log is the wrong place to look and an empty
-log proves nothing (X1 flash-m29).
+log proves nothing.
 
 Which redirect counts is decided by the command's own shell structure, from the same
 parse every other command reader uses: a redirect written in a BACKGROUNDED statement
@@ -3537,7 +3554,7 @@ parse every other command reader uses: a redirect written in a BACKGROUNDED stat
 the command's. The platform's own preview launch is exactly that — the preview server is
 started with `>/tmp/mol-preview-4173.log 2>&1 &` inside the build/serve prelude, and the
 suite's foreground command follows it — so a reader that took the last `>` in the whole
-text told a run its output went to the PREVIEW's log (X1 flash-m136 +18:31).
+text tells a run its output went to the PREVIEW's log.
 
 The target comes back without its shell quotes: `> '/tmp/x.log'` is `/tmp/x.log`, and
 the callers resolve a relative one against the command's cwd.
@@ -3555,7 +3572,7 @@ function outputRedirectTarget(command: string): string | null
 Rewrite a command about to run in the background so its log grows while it
 runs. Two shapes left the log empty until exit, and an empty log is what
 `wait_for_task` reads as "stuck", so working suites were reported stuck and
-killed (X1 run flash-m15 lost 20 of its 60 minutes this way, 2026-10-15):
+killed (one run lost 20 of its 60 minutes this way):
 
 - a trailing `| tail -N`, which holds everything back until the command ends.
   It is dropped: `wait_for_task` already returns the end of the log.
@@ -3563,7 +3580,7 @@ killed (X1 run flash-m15 lost 20 of its 60 minutes this way, 2026-10-15):
   failing test's own error and leaves the pipeline's exit status — the filter's — as the run's.
   Every such stage is dropped from EVERY suite run in the command, not only the last
   ({@link stripTrailingSuiteFilters}); `wait_for_task` already returns the end of the full log,
-  and a run whose tally shows a failure must never report 0 (xr-molecule-flash-m101 +25:54).
+  and a run whose tally shows a failure must never report 0.
 - `playwright test` with no `--reporter`, which runs the config's reporter —
   often `html`, which prints nothing per test. `--reporter=list` is added
   when the playwright run is the command's last step, piped or not: it writes each result as
@@ -3584,7 +3601,7 @@ function streamingBackgroundCommand(
 ```
 
 - `command` — The command as the executor sent it.
-- `context` — What the caller knows beyond the command: the tests the person's request excludes by name, and whether this command IS the platform's graded proof ({@link DiagnosisRunContext}). A `--grep-invert` of exactly those exclusions is the request's own scope, not a diagnosis, so it keeps the suite's retries on a deployed proof (xr-molecule-flash-m170 +33:16) — and a proof the platform itself composed and launched keeps them whatever its scope, targeted set included (xr-molecule-flash-l48 +26:35).
+- `context` — What the caller knows beyond the command: the tests the person's request excludes by name, and whether this command IS the platform's graded proof ({@link DiagnosisRunContext}). A `--grep-invert` of exactly those exclusions is the request's own scope, not a diagnosis, so it keeps the suite's retries on a deployed proof — and a proof the platform itself composed and launched keeps them whatever its scope, targeted set included.
 - `reportPath` — Where this run should write Playwright's standard `json` report, when the caller keeps one ({@link ./playwright-report.js}). The reporter is added to the run's own reporter set, never in place of one, and its output goes to that file through `PLAYWRIGHT_JSON_OUTPUT_FILE` — so the log, the executors' own reporters and every verdict stay exactly as they are. Omitted, or a run whose reporter set is not this function's to place (already names `json`, sets the variable itself, or whose runner cannot be located), leaves the command untouched and the result's `reportPath` unset.
 
 **Returns:** The command to run, one sentence per change made (empty when none), and the report path when one was actually wired — or `error` when the command starts the suite more than once.
@@ -3656,7 +3673,7 @@ function isSuiteRunCommand(command: string): boolean
 Refuse only a command made entirely of identical suite invocations.
 
 Mixed shell commands execute as written. Rebuilding their prefix or suffix can lose writes,
-break heredoc delimiters or turn an && guard into unconditional work (m277). Different args
+break heredoc delimiters or turn an && guard into unconditional work. Different args
 or environments may select different suites or targets; they are not known duplicates either.
 This is an optimization, so uncertainty always allows the original command.
 
@@ -3674,8 +3691,8 @@ A command with the supplied suite's own settings written back onto its runner as
 flags, and the flags that could not be placed.
 
 The grader walks the suite under its OWN budget, so a run whose runner config sets a different
-timeout or worker count measures a run the grader never sees (xr-molecule-flash-m169: a 60 s
-wrapper config produced a green local proof the official 15 s grader then failed). Playwright
+timeout or worker count measures a run the grader never sees (a 60 s wrapper config produced
+a green local proof the official 15 s grader then failed). Playwright
 lets a command-line flag win over every config file, so the suite's values are put on the
 runner's own arguments — written where {@link statementArgumentEnd} places them, never after a
 pipe, redirect or group closer. Only the command's LAST suite step is touched: that is the run
@@ -3733,7 +3750,7 @@ bound that was lifted.
 Used where the platform moves a run to the background: the executor wrote the bound to fit this
 tool's foreground ceiling, and in the background that ceiling no longer applies — the task is
 bounded by `wait_for_task` and the turn's deadline — so the prefix only kills the walk
-({@link withoutTimeoutWrapper}; X1 xr-molecule-flash-m143 +24:45).
+({@link withoutTimeoutWrapper}).
 
 ```typescript
 function withoutSuiteTimeout(command: string): { command: string; seconds: number | null }
@@ -3749,7 +3766,7 @@ Whether a command starts a Playwright run — a `playwright test` in command pos
 that runs something.
 
 `npx playwright test --list` matched every `\bplaywright\s+test\b` test in the platform and was
-then treated as a run: held (flash-m79's config check), backgrounded for a run that outlasts
+then treated as a run: held (a config check), backgrounded for a run that outlasts
 the tool's ceiling, and rewritten with `--reporter`. A list takes two seconds, prints its lines
 and exits, so it is none of those; {@link commandRunsNoTests} is what decides.
 
@@ -3785,8 +3802,8 @@ Where the suite runner's exit code comes from: the runner itself, or a stage pip
 code a finished run reports is its LAST pipeline stage's, so a stage after the runner makes the
 code the stage's — but only when such a stage EXISTS. The platform used to report "piped" for
 any run whose statements it could not place in the text, which one heredoc body was enough to
-cause: on X1 xr-molecule-flash-m105 (+08:12) a config written in the same `exec_command` made
-the run come back with no exit code at all, and the note under it claimed a stage after the
+cause: a config written in the same `exec_command` made the run come back with no exit code
+at all, and the note under it claimed a stage after the
 runner that was not there. The parse now places every statement (`locatedCommandSegments`), so
 "unplaced" is the rare, named case rather than a guess dressed as an answer.
 
@@ -3818,10 +3835,9 @@ Start a background suite run at lower CPU and IO priority, so the sandbox it
 shares with everything else stays responsive to what the executor does next.
 
 A whole-suite Playwright run saturates the one container the app's Vite
-server, its API process and every other command also live in: on X1 flash-m75
-the model backgrounded a 139-test run at +36:23 and the two-word shell
-command it sent next — tick its plan file — returned nothing for 2 min 40 s,
-measured on the chat payload and on the live-stream follower independently.
+server, its API process and every other command also live in: a backgrounded 139-test run
+has left the two-word shell command sent next — tick its plan file — returning nothing for
+2 min 40 s, measured on the chat payload and on the live-stream follower independently.
 The backgrounding note is right that the executor should go do other work;
 what it cannot promise is that the sandbox will let it.
 
@@ -3852,8 +3868,8 @@ Check if a command is blocked for security reasons. Returns error message or nul
 The first check reads the commands the shell actually RUNS — the statements, a `sh -c`
 string's body, and every command substitution ({@link executedCommands}) — so a `|` inside a
 quoted grep alternation is data, not a pipeline: `grep -E "USER CALLS|ENV|BUTTON|passed|failed"
-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, twice). What the
+app.log` prints log lines, and the `ENV` in its pattern starts nothing — a text
+match would block exactly that call as an environment dump, twice over. What the
 shell DOES run stays visible through the same walk: `ls | env`, `bash -c 'env'`,
 `echo "$(printenv)"` and a nested `sh -c 'x; env'` are all commands, and so is `env` itself
 when nothing follows it.
@@ -3887,8 +3903,7 @@ Whether a tool path points outside the project root once normalized (an
 absolute path elsewhere, or a `..` that climbs out). {@link resolvePath}
 clamps such a path to the root; a file tool must refuse it instead of
 answering about the root — a `list_files /tmp/x` used to return the
-workspace listing as if it were `/tmp/x` (X1 runs sonnet-m17 and sol-m05,
-2026-10-14).
+workspace listing as if it were `/tmp/x`.
 
 ```typescript
 function isOutsideRoot(path: string, projectRoot: string): boolean
@@ -3899,6 +3914,34 @@ function isOutsideRoot(path: string, projectRoot: string): boolean
 
 **Returns:** True when the path leaves the root.
 
+#### `commandStartsWithCdInto(command, directory, projectRoot)`
+
+Whether a command's FIRST statement already changes into `directory`.
+
+`exec_command` refuses a `cwd` outside the workspace, and that refusal tells
+the caller to drop `cwd` and start the command with `cd <path> && `. When the
+command ALREADY starts that way the advice describes what was just sent, so
+the command runs as written with the backend's working directory at the root
+instead (`{cwd: "/tmp", command: "cd /tmp && …"}` was refused with "start the command with
+`cd /tmp && `"; the same command resent with `cwd: "/workspace"` then passes).
+
+Only the leading statement counts, only when the shell's own parse puts it in
+the caller's shell — a `( cd … )` group or a `sh -c '…'` runs in its own
+directory and moves nothing — and only when it ends the way a following
+command needs (`&&`, `;`, a newline, or nothing after it). `cd … | cat` is a
+pipeline, so its `cd` runs in a subshell, and `&` backgrounds it: neither
+leaves the caller's directory changed.
+
+```typescript
+function commandStartsWithCdInto(command: string, directory: string, projectRoot: string): boolean
+```
+
+- `command` — The shell command as the tool received it.
+- `directory` — The `cwd` the caller asked for.
+- `projectRoot` — The project root a relative path is resolved against.
+
+**Returns:** True when the command's first statement `cd`s into `directory`.
+
 #### `isValidGlob(pattern)`
 
 Validate that a glob/include pattern is safe (no shell metacharacters that could
@@ -3929,8 +3972,8 @@ expanded pattern.
 Neither search tool expands braces itself: `grep --include` and `find` take
 the pattern as a single shell-quoted argument, so no shell ever sees it.
 `find_files {pattern:"*.{ts,tsx}"}` and `search_files {include:"*.{ts,tsx}"}`
-were both refused outright (xr-molecule-flash-m199 and m189), costing a round
-trip and pushing the agent to a narrower search. The group is expanded here
+were both refused outright, costing a round trip and pushing the agent to a narrower
+search. The group is expanded here
 instead — `search_files` passes one `--include` per alternative and
 `find_files` ORs one `-name`/`-path` predicate per alternative.
 
@@ -3953,8 +3996,8 @@ The `find` predicate for a `find_files` pattern.
 
 `find -name` compares a pattern against a file's BASENAME, so a pattern
 containing a slash (`helpers/*`, `e2e/*.spec.ts`, `src` + `**` + `/App.tsx`)
-can never match and the tool answers `[]` (xr-molecule-flash-m77, on two
-calls in one run). Such a pattern is matched with `-path` instead: an fnmatch
+can never match and the tool answers `[]` (twice in one run). Such a pattern is matched
+with `-path` instead: an fnmatch
 glob over the whole printed path, whose `*` crosses `/` — the rule
 `.gitignore` uses, and the reason a bare `helpers/*` means "a `helpers/`
 directory anywhere below the root". The pattern is anchored with a leading
@@ -3995,7 +4038,7 @@ function findPathArgs(pattern: string): string
 
 **Returns:** One or more `-path '…'` alternatives, ORed inside parens when there is more than one.
 
-#### `literalDirPrefix(pattern)`
+#### `literalDirPrefix(pattern, root)`
 
 The directory a GLOB pattern spells out, when it spells one out: everything
 before the pattern's first glob character, trimmed back to the last `/`.
@@ -4005,25 +4048,31 @@ anchor ({@link findPatternArgs}), so `find` visits every entry below the
 search root. Handed `/workspace/node_modules` and
 `@molecule/api-resource-user/dist/*.d.ts` — a directory named outright —
 `find` walked the sandbox's entire dependency tree and hit the tool's 10 s
-deadline without printing a result (xr-molecule-flash-m94: the one directory
-the model meant answered a `list_files` in 0 s). The literal prefix is that
+deadline without printing a result (the one directory the model meant answered a `list_files`
+in 0 s). The literal prefix is that
 directory, and rooting the search at it is what keeps the call instant.
 
 A BARE first segment (`helpers/*`, `bonds/*`, `e2e/*.spec.ts`) is NOT one:
 `helpers/*` means "a `helpers/` directory anywhere below the root", which the
-tool documents and a live run relied on (xr-molecule-flash-m77 — a path
-pattern is not anchored to one depth). Rooting those at
+tool documents and a live run relied on (a path pattern is not anchored to one depth).
+Rooting those at
 `<root>/helpers` would answer with a SUBSET, silently: the nested
 `api/src/helpers/` matches would disappear, and a missing file reads as
 "no such file". So a prefix is returned only when it names a path of two or
 more segments (`@molecule/api-resource-user/dist`), which is the shape that
 is a directory rather than a directory name.
 
+An npm SCOPE as the first segment, under a `node_modules` root, is the one
+exception that parameter `root` enables: npm installs a scope only directly
+
+_(description truncated — read the full text in `node_modules/@molecule/api-ai-tools/dist/utilities.d.ts`.)_
+
 ```typescript
-function literalDirPrefix(pattern: string): string | null
+function literalDirPrefix(pattern: string, root?: string): string | null
 ```
 
 - `pattern` — A pattern already accepted by {@link isValidGlob}.
+- `root` — The resolved search root, when one is already known; a scope-first prefix is returned only when this ends in a `node_modules` segment (and the pattern has more path after the scope).
 
 **Returns:** The literal directory prefix, without a trailing slash, or null when the pattern has no glob character, no `/`, or only a bare name before one.
 
@@ -4035,7 +4084,7 @@ The E2B SDK answers a timed-out `exec` with its generic text —
 `[deadline_exceeded] the operation timed out: … It can be modified by passing
 'timeoutMs' when making the request. Use '0' to disable the timeout.` — which
 names an option the executor cannot set and says nothing about the search
-that died. Handing that sentence to the model is what xr-molecule-flash-m94
+that died. Handing that sentence to the model is what a run
 read after `find_files` spent 10 s walking `node_modules`; the tool answers
 the deadline in its own words instead (see {@link searchTimeoutError}).
 
@@ -4096,8 +4145,8 @@ shape a truncated provider stream leaves behind.
 
 The path message is the wrong reading of it: "requires a non-empty path
 argument" says the call was understood and the path was left out, so the model
-retries the call it just made instead of sending the whole call again (x0
-flash-m83 +29:32: `edit_file {}`, one round lost). An empty object and a
+retries the call it just made instead of sending the whole call again (`edit_file {}` loses
+one round). An empty object and a
 missing `path` are different failures and deserve different sentences.
 
 ```typescript
@@ -4262,9 +4311,8 @@ The shell command whose stdout is the interesting part of a log that is still be
 the failure lines so far (capped at {@link RUNNING_FAILURE_LINES}), then the end of the log.
 
 A Playwright `list` run prints one line per test as it finishes, so the LAST bytes of a running
-log are its least informative part — in X1 flash-m61 the last 3 000 bytes of a 139-test walk
-were the skip list, and all 61 failures were above them, which cost the run the grep it had to
-make anyway. A background run also carries each failure's own error as it fails
+log are its least informative part — the last 3 000 bytes of a 139-test walk are the skip
+list, and all 61 failures were above them, which costs the run the grep it has to make anyway. A background run also carries each failure's own error as it fails
 ({@link PLAYWRIGHT_FAILURES_INLINE_ENV}), and {@link RUNNING_FAILURE_LINE_RE} already matches
 those blocks' headers and their `Error:` lines, so this slice shows the causes too.
 
@@ -4302,11 +4350,11 @@ function runningCauseCommand(log: string, own?: string): string
 The shell command whose stdout is a bounded CONTIGUOUS read of a running task's own log: the
 log's byte size, then its last {@link RUNNING_LOG_READ_BYTES} bytes.
 
-{@link runningOutputSliceCommand} is the wrong read for a diagnosis, and l07 is the finding: it
+{@link runningOutputSliceCommand} is the wrong read for a diagnosis: it
 stitches the first 40 grep-selected failure lines to the last 1 000 bytes with a blank line
 between, so the tail is DISJOINT from the headers above it. Read as one log, the last numbered
-header absorbs whatever the tail starts with — a clipped skipped-test title became the cause of
-a genuine failure (xr-molecule-flash-l07). A contiguous window can only ever hold real
+header absorbs whatever the tail starts with — a clipped skipped-test title becomes the cause
+of a genuine failure. A contiguous window can only ever hold real
 neighbouring lines of one log.
 
 The size rides along so a caller can say when the window is only the log's end
@@ -4350,11 +4398,12 @@ log does NOT carry.
 
 Either way the point is the same: a suite whose failures repeat one cause spends its whole
 runtime proving that one cause, and the executor watching it can be told so at the third
-failure instead of at the last. X1 flash-m76 walked 15 tests in 4.0 minutes where 15.6 s
+failure instead of at the last. Fifteen tests walked in 4.0 minutes where 15.6 s
 each was the test timeout and one missing `navigate('/')` was the cause of all of them.
 
 The quorum is of DISTINCT tests — {@link REPEATING_FAILURE_MIN} of them — because a log that
-prints each failure twice (a second reporter, a retry) had X1 flash-m83 told that four of its
+prints each failure twice (a second reporter, a retry) has told a run that four of its
+tests failed the same way when two had, so the executor stopped a 139-test walk at test 21
 
 _(description truncated — read the full text in `node_modules/@molecule/api-ai-tools/dist/utilities.d.ts`.)_
 
@@ -4366,7 +4415,7 @@ function repeatingFailure(log: string): RepeatingFailure | null
 
 **Returns:** The repeating cause, or null when no signature has {@link REPEATING_FAILURE_MIN} distinct tests behind it.
 
-#### `logShowsInlineFailureBodies(log, excluded)`
+#### `logShowsInlineFailureBodies(log, excluded, options)`
 
 Whether the log read so far carries a failure's own body under a `✘` row — the evidence that a
 run prints each failure's error as that test fails ({@link PLAYWRIGHT_FAILURES_INLINE_ENV}).
@@ -4386,17 +4435,23 @@ is one the reporter printed inline.
 A body for a test the request EXCLUDES is not that evidence: its failure does not count for
 this request ({@link matchingExcludedTitles}), so a wait that handed it over as the diagnostic
 spent a model round trip and 8 k of partial log on a test the same result says to ignore —
-exactly what xr-molecule-flash-h13 (+19:06) did twice while the platform's proof was still
-walking.
+which a run has done twice while the platform's proof was still walking.
+
+With `finalOnly`, only a failure the run has FINISHED with counts; a pending retry waits.
 
 ```typescript
-function logShowsInlineFailureBodies(log: string, excluded?: readonly string[]): boolean
+function logShowsInlineFailureBodies(
+  log: string,
+  excluded?: readonly string[],
+  options?: { finalOnly?: boolean; noRetries?: boolean },
+): boolean
 ```
 
 - `log` — A log, or the slice of one a wait reads.
 - `excluded` — The test titles the request carves out, if the caller knows them.
+- `options` — `finalOnly` reads only a failure the run has finished with; `noRetries` says the command proves the run cannot retry (`--retries=0`), so its first failure is final.
 
-**Returns:** True when a `✘` row's own test, outside the request's exclusions, has a failure body under it.
+**Returns:** True when a `✘` row's own test, outside the request's exclusions, has a failure body under it — and, with `finalOnly`, that failure is final in the log read so far.
 
 #### `specFilesSelected(command)`
 
@@ -4404,8 +4459,8 @@ How many test FILES a Playwright run's own command narrows it to, or null when i
 whole suite (or its selection cannot be read).
 
 {@link universalCause}'s file threshold is written for a whole-suite run, which a narrowed run
-can never reach. xr-molecule-flash-m119 (+42:08) re-ran ONE spec file against a hand-started
-`vite preview` the browser could not reach, and every test in it failed `page.goto: Timeout` —
+can never reach. A run that re-ran ONE spec file against a hand-started `vite preview` the
+browser could not reach had every test in it fail `page.goto: Timeout` —
 but one file is below {@link UNIVERSAL_CAUSE_FILES}, so the wait sat out its entire 280 s
 budget on a run that had already measured all it could.
 
@@ -4432,7 +4487,7 @@ The test is: the cause accounts for every failure the log names, it has hit the
 threshold, and nothing has passed since its first failure. The threshold is
 {@link UNIVERSAL_CAUSE_FILES} for a whole-suite run but the number of files the command
 SELECTED for a narrowed one ({@link specFilesSelected}): a one-file run can never span three,
-and xr-molecule-flash-m119 (+42:08) waited out its whole budget on exactly that shape. An app
+and a run can wait out its whole budget on exactly that shape. An app
 that is not up, a 5xx on every request, or a selector that is missing on every page all look
 like that, and every remaining test will fail the same way — so the run's remaining minutes
 measure nothing. A CONNECTION-class cause ({@link CONNECTION_CAUSE}) needs no file span at all:
@@ -4441,8 +4496,8 @@ case however few files the run walks.
 
 Anything less is NOT this: a cause that stops at one file of a multi-file run, or that leaves
 other tests passing, or that shares the run with failures of another shape, leaves the run with
-something to say, and the run is the only thing that will say it. X1 flash-m83 (2026-10-16)
-stopped eight local runs at their first repeating cause over 14.5 minutes and never finished
+something to say, and the run is the only thing that will say it. Stopping runs at their first
+repeating cause has burned eight local runs over 14.5 minutes without finishing
 one; three of its deploys each fixed a single cause that a finished run would have listed
 alongside the others.
 
@@ -4471,16 +4526,17 @@ Both halves are load-bearing, each of them learned from a run that lost minutes
   spec-file threshold — {@link UNIVERSAL_CAUSE_FILES}, or the files a narrowed run's own
   command selects, or {@link CONNECTION_CAUSE_TESTS} tests of an app that never answered — with
   nothing passing since the first. That is the
-  dont-stop-runs rule. X1 flash-m83 (2026-10-16) stopped eight local runs at their first
-  repeating cause in 14.5 minutes and never finished one, and a run that still has other causes
+  dont-stop-runs rule. Stopping runs at their first repeating cause has burned eight local
+  runs in 14.5 minutes without finishing one, and a run that still has other causes
   left to name is the only thing that will name them.
 - **A PROVEN cause** is an error repeated VERBATIM. A shared DURATION is a LEAD, never a cause:
   a suite whose config sets a timeout spends that timeout on every failure that waits for
   anything, so three unrelated tests timing out together look exactly like one broken run
-  (`~7 s` is a property of the CONFIG, not of the cause — {@link normalizedSignature}). X1
-  xr-molecule-flash-m99 (2026-10-16) was told `status: 'repeating_failure'` twice on that
+  (`~7 s` is a property of the CONFIG, not of the cause — {@link normalizedSignature}). A run
+  told `status: 'repeating_failure'` twice on that
   shape — three `url-navigation.spec.ts` tests at ~16.2 s, one `timeout: 15_000` plus teardown
   — read the early return as "stop waiting, edit now", and voided a run that was still walking;
+  the second cost a 224 s wait that ended with no result at all.
 
 _(description truncated — read the full text in `node_modules/@molecule/api-ai-tools/dist/utilities.d.ts`.)_
 
@@ -4505,12 +4561,11 @@ The request quotes a test's own title (`… except "should require login to post
 extracted by molecule-dev's `excludedTestTitles`) while a run's heading carries more of it
 (`comments.spec.ts › Comments › should require login to post comment`), so containment is the
 comparison. Whitespace is normalised and case is ignored: a brief may wrap the title across a
-line (`xr-molecule-flash-m44`), and the reporter's own casing never has to match the brief's.
+line, and the reporter's own casing never has to match the brief's.
 
 Two readers used to answer this separately — the causes note (which therefore asked the
 executor to fix a test the same result said not to) and molecule-dev's exclusion notes — and
-xr-molecule-flash-m101 paid for the gap (+12:00: a turn and an edit spent on the excluded
-test).
+a run paid for the gap (a turn and an edit spent on the excluded test).
 
 ```typescript
 function matchingExcludedTitles(heading: string, excluded: readonly string[]): string[]
@@ -4528,7 +4583,7 @@ tests it hit.
 
 The point is that ONE run yields EVERY cause. A Playwright report prints its failures one
 after another with no statement of which of them share a cause, so a run of 19 failures is 19
-bodies to read; X1 flash-m83 (2026-10-16) spent three deploys (6.7 minutes) each fixing a
+bodies to read; three deploys (6.7 minutes) each fixed a
 single cause, two of them found by runs stopped before they walked the rest.
 
 The signature is the cause itself where the log carries the failures' bodies (a finished run, a
@@ -4540,8 +4595,8 @@ proven cause. A test the log printed twice, or failed twice, is one test.
 A test the request EXCLUDES by name is not a cause to fix: its failure does not count for
 this request ({@link matchingExcludedTitles}), so it is dropped here rather than handed to the
 executor as work — a result that names it beside "it does not count" is the contradiction
-xr-molecule-flash-m101 filed (+12:00: the model spent a turn and an edit on the excluded test,
-on a page that was passing).
+a run filed (the model spent a turn and an edit on the excluded test, on a page that was
+passing).
 
 ```typescript
 function failuresByCause(log: string, excluded?: readonly string[]): FailureCause[]
@@ -4570,7 +4625,7 @@ function requiredLandmark(selector: string): RequiredLandmark | null
 The sentence for a run whose navigational elements are all missing from pages that otherwise
 painted — the missing shared header the executor must check BEFORE rewriting auth.
 
-xr-molecule-flash-m193 (+13:54 → +20:00): four failures on `/` — `a[href="/profile/…"]`,
+A run had four failures on `/` — `a[href="/profile/…"]`,
 `a.navbar-brand`, `nav a[href="/"]`, `nav .user-pic` — while every `error-context.md` snapshot
 showed the feed, sidebar and footer with no navigation at all. `Home.tsx` imported and
 re-exported `Navbar` but never rendered it, and `App.tsx` mounted `<Home />` in a bare route.
@@ -4664,7 +4719,7 @@ function rerunOfRunningSuite(
 ): string | null
 ```
 
-- `run` — The run in flight: the command it was started with, as it was run, the directory that command ran in, the config it loaded when the caller knows it, and the settings the request required and the run left out (`env`) — the re-run carries them, so it never reproduces the configuration the run was measured under by mistake (m182).
+- `run` — The run in flight: the command it was started with, as it was run, the directory that command ran in, the config it loaded when the caller knows it, and the settings the request required and the run left out (`env`) — the re-run carries them, so it never reproduces the configuration the run was measured under by mistake.
 - `locations` — The failing `file:line`s to re-run, as the run's log printed them.
 - `excluded` — The test titles the request carves out: the re-run inverts them out (`--grep-invert`) so it cannot report them again.
 
@@ -4681,17 +4736,18 @@ tests, so the note never names one or two tests as a cause.
 The note names the cause early so the executor can START FIXING while the run keeps walking,
 and it hands a stop command over only when {@link earlyReturnCause} says so — the SAME
 predicate the wait uses to decide whether to return early, so a finding the wait keeps waiting
-on is a finding this note never asks to stop for. X1 flash-m76 (2026-10-16) spent 4.0 minutes
+on is a finding this note never asks to stop for. One run spent 4.0 minutes
 walking 15 tests whose one cause was certain at the third, 47 s in, and the note answers
-exactly that; X1 flash-m83 then stopped eight runs at their first repeating cause in 14.5
+exactly that; another stopped eight runs at their first repeating cause in 14.5
 minutes and never finished one, so the note must not say to stop when the run still has other
-causes to name. X1 xr-molecule-flash-m99 (2026-10-16) is the third shape: a shared duration is
+causes to name. The third shape: a shared duration is
 not a cause at all, so a lead reaches the executor as a note on a result it is still waiting
 for — never as a verdict with a stop command in it.
 
 The run is STILL WALKING while this note is written — both callers produce it mid-run — so a
 re-run of one of its tests is a second run against the same app and database, and the platform
 refuses that ({@link suiteRunInTheWay}, the same rule its overlap hold answers with):
+an executor read *"Start on them now, while the run keeps walking.
 
 _(description truncated — read the full text in `node_modules/@molecule/api-ai-tools/dist/utilities.d.ts`.)_
 
@@ -4893,7 +4949,7 @@ Python WSGI server. Matched against a command segment's own text, and against a
 when the command only names the script file — but NEVER against an inline program's code
 (`node -e …`, `python3 -c …`), where this text is the user's program rather than a file being
 run: `require('…/node_modules/vite')` imports a module, it does not start a dev server
-(xr-molecule-flash-m391 +13:13, refused as "node starts a server" for exactly that line).
+(refused as "node starts a server" for exactly that line).
 
 ```typescript
 const SERVER_PROGRAM: RegExp
@@ -4947,14 +5003,13 @@ The closing advice on an over-budget message for a command that IS a suite run
 (Playwright, Vitest, a `hurl` run — {@link isSuiteRunCommand}): its files are not
 a bigger unit to break up.
 
-X1 flash-m36 asked for this half and the message kept saying "run a smaller unit"
-for two months. It is the wrong direction for a suite, and measurably: a run
-stopped here reports NO tally, so nothing in the result says which test or request
-hung — the run has to be sent again in the background (off this budget, its output
-written to a log that can be read mid-run) or, when a consumer knows the runner's
-per-request limit, with each request bounded. xr-molecule-flash-m93 (+06:22,
-2026-10-16) lost 4.8 minutes to a Hurl run whose ONE unanswered request had hurl's
-300 s default per request holding the file, ten seconds past this tool's budget.
+The wrong advice here is "run a smaller unit": it is the wrong direction for a
+suite, and measurably so — a run stopped here reports NO tally, so nothing in
+the result says which test or request hung. The run has to be sent again in the
+background (off this budget, its output written to a log that can be read
+mid-run) or, when a consumer knows the runner's per-request limit, with each
+request bounded. One Hurl run lost 4.8 minutes to a single unanswered request
+held by hurl's 300 s default per request, ten seconds past this tool's budget.
 
 ```typescript
 const SUITE_OVER_BUDGET_ADVICE: string
@@ -5021,7 +5076,7 @@ const MAX_TRACE_NOTE_REQUESTS: 4
 
 How many times ONE test may send the same method+path before the note calls it a render loop.
 
-xr-molecule-flash-m215 (+27:27 → +29:42): an Editor effect with `[seeded, slug, t]` in its
+An Editor effect with `[seeded, slug, t]` in its
 dependency list re-fetched `GET /api/articles/<slug>` 2,106 times in one test. The trace reader
 caps and de-duplicates its request list, so the note printed four identical `→ 200` lines and
 the run patched the component's seeding, rebuilt and re-ran before unzipping the trace by hand.
@@ -5085,8 +5140,8 @@ reporter still prints each failure exactly once.
 Every background command is given this (see {@link streamingBackgroundCommand}), so a suite the
 executor starts through its own wrapper is covered too — the wrapper passes the environment on
 to the Playwright process it spawns. Without it the log's only failure lines are `✘` rows:
-X1 xr-molecule-flash-m99 (+19:27 → +21:00, 2026-10-16) was told to `grep -n -A 20 '<test name>'`
-the log, got nothing back through four greps, inferred causes from the spec prose instead, and
+A run told to `grep -n -A 20 '<test name>'` the log got nothing back through four greps,
+inferred causes from the spec prose instead, and
 edited `app/src` while the run was still walking — which voids the run.
 
 ```typescript
@@ -5171,9 +5226,8 @@ place, keeping ~30 KB of each end. A batched read that crossed it lost its
 MIDDLE — the cut lands between two `"content"` values, so whole files fell
 out and the note in their place said only "N characters cut here" — while
 this tool's own note had promised each of those files that it "fits in one
-call, so it is not paged": X0 flash-m81 (2026-10-16) read ten e2e specs in
-one call (121,467 chars), lost the middle six, and bought them again in six
-further calls (52,908 chars).
+call, so it is not paged": one batched read of ten e2e specs (121,467 chars) lost the
+middle six and bought them again in six further calls (52,908 chars).
 
 So the CALL gets the ceiling the request gives it. Whole files are returned
 up to it; the paths that did not fit are named in `note` and listed in
@@ -5220,7 +5274,7 @@ const MAX_READ_RETURN_CHARS: number
 
 A file this small is returned whole on a second window of it (paging it costs a call each).
 The same bound as {@link MAX_READ_RETURN_CHARS}: the windowed-read note promises that a
-file under it "fits in ONE call", and a smaller bound here broke that promise (X1 flash-m67).
+file under it "fits in ONE call", and a smaller bound here breaks that promise.
 
 ```typescript
 const SMALL_FILE_WHOLE_CHARS: number
@@ -5235,11 +5289,11 @@ an HTML read is almost never worth it.
 An entry document is boilerplate the reader rarely needs in full: meta tags,
 stylesheet and preload links, a `<style>` block, and a handful of `<script>`
 tags. The parts an executor acts on — the body's structure, where a script is
-loaded — are all visible in an outline of one line per tag. X0 flash-m77 paid
-63,735 chars for one such read: ~60 KB of it was the IDE's own preview bridges,
+loaded — are all visible in an outline of one line per tag. One such read paid
+63,735 chars: ~60 KB of it was the IDE's own preview bridges,
 and the read pushed the transcript past its context cap, so the e2e specs the
 executor had just read were trimmed to summaries and it read the whole suite
-again — twice (findings, +01:23 and +02:56). The scaffold now keeps those
+again — twice. The scaffold now keeps those
 bridges in separate files, but a template's own head is still ~5-12 KB, and a
 static-site or SSR entry can be far more.
 
@@ -5369,8 +5423,8 @@ const TOOL_RESULT_CHARS: 8000
 
 #### `FAILURE_CAUSES_CHARS`
 
-The characters a finished run's cause list may use of {@link TOOL_RESULT_CHARS}. The recap
-measured by xr-molecule-flash-m102 (+12:43) was `12 failures, 8 causes`: one cause line is
+The characters a finished run's cause list may use of {@link TOOL_RESULT_CHARS}. A measured
+recap was `12 failures, 8 causes`: one cause line is
 ~200 chars and ~80 more with its two body lines, so 8 causes is ~2.3 k against the 8 k cap —
 the old 5-cause cap withheld 3 causes that the same result had room for.
 
@@ -5420,7 +5474,7 @@ How many tests a run must have walked — with nothing passing since its first f
 THREE, and the number is the cost of the alternative. The old floor of 15 was chosen when the
 reading was only offered at a completed run; once it STOPS the walk, every test waited for is
 a test whose result is thrown away, and a blank page costs its per-test budget each time
-(m177: 18 tests, ~4.2 minutes, on a page whose thrown error was visible in the first
+(18 tests, ~4.2 minutes, on a page whose thrown error was visible in the first
 `pageerror`). Three is the smallest count that is not one page's own bug: the cause additionally
 needs three DISTINCT spec files (`UNIVERSAL_CAUSE_FILES`, or the files a narrowed run selected),
 no failure showing a locator RESOLVING ({@link ELEMENT_FOUND} — a blank page cannot resolve
@@ -5482,7 +5536,7 @@ Peer dependencies:
   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
@@ -5508,7 +5562,7 @@ Peer dependencies:
   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`).