feat(phase-21): wave_targets skips close=0 plumbing-blocked near-misses from the pool

- self-MATCH-but-gate-rejected fns can never bank via re-drafting (the drafter reproduces the
  byte-correct body the gate rejects again) -> exclude from POOL selection so agents draft FRESH
  targets; they stay in the backlog as recovery-tooling/hand-finish fuel
- CURRENT_PHASE: sustained-loop state + pool-mode override policy (compaction-recovery anchor)

phase-ends/CURRENT_PHASE.md

@@ -138,8 +138,26 @@ cycle; after idle it did `tried.clear()` and looped forever (§20 trap). Fixed B
 136/136 byte-identical (per-bank gate G3/P9; full check-all deferred to a checkpoint), 0 NON_MATCHING, 3 new
 cookbook idioms, grinder + sig_unify both upgraded. Diagnostics in `.run/{diag_plumbing,repro_gate,test_defsig}.py`.
 
+## SUSTAINED LOOP (2026-06-21→22, Drew: "keep waves going, don't stop till I check in ~8h")
+Continuous worker loop running, driven by Workflow-completion (NOT a timer): per wave →
+`orchestrator.py finish --commit` (gate+bank+propagate ×134) → `distill.js` if verified → `orchestrator.py prep
+--mode pool --n 24` → launch `worker_wave.js` with the batch pasted **verbatim** from the compact dump (Workflow
+scripts have no fs access; transcribe carefully). Gate/finish run **backgrounded + dangerouslyDisableSandbox**
+(foreground `make build`/`git` get sandbox-killed exit 144). Grinder runs alongside (token-free, blacklist-aware).
+- **POOL-mode override (policy):** auto-mode keeps firing class-focused REGALLOC waves, but that class has
+  saturated with permuter-class/DEF-side-plumbing residuals agents can't crack from C → low yield. Use
+  `prep --mode pool` to harvest FRESH reach-134 targets (higher yield); leave regalloc residuals to the grinder
+  (permuter) + backlog (hand-finishing). The DEF-side `close=0` set (func_80174CB0/80169228/80167714 …) won't bank
+  via re-drafting — they're hand-finish fuel.
+- **Running tally (this session, fleet 59.05% start):** waves 1-6 launched; banked via worker gates + the sig_unify
+  recovery. Fleet **59.87%** after wave 5 (wave 6 in flight). 4 new cookbook idioms distilled
+  (`commit:0194 commit:0196 commit:0198 commit:0203`). Commits `commit:0193…commit:0202` + option-C `commit:0200`.
+- **To resume after compaction:** read this section + `docs/automation-runbook.md`; the next step is always
+  gate the in-flight wave (`.run/auto/finish_wave<N>.log` / orchestrator finish) → distill → prep --mode pool →
+  launch. Stop only when Drew says so (`bash tools/auto_stop.sh` halts the grinder).
+
 ## Blockers
-(none — grinder running blacklist-aware with the enhanced sig_unify in its gate; worker waves paused pending Drew.)
+(none — grinder running blacklist-aware + enhanced sig_unify; worker loop sustained per Drew until check-in.)
 
 ## Per-task log
 

tools/wave_targets.py

@@ -64,6 +64,16 @@ def backlog_walls():
     return walls
 
 
+def plumbing_blocked():
+    """near-misses with closeness==0 = match_one MATCH but the whole-binary gate REJECTED (DEF-side /
+    TU loose-typing plumbing). Re-drafting just reproduces the same byte-correct body the gate rejects
+    again -> it can NEVER bank via a worker wave (Phase-21 finding). Skip in POOL selection so agents
+    draft FRESH targets instead; these stay in the backlog as recovery-tooling / hand-finish fuel
+    (an improved sig_unify / recovery gate can still bank them out-of-band, as the arity-extend fix did)."""
+    return {r["name"] for r in backlog.load_best()
+            if r.get("status") == "near" and r.get("closeness") == 0 and r.get("name")}
+
+
 def emit(batch, out):
     s = json.dumps(batch, indent=0)
     if out == "-":
@@ -115,7 +125,7 @@ def main():
 
     m = json.load(open(os.path.join(REPO, ".run/fuel_manifest.json")))
     stubs = live_stubs()
-    walls = set() if a.include_walls else backlog_walls()
+    walls = set() if a.include_walls else (backlog_walls() | plumbing_blocked())
 
     def ok(t):
         if t["name"] not in stubs or not t["cached"]: