feat(sleep): 3-way train/val/test split + gate_mode on|off

Data-split refactor (the anti-overfitting foundation the user asked for):
  - TaskRecord gains split∈{train,val,test} and origin∈{real,dream}.
  - assign_splits: real tasks deterministically split into val/test (disjoint);
    DREAM-augmented tasks (origin='dream') NEVER enter val/test — they only go to
    train. val gates updates; test is the final held-out measure.
  - gbrain loader maps its held-out.jsonl -> test, benchmark.jsonl -> train/val,
    so the gbrain held-out stays the true final score.
  - consolidate(): train drives reflect, val gates; adds gate_mode='off' (greedy,
    no hard filter) reporting val movement (greedy_improved/regressed/flat).
  - run_gbrain/transfer/experiment score on test (val fallback); run_gbrain gains
    --gate on|off. Legacy replay/holdout names normalized.

New test proves dream tasks never land in val/test. 21 tests pass; mock
experiment + gate=off both green.

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

skillopt/sleep/experiments/run_gbrain.py

@@ -34,47 +34,56 @@ from skillopt.sleep.experiments.gbrain_bench import (
 from skillopt.sleep.replay import aggregate_scores, replay_batch
 
 
-def _score(backend, tasks, skill, memory, split="holdout", metric="mixed", w=0.5):
-    sub = [t for t in tasks if t.split == split] or tasks
+def _score(backend, tasks, skill, memory, split="test", metric="mixed", w=0.5):
+    sub = [t for t in tasks if t.split == split]
+    if not sub:  # fall back to val, then everything, so we never score on nothing
+        sub = [t for t in tasks if t.split == "val"] or tasks
     pairs = replay_batch(backend, sub, skill, memory)
     h, s = aggregate_scores(pairs)
     return h, s, select_gate_score(h, s, metric, w)
 
 
 def run_seed(backend, seed: str, skill: str, tasks: List, *,
-             nights: int = 3, edit_budget: int = 4,
+             nights: int = 3, edit_budget: int = 4, gate_mode: str = "on",
              limit_replay: int = 0, limit_holdout: int = 0) -> dict:
     memory = ""
-    # optionally cap each split to control API cost / latency
+    # optionally cap each split to control API cost / latency.
+    # limit_replay caps train; limit_holdout caps BOTH val and test.
     if limit_replay or limit_holdout:
-        replay = [t for t in tasks if t.split == "replay"]
-        holdout = [t for t in tasks if t.split == "holdout"]
+        train = [t for t in tasks if t.split == "train"]
+        val = [t for t in tasks if t.split == "val"]
+        test = [t for t in tasks if t.split == "test"]
         if limit_replay:
-            replay = replay[:limit_replay]
+            train = train[:limit_replay]
         if limit_holdout:
-            holdout = holdout[:limit_holdout]
-        tasks = replay + holdout
-    bh, bs, bscore = _score(backend, tasks, skill, memory)
-    trace = [{"night": 0, "held_out_hard": round(bh, 3), "action": "baseline"}]
+            val = val[:limit_holdout]
+            test = test[:limit_holdout]
+        tasks = train + val + test
+    # final measure is TEST (the gbrain held-out set); val gates internally
+    bh, bs, bscore = _score(backend, tasks, skill, memory, split="test")
+    trace = [{"night": 0, "test_hard": round(bh, 3), "action": "baseline"}]
     cur = skill
     for night in range(1, nights + 1):
         res = consolidate(
             backend, tasks, cur, memory,
             edit_budget=edit_budget, gate_metric="mixed", gate_mixed_weight=0.5,
-            evolve_skill=True, evolve_memory=False, night=night,
+            gate_mode=gate_mode, evolve_skill=True, evolve_memory=False, night=night,
         )
         if res.accepted:
             cur = res.new_skill
+        # report the TEST score each night (independent of the val gate)
+        th, _ts, _ = _score(backend, tasks, cur, memory, split="test")
         trace.append({
             "night": night,
-            "held_out_hard": round(res.holdout_candidate, 3),
+            "val_hard": round(res.holdout_candidate, 3),
+            "test_hard": round(th, 3),
             "action": res.gate_action,
             "accepted": res.accepted,
             "edits": [e.content for e in res.applied_edits],
         })
-        if res.holdout_candidate >= 0.999:
+        if th >= 0.999:
             break
-    ah, as_, ascore = _score(backend, tasks, cur, memory)
+    ah, as_, ascore = _score(backend, tasks, cur, memory, split="test")
     return {
         "seed": seed,
         "held_out_before": round(bh, 3),
@@ -99,8 +108,10 @@ def main(argv=None) -> int:
     ap.add_argument("--seeds", default="", help="comma list; default = all available")
     ap.add_argument("--nights", type=int, default=3)
     ap.add_argument("--edit-budget", type=int, default=4)
-    ap.add_argument("--limit-replay", type=int, default=0, help="cap #training tasks (cost control)")
-    ap.add_argument("--limit-holdout", type=int, default=0, help="cap #held-out tasks (cost control)")
+    ap.add_argument("--gate", default="on", choices=["on", "off", "hard", "soft"],
+                    help="on/hard/soft = validation-gated; off = greedy (no hard filter)")
+    ap.add_argument("--limit-replay", type=int, default=0, help="cap #train tasks (cost control)")
+    ap.add_argument("--limit-holdout", type=int, default=0, help="cap #val and #test tasks (cost control)")
     ap.add_argument("--json", action="store_true")
     args = ap.parse_args(argv)
 
@@ -125,6 +136,7 @@ def main(argv=None) -> int:
             continue
         r = run_seed(backend, seed, skill, tasks, nights=args.nights,
                      edit_budget=args.edit_budget,
+                     gate_mode=("off" if args.gate == "off" else "on"),
                      limit_replay=args.limit_replay, limit_holdout=args.limit_holdout)
         results.append(r)
         if not args.json: