pi-crew 0.11.2 → 0.11.4

package/package.json

@@ -1,9 +1,12 @@
 {
 	"name": "pi-crew",
-	"version": "0.11.2",
+	"version": "0.11.4",
 	"description": "Pi extension for coordinated AI teams, workflows, worktrees, and async task orchestration",
 	"author": "baphuongna",
 	"license": "MIT",
+	"publishConfig": {
+		"access": "public"
+	},
 	"engines": {
 		"node": ">=22.0.0"
 	},
@@ -93,7 +96,7 @@
 		"test:functional": "node scripts/test-runner.mjs --test-concurrency=1 --test-timeout=120000 test/functional/pi-crew-functional.test.ts",
 		"test:platform": "node scripts/test-runner.mjs --test-concurrency=1 --test-timeout=60000 test/platform/*.test.ts",
 		"build:bundle": "node scripts/build-bundle.mjs",
-		"test:bundle": "node --experimental-strip-types --test --test-force-exit test/unit/bundle-load.test.ts",
+		"test:bundle": "node scripts/test-runner.mjs --test-timeout=60000 --test-force-exit test/unit/bundle-load.test.ts",
 		"watch:bundle": "node scripts/watch-bundle.mjs",
 		"build:bundle:once": "node scripts/watch-bundle.mjs --once",
 		"dev": "node scripts/dev-runner.mjs",

package/skills/real-test-pi-crew/SKILL.md

@@ -119,6 +119,8 @@ End-to-end verification discipline for pi-crew changes. Distilled from the broke
 | `workflows/*.workflow.md` | T7 |
 | `.github/workflows/ci.yml` | T11e |
 | `scripts/wc-gate.mjs` | T11b |
+| `scripts/test-runner.mjs` (the runner itself) | T1 (exercises it) + `test/unit/scripts/test-runner-exit.test.ts` (21 tests: exit codes, cancelled-guard red-green, missing-file pre-check, batch shard empirical) + ONE batch-mode run (`PI_CREW_TEST_BATCH_SIZE=2 node scripts/test-runner.mjs --shard=0/1 <3 small files>`). Dev script — NOT bundled, no T3/T4 needed |
+| `scripts/check-lazy-imports.mjs` | Run the gate on a clean tree (`node scripts/check-lazy-imports.mjs` exit 0) + re-probe the pattern battery vs the KNOWN GAPS comment (round-3 lesson: a skip-rule fix can OPEN a new false-skip hole — probe both directions). NOT bundled |
 | `dist/` (bundle) | T3 → T4 → T8 → T11j |
 | bất kỳ đường dẫn trên, trước khi commit | gates đầy đủ: critical + unit + tsc + biome + md5 |
 
@@ -134,6 +136,8 @@ End-to-end verification discipline for pi-crew changes. Distilled from the broke
 
 > **2026-09-26 update (ambient-noise triage + temp-workspace hygiene + inline-async seam, commits `73790eaa`→`0006ddd5`, reports `real-test-2026-09-26-full-battery-manual.md` + addenda 1-5, ADRs `2026-09-26-inline-async-test-seam.md` / `2026-09-26-temp-workspace-hygiene.md`)**: (1) **Guest `gc-*` skip** — delegate-owned guest tasks have NO heartbeat channel; watcher + aggregator skip them at two independent layers (`agent==="delegate"` marker), guard-tests prove a genuinely-missing REAL worker is still flagged. (2) **Reconciler hygiene** — sweep batch rotates statelessly (`floor(now/60s) % batches`, starvation từ cluster kẹt đầu alphabet đã chết), `.cleanup-in-progress` sentinels cũ >10 phút được reclaim, test-runner dọn `pi-crew-*` pre-existing (mtime < suiteStart−30') sau mỗi suite — battery probe dirs trong /tmp phải KHÔNG đặt tên `pi-crew-*` hoặc phải tạo <30' trước T11. (3) **Inline-async test seam** — `PI_CREW_TEST_ASYNC_INLINE=1` + `PI_CREW_ALLOW_MOCK=1` chạy async run IN-PROCESS (`executeBackgroundRun` core shared với runner detached; `main()` giờ entry-guarded bằng `PI_CREW_BACKGROUND_RUNNER_ENTRY` hoặc argv check). Seam là công cụ UNIT TEST cho heavy async files (subagent-tools-integration: 5+min stall-prone → 14/14 trong 37s) — **battery T7/T9b/T10 TUYỆT ĐỐI không set** (xem row troubleshooting "seam leak"). New pinned suites: `stale-reconciler-rotation` (mutation-checked), `stale-reconciler-sentinel-reclaim`, `sweep-test-tmp` ×2, `async-runner-inline-seam` (mutation-checked), `heartbeat-watcher-guest-skip` ×2, `heartbeat-overlay` guest tests ×2. Suite anchors @ 2026-09-26: `npm test` **EXIT=0** — 8379 tests / 8372 pass / 0 fail / 7 skipped (~14 min), `test:critical` 116 (~25s), bundle **1677.8 KB** md5 `3860c0264940e7df91511da493fa375e`; CI flake Windows `subagent-tools-integration` spawn-stall **RESOLVED** bởi seam (đã từng tốn rerun ×4 trong một ngày).
 
+> **2026-09-29 update (RR-021 optimization wave + 4 review rounds, baseline `79a758d2`..`4393858c`, 37 commits; story `docs/stories/RR-021.md`; audit `pi-crew-optimization-audit.md`)**: (1) **Correctness/hang-risks** — `classifyReviewOutcome` word-boundary fix (the `\baccept\b` string-literal bug + negation guard), git/rg probe timeouts, `withRunLockSync`→`withRunLock` rerouting (lock family v0.9.26 intact), `reconcileAllStaleRuns` concurrent (`mapConcurrent` bound 4, per-run error isolation), sleeps→waitFor. (2) **Bundle hygiene** — esbuild/acorn/diff load via lazy sync-createRequire shims, ajv external, dead code −767 lines: bundle 3360 KB → **1575.2 KB**; NEW gates `check:lazy-imports` (ci.yml:142; src-side `// LAZY:` marker enforcement + dist-side no-hoisted-heavy-import assertion) and `check:bundle-size` (ci.yml:169). (3) **Test-gate integrity (review rounds 2–4)** — the runner now fails LOUDLY on `# cancelled N>0` (dual reporter: stdout UX unchanged, full TAP to a temp file, scraped in BOTH single-run and batch paths — `parseCancelledCount` + 21-test `test-runner-exit.test.ts`), on explicitly-listed files that do not exist (node:test v22 silently skipped them → exit 0; round-3 MAJOR B1), and `test:bundle` routes through the guarded runner (was the only CI gate bypassing it). Incremental tsc: typecheck ~20s → **~3.5s warm**. Suite anchors @ 2026-09-29: unit **8204 tests / 8201 pass / 0 fail / 3 skipped** (909 files), integration **136 / 132 pass / 4 skipped** (35 files incl. 3 slow), `test:critical` **116** (~18s), bundle **1575.2 KB** md5 `35ca335a90da01ac631493f220aaf121` (`--committed-hash` OK). Line refs moved: `PI_CREW_TEST_RUNNER_TIMEOUT_MS` now `scripts/test-runner.mjs:419`; crash-recovery design comment `:228`.
+
 > **2026-09-21 update (F-L2 — steer boot-window loss, found by the live feature battery)**: a steer written to `<artifactsRoot>/steering/<taskId>.jsonl` while the worker extension is still LOADING was silently lost forever — `registerPiTeamsPromptRuntime` starts the file poll at load time, pi's loader gates action methods until bind (`sendMessage: notInitialized` THROWS), and the old poll advanced `lastOffset` to `stat.size` BEFORE the line loop while its per-line catch swallowed the throw as "malformed line" (run `team_20260921035840`, root-caused by watcher-driven bisection probes R7-R9: +0.65s post-boot = lost, +2.5s+ = delivered). Fix (`src/prompt/prompt-runtime.ts`): walk the buffer by byte offset, advance only past terminal verdicts (delivered/non-steer/rejected/malformed), rewind to the failing line on a DELIVERY failure, `createSeenSteerIdSet.unmark()` releases the dedup id so the retry is not skipped. Regression suite `test/unit/prompt/prompt-runtime-steer-boot-window.test.ts` (4 tests) — mutation-checked both layers (offset-revert → 4 fail; unmark-removal → exactly the id-bearing test fails). Note: `dist/index.mjs` is UNCHANGED by this fix — child workers load prompt-runtime from the SOURCE path (`pi-args.ts PROMPT_RUNTIME_EXTENSION_PATH`), so the fix is live without a bundle bump.
 >
 > **F-L2 live re-verification (post-restart, 2026-09-21 afternoon)** — two independent proofs: (a) **lab**: pre-write the steer, then `PI_CREW_STEERING_FILE=<file> pi --extension <repo>/src/prompt/prompt-runtime.ts -p '<long task>'` — stderr shows `[pi-crew:prompt-runtime.steer-delivery-failed] Extension runtime not initialized…` ×2 (pre-bind ticks now LOGGED instead of swallowed) then the post-bind tick delivers and the model complies; (b) **real team run**: watcher writes at **+0.51s** after the steering dir appears (the previously-lost window) → worker session log gains the `custom_message` and the probe token lands in `results/<taskId>.txt`. Suite anchors @ 2026-09-21 (post-fix): unit **8006 tests / 8003 pass / 0 fail / 3 skipped** (875 files; 1088s under load), integration **134 / 130 pass / 4 skipped**, `test:critical` **116**, bundle **3360.1 KB** md5 `2f45df91ed0580ee5bb5b9b57a8a8c3f` (UNCHANGED — see the source-path note above).
@@ -194,14 +198,16 @@ The skill maps to existing CI gates as follows:
 | `npm run typecheck` | Tier 3 | `.github/workflows/*.yml` (every PR) |
 | `npm run check:wc-gate` | Tier 11b | **in BOTH `ci` and `ci:fast` scripts** (`package.json:71-72`) + explicit step in `.github/workflows/ci.yml:66-71` (since `09dda842` — was `ci:fast`-only, i.e. advisory) |
 | Bundle-staleness check (incl. **ARCH-7 path-leak scan** since `7d18508b` — line-scans `dist/index.mjs` + structural sourcemap check for tracked-source leaks) | Tier 3 last step | `scripts/check-bundle-staleness.mjs`; `--committed-hash` mode = Tier 11j release gate |
-| `npm run test:bundle` (bundle import smoke, 2 tests) | Tier 3 post-build sanity | `test/unit/bundle-load.test.ts` |
+| `npm run test:bundle` (bundle import smoke, 2 tests) | Tier 3 post-build sanity | `test/unit/bundle-load.test.ts` — routed through the guarded `scripts/test-runner.mjs` since RR-021 round-3 (was a bare `node --test` bypass, the only CI gate without the wrappers) |
 | `node scripts/release-smoke.mjs` (manual, release cut) | Tier 3/11j companion | ARCH-6: installs pi-* peer deps, `import()`s the tarball-installed bundle (`:77`), shape-checks exports |
-| Full `npm test` (= unit 869 files + integration 35 @ 2026-09-17) | n/a — too slow for in-loop | CI only; slow tier (3 files) is a SEPARATE glob `test:integration:slow` — only `npm run test:full` includes it |
+| Full `npm test` (= unit 909 files + integration 35 incl. 3 slow @ 2026-09-29) | n/a — too slow for in-loop | CI only; slow tier (3 files) is a SEPARATE glob `test:integration:slow` — only `npm run test:full` includes it |
 | `PI_CREW_SMOKE=1` env | Tier 11e | set ONLY in `weekly-smoke.yml` (auth-gated); nightly.yml deliberately does NOT (comment at `:24`) |
 | `npm run check:decision-drift` | Tier 11 (doc↔code) | **build-blocking in `.github/workflows/ci.yml` since 2026-09-17** (review-remediation baseline): every `PI_CREW_*` token cited in `docs/decisions/*.md` must exist in `src/` |
 | `npm run check:env-vars` | Tier 11 | **build-blocking in `ci.yml` since 2026-09-17**: every `PI_CREW_*` read must be routed via `getCrewEnv` + registered |
 | `npm run check:event-types -- --enforce` | Tier 9a/11 | **build-blocking in `ci.yml` since 2026-09-17**: event registry (`src/state/contracts.ts`) must cover every emitted type — 168 registered / 0 drift @ 2026-09-17 (was 89, drift silent) |
-| `PI_CREW_TEST_RUNNER_TIMEOUT_MS` env | Tier 1 companion | overrides the test-runner spawn deadline (`scripts/test-runner.mjs:206`); default **1_500_000 ms** since 2026-09-17 (was 900_000 — sized for a 5800-test suite; the full suite outgrew it and the ETIMEDOUT became a false green pre-F05) |
+| `npm run check:lazy-imports` | Tier 3 companion (RR-021 WI-2.3 + review rounds 2-4) | `scripts/check-lazy-imports.mjs` — src-side: every runtime `import()` position needs a `// LAZY:` marker (known gaps: ternary-else / object-property / case-label / runtime member-access after same-line colon — documented in-script); dist-side: no module-scope hoisted heavy import (esbuild/acorn/diff/jiti/cli-highlight/yaml/ajv). Build-blocking at `ci.yml:142` |
+| `npm run check:bundle-size` | Tier 3 companion | `scripts/check-bundle-size.mjs` — committed bundle ≤ budget (Sprint 6 gate, `ci.yml:169`; budget re-anchored when RR-021 shrank the bundle 3360→1575 KB) |
+| `PI_CREW_TEST_RUNNER_TIMEOUT_MS` env | Tier 1 companion | overrides the test-runner spawn deadline (`scripts/test-runner.mjs:419` since RR-021; was :206); default **1_500_000 ms** since 2026-09-17 (was 900_000 — sized for a 5800-test suite; the full suite outgrew it and the ETIMEDOUT became a false green pre-F05). Since RR-021 rounds 2-3 the runner ALSO fail-closes on `# cancelled N>0` (TAP dual-reporter scrape) and on explicitly-listed missing files — see `test/unit/scripts/test-runner-exit.test.ts` (21 tests) |
 
 To add Tier 1 to a pre-commit hook:
 
@@ -231,7 +237,7 @@ To add Tier 1 to CI as a fast-feedback gate (under 30s):
 
 **What**: run the curated 14-file fast subset.
 
-**Why this exists**: full `npm run test:unit` runs 875 files (was 642 at skill-writing time — it keeps growing), several minutes. Verifier worker response timeout would kill the worker mid-run → run = "hang". The fix (introduced in commit `1cb2dca`) splits out a `test:critical` subset covering exactly what changed in the broker/UI work.
+**Why this exists**: full `npm run test:unit` runs 909 files (was 642 at skill-writing time — it keeps growing), several minutes. Verifier worker response timeout would kill the worker mid-run → run = "hang". The fix (introduced in commit `1cb2dca`) splits out a `test:critical` subset covering exactly what changed in the broker/UI work.
 
 **How**:
 
@@ -239,7 +245,7 @@ To add Tier 1 to CI as a fast-feedback gate (under 30s):
 time npm run test:critical
 ```
 
-Expected output: `# tests 116 # pass 116 # fail 0 # duration_ms ~21000`. (Count was 97 at v0.9.46, 101 at v0.9.66, 102 at the waitMethodsEnabled flip, **116 @ 2026-09-20** — verify with the actual run; the skill's hard-coded numbers drift between releases.)
+Expected output: `# tests 116 # pass 116 # fail 0 # cancelled 0 # duration_ms ~18000`. (Count was 97 at v0.9.46, 101 at v0.9.66, 102 at the waitMethodsEnabled flip, **116 since 2026-09-20** — verify with the actual run; the skill's hard-coded numbers drift between releases.) **Since RR-021 round-2 the runner itself fails loudly on `# cancelled N>0`** (dual-reporter TAP scrape — the round-1 unref incident shipped green with 2 cancelled tests), and **round-3 added the missing-file pre-check**: an explicitly-listed file that does not exist now exits 1 naming the path instead of being silently skipped by node:test.
 
 **References**:
 
@@ -303,7 +309,7 @@ All three must show `# pass 101 # fail 0`. Measured times in this session (2026-
 **How**:
 
 ```bash
-npm run typecheck    # ~20s, exits 0 with "strip-types import ok"
+npm run typecheck    # ~3.5s warm / ~5s cold since RR-021 incremental tsc (was ~20s), exits 0 with "strip-types import ok"
 npm run build:bundle # <1s, prints "[build-bundle] dist/index.mjs NNNN KB in NNN ms"
 md5sum dist/index.mjs
 node scripts/check-bundle-staleness.mjs   # ARCH-7: staleness + path-leak scan — exit 0
@@ -320,7 +326,7 @@ Compare the printed md5 against what the user's Pi session loaded. If they diffe
 | Bundle builder | `scripts/build-bundle.mjs` (esbuild-based, bundles `index.bundle.ts` → `dist/index.mjs`) |
 | Bundle resolution rule | `index.ts:1-25` (entrypoint docstring); also `scripts/build-bundle.mjs:14-20` (entrypoint preference); **symlink is live for source files but the bundled `dist/index.mjs` is loaded** |
 | Postinstall hook | `scripts/postinstall.mjs:43` — best-effort bundle rebuild; falls back to strip-types if esbuild missing |
-| Bundle md5 anchors | `1cc4d55e18add7b9a036c569143320b6` (Phase-4 flip, ~2.78 MB) → `16e29d053bd370e24f40df147dadcb79` (v0.9.66, 2026-08-11) → `9b557ac106b82e1ee33d39dd0d6c7dd7` (post-MuxSurface-A1 main, 2026-08-27) → `945720b1ad25673d86e263cdd834532f` (post-Batch-10 branch tip `aa899a1e`, 2026-09-11, ~3.30 MB) → `25ffc88e9a13611f61871b4c4a5b17ab` (review-remediation F01–F20 wave, 2026-09-17, 3357.3 KB / 3,437,867 B). **Always check current**: `md5sum dist/index.mjs` |
+| Bundle md5 anchors | `1cc4d55e18add7b9a036c569143320b6` (Phase-4 flip, ~2.78 MB) → `16e29d053bd370e24f40df147dadcb79` (v0.9.66, 2026-08-11) → `9b557ac106b82e1ee33d39dd0d6c7dd7` (post-MuxSurface-A1 main, 2026-08-27) → `945720b1ad25673d86e263cdd834532f` (post-Batch-10 branch tip `aa899a1e`, 2026-09-11, ~3.30 MB) → `25ffc88e9a13611f61871b4c4a5b17ab` (review-remediation F01–F20 wave, 2026-09-17, 3357.3 KB) → `3860c0264940e7df91511da493fa375e` (2026-09-26, 1677.8 KB) → **`35ca335a90da01ac631493f220aaf121`** (RR-021 wave, 2026-09-29, **1575.2 KB** — lazy esbuild/acorn/diff shims + ajv external + −767 dead lines). **Always check current**: `md5sum dist/index.mjs` |
 
 ---
 
@@ -776,9 +782,9 @@ herdr chỉ được detect khi **chính pi session đang chạy trong một her
 grep -c "atomicWriteJson" src/state/stores/plan-store.ts src/state/stores/ownership-map.ts  # >=1 each
 # 2. terminal-state events are sync appendEvent (crash-recovery design comment at :221
 #    (file lives at src/runtime/recovery/crash-recovery.ts after the runtime reorg)
-grep -n "Log the event first" src/runtime/recovery/crash-recovery.ts   # design intent: sync
+grep -n "Log the event first" src/runtime/recovery/crash-recovery.ts   # design intent: sync (:228 @ 2026-09-29; was :221 pre-RR-021)
 # 3. buffered-site census — snapshot & audit:
-grep -rln "appendEventBuffered" src/ | wc -l   # 16 files / ~70 raw matches (incl. imports+definition) at v0.10.5; audited live conversions = 43; EVERY new site needs the reader-audit
+grep -rln "appendEventBuffered" src/ | wc -l   # 15 files @ 2026-09-29 (16 at v0.10.5; RR-021 WI-4.2 dead-code sweep removed one); audited live conversions = 43; EVERY new site needs the reader-audit
 # 4. the full gate — test:critical has NO stores/dwf/recovery coverage:
 npm run test:unit    # 875 files, ~8006 tests, ~11-12 min (670-730s measured 2026-09-20; 1088s under load 2026-09-21) — MANDATORY after any delayed-write conversion program
 ```
@@ -1080,7 +1086,7 @@ PY
 | Test using real `loadConfig()` to mock config | Flaky when env / disk config changes | `612e18b` | `test/unit/runtime/broker/crew-broker-server-gate.test.ts:78` (use `brokerEnv: "0"` instead of `flagOn: false`) |
 | Source edit seen immediately | No, requires bundle rebuild + reload | n/a (permanent) | `index.ts:1-25` — bundle resolution rules |
 | Skip disabled-path proof | `effectiveEnabled()` regression slips through | n/a (permanent) | Tier 2 above |
-| `npm run test:unit` against the full suite (823 files now, 642 then) | several minutes; mis-judges verifier runtime | n/a (permanent) | Tier 1 above |
+| `npm run test:unit` against the full suite (909 files now, 642 then) | several minutes; mis-judges verifier runtime | n/a (permanent) | Tier 1 above |
 | Skip typecheck | TS errors slip past `test:critical` (which uses `--test-timeout=30000`) | n/a (permanent) | Tier 3 above |
 | Run `pi` from a stale bundle | Session shows old behavior despite src/ edits | n/a (permanent) | `scripts/check-bundle-staleness.mjs` — CI gate |
 | Test by reading code | Proves nothing about runtime | n/a (permanent) | All tiers above |
@@ -1109,7 +1115,7 @@ PY
 | **Worker killed mid long-silent-bash** (Batch-1 postmortem): one >5–10 min command emits no output events → watchdog SIGTERM mid-run — exit 143 WHILE the command runs. Work was intact; manual re-run green — the kill WAS the "hang". **2026-09-20 sharpening**: the trigger is EVENT SILENCE, not duration — `\| tail`/`\| head`/`> file` buffering manufactured silence from a chatty suite (proven: `worker.response_timeout` at exactly cmd_start+600s, heartbeat fresh, 29 earlier streaming commands all survived); genuinely-silent commands die unpiped too. | n/a (quirk — `CONTEXT.md` Flagged #1; P2 candidate) | Never `\| tail` a long suite in a worker — stream or split it; if buffering stdout, keep stderr out of the pipe (`2>&1` removes the last update source); raise `PI_TEAMS_CHILD_RESPONSE_TIMEOUT_MS` for legit silent workloads. On exit-143-mid-command: re-run manually BEFORE diagnosing a code bug; mine `.crew/state/runs/<runId>/background.log` for the killed worker's findings. Postmortem: `postmortem-batch-1-sigterm.md`; full RCA: run `team_20260919150900_6af9ee2bcd57a7f3` |
 | **`pkill -f "test:unit"` kills your own shell** (2026-09-16): the pattern matches the `bash -c` cmdline of the tool call that runs it, so the command dies before it starts the replacement suite — and the log file simply never appears. | n/a (self-inflicted) | Kill by pid (`pgrep -f test-runner` → `kill <pid>`), or match a pattern the sink does not contain | Tier 13 "How" step 0 — detached start: `(setsid nohup npm run test:unit > /tmp/suite.log 2>&1 < /dev/null &)` |
 | **`pgrep -f test-runner` read as liveness** (2026-09-16): the same self-match makes it report `RUNNING` forever, so a suite that died 10 minutes ago looks alive and the "result" you read is a truncated log. | n/a (self-inflicted) | Liveness = `ps -eo pid,etime,cmd \| grep -E "test-runner\|node --test"` with the grep itself excluded | Tier 13 harness step 1 — a run is DONE only when the `# tests/# pass/# fail` block exists at EOF |
-| **Reading a truncated suite log as a summary** (2026-09-16): the runner died with `Test runner error: spawnSync … ETIMEDOUT` at subtest 3946/7860 under load; the last numbers looked like a verdict. | n/a (runner) | The verdict is the `# tests/# pass/# fail` block at EOF — absent means the run did not finish; re-run in the foreground with nothing else heavy running. Since 2026-09-17 (F05) the runner itself fails CLOSED on this class — `resolveExitCode()` (`scripts/test-runner.mjs:44`) maps ETIMEDOUT/spawn-error/signal-kill to a non-zero exit, so wrappers/CI see red instead of a silent exit-0 false green; the spawn deadline also rose 900s→1500s (`PI_CREW_TEST_RUNNER_TIMEOUT_MS` override) | Failure symptoms row "Test runner error: spawnSync … ETIMEDOUT" |
+| **Reading a truncated suite log as a summary** (2026-09-16): the runner died with `Test runner error: spawnSync … ETIMEDOUT` at subtest 3946/7860 under load; the last numbers looked like a verdict. | n/a (runner) | The verdict is the `# tests/# pass/# fail` block at EOF — absent means the run did not finish; re-run in the foreground with nothing else heavy running. Since 2026-09-17 (F05) the runner itself fails CLOSED on this class — `resolveExitCode()` (`scripts/test-runner.mjs:45`) maps ETIMEDOUT/spawn-error/signal-kill to a non-zero exit, so wrappers/CI see red instead of a silent exit-0 false green; the spawn deadline also rose 900s→1500s (`PI_CREW_TEST_RUNNER_TIMEOUT_MS` override). RR-021 rounds 2-3 closed the LAST two silent-green classes in the wrapper: `# cancelled N>0` (TAP dual-reporter scrape, fails both single-run and batch paths) and explicitly-listed missing files (pre-check exits 1 naming paths — node:test v22 used to silently skip them) | Failure symptoms row "Test runner error: spawnSync … ETIMEDOUT" |
 | **Running the full suite on a tree you are still editing** (2026-09-16): a 12-minute suite started before the last fixes reports failures that no longer exist — and passes fixes that were not in yet. | n/a (process) | Freeze the tree first; if you must edit, the run is VOID — say so instead of quoting its numbers | Done-criteria: "Full `test:unit` fresh-run" |
 | **Grepping the bundle without context or escape-awareness** (2026-09-16): esbuild escapes non-ASCII as `\u250F` (uppercase hex) so glyph greps miss, while `"->"` (the progress **wire format**, `roleSeparator`) and `Crew agents` (error message + task-graph markdown) are permanent false positives. | n/a (permanent) | Grep the codepoint escape (`u250F`, `u258F`) and always print ±90 chars of context before concluding | Tier 3 bundle check + Tier 13 step 2 (escape-aware proof snippet) |
 | **Trusting a delegated UI claim** (2026-09-16): four parallel executors + a verifier reported "dedupe applied" and "hints canonical"; the rendered surfaces still showed `fast-fix/fast-fix` and an invented `· right default`. Summaries describe intent. | n/a (process) | Render the surface with REAL state before believing any UI claim — including your own | Tier 13 (this entire tier exists for this class) |
@@ -1153,6 +1159,8 @@ When a tier fails, the recovery is usually quick. Match the symptom to the cause
 | Steer written during worker BOOT never reaches the model (no error, no log; later steers work) | F-L2 (fixed 2026-09-21): poll advanced its offset past an entry whose `pi.sendMessage` threw pre-bind ("not initialized") and the per-line catch ate the throw — one-shot silent loss | Fixed in `prompt-runtime.ts` (offset rewind + dedup unmark); pinned by `prompt-runtime-steer-boot-window.test.ts`. On older builds: re-send the steer after ~5s — a steer that lands post-bind delivers fine |
 | Steer "lost" but the file you wrote is FULL while a 0-byte `<taskId>.jsonl` sits beside it | **Probe bug, not a product bug** — the steering filename depends on run kind: team runs poll `<taskId>.jsonl`, crew_agent/subagent runs use `<slot>-agent.jsonl`; you wrote the wrong channel (no component reads it) | Re-run writing every `*.jsonl` in the steering dir (Tier 9g), or derive the name from the run kind. Cross-check `results/<taskId>.txt` + the worker session's `custom_message` before calling it a loss |
 | Fix verified in unit tests but a live probe still fails | Live path ≠ unit path: wrong filename (above), wrong role/tool for the probe instruction, or the session did not cold-start the changed module | Confirm the loaded artifact (`--extension <path>` resolution for workers is the SOURCE file, so a restart is enough; parent-side needs bundle+restart), then re-run Tier 9g with text-only compliance |
+| `[test-runner] FAIL: N cancelled test(s)` (runner diagnostic, any suite size) | A test drains the event loop while pending (unref'd race timers — the RR-021 round-1 shape) — node:test cancels it and the runner now fails loudly instead of exiting 0 | Fix the TEST (ref the timer / gate-promise pattern), never ignore or re-run hoping it passes; `test-runner-exit.test.ts` has the canonical red-green fixture |
+| `[test-runner] FAIL: N explicitly-listed test file(s) do not exist` | An explicit-list script (`test:critical` & friends) or manual command references a renamed/deleted file — node:test v22 silently skipped it (exit 0); the RR-021 round-3 pre-check refuses to spawn | Update the invoking script/command — the named path is the file that moved. Glob args are exempt (node:test expands them) |
 | Full `test:unit` fails ONLY on `wait-request-broker.test.ts` under parallel load | Per-file 180s runner timeout vs the file's real runtime (passes isolated) | `node scripts/test-runner.mjs test/unit/runtime/broker/wait-request-broker.test.ts` — green in isolation = infra flake, not a regression |
 | `undefined` (or `undefined — …`) painted in a live surface | an optional segment interpolated into a template literal without a guard. **Check BOTH paths**: the pure builder and the component that composes the same row (2026-09-16: `widget-renderer.buildWidgetLines` guarded it, `src/ui/widget/index.ts` did not). | Guard before composing (`if (!x) return [] / return undefined`), add a regression lock that renders the zero-state through the COMPONENT, and sweep every `${optional}` on the surface. |
 | Spinner keeps spinning after the run finished (`⠹ … 0 running`) | the surface hardcodes a spinner frame instead of deriving the glyph from state | Derive it: spinner only while an agent/run is actually running, otherwise the outcome glyph (`✓`/`✗`). Assert in the battery that "0 running" never coexists with a braille glyph. |

package/src/extension/async-notifier.ts

@@ -1,13 +1,13 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { readCrewAgents, saveCrewAgents } from "../runtime/crew-agent-records.ts";
 import { checkProcessLiveness, isActiveRunStatus } from "../runtime/process-status.ts";
-import { withRunLockSync } from "../state/coordination/locks.ts";
+import { withRunLock } from "../state/coordination/locks.ts";
 import { appendEvent, readEventsCursor, type TeamEvent } from "../state/event-log/event-log.ts";
 import { loadRunManifestById, saveRunTasks, updateRunStatus } from "../state/stores/state-store.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 import { extractSessionId } from "../utils/session-utils.ts";
-import { listRuns } from "./run-index.ts";
+import { listRecentRuns, listRuns } from "./run-index.ts";
 import type { WebhookNotifier } from "./webhook-notify.ts";
 
 export interface AsyncNotifierState {
@@ -107,7 +107,11 @@ function markActiveTasksAndAgentsFailed(run: TeamRunManifest, message: string):
 	}
 }
 
-export function markDeadAsyncRunIfNeeded(run: TeamRunManifest, now = Date.now(), quietMs = 30_000): TeamRunManifest | undefined {
+export async function markDeadAsyncRunIfNeeded(
+	run: TeamRunManifest,
+	now = Date.now(),
+	quietMs = 30_000,
+): Promise<TeamRunManifest | undefined> {
 	if (!run.async || !isActiveRunStatus(run.status)) return undefined;
 	const liveness = checkProcessLiveness(run.async.pid);
 	if (liveness.alive) return undefined;
@@ -116,8 +120,13 @@ export function markDeadAsyncRunIfNeeded(run: TeamRunManifest, now = Date.now(),
 	if (latestEventAgeMs(events, now) < quietMs) return undefined;
 	const asyncPid = run.async.pid;
 	const message = `Background runner died unexpectedly; check background.log (${liveness.detail}).`;
-	return withRunLockSync(run, () => {
-		const fresh = loadRunManifestById(run.cwd, run.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency;
+	// RR-021 WI-1.4: rerouted to the async run-lock (same v0.9.26 lock family as
+	// the sync helper — sync and async acquisitions interoperate via live-token
+	// registration, RR-011 F02). The notifier tick is async, so we must not hold
+	// the event loop with a blocking sync acquisition while other async contenders
+	// (background runner, stale reconciler) wait.
+	return withRunLock(run, async () => {
+		const fresh = loadRunManifestById(run.cwd, run.runId); // NOTE: best-effort only inside the lock; concurrent writes may cause inconsistency;
 		if (!fresh || !isActiveRunStatus(fresh.manifest.status)) return undefined;
 		const failed = updateRunStatus(fresh.manifest, "failed", message);
 		markActiveTasksAndAgentsFailed(failed, message);
@@ -163,16 +172,25 @@ export function startAsyncRunNotifier(
 		if (isFinished(run.status) && updatedAtMs < staleBeforeMs) addSeenFinishedRunId(state, run.runId);
 	}
 	let cachedRuns: TeamRunManifest[] | undefined;
-	state.interval = setInterval(() => {
+	// RR-021 WI-1.4: the tick is async now (markDeadAsyncRunIfNeeded awaits the
+	// run-lock). `ticking` preserves the old no-overlap semantics — setInterval
+	// must not re-enter a tick that is still awaiting a lock.
+	let ticking = false;
+	const tick = async (): Promise<void> => {
+		if (ticking) return;
+		ticking = true;
 		try {
 			if (options.isCurrent && !options.isCurrent(generation)) return;
 			const nowMs = Date.now();
 			if (cachedRuns === undefined || nowMs - (state.lastListRunsMs ?? 0) > LIST_RUNS_DEBOUNCE_MS) {
-				cachedRuns = listRuns(ctx.cwd).filter(ownsRun).slice(0, 20);
+				// RR-021 WI-4.1: bounded recent-runs read (40 = 2x the 20 we keep) instead
+				// of a full listRuns() index scan on every debounce window — the 2x bound
+				// survives the ownsRun filter still yielding 20 owned runs.
+				cachedRuns = listRecentRuns(ctx.cwd, 40).filter(ownsRun).slice(0, 20);
 				state.lastListRunsMs = nowMs;
 			}
 			for (const run of cachedRuns) {
-				const current = markDeadAsyncRunIfNeeded(run) ?? run;
+				const current = (await markDeadAsyncRunIfNeeded(run)) ?? run;
 				if (!isFinished(current.status) || state.seenFinishedRunIds.has(current.runId)) continue;
 				addSeenFinishedRunId(state, current.runId);
 				// Suppress notifications for INTERNAL goal-loop sub-runs.
@@ -213,7 +231,13 @@ export function startAsyncRunNotifier(
 				return;
 			}
 			logInternalError("async-notifier", error, `interval=${intervalMs}`);
+		} finally {
+			ticking = false;
 		}
+	};
+	state.interval = setInterval(() => {
+		// tick() never rejects (it catches internally) — void is safe.
+		void tick();
 	}, intervalMs);
 	// Defense-in-depth: never let the notifier timer keep the event loop alive.
 	// If stopAsyncRunNotifier is missed (session switch race), the next run of

package/src/extension/crew-input-router.ts

@@ -55,6 +55,13 @@ function phraseToRegex(phrase: string): RegExp {
 	return new RegExp(`^${escaped}\\b`, "i");
 }
 
+// RR-021 WI-4.3k: precompile the per-phrase regexes ONCE — the router used to
+// rebuild every phrase regex on every routed input line.
+const CREW_PHRASE_MATCHERS: ReadonlyArray<{ command: string; regex: RegExp }> = CREW_PHRASES.map((entry) => ({
+	command: entry.command,
+	regex: phraseToRegex(entry.phrase),
+}));
+
 /**
  * Try to rewrite a natural-language crew phrase into a slash command.
  * Returns the rewritten command string, or `null` if no rule matches.
@@ -67,8 +74,8 @@ export function rewriteCrewInput(text: string): string | null {
 	// Never transform explicit slash commands or inputs that don't start with
 	// a crew/team keyword phrase.
 	if (trimmed.startsWith("/")) return null;
-	for (const entry of CREW_PHRASES) {
-		const match = trimmed.match(phraseToRegex(entry.phrase));
+	for (const entry of CREW_PHRASE_MATCHERS) {
+		const match = trimmed.match(entry.regex);
 		if (!match) continue;
 		// Carry any remaining args after the matched phrase forward.
 		const rest = trimmed.slice(match[0].length).trim();

package/src/extension/plan-orchestrate.ts

@@ -183,11 +183,27 @@ export function parsePlanDocumentSimple(planPath: string): OrchestratedStep[] {
 /**
  * Detect implicit tag from content keywords when no explicit tag is present.
  */
+// RR-021 WI-4.3k: precompiled word-boundary regexes — hasWord used to compile
+// a fresh RegExp for every word on every call.
+const WORD_MATCHERS: Readonly<Record<string, RegExp>> = {
+	design: /\bdesign\b/,
+	architecture: /\barchitecture\b/,
+	implement: /\bimplement\b/,
+	coding: /\bcoding\b/,
+	security: /\bsecurity\b/,
+	audit: /\baudit\b/,
+	build: /\bbuild\b/,
+	compile: /\bcompile\b/,
+	test: /\btest\b/,
+	verify: /\bverify\b/,
+	review: /\breview\b/,
+	feedback: /\bfeedback\b/,
+};
 function detectImplicitTag(content: string): string | undefined {
 	const lowerContent = content.toLowerCase();
-	// Use word-boundary regex to avoid substring false matches.
-	// E.g., "implementation" must NOT trigger "impl" — only the word "implement" should.
-	const hasWord = (word: string): boolean => new RegExp(`\\b${word}\\b`).test(lowerContent);
+	// Word-boundary match avoids substring false matches: "implementation"
+	// must NOT trigger "impl" — only the word "implement" should.
+	const hasWord = (word: keyof typeof WORD_MATCHERS): boolean => WORD_MATCHERS[word].test(lowerContent);
 
 	if (hasWord("design") || hasWord("architecture")) return "design";
 	if (hasWord("implement") || hasWord("coding")) return "impl";

package/src/extension/registration/commands/shared.ts

@@ -46,6 +46,7 @@ export async function handleTeamTool(
 	if (!_cachedHandleTeamTool) {
 		if (!_handleTeamToolPromise) {
 			_handleTeamToolPromise = import("../../team-tool.ts").then((mod) => {
+				// LAZY: defer heavy command/UI chain until first slash-command (blind-spot #2)
 				_cachedHandleTeamTool = mod.handleTeamTool;
 				return mod.handleTeamTool;
 			});
@@ -109,13 +110,13 @@ export async function ui(): Promise<NonNullable<typeof _uiCache>> {
 		if (!_uiCachePromise) {
 			_uiCachePromise = (async () => {
 				const [rd, tv, co, md, mc, ap, ma] = await Promise.all([
-					import("../../../ui/run-dashboard.ts"),
-					import("../../../ui/transcript-viewer.ts"),
-					import("../../../ui/overlays/confirm-overlay.ts"),
-					import("../../../ui/overlays/mailbox-detail-overlay.ts"),
-					import("../../../ui/overlays/mailbox-compose-overlay.ts"),
-					import("../../../ui/overlays/agent-picker-overlay.ts"),
-					import("../../../ui/mascot.ts"),
+					import("../../../ui/run-dashboard.ts"), // LAZY: defer heavy command/UI chain until first slash-command (blind-spot #2)
+					import("../../../ui/transcript-viewer.ts"), // LAZY: defer heavy command/UI chain until first slash-command (blind-spot #2)
+					import("../../../ui/overlays/confirm-overlay.ts"), // LAZY: defer heavy command/UI chain until first slash-command (blind-spot #2)
+					import("../../../ui/overlays/mailbox-detail-overlay.ts"), // LAZY: defer heavy command/UI chain until first slash-command (blind-spot #2)
+					import("../../../ui/overlays/mailbox-compose-overlay.ts"), // LAZY: defer heavy command/UI chain until first slash-command (blind-spot #2)
+					import("../../../ui/overlays/agent-picker-overlay.ts"), // LAZY: defer heavy command/UI chain until first slash-command (blind-spot #2)
+					import("../../../ui/mascot.ts"), // LAZY: defer heavy command/UI chain until first slash-command (blind-spot #2)
 				]);
 				const cache = {
 					RunDashboard: rd.RunDashboard,
@@ -249,9 +250,9 @@ export function teamCommandContext(ctx: ExtensionCommandContext): ExtensionComma
 export async function openTeamSettingsOverlay(ctx: ExtensionContext): Promise<void> {
 	if (!ctx.hasUI) return;
 	const [{ updateConfig, parseConfig }, { asCrewTheme }, { createSettingsOverlay }] = await Promise.all([
-		import("../../../config/config.ts"),
-		import("../../../ui/theme-adapter.ts"),
-		import("../../../ui/settings-overlay.ts"),
+		import("../../../config/config.ts"), // LAZY: defer heavy command/UI chain until first slash-command (blind-spot #2)
+		import("../../../ui/theme-adapter.ts"), // LAZY: defer heavy command/UI chain until first slash-command (blind-spot #2)
+		import("../../../ui/settings-overlay.ts"), // LAZY: defer heavy command/UI chain until first slash-command (blind-spot #2)
 	]);
 	const loaded = loadConfig(ctx.cwd);
 	const config = loaded.config as Record<string, unknown>;

package/src/extension/registration/foreground-run-controller.ts

@@ -103,7 +103,7 @@ function startForegroundRunImpl(
 		extensionCtx.ui.setWorkingMessage(runId ? `pi-crew foreground run ${runId}...` : "pi-crew foreground run...");
 	}
 	if (runId) {
-		void import("../../runtime/foreground-watchdog.ts")
+		void import("../../runtime/foreground-watchdog.ts") // LAZY: defer watchdog module until first foreground run
 			.then(({ startForegroundWatchdog }) => {
 				startForegroundWatchdog({ pi, cwd: extensionCtx.cwd, runId });
 			})
@@ -139,7 +139,7 @@ function startForegroundRunImpl(
 			.finally(() => {
 				ctx.foregroundTeamRunControllers.delete(key);
 				if (runId) {
-					void import("../../runtime/foreground-watchdog.ts")
+					void import("../../runtime/foreground-watchdog.ts") // LAZY: defer watchdog module until first foreground run
 						.then(({ stopWatchdog }) => {
 							stopWatchdog(runId);
 						})

package/src/extension/registration/lazy-configurers.ts

@@ -67,7 +67,10 @@ function installTurnReconcileHook(pi: ExtensionAPI, ctx: RegistrationContext): v
 			const current = ctx.currentCtx;
 			if (!current || ctx.cleanedUp) return;
 			try {
-				reconcileAllStaleRuns(current.cwd, ctx.getManifestCache(current.cwd), undefined, extractSessionId(current));
+				// RR-021 WI-1.5: async reconcile — fire-and-forget from the sync hook.
+				void reconcileAllStaleRuns(current.cwd, ctx.getManifestCache(current.cwd), undefined, extractSessionId(current)).catch(
+					(error) => logInternalError("register.autoRepair.turnHook", error),
+				);
 			} catch (error) {
 				logInternalError("register.autoRepair.turnHook", error);
 			}

package/src/extension/registration/lifecycle-handlers.ts

@@ -456,17 +456,23 @@ async function runDeferredSessionCleanup(
 
 	// Reconcile stale runs found on disk
 	try {
-		const staleResults =
-			reconcileAllStaleRuns(extensionCtx.cwd, ctx.getManifestCache(extensionCtx.cwd), Date.now(), currentSessionId) ?? [];
-		if (staleResults.length > 0) {
-			ctx.notifyOperator({
-				id: "stale_reconcile",
-				severity: "info",
-				source: "crash-recovery",
-				title: `Reconciled ${staleResults.length} stale run(s)`,
-				body: `Found and repaired ghost runs from previous sessions: ${staleResults.map((r) => r.runId).join(", ")}`,
+		// RR-021 WI-1.5: reconcile is async (mapConcurrent bound 4) — keep this
+		// session_start callback synchronous; notify when the result lands.
+		void reconcileAllStaleRuns(extensionCtx.cwd, ctx.getManifestCache(extensionCtx.cwd), Date.now(), currentSessionId)
+			.then((staleResults) => {
+				if ((staleResults ?? []).length > 0) {
+					ctx.notifyOperator({
+						id: "stale_reconcile",
+						severity: "info",
+						source: "crash-recovery",
+						title: `Reconciled ${staleResults.length} stale run(s)`,
+						body: `Found and repaired ghost runs from previous sessions: ${staleResults.map((r) => r.runId).join(", ")}`,
+					});
+				}
+			})
+			.catch((error) => {
+				logInternalError("register.sessionStart.reconcileStale", error);
 			});
-		}
 	} catch (error) {
 		logInternalError("register.sessionStart.reconcileStale", error);
 	}

package/src/extension/registration/lifecycle.ts

@@ -87,6 +87,7 @@ export function startLifecycleWatchers(ctx: ExtensionContext, state: LifecycleSt
 		// LAZY: async-notifier pulls in debounce + cron helpers — defer
 		// until the first lifecycle install (deferred import within module).
 		void import("../async-notifier.ts").then(({ startAsyncRunNotifier }) => {
+			// LAZY: defer async-notifier until the lifecycle event fires
 			if (deps.isCleanedUp()) return;
 			startAsyncRunNotifier(ctx, deps.notifierState, loadedConfig.config.notifierIntervalMs ?? DEFAULT_UI.notifierIntervalMs, {
 				generation: deps.ownerGeneration,
@@ -110,6 +111,7 @@ export function stopLifecycleWatchers(state: LifecycleState, deps: LifecycleDeps
 	state.notifierStarted = false;
 	try {
 		void import("../async-notifier.ts").then(({ stopAsyncRunNotifier }) => {
+			// LAZY: defer async-notifier until the lifecycle event fires
 			stopAsyncRunNotifier(deps.notifierState);
 		});
 	} catch (error) {

package/src/extension/registration/observability.ts

@@ -71,7 +71,11 @@ export interface ObservabilityDeps {
 	 * newer session. Reuse this counter — do not invent a parallel one.
 	 */
 	getSessionGeneration: () => number;
-	reconcileStaleRuns: (cwd: string, cache: ReturnType<ObservabilityDeps["getManifestCache"]>, currentSessionId?: string) => unknown[];
+	reconcileStaleRuns: (
+		cwd: string,
+		cache: ReturnType<ObservabilityDeps["getManifestCache"]>,
+		currentSessionId?: string,
+	) => unknown[] | Promise<unknown[] | undefined>;
 	reconcileOrphanedTempWorkspaces: (now: number, opts: { cleanupOrphanedTempDirs?: boolean }) => unknown;
 	cleanupOrphanTempDirs: () => { cleaned: number; scanned: number; failed: number };
 	cleanupLegacyOrphanTempDirs: () => { cleaned: number; scanned: number; failed: number };
@@ -253,26 +257,31 @@ async function configureObservabilityInternal(ctx: ExtensionContext, state: Obse
 	if (autoRepairIntervalMs > 0) {
 		state.autoRepairTimer = setInterval(() => {
 			if (deps.isCleanedUp()) return;
-			try {
-				const staleResults = deps.reconcileStaleRuns(ctx.cwd, deps.getManifestCache(ctx.cwd), extractSessionId(ctx));
-				if (Array.isArray(staleResults) && staleResults.length > 0) {
-					for (const result of staleResults) {
-						const repaired = (result as { repaired?: boolean }).repaired;
-						if (repaired) {
-							deps.notifyOperator({
-								id: `auto_repair_${(result as { runId: string }).runId}`,
-								severity: "info",
-								source: "auto-repair",
-								runId: (result as { runId: string }).runId,
-								title: `Auto-repaired stale run`,
-								body: (result as { detail?: string }).detail ?? "",
-							});
+			// RR-021 WI-1.5: reconcileStaleRuns may be async (mapConcurrent) —
+			// settle the result before inspecting, keep errors inside the log.
+			void (async () => {
+				try {
+					const settled = await deps.reconcileStaleRuns(ctx.cwd, deps.getManifestCache(ctx.cwd), extractSessionId(ctx));
+					const staleResults = Array.isArray(settled) ? settled : [];
+					if (staleResults.length > 0) {
+						for (const result of staleResults) {
+							const repaired = (result as { repaired?: boolean }).repaired;
+							if (repaired) {
+								deps.notifyOperator({
+									id: `auto_repair_${(result as { runId: string }).runId}`,
+									severity: "info",
+									source: "auto-repair",
+									runId: (result as { runId: string }).runId,
+									title: `Auto-repaired stale run`,
+									body: (result as { detail?: string }).detail ?? "",
+								});
+							}
 						}
 					}
+				} catch (error) {
+					logInternalError("register.autoRepair", error);
 				}
-			} catch (error) {
-				logInternalError("register.autoRepair", error);
-			}
+			})();
 		}, autoRepairIntervalMs);
 		state.autoRepairTimer.unref();
 

package/src/extension/registration/team-tool.ts

@@ -2,7 +2,7 @@ import { statSync } from "node:fs";
 import type { ExtensionAPI, ExtensionContext, ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import type { TObject } from "@sinclair/typebox";
-import { Value } from "@sinclair/typebox/value";
+import { TypeCompiler } from "@sinclair/typebox/compiler";
 import { loadConfig } from "../../config/config.ts";
 import { findClosestKey } from "../../config/suggestions.ts";
 import type { MetricRegistry } from "../../observability/metric-registry.ts";
@@ -36,6 +36,12 @@ import { withSessionId } from "../team-tool/context.ts";
 import { formatTeamToolParamError } from "../team-tool/param-error.ts";
 import { toolResult } from "../tool-result.ts";
 
+// RR-021 WI-4.3g: compile the team-tool schema ONCE. Value.Check re-walks the
+// whole (large) schema object on every tool call; TypeCompiler.Compile (STATIC
+// method on @sinclair/typebox/compiler) builds a specialized checker at module
+// load. The error formatter keeps using the schema + Value.Errors (cold path).
+const compiledTeamToolParams = TypeCompiler.Compile(TeamToolParams);
+
 /**
  * Normalize model-generated tool params before schema validation.
  *
@@ -228,7 +234,8 @@ export function registerTeamTool(pi: ExtensionAPI, deps: RegisterTeamToolDeps):
 				// validation so strict unions/patterns accept "unset" as omitted.
 				const normalized = normalizeTeamParams(params);
 				// Defense-in-depth: validate params at runtime even though Pi framework already does
-				if (!Value.Check(TeamToolParams, normalized)) {
+				// (RR-021 WI-4.3g: precompiled checker — same semantics as Value.Check.)
+				if (!compiledTeamToolParams.Check(normalized)) {
 					return toolResult(formatTeamToolParamError(TeamToolParams, normalized), { action: "list", status: "error" }, true);
 				}
 				// EXT-1: additionalProperties:true lets unknown (typo'd) keys slip past

package/src/extension/registration/wire-cross-extension.ts

@@ -28,6 +28,7 @@ export function installCrossExtensionWiring(pi: ExtensionAPI, ctx: RegistrationC
 	// in the entire runtime chain) out of the cold-start module graph. EXT-9:
 	// the registry now lives in module-scoped state, not globalThis.
 	void import("../team-tool.ts").then(({ installCrewGlobalRegistry }) => {
+		// LAZY: defer team-tool until cross-extension wiring fires
 		const manifestCacheForRegistry = ctx.getManifestCache(ctx.currentCtx?.cwd ?? process.cwd());
 		installCrewGlobalRegistry({
 			manifestCache: manifestCacheForRegistry,
@@ -57,6 +58,7 @@ export function refreshCrossExtensionWiringForSession(pi: ExtensionAPI, ctx: Reg
 		return;
 	}
 	void import("../team-tool.ts").then(({ installCrewGlobalRegistry }) => {
+		// LAZY: defer team-tool until cross-extension wiring fires
 		installCrewGlobalRegistry({
 			manifestCache: ctx.getManifestCache(ctx.currentCtx?.cwd ?? process.cwd()),
 			cwdProvider: () => ctx.currentCtx?.cwd ?? process.cwd(),

package/src/extension/team-manager-command.ts

@@ -1,5 +1,5 @@
 import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import { listRuns } from "./run-index.ts";
+import { listRecentRuns } from "./run-index.ts";
 // Lazy-loaded: team-tool.ts pulls in entire runtime chain.
 import type { handleTeamTool as HandleTeamToolFn } from "./team-tool.ts";
 
@@ -122,7 +122,8 @@ export async function handleTeamManagerCommand(_args: string, ctx: ExtensionComm
 		return;
 	}
 
-	const runs = listRuns(ctx.cwd).slice(0, 20);
+	// RR-021 WI-4.1: bounded recent-runs read instead of a full index scan.
+	const runs = listRecentRuns(ctx.cwd, 20);
 	if (runs.length === 0) {
 		ctx.ui.notify("No pi-crew runs found.", "info");
 		return;

package/src/extension/team-tool/goal-wrap.ts

@@ -21,6 +21,7 @@ import { loadConfig } from "../../config/config.ts";
 import type { GoalWrapWorkflowConfig } from "../../config/types.ts";
 import { spawnBackgroundTeamRun } from "../../runtime/async-runner.ts";
 import { GoalStore } from "../../runtime/goal-workflow/goal-state-store.ts";
+import { captureRunModelContext } from "../../runtime/model/session-model.ts";
 import { snapshotManifests } from "../../runtime/verification/verification-integrity.ts";
 import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
 import { atomicWriteJson } from "../../state/atomic-write.ts";
@@ -248,6 +249,11 @@ export async function startGoalWrappedRun(
 		store.save(goalState);
 
 		const paths = createRunPaths(cwd, goalId);
+		// Finding #1 (battery 2026-09-29): persist the parent session's model
+		// routing on the goal-loop manifest — the DETACHED runner re-loads this
+		// manifest and has no ExtensionContext to re-resolve it. Without it,
+		// goal-wrap turns silently default-chain (minimax 402 family).
+		const modelContext = captureRunModelContext(ctx, typeof params.model === "string" ? params.model : undefined);
 		const goalLoopManifest: TeamRunManifest = {
 			schemaVersion: 1,
 			runId: goalId,
@@ -267,6 +273,7 @@ export async function startGoalWrappedRun(
 			artifacts: [],
 			ownerSessionId,
 			runKind: "goal-loop",
+			...(modelContext ? { modelContext } : {}),
 		};
 		await saveRunManifestAsync(goalLoopManifest);
 		await appendEventAsync(paths.eventsPath, {