pmacs/TEST_IMPROVEMENT.md

# Testing audit — gaps and shortcomings

Audited 2026-07-29 at `7a3a55d` (branch `journey-stage1a-directory-open`,
even with `main` for everything cited here). Scope: testing coverage and
test quality only, plus CI-pipeline improvements (added mid-audit at the
user's request). This document is the raw material for a future testing
arc; each numbered lane in §8 still needs its own framing doc per the
workflow, and coherence-affecting lanes must state their `COHERENCE.md`
§20 impact there, not here.

**Every count in this file is a reading, not a constant.** The dark-test
census in `docs/active-work.md` ("The CRDT half of the test corpus is
dark in CI — NEEDS A LANE") moved three times in three weeks. Re-measure
before acting; the appendix gives the commands.

Method: five parallel read-only audits (dark/gated tests; unit-coverage
map; Lua-layer coverage; test-quality/flake patterns; CI-vs-local-gate
delta), findings cross-checked against `docs/active-work.md`,
`docs/agent-handoff.md` §3/§5, and the memory of prior review rounds.
Claims that accuse an existing doc of being wrong were re-verified by
hand before inclusion.

---

## 0. Baseline: what exists

- Root `pmacs` package: ~2,030 unit tests in `src/`, 92 integration
  targets in `tests/` (~93k lines, ~1,426 tests), shared harness in
  `tests/common/` (daemon + PTY, both high quality).
- `pmacs-gpu`: 202 unit tests, including a real headless wgpu render
  harness with ~20 pixel-asserting tests. No `tests/` dir; bin-only, so
  doctests are structurally impossible.
- `pmacs-protocol`: 17 unit tests (12 transport, 5 terminal). No
  `tests/` dir.
- `builtin/`: 16,445 lines of Lua across 31 files. No Lua test
  framework of any kind; all coverage is indirect via Rust `eval()`.
- Property tests: 5 proptest sites, all in the root crate (CRDT
  convergence, rope≡CRDT projection, text_view inverse, keymap stack,
  manifest round-trip). One checked-in regression seed (`crdt.txt`).
  No fuzzing anywhere.
- CI: one workflow, 8 jobs / 12 legs, ~14.5 min wall per run, triggers
  on `push:main` + `pull_request` only. No coverage measurement, no
  scheduled runs, no branch protection on `main` (verified via API:
  404, so every job is advisory).

The suite is unusually thoughtful in places — the daemon harness's
connect-based readiness probe, the `PMACS_REQUIRE_GPU` hard-fail
pattern, `dual_mode_test!`, the encoding-stability pins, `scripts/bite`
itself. Most defects below are **inconsistent application of patterns
the project already invented**: the correct helper exists in one file
and a degraded copy exists in another.

---

## 1. Dark tests — things that never run

### 1.1 CRDT (known; already a scoped lane — do not re-scope here)

`docs/active-work.md` §"The CRDT half of the test corpus is dark in CI"
carries the full census (273 dark at `74301d1`: 185 library + 88
integration), the two-part fix shape, and the two standing obstacles
(`clippy --features crdt` is red on `main`; the `setsid_escapee` ~1-in-5
load flake). Defer to it. What this audit **adds** to that lane:

- **Nothing anywhere compiles the 8 `#![cfg(feature = "crdt")]`
  integration targets** — not CI, and not the local gates either:
  `cargo test --lib --features crdt` builds the library only. The
  `*_crdt_acceptance.rs` / `m10_*` files are type-checked exclusively
  on developer machines that happen to run them by name. CI builds
  them as empty green binaries, which reads as "passed" in the log.
- `tests/m10_11_perf.rs` puts its `#![cfg(feature = "crdt")]` at line
  60, after the module doc — any future head-of-file scan for the gate
  will misclassify it (the "never classify from truncated output" trap,
  now in file-layout form).
- `src/buffer.rs:2984` — the parked CRDT no-op-replace undo bug is
  doubly dark (`#[ignore]` + crdt) and its own comment says un-ignoring
  it is step one of the fix. It needs a named owner or it will sit
  forever.

### 1.2 Vacuous-green skips: tests that pass without executing

The `let Ok(_) = which_binary(x) else { eprintln!(...); return; }` shape
passes green when the tool is absent. **21 external-tool-gated tests; 15
have never executed their bodies in CI** because `ci.yml` installs none
of the tools (the only `apt-get install` in the workflow is lavapipe):

- All 9 real-language-server tests in `tests/m4_acceptance.rs`
  (rust-analyzer ×2, basedpyright, clangd ×2, gopls ×2, json-ls,
  yaml-ls) — the only real-LSP coverage in the suite.
- The entire M6.8 multi-REPL acceptance (6/6 tests, gated on a
  lua/luajit binary) plus the zsh/fish/lua shell-spawn tests in
  `tests/m6_5_repl_acceptance.rs`.

Same pathology, already ledger-documented: `a37` in
`tests/vterm_stage3_acceptance.rs` is triple-dark (crdt-gated; skips
when `pmacs-gpu` isn't built; `PMACS_REQUIRE_GPU` is only set on a job
that tests a *different package*). It has never executed in CI.

**The project already owns the fix pattern**: `PMACS_REQUIRE_GPU`
promotes a silent skip to a hard failure, and CI arms it on the
`gpu-render` job. There is no `PMACS_REQUIRE_LSP` / `PMACS_REQUIRE_SHELLS`
analogue, and no CI step installs the cheap tools (gopls, clangd, zsh,
fish, lua are all one `apt-get`/`brew` line; basedpyright is an npm
install).

Related mid-test variant: `tests/m4_acceptance.rs:5783-5789` skips its
only assertion when rust-analyzer is "likely still indexing" — the
assertion vanishes exactly when the system is slow, which is when a
regression would show.

### 1.3 Ignored tests owned by nobody

27 `#[ignore]` tests; 11 run in the four `--ignored` CI jobs; **16 run
nowhere**:

- `src/rope.rs:1101,1112,1130` (3 perf smokes) and `src/buffer.rs:2984`
  — `cargo test --lib` never passes `--ignored`; these are dead code
  that still compiles.
- `tests/m3_acceptance.rs:218` (`m3_6_grep_kernel_under_2s_on_8_cores`)
  — `#[ignore]` + needs `PMACS_KERNEL_PATH` + no job names
  `m3_acceptance --ignored`.
- The m10_2/m10_11 perf and doubled-PTY operator tests (crdt-gated on
  top of `#[ignore]`; the doubled-PTY trio is deliberately
  operator-invoked — fine, but nothing records when it last ran).

### 1.4 CI runs weakened versions of the gates it does run

CI green currently certifies less than the spec text implies:

- `async_runtime_soak_lifecycle_stable` runs at **10 s vs its 3600 s
  spec gate** (`PMACS_SOAK_SECS`); the hour-long soak has never run.
- M6 ingest gate: CI floor 64 MB/s vs the 100 MB/s default; cancel
  gate: 30 trials/500 ms vs 100/5000. Documented in `ci.yml` comments
  as a runner-budget tradeoff, but nothing anywhere runs the full
  profile, ever.
- The soak's FD and RSS assertions silently no-op on macOS
  (`/proc`-dependent) while the test reports green.

---

## 2. Coverage gaps by layer

### 2.1 pmacs-protocol: the wire format is tested from the wrong crate

`pmacs-protocol/src/message.rs` — 2,100 lines: `InstanceMessage`,
`FrontendEvent`, `Hello`, capability negotiation, version constants —
has **zero tests in its own crate**. The real coverage (117 tests:
postcard round-trips, v16–v19 encoding-stability pins, negotiation
matrix) lives in the root package's `src/protocol.rs`. Consequences:

- `cargo test -p pmacs-protocol` certifies almost nothing (17 tests).
- A future consumer that depends on `pmacs-protocol` alone inherits an
  effectively untested crate.
- CI's `-p pmacs-protocol --all-targets` step cannot run doctests
  (`--all-targets` excludes them) — zero exist today, so this is a trap
  armed for the first doctest someone writes.

Also: local `cargo fmt --check` (no `--all`) formats the root package
only, and local clippy via `--workspace` covers `pmacs-protocol` while
CI's clippy never does — each side has a hole the other covers.

### 2.2 Root crate: zero-test production files

Largest files with **no `#[cfg(test)]` at all**:
`src/terminal/session.rs` (854 — the process/session registry),
`src/lua_bindings/window_panel.rs` (796), `src/lua_bindings/mcp.rs`
(602), `src/lua_bindings/index.rs` (395), `src/lua_bindings/fold.rs`
(390), `src/lua_bindings/diag.rs` (237), `src/audit/rules.rs` (154).
Thinnest large files: `src/mcp.rs` (2.5 tests/kloc),
`src/lua_bindings/mod.rs` (13,955 prod lines, 10.6/kloc — also the
F-016 split candidate), `src/daemon.rs` (9.7/kloc). The lua_bindings
submodules are integration-covered via acceptance suites but have no
unit-level pins; per the project's own review history ("pin where
production CALLS"), that leaves the binding seam itself unpinned.

The LSP client (`src/lsp.rs`) unit-tests only wire mechanics (framing,
URIs, position encoding); server lifecycle, capability handling, and
the diagnostics pipeline are covered solely through the fake-LSP
acceptance path — plus the 9 real-server tests that never run (§1.2).

### 2.3 pmacs-gpu: the live half is untested

Well covered: headless render, math layout/parse, attach negotiation,
coalescing, minimap, tab projection. Untested: the winit
`ApplicationHandler` event loop (one test), the live surface/swapchain
`render()` path (only the offscreen twin is exercised), clipboard
(`arboard` — zero tests reference cut/copy/paste), font-database
sanitization beyond the four bundled fixture TTFs, edge-scroll/context
menu/minibuffer interactive drivers. No proptests in the crate.

### 2.4 The Lua layer: 16.4k lines, no test framework, one universal
guarantee

Every `EditorState::new()` evals all 30 runtime chunks, so every Rust
test is a *load/syntax* smoke for all Lua. Behavior coverage is via
per-file `eval()` helpers **copy-pasted into 67 of 92 test files** (823
call sites) poking module namespaces directly. Findings:

- **`pmacs.error` is a test-stub-only API — confirmed and worse than
  the memory of it.** ~35 references across 9 builtin files, every one
  guarded (`if pmacs.error then` / `pcall`). Production never assigns
  it; the only assignments are 10 stubs inside test code. The tests
  that assert into those stubs prove the message is *formatted*, not
  that anyone receives it — all would stay green if the channel were
  deleted. `dired.lua:56`, `lsp.lua:1659`, `lean.lua:171` acknowledge
  this in comments and route around it via `set_status`. The
  `COHERENCE.md` tally ("fifteen call sites") is stale.
- **56 statement-position `pcall`s discard errors entirely**, 25 of
  them in `lsp.lua`'s hot path (`did_change`, `did_open`, inlay/token
  pulls). A server going silent after a failed `did_change` is
  unobservable — including to the test suite.
- **Interaction islands with zero test contact**: `menus/default.lua`
  (6 of 11 commands never referenced anywhere in the tree),
  `keymaps/default.lua` (no suite pins the default binding table — a
  silent rebinding regression only surfaces if an unrelated suite
  happens to type that key), `window.lua` and `fold.lua` (10/10
  registered commands unnamed in tests; their frontend/point-resolution
  wrapper bodies are bypassed by the Rust-level tests underneath),
  `workers.cancel-at-point` and `recent-files` (never mentioned).
- **Command-name coverage is the honest metric and it is low**:
  `lsp.lua` registers 15 commands, 12 never named by any test;
  `commands/default.lua` registers 80, 35 never named.
- `builtin/api/packages.lua` is never loaded or parsed by anything; its
  single "test" greps it as a string for three substrings.
- `lean_abbrev.lua` (1,883 lines, 11% of the Lua tree) has ~5
  assertions; generated data, low risk, but zero drift detection
  against its generator.

### 2.5 No fuzzing, and two ideal targets

No cargo-fuzz/AFL/libfuzzer anywhere. The two highest-value targets are
exactly the shapes fuzzing is best at: `pmacs_protocol::transport::
read_message` (length-prefixed decoder with a `MAX_FRAME_BYTES` guard;
12 hand tests) and `src/ansi.rs` (VT escape parser; 44 hand tests).
Both parse attacker-adjacent input (a compromised frontend socket; PTY
output from arbitrary child processes). The existing 30 s
`fuzz_no_crashes` in `tests/acceptance.rs` fuzzes buffer edits only.

---

## 3. Test-quality defects (races, hangs, silent lies)

Ranked; each is a known-bitten shape recurring in a new place.

1. **`RuntimeHandles::drop` joins a non-interruptible reader with no
   timeout** (`src/process.rs:631-642` + `:1874`). This is the real
   basedpyright hang: a PATH'd server leaving a descendant holding the
   stdout write end blocks `read()` forever, below every test-level
   deadline. It is a **product** defect the skip merely hides; the fix
   (give non-group readers the `O_NONBLOCK`+poll loop that group
   readers already have) is named as a deferral at
   `src/process.rs:1937-1940`. Fixing it retires the `--skip
   basedpyright` clause from the gates and the latent CI stall (§4).
2. **`wait_for_file` without a non-empty guard**
   (`tests/vterm_stage2_acceptance.rs:723`) — returns on the first
   successful read, including the zero-byte window of the non-atomic
   writers it waits on; four call sites then assert exact bytes. The
   fixed variant (`&& !bytes.is_empty()`) already exists at
   `tests/bottom_panel_stage1_acceptance.rs:2307` — someone was bitten
   and patched only the local copy. The vterm file's own panic message
   ("published but malformed") describes the race it causes. Cheapest
   high-value fix in this audit.
3. **Fixed-iteration `settle()` as the sole synchronization before
   strict assertions about a real forked LSP child** — 16–20 ms total,
   no predicate, no deadline: `tests/lsp_multi_root_acceptance.rs:125`,
   `tests/lsp_dispatch_seams_acceptance.rs:105`,
   `tests/lean4_server_acceptance.rs:112`; ~58 `settle()` calls gating
   ~68 tests. The correct predicate-plus-deadline pump exists at
   `tests/journey_acceptance.rs:63`, `tests/dired_acceptance.rs:107`,
   and (exemplary, with diagnostic dumps) `tests/m10_11_acceptance.rs:316`.
4. **`drain_until`/`drain_lsp_until` return partial results on timeout
   instead of panicking, and 15 call sites discard the result** (`let _
   = drain_lsp_until(...)`). A test whose awaited event never arrives
   proceeds unsynchronized and fails elsewhere — or passes for the
   wrong reason. `tests/m9_4_acceptance.rs:121` already does it right
   (panic with the job id). Also note these helpers are effectful
   (ticking reaps children, `take_events` consumes) — the known
   `drain_until` trap — and at least one assertion
   (`tests/m4_acceptance.rs:1070-1084`) is load-bearing on the side
   effect of a *discarded* call.
5. **Git fixtures inherit the ambient global gitconfig** (9 files, e.g.
   `tests/m8_7_acceptance.rs:87`, `tests/m7_review_acceptance.rs:30`).
   A developer with `commit.gpgsign = true` gets an unbounded pinentry
   hang inside `git commit`. One `GIT_CONFIG_GLOBAL=/dev/null` +
   `GIT_CONFIG_NOSYSTEM=1` pair per fixture closes it.
6. **Bare sleeps with strict assertions after**: 20 sleep-then-assert
   sites outside poll loops, notably `tests/m5_5_acceptance.rs:184`
   (300 ms for daemon slot-clear), `tests/m4_acceptance.rs:7093`
   (120 ms against a 75 ms coalescing window — 45 ms of margin), and
   negative assertions after fixed waits
   (`tests/lean4_server_acceptance.rs:493` acc28,
   `tests/m8_7_acceptance.rs:786`) that pass if the thing simply
   hasn't happened *yet* — each needs a positive-control sentinel.
7. **Unit tests that require serial execution without declaring it**:
   `src/file_io.rs:427` mutates process-wide cwd (`set_current_dir`)
   while concurrent tests resolve relative paths through
   `current_dir()` fallbacks; `/proc`-global probes in
   `tests/worker_shutdown_acceptance.rs` and the M6.6 RSS gate.
8. **Smaller but real**: no `set_read_timeout` in
   `tests/gpu_invocation_acceptance.rs:165`'s hand-rolled
   `wait_for_daemon` (the shared harness's version at
   `tests/common/daemon.rs:200` has one, with a comment saying why); a
   2 s 100%-CPU busy-spin at
   `tests/statusline_segments_acceptance.rs:1016` that manufactures
   load for its siblings; leaked orphan daemons on timeout in
   `tests/m5_7_acceptance.rs:211` plus a PID-reuse-unsafe `kill(pid,0)`
   probe; `PmacsPty::output()` clones an unbounded buffer on every
   20 ms poll (`tests/common/pty.rs:55`); `sleep(1100ms)` in a unit
   test (`src/file_io.rs:420`).

**The serialization contract is CI-only and it cuts both ways.**
`--test-threads=1` appears at five points in `ci.yml` and nowhere in
the documented local gates, `.cargo/`, or any hook. So the process-
lifecycle races CI's comment admits to dodging are structurally never
caught (masked in CI, dismissed as local flakes), while
serial-dependent tests (the `settle()` family, `/proc` probes, the cwd
test) pass in CI and flake for whoever runs the documented local gate.

---

## 4. Tooling and infrastructure gaps

- **`scripts/bite` has no positive control.** It never runs the tests
  against the *current* tree, so a test that fails everywhere — e.g.
  broken, or environmentally skipped-then-failing — reports `bite: OK`.
  Given §1.2's silent skips, a bite claim on a PATH-gated test is
  meaningless. ~5-line fix: require `cargo test "$@"` to pass on the
  unmodified tree first.
- **`docs/agent-handoff.md` (§5, "A fix must be COMMITTED before it is
  bitten") misdescribes bite's mechanism** — verified: it claims
  restore-by-`git checkout --` (revert to HEAD, destroying uncommitted
  work), but the script has restored from a `mktemp` copy via `cp` +
  `trap` since its only commit. The commit-first rule stays sound for
  two *different* reasons (SIGKILL bypasses the trap; biting an old
  version of your own uncommitted claim is circular), but the stated
  mechanism will mislead an agent reasoning about what is safe. Fix
  the doc, keep the rule.
- **Bite-verification is honor-system.** It's step 4 of the working
  method and appears in eight framing docs as prose claims, but
  nothing re-checks a bite after the code moves. (A CI mode is
  probably overkill; recording the bitten ref+command in the framing
  doc would at least make claims re-runnable.)
- **No coverage measurement, Rust or Lua.** No tarpaulin/llvm-cov/
  grcov/luacov anywhere. For Lua it's worse than absent: Rust line
  coverage of `include_str!` chunks would report the *eval* line, not
  which Lua branches ran. §2.4's command-name coverage is currently the
  only measurable proxy.
- **No enforcement layer between "documented gates" and "what runs"**:
  the gate list exists as prose in three places (CLAUDE.md, AGENTS.md,
  handoff §3 — the handoff adds a full-workspace sweep the other two
  omit). No script runs the suite, so drift among the three copies is
  invisible. A `scripts/gates` that executes the canonical list would
  make the prose testable.

---

## 5. CI: correctness hardening

(Findings that change what CI *certifies*; speedups are §6.)

1. **Branch protection is off** — every job is advisory; a red run
   merges as easily as a green one. Turn on required checks for the
   cheap deterministic jobs at minimum (fmt, clippy, ubuntu test legs).
2. **No job timeouts except m6** (15 min). Everything else inherits
   360 min. The day a runner image ships any of the PATH-gated tools
   (§1.2), the basedpyright-class hang burns 6 h × 4 matrix legs with
   no signal. `timeout-minutes: 25` on every job is free insurance.
3. **The crdt lane** (already scoped in `docs/active-work.md`): CI leg
   for `--features luajit,crdt`, GPU-requiring crdt suites onto
   `gpu-render` with `PMACS_REQUIRE_GPU=1` stated as a requirement (or
   a37 runs vacuously), clippy-crdt fixed first. Not re-scoped here.
4. **Arm the skips it already runs**: install gopls/clangd/zsh/fish/
   lua on the ubuntu test leg (one apt line + one `go install`/npm
   line) and add `PMACS_REQUIRE_LSP`/`PMACS_REQUIRE_SHELLS` env
   guards mirroring `PMACS_REQUIRE_GPU`, set only on legs where the
   tools are installed. This converts 15 permanently-vacuous tests
   into real CI coverage.
5. **A scheduled (cron) job** for what per-PR CI can't afford: the
   3600 s soak, full M6 cancel/ingest profiles, the `--ignored` perf
   smokes nothing runs (§1.3), and N repetitions of the known
   load-sensitive suites as a flake canary. Nightly, ubuntu-only,
   `workflow_dispatch` for manual runs. This also gives intermittent
   failures a place to burn in instead of surfacing mid-review.
6. **One deliberately-parallel leg** (default test threads, ubuntu,
   allowed-to-fail at first) so the races serialization currently
   masks become visible on purpose instead of as local flakes.
7. **`pmacs-protocol` clippy** — add `-p pmacs-protocol` to the CI
   clippy job (local `--workspace` covers it; CI never has).

## 6. CI: speedups and efficiency

Measured baseline (run 30454133846, warm cache): wall ~14.5 min;
critical path is `Test (macos-latest/luajit)` at ~14.6 min, macos/lua54
~10 min, ubuntu test legs ~6.7 min, perf gates 2–3.5 min, everything
else ≤1.5 min.

1. **No `concurrency` group** — force-pushes and the ledger-contention
   rebase treadmill leave superseded runs burning to completion. Add
   `concurrency: {group: ci-${{ github.ref }}, cancel-in-progress:
   true}` guarded to PRs. Likely the single largest minutes saving
   given the project's rebase-heavy flow, and macOS minutes are the
   expensive ones.
2. **Split serial from parallel on the test job.** `--test-threads=1`
   serializes ~3,200 tests for the sake of a handful of
   process-lifecycle suites. Splitting into `cargo test --lib` (parallel)
   + integration targets (serial) would cut the critical-path macOS leg
   substantially; nextest (below) is the cleaner version of the same
   move.
3. **Consider cargo-nextest** for the test job: per-test process
   isolation retires the cwd/`/proc`/env hazards of §3.7 *and* enables
   safe parallelism; per-test timeouts retire the hang class at the
   runner level; automatic retries with failure reporting make the
   known load-flakes visible instead of rerun-by-hand; JUnit output
   for free. This is the one tool that converts several §3 classes
   from "fix each site" to "fixed by construction".
4. **Trim the macOS matrix if minutes matter**: the lua-flavor cfg
   audit found zero flavor-gated tests — the 2×2 matrix only varies
   mlua's backend. macOS × lua54 has caught real macOS bugs
   (`m4_5` config-sink race was lua54/macOS-shaped), so don't drop
   macOS — but macOS × one flavor + ubuntu × both retains the platform
   signal at ¾ the macOS cost. Decide from flake history, not a priori.
5. **Redundant work, minor**: `cargo build --all-targets` before
   `cargo test --all-targets` is a near-no-op (incremental) but adds
   log noise; `-p pmacs-protocol` runs identically on all 4 legs
   (comment acknowledges; it's seconds); the gpu-render apt-get runs
   every job (~20 s; cacheable via `actions/cache` on the deb pool if
   it ever grows).
6. **Perf gates on shared runners** already run loosened profiles
   (§1.4) and are the most variance-exposed jobs. If they start
   flaking, prefer trend-tracking (store the measured numbers as
   artifacts, gate on regression-vs-window) over further threshold
   loosening — a threshold loose enough to never flake certifies
   nothing.

---

## 7. What is deliberately out of scope

- Windows: no `cfg(windows)` code exists; unix-only sockets. Not a
  testing gap until the product targets it.
- `src/bin/pmacs_fake_lsp.rs` / `pmacs_fake_mcp.rs` (3,145 untested
  lines): test fixtures; testing the fakes is circular. Their fidelity
  is instead covered by §1.2's real-server tests — which is an argument
  for §5.4, not for unit-testing the fakes.
- The lean4/latex suites' stub-based design (`lake_stub`,
  vendored grammar): verified deliberate and CI-real; not a gap.

## 8. Candidate lanes for the arc (priority order)

1. **CRDT CI lane** — already scoped in `docs/active-work.md`; first
   task there is deliberate-vs-accidental classification. Blockers:
   clippy-crdt red, a37 vacuity, first-run flake budget.
2. **Silent-skip arming** (§1.2, §5.4) — install tools + `PMACS_REQUIRE_*`
   guards. Small, mechanical, converts 15 vacuous tests to real ones.
   Independent of lane 1.
3. **CI hardening/speedup** (§5.1–2, §6.1–3) — timeouts, concurrency,
   branch protection, serial/parallel split or nextest. No product code.
4. **The reader-join hang** (§3.1) — the one product fix in this list;
   retires the basedpyright skip everywhere. Already a named deferral
   in `src/process.rs`.
5. **Race-shape cleanup sweep** (§3.2–6) — port the already-invented
   fixes (non-empty guard, predicate pumps, panic-on-timeout, git env
   pinning) to the degraded copies. Mostly mechanical; each fix should
   be bite-verified, which motivates doing lane 6 first or alongside.
6. **`scripts/bite` positive control + handoff correction** (§4) —
   tiny, but raises the trust ceiling on every other lane's
   verification claims.
7. **Lua error-channel decision** (§2.4) — either define `pmacs.error`
   in production or delete the 35 dead references and standardize on
   `set_status`; then a sweep of the 56 discarded pcalls. This is a
   product-coherence question (COHERENCE.md owns the framing) as much
   as a testing one.
8. **Protocol-crate self-sufficiency** (§2.1) — move/duplicate the
   round-trip + negotiation pins into `pmacs-protocol`; add its clippy
   to CI. Mechanical but wide.
9. **Fuzz targets** (§2.5) — `read_message` + ANSI parser, run on the
   cron job (lane 3's infrastructure).
10. **Coverage floor for the untested-file list** (§2.2, §2.3) and
    **Lua interaction-island pins** (§2.4: menus, default keymap,
    window/fold wrappers) — largest and least mechanical; needs its
    own framing to avoid writing biteless tests, per the project's own
    "new tests need their own bite" history.

---

## Appendix: re-measurement commands

```sh
# Dark-test census (re-measure, never quote):
cargo test --all-targets --no-default-features --features luajit -- --list | grep -c ': test'
cargo test --all-targets --no-default-features --features luajit,crdt -- --list | grep -c ': test'

# Ignored tests that no job runs:
grep -rn '#\[ignore' src/ tests/ --include='*.rs'

# Silent-skip sites:
grep -rn 'which_binary\|not on PATH; skipping' tests/

# pmacs.error references (production never assigns it):
grep -rn 'pmacs\.error\b' builtin/ --include='*.lua'

# Discarded statement-position pcalls:
grep -rn '^\s*pcall(' builtin/ --include='*.lua'

# Per-job CI timing for a run:
gh run view <run-id> --json jobs --jq '.jobs[] | "\(.name): \(.startedAt) -> \(.completedAt)"'
```