hard benchmark: the 7B "fusion wins / no headroom" results were saturation artefacts

The easy task families saturated 7B (strings & arith at 1.00), so the earlier
7B nulls — moe: fusion 0.87 > union 0.84; directed ~= soup — could not separate
"refinements don't help at scale" from "tasks too easy at 7B". Adds a hard task
variant (hard: true in tasks.py: multi-step lists, Caesar ciphers / letter
transforms, multi-step & larger arithmetic; same family labels and answer
formats, threaded through make_tasks/train_specialist/runners; hard specialists
cache separately as spec_*_hard) and re-runs both experiments at 7B on Imperial
CX3 (one L40S, 24 min, unsaturated: arith ~0.48, strings 0.67, lists 0.34).

Both nulls flip back to the 0.5B ordering:
- Union beats fusion again: routing 0.500 > fusion 0.40 (soup 0.392 / ties
  0.400), the same 10-pt margin as 0.5B. Fusion dilutes the fragile strings
  specialist so hard (0.665 -> soup 0.300) that soup even trails the best single
  specialist (0.425); routing keeps it intact (0.670).
- Directed selection beats soup again: 0.492 > 0.392 (+10 pts), recovering most
  of routing's benefit from one deployable merged model (lifts strings to 0.630).

Correction to the earlier interpretation: the llm_moe_hpc "regime flip" and the
llm_directed_hpc "no headroom" null were driven by TASK SATURATION, not base
capability. The operative variable is headroom — "merge, don't average" (union >
fusion) and "directed sex" (selection > single blend) hold whenever there is room
to lose to dilution: a weak base (0.5B) OR hard tasks at a strong base (7B-hard).
Fusion only wins in the degenerate corner where easy tasks let a strong base
compose to the 1.00 ceiling. Vindicates E8's max > mean in real 7B weights once
saturation is controlled.

Default (easy) task behaviour is unchanged (hard defaults False). +1 hard-task
test (131 green). Excludes the 0.5B smoke bundle (a pipeline gate, not a
deliverable). Results in results/llm_{moe,directed}_hard_hpc/ (parquet gitignored).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

tests/test_llm.py

@@ -25,6 +25,21 @@ def test_make_tasks_wellformed_and_deterministic():
     assert [t.answer for t in a] == [t.answer for t in b]      # deterministic in the seed
 
 
+def test_hard_tasks_wellformed_verifiable_and_distinct():
+    # The hard variant must stay well-formed, self-verifying (canonical answer passes its own verifier),
+    # and genuinely different from the easy variant (harder content, same family labels + answer format).
+    for fam in FAMILIES:
+        hard = make_tasks(fam, 30, seed=7, hard=True)
+        assert len(hard) == 30 and all(t.family == fam for t in hard)
+        assert all(t.prompt and t.answer for t in hard)
+        assert all(verify(t.answer, t) for t in hard)              # canonical answers verify
+        easy = make_tasks(fam, 30, seed=7, hard=False)
+        assert [t.prompt for t in hard] != [t.prompt for t in easy]  # hard != easy
+    # a Caesar-cipher answer is a real transform of the input (not the identity)
+    caesars = [t for t in make_tasks("strings", 60, seed=2, hard=True) if "Caesar" in t.prompt]
+    assert caesars and any(t.answer not in t.prompt for t in caesars)
+
+
 def test_verifier_accepts_correct_including_verbose():
     tasks = make_tasks("lists", 40, seed=1) + make_tasks("arith", 40, seed=2)
     assert all(verify(t.answer, t) for t in tasks)              # the canonical answer verifies