bench(learn): injection first slice -- compiled AI classifier, out-of-repo evaluation (decision-engine 6.2, 6.6)

6.2: the 724 static examples' 616 distinct excerpts embedded with openai/text-embedding-3-small via
OpenRouter, 198,819 tokens, $0.0040 metered (ceiling $1).

6.6, family injection only, memory = every family (at most 2 contrast examples per prompt), input
profile v1: smoke fixed k = 5 (repeat prefix-cache hit share 0.96); one compile (program c1237a49,
proposed instruction 5, balanced Brier 0.128 on 13 C_val candidates vs 0.199 baseline); outer grouped
5-fold, 110 out-of-repository candidates in 29 groups: ADVISORY recall 0.90 [0.82, 0.97], precision
0.54 [0.44, 0.65], AUC 0.74; BLOCK not offered (ECE 0.064 > 0.05; no fold reached a Wilson lower bound
of 0.95); canary re-ask agreement 0.83. $0.91 metered at list price; DeepSeek balance $18.20 -> $17.90.

Instrument fixes found on the way, each with a test:
- memory build: pair sides join the record stored under their harvest unit pin (--units), and only the
  built profile's records are read (static and plane shared a key; 85 -> 724 examples);
- retrieval: stage 1 per side (family / contrast) and at most 2 contrast examples, never padded;
- program: the JSON answer contract is part of the signature, appended to proposed instructions
  (DeepSeek JSON mode refused a prompt without "json");
- compile: candidate_families for a one-family compile; compile.toml k = 5 from the smoke rule.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_01EmM1j46qgKMh3zqD1QMwEo

tests/test_learn_compile.py

@@ -6,7 +6,7 @@ byte for byte at $0 (``test_reproducible_from_cache``); the permissive-licence f
 from __future__ import annotations
 
 import json
-from collections.abc import Iterator, Mapping, Sequence
+from collections.abc import Iterable, Iterator, Mapping, Sequence
 from pathlib import Path
 
 import pytest
@@ -30,6 +30,7 @@ from openultrasast.learn.compile import (
     permissive,
     program_id,
 )
+from openultrasast.learn.examples import Example
 from openultrasast.learn.folds import Fold, FoldError
 from openultrasast.learn.program import Caller, Demo
 from openultrasast.plane.budget import MeteredClient
@@ -191,3 +192,23 @@ def test_only_permissively_licensed_demonstrations_are_packaged() -> None:
     assert [d["example_id"] for d in packaged["demos"]] == [mit.id, apache.id]
     assert packaged["program_id"] == program_id(packaged) != artifact["program_id"]
     assert packaged["packaged"]["from"] == artifact["program_id"]
+
+
+def test_a_one_family_compile_asks_only_that_family(monkeypatch: pytest.MonkeyPatch) -> None:
+    """``candidate_families`` limits the bootstrap and validation candidates; the compile memory keeps every family
+    (retrieval's contrast examples), so the artifact's data counts are those of the whole pool."""
+    asked: dict[str, set[str]] = {}
+    real = compile_module._order
+
+    def spy(items: Iterable[Example], seed: int, salt: str) -> list[Example]:
+        items = list(items)
+        asked.setdefault(salt, set()).update(e.family for e in items)
+        return real(items, seed, salt)
+
+    monkeypatch.setattr(compile_module, "_order", spy)
+    result = compile_program(MEMORY, _caller(ScriptedChat(answer)), excerpt_text, spec=SPEC, candidate_families=("injection",))
+    assert result.status == "done" and result.artifact is not None
+    assert asked["boot"] == asked["val"] == {"injection"}
+    assert result.artifact["data"]["examples"] == len(MEMORY)
+    with pytest.raises(CompileError, match="compile split too small"):
+        compile_program(MEMORY, _caller(ScriptedChat(answer)), excerpt_text, spec=SPEC, candidate_families=("memory",))