@mu-crew/mu 3.13.0 → 3.13.2

package/skills/mu/recipes/review-panel.md

@@ -28,11 +28,12 @@ panel's findings will be fixed by agents. Both modes are in
    | correctness | logic errors, edge cases, error paths, races |
    | security | injection, auth and permission checks, secrets, unsafe input |
    | simplicity | duplication, dead code, needless abstraction, an existing helper not reused |
-   | tests | changed behaviour without a test, tests that cannot fail |
+   | tests | risky coverage gaps, ineffective tests, level/duplication/wait/cost findings ([test-health](test-health.md#adding-or-changing-tests)) |
    | rules | the repo's written rules (see [rules-audit](rules-audit.md)) |
 
    Each reviewer gets the range, its angle, and the [brief](brief.md)
-   rules; it edits nothing. A clean result (`FINDINGS: none` plus the
+   rules and available gate records ([test-health](test-health.md#gate-contract));
+   coordinate targeted checks across angles. It edits nothing. A clean result (`FINDINGS: none` plus the
    commands it ran) is a valid result.
 3. **Record findings** by mode:
    - delegate: each reviewer ends its answer with `FINDING:` lines;
@@ -60,5 +61,5 @@ triage and the umbrella closes with `--if-ready` (workstream mode).
   author's tier or higher ([models](models.md#checkers)); one model's
   blind spot repeated five times is still one blind spot. Pass `model`
   to `mu_delegate`.
-- **The panel is not the gate command.** Merge verification still runs on the
+- **The panel is not the slow gate.** Merge verification still runs on the
   merged tree ([orchestrator-loop](orchestrator-loop.md#merging)).

package/skills/mu/recipes/test-health.md

@@ -0,0 +1,84 @@
+# Test health
+
+Read when defining gates, choosing worker/reviewer verification, adding tests,
+or doing upkeep at a milestone, a budget crossing, or the user's request.
+Testing stays encouraged; upkeep protects coverage and the iteration loop.
+
+## Gate contract
+
+Use the repo's `## Gates` in AGENTS.md or README: fast and slow commands,
+slow-gate budget (default 5 min), and a targeted slow-test command. Plan notes
+point there. Until a split is approved, keep the existing repo gate intact;
+recipe guidance does not waive project checks. Fast means iteration checks,
+not a universal seconds promise: measure cold and warm costs.
+
+- **Worker:** run the fast gate while iterating; before closing, run slow
+  tests for the changed area once, then fast on the final commit. Record
+  both, or why a scope is inapplicable/unavailable. Changes invalidate records.
+- **Reviewer:** inspect the diff and reuse equivalent worker records. Run
+  uncovered tests for the diff and reproduce claimed failures, rather than
+  repeating the full suite or building the parent for every new test.
+- **Orchestrator:** verify one pinned merged tree per batch with the full
+  slow gate, plus fast if slow does not include it. All required integration,
+  auth, release and packaging checks still pass before push. Bisect a failed
+  batch; record the corrected tree's pass. See [merging](orchestrator-loop.md#merging).
+
+Gate records are task-note text, not a mu command or stored result cache:
+
+```text
+GATE: commit=<sha> tree=<hash>; command=<exact command + filters>; scope=<full/area>
+RESULT: exit=<code>; duration=<wall time>; counts=<tests/assertions>; skips=<none or reasons>
+CONDITIONS: <toolchain, host/platform, privileges, relevant env/features, cache state>
+```
+
+Reuse requires the same tree, command/scope and equivalent execution
+conditions. Record uncommitted inputs too; a dirty tree hash alone is not
+an identity. A targeted pass, zero selected cases, or a skipped privileged
+check is not a full pass. Clear/reject inherited selectors for full runs;
+report skips explicitly and resolve required missing checks before push.
+
+## Adding or changing tests
+
+Use the lowest level that catches the failure, covering behaviour not
+already guarded. A new slow case states what only it can see in a comment
+or commit message. For a bug with a cheap, obvious local target, the worker
+shows red on the base and green on the fix; feature work and integration-heavy
+paths need no mandatory red-green ceremony. Use direct executable evidence
+when stronger, recording the reason.
+
+Poll readiness/completion with a bound and useful failure output. Retain
+necessary temporal sampling, negative-observation windows and deliberately
+sleeping process fixtures; explain their timing contract.
+
+Reviewer findings identify risky untested/broken behaviour, a wrong test
+level, duplication of a named test, avoidable readiness padding, or measured
+gate slowdown—not every conceivable edge case without a test.
+
+## Upkeep loop
+
+Queue ordinary upkeep work at each phase/milestone end or when a merged slow
+gate exceeds budget. Prioritise it before new features; continue independent
+work. A budget is a scheduling trigger, not an indefinite crew-wide stop.
+
+1. **Profile.** Time each gate step and test, including setup/teardown.
+   List up to 20 slowest tests per level; inspect waits and repeated builds,
+   cold caches and profiles. BEFORE records wall time, counts, skips and
+   conditions. Use inspected execution logs, not commands merely mentioning
+   a gate or compound-command durations attributed entirely to tests.
+2. **Classify.** Parallel [delegate calls](tasks-or-calls.md#delegate-call),
+   one per area, give slow/overlapping tests an evidenced verdict:
+   KEEP; SPEED-UP (poll or share setup with isolation); MOVE-DOWN;
+   MERGE into a named test; DELETE as covered by a named test.
+3. **Refute.** Send every MERGE/DELETE verdict to a refuter: which failure
+   would no longer be caught? A refuted or unresolved verdict becomes KEEP.
+4. **Do.** Dispatch surviving changes as normal test-only tasks. Review
+   coverage preservation, isolation and correctness of the harness changes.
+   Preserve auth lanes, privilege checks and release scans; measure safe
+   [build reuse](orchestrator-loop.md#build-cache) separately.
+5. **Measure.** Run the merged gates and record AFTER under comparable
+   conditions, including coverage/count changes. If neither faster nor
+   smaller, say so and why; smaller alone does not prove preserved coverage.
+
+Done when AFTER records the outcome and the slow gate is within budget, or
+names the remaining bottleneck and prioritised follow-up. Keep unmet required
+checks distinct from a time-budget overrun.

package/skills/mu/recipes/waves.md

@@ -10,12 +10,12 @@ runs in its own `--workspace`; this recipe decides what each one gets.
    the shared files. A blanket freeze idled four of five workers for a
    day.
 3. **Pipeline the merge.** Cherry-pick each task as it closes and
-   verify the merged tree ([orchestrator-loop § Merging](orchestrator-loop.md#merging));
-   never wait for the whole wave.
+   verify pinned merge batches ([orchestrator-loop § Merging](orchestrator-loop.md#merging));
+   batching gates does not mean waiting for the whole wave.
 4. **Refresh before each dispatch.** `mu workspace refresh <agent>`
    rebases onto the tracked main (git: `origin/HEAD`, so unpushed local
    merges are missed; pass `--from <local-branch>` to include them) and
    keeps the agent's context; run it before every `--fresh` send.
 
 Done when every task in the wave is `CLOSED/done`, merged, and the
-merged tree passes the gate command.
+merged tree passes the slow gate and fast if needed, per the repo contract.

package/skills/mu/recipes/worker.md

@@ -17,11 +17,15 @@ mu task note <id> "FILES: ...\nCOMMANDS: ... (exit codes)\nDECISION: ...\nVERIFI
 mu task close <id> --evidence "tests pass: ..."  # LAST action
 ```
 
+Follow [test-health](test-health.md) for fast iteration checks, targeted slow
+checks before close, gate records, and cheap bug red-green. Include the gate
+records in your final note; adding tests uses its test-level and timing rules.
+
 The note follows the task note contract in SKILL.md. Keep each tool
 call to minutes (short batches, waits with a timeout): steering reaches
 you only between tool calls. Commit before you close: the orchestrator cherry-picks your commits, not your tree. A
 review or audit task records each problem per
 [findings § Record](findings.md#record).
 
-Done when your changes are committed in the workspace, the task note holds FILES, COMMANDS (with exit codes) and VERIFIED, and `mu task close` succeeded as your last action. Skipping close makes the orchestrator's
+Done when your changes are committed in the workspace, the task note holds FILES, COMMANDS (with exit codes), VERIFIED and applicable gate records, and `mu task close` succeeded as your last action. Skipping close makes the orchestrator's
 wait hang. Won't do it: `close --as wontfix --why "..."`.