Harden the governed loop after review

- Governor.__post_init__ rejects an unbounded config (all stop conditions
  None would loop forever) and dry_patience < 1 (would stop before any
  round runs) — fail fast at construction instead of hanging.
- _best_of returns None for an all-killed batch instead of handing a
  killed entry (with no score) to the post-run Reflector/Advisor.
96 tests pass.

Author: renee-jia

scholarloop/governor.py

@@ -49,6 +49,13 @@ class Governor:
     _best: float | None = None
     _alerted: set = field(default_factory=set)
 
+    def __post_init__(self) -> None:
+        if self.dry_patience is not None and self.dry_patience < 1:
+            raise ValueError("dry_patience must be >= 1 (rounds with no improvement before stopping)")
+        if self.max_cost is None and self.max_rounds is None and self.dry_patience is None:
+            raise ValueError("Governor needs at least one stop condition "
+                             "(max_cost / max_rounds / dry_patience) or the loop never ends")
+
     def update_frontier(self, score: float | None, direction: str) -> bool:
         """Fold a fresh result into the tracked frontier. Returns True iff it improved the best so far."""
         if score is None:

scholarloop/orchestrator.py

@@ -99,7 +99,7 @@ def _best_of(self, entries: list[LedgerEntry]):
         """The best-scoring entry in a batch by the metric direction (None scores ignored)."""
         scored = [e for e in entries if e.primary_score() is not None]
         if not scored:
-            return entries[-1] if entries else None
+            return None                                 # all killed/unscored — no result to reflect on
         return min(scored, key=lambda e: e.primary_score()) if self.profile.metric.direction == "minimize" \
             else max(scored, key=lambda e: e.primary_score())
 

tests/test_governor.py

@@ -1,8 +1,17 @@
 """The loop Governor: budget / round-cap / convergence stop conditions (pure, no LLM)."""
 
+import pytest
+
 from scholarloop.governor import Governor, cost_of
 
 
+def test_governor_rejects_unbounded_and_degenerate_configs():
+    with pytest.raises(ValueError):
+        Governor()                       # no stop condition at all -> would loop forever
+    with pytest.raises(ValueError):
+        Governor(dry_patience=0)         # 0 would stop before any round runs
+
+
 def test_cost_of_known_and_unknown_model():
     assert cost_of({"input_tokens": 1_000_000, "output_tokens": 1_000_000}, "claude-opus-4-8") == 30.0
     assert cost_of({"input_tokens": 1000, "output_tokens": 0}, "no-such-model") is None   # unmetered

tests/test_orchestrator.py

@@ -195,6 +195,15 @@ def test_run_with_governor_stops_on_round_cap(tmp_path):
     assert gov.rounds == 2                                   # stopped exactly at the cap
 
 
+def test_best_of_returns_none_for_an_all_killed_batch(tmp_path):
+    orch = Orchestrator(MockLLM(), PROFILE, ledger_path=tmp_path / "ledger.jsonl",
+                        registry_dir=tmp_path / "registry")
+    killed = LedgerEntry(id="exp_k", domain="image-classification",
+                         hypothesis=Hypothesis("c", "arXiv:1"), metric_name="val_top1_err",
+                         fidelity=["smoke"], metric={}, verdict="killed")   # no score
+    assert orch._best_of([killed]) is None                  # nothing to reflect on, not a killed entry
+
+
 def test_promote_gate_uses_statistical_significance(tmp_path):
     orch = Orchestrator(MockLLM(), PROFILE,            # promote_z=1.0 default
                         ledger_path=tmp_path / "ledger.jsonl", registry_dir=tmp_path / "registry")