llm_directed: directed sex (breed offspring + select on verifier) — E10 in real weights

Adds the "directed sex" operator (E10) the moe regime-flip pointed to: don't
commit to one a-priori blend — breed a population of recombinant offspring
(specialists merged at Dirichlet-sampled weights), score each on a held-out
validation split with the verifier, and keep the fittest, reported on a fresh
test split. Two breeding objectives: best-overall and best-worst-family.
src/llm/directed.py + kind llm_directed, reusing the cached specialists.

Result — refinements pay off in proportion to how far the uniform soup is from
optimal:
- 0.5B (soup dilutes): directed selection beats soup on the bred objective —
  directed_overall 0.69 > soup 0.64; directed_balanced worst-family 0.37 > 0.26.
  Riders: single-objective selection trades off the other axis (overall-breed
  tanks lists to 0.17); a global blend still trails per-input routing (0.74).
- 7B (Imperial CX3, soup already composes to ceiling on near-saturated families,
  strings/arith 1.00): directed ~= soup (0.868 ~ 0.873, marginally below via a
  val/test overfit gap) — no fitter offspring to breed.

Through-line across all four LLM runs: "merge, don't average" and its refinements
(routing, directed selection) are weak-base / suboptimal-default phenomena — they
help at 0.5B and are inert at 7B. Honest limitation kept in the writeup: the 7B
families are near-saturated, which caps the headroom; a harder unsaturated
benchmark is the fair next test.

Also folds in the two llm_moe local manifest/config files missed in 8da0dac.
+3 directed unit tests (130 green). Results in results/llm_directed{,_hpc}/
(parquet gitignored).

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

tests/test_llm.py

@@ -10,6 +10,7 @@ from __future__ import annotations
 
 import numpy as np
 
+from llm.directed import sample_merge_weights, select_winners
 from llm.moe import learned_routes
 from llm.tasks import FAMILIES, make_tasks, verify
 
@@ -66,3 +67,28 @@ def test_learned_router_is_cosine_scale_invariant():
     test_emb = np.array([[10.0, 0.0], [0.0, 0.01]])            # very different magnitudes
     routes = learned_routes(train_emb, train_fam, test_emb, fams)
     assert [fams[r] for r in routes] == ["a", "b"]
+
+
+def test_merge_weights_population_pins_baselines_and_diversifies():
+    # The offspring population must contain the two canonical baselines (uniform soup, unit task-arith)
+    # and be diverse + reproducible for the rest.
+    rng = np.random.default_rng(0)
+    w = sample_merge_weights(3, 16, rng)
+    assert w.shape == (16, 3)
+    assert np.allclose(w[0], 1 / 3)                             # candidate 0 = uniform soup
+    assert np.allclose(w[1], 1.0)                              # candidate 1 = task arithmetic
+    assert np.unique(w[2:].round(3), axis=0).shape[0] > 5      # the random offspring are diverse
+    assert np.allclose(sample_merge_weights(3, 16, np.random.default_rng(0)), w)  # deterministic
+
+
+def test_select_winners_picks_argmax_per_objective():
+    val_overall = np.array([0.5, 0.9, 0.7])
+    val_worst = np.array([0.4, 0.1, 0.6])                       # a different candidate is most balanced
+    w = select_winners(val_overall, val_worst)
+    assert w == {"overall": 1, "balanced": 2}
+
+
+def test_merge_weights_requires_two_candidates():
+    import pytest
+    with pytest.raises(ValueError):
+        sample_merge_weights(3, 1, np.random.default_rng(0))