test(#3145): bound the installer/runtime cluster onto the process seam (#3176)

* test(#3145): bound the installer/runtime cluster onto the process seam

Migrates 156 unbounded sync spawn sites across 47 files. Allowlist 120 to 73.

Timeouts are sized from evidence already in the tree rather than a house
default, because this wave spawns installers rather than git plumbing and an
undersized bound does not catch a hang -- it manufactures CI flake, which is
worse, since a flake gets re-run instead of investigated. install.test.cjs
records a real spawnSync ETIMEDOUT at a 60000ms cap on a loaded bench while
another lane passed the same commit in 12.7s, so full installs are bound at
120000ms against that recorded incident.

Also adds an auditable escape to the guard's timeout ceiling. The 600000ms
cap was set in #3143 from partial evidence, but fragment-single-edit-
propagation carries a documented, load-tested 900000ms bound on a run that
chains a full build plus eight generators -- the guard would have rejected a
correct timeout the moment that file left the allowlist. A value above the
ceiling is now permitted only with an inline allow-spawn-timeout-ceiling
marker carrying a non-empty reason. It raises the ceiling; it never waives
the requirement for a bound, which is asserted directly.

install-shared.cjs keeps its hand-rolled assert rather than routing through
throwIfFailed: its message embeds both streams, and throwIfFailed carries
only a trimmed stderr. The message now also names the outcome, so a bounded
timeout reads as such across its 38 importers instead of as
expected null to equal 0.

* test(#3145): extract class-norm timeouts and correct the build-hooks sizing

A pre-PR review found 52 copies of four class-norm timeout constants across
this wave. These are not per-suite fixture bindings -- they are shared facts
about how long a class of subprocess takes, derived from a recorded bench
incident. That norm already moved once (60000 to 120000 after a real
ETIMEDOUT), and 52 copies would have drifted the next time it moved.

Extracts tests/helpers/timeouts.cjs, where each norm is justified once, and
converts the copies. A site that genuinely differs -- a real tsc compile, or
regen:derived -- keeps its own local constant with its own justification.

Also corrects a misclassification: scripts/build-hooks.js was sized as a
build at 120000 in twelve places and 60000 in another, but it compiles and
bundles nothing. Its own header says no bundling needed; it copies pre-built
files and syntax-checks them with vm. Three different values bounded one
script; now there is one.

* test(#3145): fix red CI — lint self-match and a Windows chunk overrun

Two failures on PR 3176.

lint-allow-test-rule-refs read a RuleTester fixture as a real exemption. The
fixture exists to prove an unrelated marker does NOT suppress the rule, so it
carries that marker's literal text as test data. Split via concatenation, the
same idiom no-unbounded-spawn-allowlist.test.cjs already uses for its own
self-match problem. The explanatory comment needed the same treatment.

The Windows shard 3/3 chunk was killed at its 600000ms budget. Output stopped
seven minutes before the kill, so this was an overrun rather than a slow
chunk: regenDerivedPropagatesSingleFragmentEditWithNoSecondSourceSurface runs
regen:derived bounded at 900000ms, which is larger than the whole chunk
budget, so the chunk killer always fires first and it can never complete
there. Both the test and that bound predate this change; modifying the file
pulled it into the Windows targeted set and exposed it. Skipped on Windows
with the reason recorded; the Linux lanes cover it. The 900000 bound and its
ceiling marker are unchanged -- they are correct.

* test(#3145): refresh the stale test-timings cost table

The Windows shard was killed at its 600000ms per-chunk budget. run-tests.cjs
packs chunks by measured duration from tests/test-timings.json, and an
unknown file falls back to the table's median weight -- advisory by design,
but it silently underweights exactly the files that matter.

Four of the failing chunk's 22 files were absent from the table, including
the two heaviest: fragment-single-edit-propagation.install.test.cjs at 230s
(it runs regen:derived) and agent-fragments-emission.install.test.cjs at 79s.
Both were weighted as average, so the chunk's total weight read 53.68 against
a budget of 60 and the packer produced a single chunk.

Regenerated from a passing full-suite run, per the remedy the script itself
documents. 700 to 770 entries, 70 added, 0 dropped -- verified, since
gen-test-timings.cjs replaces the table wholesale rather than merging.

Proven against the real packer: the same 22 files now weigh 103.91 and split
into two chunks. No logic, budget, or timeout was changed; raising a budget
to make a red gate pass is not a fix.

---------

Co-authored-by: sim <sim@local>

CONTRIBUTING.md

@@ -417,6 +417,14 @@ bench OOM. Inject faults in-process through a module's `deps` parameter instead.
 Per-suite wrappers are still expected and encouraged: bind your fixture (cwd, env, payload) in a
 local helper and delegate the spawn to the seam.
 
+**Class-norm timeouts live in `tests/helpers/timeouts.cjs`** — `PROBE_TIMEOUT_MS`,
+`GIT_TIMEOUT_MS`, `BUILD_TIMEOUT_MS`, `INSTALL_TIMEOUT_MS`. These describe how long a whole CLASS
+of subprocess call takes (a CLI probe, git plumbing on a fixture repo, a hooks build, a full
+`bin/install.js` run), not a single suite's preference, so import them rather than re-declaring the
+same literal with the same comment in yet another file. Only write a local constant when a site
+genuinely differs from its class (a real `tsc` compile, a `regen:derived` run, ...) — and give that
+local constant its own justifying comment explaining why it departs from the norm.
+
 #### When you want git to *throw*: `gitOrThrow`
 
 `runGit` never throws — that is the whole point of it. But `execSync` and `execFileSync` **do**
@@ -476,6 +484,23 @@ Two things it deliberately rejects, because both look bounded and are not:
 A non-literal value (`timeout: GIT_TIMEOUT_MS`) is trusted — that is the shape you should be
 writing.
 
+When a call genuinely needs more than the 600000 ms ceiling — a full installer run, a build plus
+generators — the escape is an inline marker comment, exactly the `// allow-test-rule: <reason>`
+idiom above:
+
+```javascript
+// allow-spawn-timeout-ceiling: regen:derived chains a full build plus eight generators
+timeout: 900000,
+```
+
+The reason is required and must be non-empty; a bare `// allow-spawn-timeout-ceiling:` (or one
+with only whitespace after the colon) is not an audit trail and still reports `timeoutTooLarge`.
+The marker binds only to the call it decorates — either the line immediately above it, or
+anywhere inside that call's own source range — never to the rest of the file. Critically, the
+escape only ever raises the ceiling for a call that already resolves to a numeric timeout: it
+never waives the requirement for a bound. A marked call with no `timeout` at all still reports
+`unboundedSpawn`.
+
 `eslint-rules/no-unbounded-spawn.allowlist.json` grandfathers files that predate the rule. It only
 ratchets **down**: once a file is clean, the rule reports its allowlist line as stale and you delete
 it. Never add an entry, and never reach for `eslint-disable` on this rule — a test asserts that no