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

src/openultrasast/learn/compile.py

@@ -354,12 +354,14 @@ def compile_program(
     vectors: Mapping[str, Sequence[float]] | None = None,
     identities: Callable[[Example], Iterable[str]] | None = None,
     families: Sequence[str] = (),
+    candidate_families: Sequence[str] = (),
     store: MemoryStore | None = None,
     created: str = "",
     code_commit: str = "",
 ) -> CompileResult:
     """Compile one profile's program from ``memory`` (module docstring). Deterministic given the memory, the spec and
-    the response cache."""
+    the response cache. ``candidate_families`` limits the bootstrap and validation candidates to those families (a
+    one-family slice); retrieval still draws on every family of the compile split, for contrast examples."""
     seed = spec.seed
     pool = [e for e in memory if e.profile == profile]
     split: CompileSplit = compile_split(pool, fraction=float(spec["split"].get("compile_fraction", 0.25)),
@@ -368,8 +370,9 @@ def compile_program(
     assert_disjoint(split, evaluation)
     compile_memory = [e for e in pool if e.group in split.groups]
     fold = Fold("compile", "compile", frozenset(), phase="compile")
-    boot = _order([e for e in compile_memory if e.group in split.boot], seed, "boot")[: int(spec["bootstrap"].get("max_candidates", 150))]
-    val = _order([e for e in compile_memory if e.group in split.val], seed, "val")[: int(spec["search"].get("val_candidates", 60))]
+    asked = [e for e in compile_memory if not candidate_families or e.family in candidate_families]
+    boot = _order([e for e in asked if e.group in split.boot], seed, "boot")[: int(spec["bootstrap"].get("max_candidates", 150))]
+    val = _order([e for e in asked if e.group in split.val], seed, "val")[: int(spec["search"].get("val_candidates", 60))]
     if not boot or not val:
         raise CompileError(f"compile split too small: {len(boot)} bootstrap and {len(val)} validation candidates")
     retrieval, classify = spec["retrieval"], spec["classify"]