@mjasnikovs/pi-task 0.38.29 → 0.38.30

package/dist/task/batch-test-task.js

@@ -1,31 +1,25 @@
 /**
  * batch-test-task — ban the whole-project "write all the tests" task when the
- * DECISIONS channel mandates tests-in-the-same-change (mx5 run 14, PROMPT item 6).
+ * DECISIONS channel mandates tests-in-the-same-change.
  *
- * The failure this closes: run 14's plan contained
+ * The failure this closes: a plan carrying one enormous title like "Write
+ * component and page tests — with screenshot baselines for all components and
+ * pages", which cannot converge, while the decision carried ON THAT TITLE says
+ * the opposite — that a test lands in the same change as each new route or
+ * component, and testing is not batched to the end of a milestone.
  *
- *   TASK_0037  "Write component and page tests — Playwright CT tests with
- *               screenshot baselines for all components and pages"
+ * Decompose did not invent the shape; it mirrors a spec whose own milestone
+ * structure induces it. So the conflict is SPEC-INTERNAL — the spec's structure
+ * against the spec's own cadence rule — and the decisions channel OVERRIDES the
+ * spec doc by definition, the same precedence the task titles already state.
+ * Resolve toward the decision; never ask the user.
  *
- * — ~4.7h, the worst active-time task of the run, ended in a yolo-accepted verify
- * FAIL with a frozen-config violation — while the very decision carried ON THAT
- * TITLE said the opposite:
- *
- *   "a test lands *as fast as possible* — in the same change — as each new route
- *    or React component/page. No route or component is considered done until its
- *    test exists and passes. Don't batch testing to the end of a milestone."
- *
- * Decompose did not invent the shape: the spec's own §10/§12 structure induced it,
- * and decompose mirrors the spec. So the conflict is SPEC-INTERNAL (the spec's
- * milestone shape vs the spec's own cadence rule), and the decisions channel
- * OVERRIDES the spec doc by definition — the same precedence the task titles
- * already state. Resolve toward the decision; never ask the user.
- *
- * The mechanism is a deterministic post-decompose rewrite (applied on EVERY
- * decompose output, like fidelity reconciliation), plus a conditional prompt rule
+ * The mechanism is a deterministic post-decompose rewrite, applied on every
+ * decompose output like fidelity reconciliation, plus a conditional prompt rule
  * as the belt. Only the batch-EVERYTHING shape is banned — coverage is never
- * nuked (run 12's lesson). Which of the two outcomes fires is decided by
- * `groundedCoverage`, not by wording:
+ * nuked. Which of the two outcomes fires is decided by `groundedCoverage`, not by
+ * wording, and holding the title fixed while changing only the requirement
+ * switches it:
  *
  *   • the batch title grounds NO requirement that survives its removal ⇒ every
  *     requirement it touched is owned by some other task, the per-change cadence
@@ -41,8 +35,12 @@
 import { groundedCoverage } from './coverage-loop.js';
 /**
  * Sentences that MANDATE tests landing with the change they cover. Deliberately
- * narrow: a spec that merely REQUIRES tests ("every route has tests") does not
- * ban a batch task — only an explicit cadence/anti-batch directive does.
+ * narrow: a spec that merely REQUIRES tests does not ban a batch task — only an
+ * explicit cadence or anti-batch directive does. Run: "every route has tests"
+ * does NOT mandate, while "a test lands in the same change as each new route",
+ * "never batch tests" and "a route is not considered done until its test exists"
+ * all do. That last alternative needs the literal word "not" — a sentence phrased
+ * "NO route is considered done until…" does not match it on its own.
  */
 const SAME_CHANGE_RE = /\bin the same (?:change|commit|pr|patch|diff|task|step)\b|\b(?:do ?n['’]?t|do not|never|no)\s+(?:batch|defer|postpone|save|leave)\b|\bnot\b[^.]{0,60}\bdone until\b[^.]{0,60}\btest/i;
 /** Any mention of testing — the mandate must be ABOUT tests, not about docs. */
@@ -50,11 +48,12 @@ const TEST_WORD_RE = /\btests?\b|\btesting\b|\btest-first\b/i;
 /**
  * Does the decisions/spec text mandate tests-in-the-same-change?
  *
- * Scans sentence by sentence and requires BOTH signals in the SAME sentence, so
- * a testing section that happens to sit near an unrelated "don't defer" line
- * cannot trigger the ban. `decisions` is checked first and alone is sufficient;
- * the spec is scanned too because run 14's cadence rule is stated in §10 of the
- * doc and only echoed into the decisions channel.
+ * Scans sentence by sentence and requires BOTH signals in the SAME sentence, so a
+ * testing section that happens to sit near an unrelated "don't defer" line cannot
+ * trigger the ban — confirmed, "Don't defer the docs. Every route has tests."
+ * returns false. `decisions` is checked first and alone is sufficient; the spec is
+ * scanned too, and a mandate found only there is enough, because a cadence rule is
+ * often stated in the doc body and only echoed into the decisions channel.
  */
 export function mandatesTestsInSameChange(decisions, spec = '') {
     for (const text of [decisions, spec]) {
@@ -70,13 +69,13 @@ export function mandatesTestsInSameChange(decisions, spec = '') {
 const DECISIONS_CLAUSE_RE = /\s*\[decisions:/i;
 /**
  * Where decompose's trailing metadata starts. `[source: …]` is included because
- * reconcileTitleSources only strips a WELL-FORMED trailing citation: measured
- * live, the model also emits `[source: "…" [10. Testing]]`, which fails that
- * regex and leaks the QUOTED SPEC LINE into the title. Judging scope on such a
- * title reads the citation's words as the task's own — the cadence quote "…as
- * each new route or React component/page" made a properly scoped
- * "Write route/API tests for auth" look like a batch task (live false positive,
- * rep 1). A citation is provenance, never scope.
+ * reconcileTitleSources only strips a WELL-FORMED trailing citation. Confirmed by
+ * running it: `[source: "…"]` is stripped, while `[source: "…" [10. Testing]]`
+ * comes back untouched, leaking the QUOTED SPEC LINE into the title. Judging scope
+ * on such a title reads the citation's words as the task's own, so a cadence quote
+ * about "each new route or React component/page" makes a properly scoped "Write
+ * route/API tests for auth" look like a batch task. A citation is provenance,
+ * never scope.
  */
 const CLAUSE_START_RE = /\s*\[(?:source|decisions)\s*:/i;
 /** Split a title into the part decompose authored, and the `[decisions: …]` tail
@@ -99,10 +98,10 @@ function head(body) {
  * scope. Measured live: the model frequently appends its citation as a bare
  * quote with no `[source: …]` wrapper ("Write auth route tests — … — "…a test
  * lands as fast as possible — in the same change — as each new route or React
- * component/page.""), and that borrowed "each" made five correctly scoped
- * per-area test tasks read as batch tasks (rep 5). Trading a possible miss (a
- * batch title whose only quantifier sits inside a quote) for never deleting a
- * properly scoped test task: the false positive is far the more expensive error.
+ * component/page.""), and that borrowed "each" makes a correctly scoped per-area
+ * test task read as a batch task. Trading a possible miss — a batch title whose
+ * only quantifier sits inside a quote — for never deleting a properly scoped test
+ * task: the false positive is far the more expensive error.
  */
 function stripQuotedSpans(s) {
     return s.replace(/"[^"]*"/g, ' ').replace(/[“][^”]*[”]/g, ' ');
@@ -127,19 +126,19 @@ const MIN_ECHO_CHARS = 40;
 /**
  * Drop detail segments that are VERBATIM spec text.
  *
- * Third variant of the same failure, and the one the syntactic defenses miss:
- * measured live (rep 4, Qwen3.6-27B on the mx5 fixture), the model appended its
- * citation as BARE PROSE — no quotes, no `[source: …]` wrapper — and then
- * repeated it inside a `[source: "…"]` clause:
+ * Third variant of the same failure, and the one the syntactic defenses miss: the
+ * model appends its citation as BARE PROSE — no quotes, no `[source: …]` wrapper —
+ * and may then repeat it inside a `[source: "…"]` clause:
  *
  *   "Implement Login page with phone/password form and tests — **Client/UI:**
  *    Playwright `1.61.1` React component tests … — every component/page test
  *    captures a screenshot committed as a baseline. [source: "…"]"
  *
  * `stripQuotedSpans` sees no quotes and `splitDecisions` cuts only at the clause,
- * so the borrowed "every component/page" survived as if it were the task's own
- * scope, and a correctly per-change-scoped Login task was DROPPED — the exact
- * deletion this module exists to avoid.
+ * so the borrowed "every component/page" survives as if it were the task's own
+ * scope and a correctly per-change-scoped Login task is DROPPED — the exact
+ * deletion this module exists to avoid. Demonstrated by running that title both
+ * ways: WITHOUT the spec it is flagged as a batch task, WITH the spec it is kept.
  *
  * The general rule the two earlier guards were reaching for: text the title shares
  * verbatim with the spec is provenance, whoever failed to mark it as such. So the
@@ -175,12 +174,13 @@ const TEST_INFRA_RE = /\b(?:harness|infrastructure|infra|runner|config|configura
  * WHOLE-PROJECT scope: a universal quantifier that governs a PROJECT-LEVEL target
  * ("all components and pages", "every route"), not merely any noun.
  *
- * Both halves are load-bearing, each learned from a live false positive:
+ * Both halves are load-bearing:
  *   - "full"/"complete" are excluded — they routinely scope a single area
  *     ("full login flow");
- *   - the quantifier must reach a project-level plural within ~20 chars, because
- *     "Test PartCard component — ALL badge combinations…" is a one-component task
- *     that a bare-quantifier rule flagged and DROPPED (live rep 3).
+ *   - the quantifier must reach a project-level plural within a short span, so
+ *     "Test PartCard component — ALL badge combinations…" stays a one-component
+ *     task. Confirmed: that title is NOT flagged, while "…for all components and
+ *     pages" is.
  */
 const WHOLE_SCOPE_RE = /\b(?:all|every|each|entire|whole|comprehensive)\b[\w\s,/-]{0,20}?\b(?:components?|pages?|routes?|endpoints?|screens?|views?|modules?|layers?|files?|features?|app|application|project|codebase|repo|repository|system|surface)\b|\bacross the (?:app|application|project|codebase|repo|repository)\b|\bend[- ]to[- ]end coverage\b/i;
 /**
@@ -218,9 +218,11 @@ const TEST_COMMAND_RE = /\b(?:bun test|npm (?:run )?test|yarn test|pnpm (?:run )
  * The spec's own coverage source — the command whose report scopes the sweep.
  *
  * Only backticked spans are considered, so the result is a command the spec
- * actually writes down rather than a phrase inferred from prose; a span carrying
- * a coverage flag wins over a plain test run. Falls back to a generic phrase when
- * the spec names no command, which keeps the sweep title well-formed either way.
+ * actually writes down rather than a phrase inferred from prose: a plain-prose
+ * "bun test" is ignored and falls through to the generic phrase. A span carrying a
+ * coverage flag wins over a plain test run — a spec naming both `bun test` and
+ * `bun test --coverage` yields the latter. The fallback keeps the sweep title
+ * well-formed when the spec names no command at all.
  */
 export function coverageSourceFromSpec(spec) {
     const spans = [...spec.matchAll(/`([^`\n]+)`/g)].map(m => m[1].trim());
@@ -233,9 +235,9 @@ export function coverageSourceFromSpec(spec) {
  * carries NO ownership signal here. Without this scrub the bare token "test"
  * connects a screenshot-baseline requirement to "Write auth route tests", and the
  * orphan check goes blind. (Scrubbed locally rather than added to
- * COVERAGE_STOPWORDS: those govern the A/B-validated monotonic adoption guard,
+ * COVERAGE_STOPWORDS: those govern the monotonic adoption guard,
  * where "test" IS a discriminating noun for a plan that has no testing task at
- * all.) Token-level, not regex — `mx5_test` must scrub to `mx5`.
+ * all.) Token-level, not regex — `myapp_test` must scrub to `myapp`.
  */
 const GENERIC_TEST_TOKENS = new Set([
     'test',
@@ -327,15 +329,20 @@ export function buildSweepTitle(orphaned, coverageSource) {
  * Rewrite a decomposed plan so it carries no whole-project batch test task when
  * the decisions mandate tests-in-the-same-change.
  *
- * No mandate, or no batch title ⇒ the plan is returned untouched (identity), so
- * every non-cadence run behaves exactly as before.
+ * No mandate, or no batch title ⇒ the plan is returned untouched, with no actions,
+ * so every non-cadence run is unaffected. Both identity paths run as described.
  *
  * With a mandate, ALL batch titles are removed at once before coverage is
  * re-measured — otherwise two batch tasks would each mask the other's orphans and
  * both would look droppable. The orphaned set is then whatever grounded coverage
  * the removal costs; it is non-empty only when no other task's title claims that
- * requirement, and it becomes the sweep's scope. At most ONE sweep is emitted (in
- * the first batch title's position, so plan order is preserved).
+ * requirement, and it becomes the sweep's scope. At most ONE sweep is emitted, in
+ * the first batch title's position, so plan order is preserved.
+ *
+ * Run on the SAME batch title twice, changing only the requirement list: when
+ * another task grounds the requirement the title is DROPPED, and when the batch
+ * title is its only owner it is SCOPED into a sweep naming that quote and the
+ * spec's own coverage command. Any `[decisions: …]` tail rides onto the sweep.
  */
 export function rewriteBatchTestPlan(titles, decisions, spec, requirementQuotes, isCrossCutting) {
     if (!mandatesTestsInSameChange(decisions, spec))

package/dist/task/boot-probe.d.ts

@@ -3,9 +3,9 @@ import { type DeepRenderOutcome } from './deep-render-check.js';
 import type { HealthCommand } from './repo-health-check.js';
 /**
  * Why this script is NOT a launch of the shipped app, or null when it plausibly
- * is one (mx5 run 18, validated).
+ * is one.
  *
- * Run 18's boot command resolved to `bun run dev`, whose body is
+ * A boot command can resolve to `bun run dev`, whose body is
  * `docker compose -f docker-compose.dev.yml up -d && until docker compose … pg_isready
  * … && concurrently "bun run dev:css" "bun run dev:js" "bun run --watch
  * src/server/index.ts"`. The gate sandbox has no docker, so the chain died at 127 and
@@ -17,15 +17,22 @@ import type { HealthCommand } from './repo-health-check.js';
  * producing an unfalsifiable skip.
  *
  * CONSERVATIVE AND LEXICAL BY CONSTRUCTION. Only two shapes are rejected, both
- * decidable from the script text alone:
+ * decidable from the script text alone, and both run against every case named
+ * below:
  *   1. the chain OPENS with container orchestration (docker/podman/nerdctl … up|start|run);
  *   2. the whole body is a multiplexer (concurrently/npm-run-all/run-p/run-s/turbo)
  *      whose every child is an ASSET watcher in watch mode (tailwind/tsc/esbuild/…),
  *      i.e. nothing in it can ever listen.
- * Anything else — `vite`, `next dev`, `node dist/index.js`, `nodemon`, `bun --watch
- * src/index.ts`, and any multiplexer with one non-asset child — is accepted
- * unchanged. Deciding whether a watcher actually SERVES is not attempted here; that
- * is exactly what the static serve-entry check is for.
+ * Anything else — `vite`, `next dev`, `node dist/index.js`, `nodemon`, `bun run
+ * --watch src/index.ts`, and any multiplexer with one non-asset child — is accepted
+ * unchanged. All of those were run and accepted; so was a bare
+ * `tailwindcss … --watch`, which is only rejected INSIDE a multiplexer. A chain
+ * opening `docker compose … up` is rejected even when a real launch follows it,
+ * while `bun run docker-compose.dev.yml` is accepted, since the verb must be a
+ * bare token.
+ *
+ * Deciding whether a watcher actually SERVES is not attempted here; that is exactly
+ * what the static serve-entry check is for.
  */
 export declare function nonLaunchScriptReason(body: string, scripts?: Record<string, string>): string | null;
 /**
@@ -33,7 +40,7 @@ export declare function nonLaunchScriptReason(body: string, scripts?: Record<str
  * else `dev`; Makefile `run`). null means the project has nothing to boot —
  * the boot check degrades to nothing-to-run.
  *
- * A script that is not a LAUNCH at all (nonLaunchScriptReason — mx5 run 18's
+ * A script that is not a LAUNCH at all (nonLaunchScriptReason — an
  * `docker compose up` orchestrator) is rejected here and falls through to the
  * next candidate, then to null. Discovering nothing is strictly better than
  * discovering something unfalsifiable: an env-gap skip of an orchestration script
@@ -42,7 +49,7 @@ export declare function nonLaunchScriptReason(body: string, scripts?: Record<str
 export declare function discoverBootCommand(cwd: string): HealthCommand | null;
 /**
  * The launch script that EXISTS but was rejected as not-a-launch, if any. Without
- * this the rejection would trade run 18's unfalsifiable skip for pure silence: no
+ * this the rejection would trade an unfalsifiable skip for pure silence: no
  * boot command means bootSkipVerdict has no label to name, and a project whose test
  * suite ran still reports `observed > 0`, so unobservedVerdict stays quiet too. A
  * served app whose only declared launch script cannot start it was not observed to
@@ -60,7 +67,7 @@ type BootOutcome = {
      *  by the gate as an UNOBSERVED warning. */
     renderNote?: string;
     /** skip only: the boot command never spawned (ENOENT) — feeds the
-     *  full-blindness guard (mx5 run 16), unlike a 127 where the runner ran. */
+     *  full-blindness guard, unlike a 127 where the runner ran. */
     spawnFailed?: boolean;
 } | {
     outcome: 'fail';
@@ -82,7 +89,7 @@ export interface BootDeps {
     reap?: (pid: number) => boolean;
     /**
      * Does process group `pgid` currently own a LISTENing TCP socket? Drives the
-     * served-app boot check (mx5 run 10): a watcher (`dev` = tailwind/bundler
+     * served-app boot check: a watcher (`dev` = tailwind/bundler
      * --watch) stays alive forever without ever listening, so "still alive after the
      * grace window = PASS" blessed a project that cannot serve a single request.
      * Injected so the listener requirement is deterministically testable without a
@@ -97,15 +104,15 @@ export interface BootDeps {
     groupListeningPort?: (pgid: number) => number | null;
     /**
      * Load the served page once in a headless browser and judge the RENDERED DOM
-     * (mx5 runs 8/11: curl cannot execute JS, so a blank-mount app passed every
+     * (curl cannot execute JS, so a blank-mount app passes every
      * gate). Runs only for a served app, against the live listener, before the
      * boot child is killed. Absent → the boot check behaves exactly as before;
      * the gate wires runRenderCheck by default for served apps.
      */
     renderProbe?: (url: string) => RenderOutcome;
     /**
-     * SIGN IN on the served page and judge the AUTHENTICATED half of the app (mx5
-     * run 17). Runs only after `renderProbe` PASSED — the shallow blank-page rule
+     * SIGN IN on the served page and judge the AUTHENTICATED half of the app.
+     * Runs only after `renderProbe` PASSED — the shallow blank-page rule
      * keeps its own RED/GREEN-proven verdict and is never shadowed by this one.
      * Absent → the boot check behaves exactly as before; the gate wires
      * runDeepRenderCheck by default for served apps. May only FAIL when the SERVER
@@ -152,7 +159,7 @@ export interface BootDeps {
     spawnBoot?: (bin: string, args: string[], opts: BootSpawnOptions) => BootChild;
     /**
      * Tear down the child's whole process group. Injected with `spawnBoot`, because
-     * a fake child has no group to kill and a real `process.kill(-pid)` against a
+     * a fake child has no group to kill and a real `process.kill(pid)` against a
      * fake pid would signal something else entirely.
      */
     killGroup?: (pid: number, signal: NodeJS.Signals) => void;
@@ -196,11 +203,14 @@ export declare function parseSsListeners(stdout: string): Array<{
     port: number;
 }>;
 /**
- * `netstat -tlnp` rows → {pid, port} (mx5 run 14, validated: the agent-sandbox
- * image ships NEITHER ss NOR lsof — only ps and netstat — so the served-app boot
- * check could never observe a listener and failed unfalsifiably). The pid rides
- * in the trailing "PID/Program name" column ("1234/bun"); rows the kernel will
- * not attribute to us print "-" there and are skipped.
+ * `netstat -tlnp` rows → {pid, port}. Three parsers exist because no single
+ * enumerator is present everywhere — a box may ship netstat and no ss, or ss and
+ * no netstat — and without SOME enumerator the served-app check can never observe
+ * a listener and fails unfalsifiably.
+ *
+ * The pid rides in the trailing "PID/Program name" column ("1234/bun"); rows the
+ * kernel will not attribute to us print "-" there and are skipped. Both run as
+ * described.
  */
 export declare function parseNetstatListeners(stdout: string): Array<{
     pid: number;
@@ -214,13 +224,14 @@ export declare function parseLsofListeners(stdout: string): Array<{
 export declare function canEnumerateListeners(): boolean;
 /**
  * A free TCP port on the loopback interface, or null if one cannot be reserved.
- * The boot check hands this to the child as PORT so that a successful HTTP
- * request to it is OWNERSHIP evidence: nobody else knows the number (mx5 runs
- * 8/10/11 — orphaned servers from earlier checks answered curl on the
- * conventional :3000 and passed checks the app had not earned).
+ * The boot check hands this to the child as PORT so that a successful HTTP request
+ * to it is OWNERSHIP evidence: nobody else knows the number, whereas an orphaned
+ * server left by an earlier check still answers on a conventional port and would
+ * pass a check the app had not earned.
  */
 export declare function pickFreePort(): Promise<number | null>;
-/** Can we bind 127.0.0.1:`port` right now? (Free ⇒ the boot child can have it.) */
+/** Can we bind 127.0.0.1:`port` right now? Free ⇒ the boot child can have it.
+ *  Run: true for a just-reserved port, false while anything holds it. */
 export declare function isPortFree(port: number): Promise<boolean>;
 /**
  * The project's own declared local port, but only if nothing is holding it — the
@@ -236,8 +247,11 @@ export declare function defaultFindPortHolder(port: number): {
     command: string;
 } | null;
 /**
- * Exercise the start command ONCE. For a CLI project (`expectServer` false) the
- * command's own fate within the grace window decides:
+ * Exercise the start command ONCE. All four outcomes below were run against real
+ * child processes in throwaway projects.
+ *
+ * For a CLI project (`expectServer` false) the command's own fate within the grace
+ * window decides:
  *
  *   - non-zero exit (or signal death) before the window closes → FAIL, output tail;
  *   - exit 0 before the window closes → PASS (a CLI-style "run" that finished);
@@ -247,22 +261,21 @@ export declare function defaultFindPortHolder(port: number): {
  * For a SERVED app (`expectServer` true — the spec/plan promised an HTTP server) mere
  * survival is not enough: a watcher (`dev` = tailwind/bundler --watch) stays alive
  * forever without ever listening, and a type-only entrypoint exits 0 in <1s having
- * served nothing (mx5 run 10 — both were blessed by the survival rule). The boot then
+ * served nothing. The boot then
  * PASSes only once a LISTENing socket owned by our process group is observed; if the
  * command exits, or the grace window closes, with no listener ever seen → FAIL naming
  * that a listening server was expected.
  *
- * OBSERVABILITY is a precondition of that FAIL (mx5 run 14, validated). The listener
- * requirement needs pgid-attributed socket enumeration; win32 has none, and neither
- * does a Linux image shipping no ss/netstat/lsof — run 14's sandbox was exactly that,
- * so the check emitted "never opened a listening socket" against an app that
- * demonstrably served, three autofix passes could not falsify it, and the run was
- * recorded failed. Two defences, in order:
+ * OBSERVABILITY is a precondition of that FAIL. The listener requirement needs
+ * pgid-attributed socket enumeration; win32 has none, and neither does a Linux
+ * image shipping no ss, netstat or lsof. Without a defence the check would emit
+ * "never opened a listening socket" against an app that demonstrably serves, and
+ * no amount of fixing could falsify it. Two defences, in order:
  *
  *   - the child is spawned with a freshly reserved, otherwise-unused PORT, and an
  *     HTTP answer on THAT port proves a listener regardless of tooling. The private
  *     port is what makes the HTTP probe trustworthy: an orphaned server from an
- *     earlier check answers on :3000, but nobody else knows this number.
+ *     earlier check answers on:3000, but nobody else knows this number.
  *   - if nothing can enumerate listeners AND the assigned port never answered, the
  *     served-app requirement is unobservable here, so `expectServer` collapses to
  *     the survival rule and the PASS is stamped UNOBSERVED. An app that ignores PORT
@@ -270,8 +283,10 @@ export declare function defaultFindPortHolder(port: number): {
  *     not an app defect, and it may not be reported as one.
  *
  * A child that EXITS non-zero still FAILs in every environment: "the process died"
- * needs no socket probe, so run 14's original true positive (a `--hot` runtime
- * pinning a crashed app) stays reportable wherever the tooling exists.
+ * needs no socket probe. Confirmed — a start script exiting 3 comes back as
+ * `exited 3` with the output tail attached, with no listener question asked. That
+ * is what keeps a crashed app reportable even where a hot-reloading runtime would
+ * otherwise hold the process open.
  *
  * Env-gap contract as everywhere: spawn error (ENOENT) or a command-not-found
  * inside the chain (exit 127, or the runner's own wording where the platform
@@ -283,9 +298,9 @@ export declare function runBootCheck(cwd: string, [bin, args]: HealthCommand, gr
 }): Promise<BootOutcome>;
 /**
  * The SAME third verdict, at the door unobservedVerdict cannot reach: the boot
- * check specifically (mx5 run 18, validated).
+ * check specifically.
  *
- * Run 18 shipped an app with no HTTP server behind a converged final gate. Its
+ * A run can ship an app with no HTTP server behind a converged final gate. Its
  * `src/server/index.ts` ends at `export {app}` — no `Bun.serve`, no
  * `export default app`, no `start` script — so `bun run src/server/index.ts` exits
  * 0 immediately and the product cannot be started at all. The gate's boot command
@@ -294,26 +309,27 @@ export declare function runBootCheck(cwd: string, [bin, args]: HealthCommand, gr
  * contribute nothing to `dynObserved`, and `bun run test`, `test:ct`, `build`,
  * `lint`, `seed` and `migrate` all ran — so `dynObserved > 0`, the full-skip
  * blindness guard (observabilityGapFailure) stayed correctly quiet, and the trail
- * read `final-gate: autofix converged — statics + … passed` with 24/24 tasks green.
+ * report then reads `final-gate: autofix converged — statics + … passed`, with
+ * every task green.
  *
  * The defect is that "the app was never observed to boot" and "the app booted
- * fine" produced BYTE-IDENTICAL gate output. That is the class scripts/ab-verdict.ts
+ * fine" produced BYTE-IDENTICAL gate output. That is the class the verdict check
  * exists to kill one layer up: absence of evidence rendered in the shape of
  * evidence. So a discovered-but-skipped boot now names itself, and — unlike every
  * other skip — it CANNOT be cancelled by observations from other commands.
- * Component tests are the trap here, not the alibi: run 18 had 51 green Playwright
+ * Component tests are the trap here, not the alibi: a suite of green Playwright
  * CT tests, and CT mounts components in a browser without ever assembling or
  * starting the server.
  *
  * DECIDED, do not silently re-open:
  *  - NOT a FAIL. A boot skip on a docker-less box is a genuine environment gap, and
- *    failing it re-creates run 16's unfalsifiable-FAIL mistake pointing the other
+ *    failing it re-creates the unfalsifiable-FAIL mistake pointing the other
  *    way. UNOBSERVED blocks nothing while being loud and durable (the caller records
  *    it as final-gate debt the next run re-surfaces), and it keeps "boot never ran"
  *    out of the autofix child's seed — a child cannot fix a missing docker, so the
  *    highest-probability response would be to FABRICATE a bootable command, the
  *    class that refuted the `## verified tooling` harvest.
- *  - BOTH skip flavours count. Run 18's skip carried `spawnFailed: false` (127 inside
+ *  - BOTH skip flavours count. A skip can carry `spawnFailed: false` (127 inside
  *    the script chain, not an ENOENT on the runner), so keying off spawnFailed would
  *    have missed the actual defect.
  *  - SERVED APPS ONLY. `expectServer === false` (a CLI/library project) is fenced off