Deploy from GitHub Actions (ad47ba2f9b2bd4acb980f4d33e508ea187f7960d)

README.md

@@ -390,7 +390,7 @@ GitHub **variables** (not secrets — visible in logs, fine for non-sensitive co
 |----------|----------|-------|
 | `HF_USERNAME` | ✅ | e.g. `abhay1704` |
 | `HF_SPACE_ID` | ✅ | e.g. `abhay1704/content-generator-rsi` |
-| `MUTATOR_MODEL` | optional | Head of the coder cascade, e.g. `nim/z-ai/glm-5.2` (`nim/*` = NVIDIA NIM, `openrouter/*`, `gemini/*`) |
+| `MUTATOR_MODEL` | optional | Head of the coder cascade, e.g. `nim/nvidia/nemotron-3-ultra-550b-a55b` (`nim/*` = NVIDIA NIM, `openrouter/*`, `gemini/*`) |
 | `RESEARCH_MODEL` | optional | Head of the reasoner cascade, default `nim/nvidia/nemotron-3-ultra-550b-a55b` |
 | `MONGO_DATABASE` | optional | default `content_generator` |
 | `AUTONOMOUS_MERGE` | optional | `false` (default) or `true` |

harness/researcher.py

@@ -34,6 +34,7 @@ import datetime as _dt
 import json
 import os
 import re
+import time
 from pathlib import Path
 
 import requests
@@ -58,9 +59,11 @@ GENOME_PATH = Path(__file__).resolve().parent / "genome.py"
 # were removed from this cascade.
 DEFAULT_PRIMARY = "nim/nvidia/nemotron-3-ultra-550b-a55b"
 DEFAULT_FALLBACKS = [
+    "nim/nvidia/llama-3.3-nemotron-super-49b-v1",
+    "nim/minimaxai/minimax-m3",
     "nim/nvidia/nemotron-3-super-120b-a12b",
-    "nim/z-ai/glm-5.2",
     "gemini/gemini-flash-latest",
+    "openrouter/z-ai/glm-5.3",
     "openrouter/nvidia/nemotron-3-ultra-550b-a55b:free",
 ]
 
@@ -164,56 +167,62 @@ def _call_openai_compatible(provider: str, model: str, system: str, user: str) -
     if provider == "openrouter":
         headers["HTTP-Referer"] = "https://github.com"
         headers["X-Title"] = "content-generator-rsi-mutator"
-    try:
-        resp = requests.post(
-            url,
-            headers=headers,
-            json={
-                "model": model,
-                "messages": [
-                    {"role": "system", "content": system},
-                    {"role": "user", "content": user},
-                ],
-                "temperature": 0.7,
-                "max_tokens": _MAX_OUTPUT_TOKENS,
-                "stream": True,
-            },
-            timeout=_HTTP_TIMEOUT,
-            stream=True,
-        )
-        resp.raise_for_status()
-        content: list[str] = []
-        reasoning: list[str] = []
-        for line in resp.iter_lines(decode_unicode=True):
-            if not line or not line.startswith("data:"):
-                continue
-            chunk = line[5:].strip()
-            if chunk == "[DONE]":
-                break
-            try:
-                event = json.loads(chunk)
-            except json.JSONDecodeError:
+    
+    for attempt in range(1, 3):
+        try:
+            resp = requests.post(
+                url,
+                headers=headers,
+                json={
+                    "model": model,
+                    "messages": [
+                        {"role": "system", "content": system},
+                        {"role": "user", "content": user},
+                    ],
+                    "temperature": 0.7,
+                    "max_tokens": _MAX_OUTPUT_TOKENS,
+                    "stream": True,
+                },
+                timeout=_HTTP_TIMEOUT,
+                stream=True,
+            )
+            resp.raise_for_status()
+            content: list[str] = []
+            reasoning: list[str] = []
+            for line in resp.iter_lines(decode_unicode=True):
+                if not line or not line.startswith("data:"):
+                    continue
+                chunk = line[5:].strip()
+                if chunk == "[DONE]":
+                    break
+                try:
+                    event = json.loads(chunk)
+                except json.JSONDecodeError:
+                    continue
+                for choice in event.get("choices") or []:
+                    delta = choice.get("delta") or {}
+                    if delta.get("content"):
+                        content.append(delta["content"])
+                    thought = delta.get("reasoning_content") or delta.get("reasoning")
+                    if thought:
+                        reasoning.append(thought)
+            text = _THINK_BLOCK.sub("", "".join(content)).strip()
+            # A reasoning model that spends its whole budget thinking leaves content empty; its
+            # draft plan usually lives in reasoning_content, which beats cascading to a weaker model.
+            text = text or "".join(reasoning).strip()
+            if text:
+                return text
+            if attempt < 2:
+                time.sleep(1.5)
                 continue
-            for choice in event.get("choices") or []:
-                delta = choice.get("delta") or {}
-                if delta.get("content"):
-                    content.append(delta["content"])
-                thought = delta.get("reasoning_content") or delta.get("reasoning")
-                if thought:
-                    reasoning.append(thought)
-        text = _THINK_BLOCK.sub("", "".join(content)).strip()
-        # A reasoning model that spends its whole budget thinking leaves content empty; its
-        # draft plan usually lives in reasoning_content, which beats cascading to a weaker model.
-        text = text or "".join(reasoning).strip()
-        if not text:
-            # Say so out loud: an empty 200 is the quietest way this loop fails, and a silent
-            # None here reads identically to "no API key configured" in the run log.
             print(f"::warning::{provider} returned an EMPTY completion model={model}")
             return None
-        return text
-    except Exception as error:  # network, auth, model unavailable, bad payload
-        print(f"::warning::{provider} call failed model={model} error={error}")
-        return None
+        except Exception as error:  # network, auth, model unavailable, bad payload
+            if attempt < 2:
+                time.sleep(1.5)
+                continue
+            print(f"::warning::{provider} call failed model={model} error={error}")
+            return None
 
 
 def _call_gemini(model: str, system: str, user: str) -> str | None:

scripts/aider_llm_proxy.py

@@ -73,13 +73,12 @@ PROVIDERS: dict[str, tuple[str, tuple[str, ...]]] = {
 PROVIDER_ALIASES = {"nvidia_nim": "nim", "nvidia": "nim"}
 
 # The workflow overrides this list; this default is the safe standalone one.
-# Both deepseek-v4 ids reached end-of-life on 2026-08-07 (permanent 410 Gone) and are dropped.
 DEFAULT_MODELS = [
-    "nim/z-ai/glm-5.2",
-    "nim/nvidia/nemotron-3-super-120b-a12b",
-    "nim/openai/gpt-oss-120b",
-    "nim/minimaxai/minimax-m3",
     "nim/nvidia/nemotron-3-ultra-550b-a55b",
+    "nim/nvidia/llama-3.3-nemotron-super-49b-v1",
+    "nim/minimaxai/minimax-m3",
+    "nim/nvidia/nemotron-3-super-120b-a12b",
+    "nim/deepseek-ai/deepseek-v4-flash-0731",
 ]
 
 _THINK_BLOCK = re.compile(r"^\s*<(think|thinking|reasoning)>.*?</\1>\s*", re.DOTALL | re.IGNORECASE)
@@ -227,6 +226,11 @@ class Handler(BaseHTTPRequestHandler):
                     "failed model=%s attempt=%s status=%s after=%.1fs error=%s",
                     spec, attempt, status, time.time() - started, last_error,
                 )
+                # 404 / 410 = model is retired or not found on provider -> bench permanently (24h)
+                if status in {404, 410}:
+                    self.log_message("model=%s permanently unavailable (status %s); benching indefinitely", spec, status)
+                    _start_cooldown(spec, 86400)
+                    break
                 # 429 = rate limited; 502/503/504 = the provider gateway gave up on a queue that
                 # never got scheduled; 599 = our own socket timeout. All mean "this model is
                 # busy" -> bench it. Only a 429 is worth an immediate retry: re-queueing behind

scripts/check_models.py

@@ -7,7 +7,7 @@ the cycle records a phantom "mutation" with no code change. One cheap ping per m
 that into a line in the run log you can read at a glance.
 
     python scripts/check_models.py                       # checks the default cascades
-    python scripts/check_models.py --models nim/z-ai/glm-5.2,gemini/gemini-flash-latest
+    python scripts/check_models.py --models nim/nvidia/nemotron-3-ultra-550b-a55b,gemini/gemini-flash-latest
     python scripts/check_models.py --require 2           # exit 1 if fewer than 2 answered
 
 Never blocks by default (exit 0 even if everything is down) — pass --require to gate on it.
@@ -27,25 +27,20 @@ sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from harness.researcher import DEFAULT_FALLBACKS, DEFAULT_PRIMARY, _complete  # noqa: E402
 
 # Coder cascade — keep in sync with AIDER_PROXY_MODELS in .github/workflows/mutator.yml.
-# The deepseek-v4 pair was removed on 2026-08-07 (end-of-life, permanent 410).
 IMPL_MODELS = [
-    "nim/z-ai/glm-5.2",
-    "nim/nvidia/nemotron-3-super-120b-a12b",
-    "nim/openai/gpt-oss-120b",
-    "nim/minimaxai/minimax-m3",
     "nim/nvidia/nemotron-3-ultra-550b-a55b",
+    "nim/nvidia/llama-3.3-nemotron-super-49b-v1",
+    "nim/minimaxai/minimax-m3",
+    "nim/nvidia/nemotron-3-super-120b-a12b",
+    "nim/deepseek-ai/deepseek-v4-flash-0731",
 ]
 
 # Not in any cascade — probed only so the preflight table tells us whether they are entitled to
-# this account and how fast they schedule. glm-5.2's queue keeps growing, so we need a shortlist
-# of replacements measured under real conditions before promoting one. All four are present in
-# NIM's public /v1/models catalog as of 2026-08-07; entitlement is a separate question, and a
-# model that 404s/410s here costs the preflight ~0.1s. Promote anything that answers fast.
+# this account and how fast they schedule.
 CANDIDATE_MODELS = [
-    "nim/moonshotai/kimi-k2.6",
+    "nim/nvidia/nemotron-3.5-lightning-30b-a3b",
     "nim/stepfun-ai/step-3.7-flash",
-    "nim/poolside/laguna-xs-2.1",
-    "nim/deepseek-ai/deepseek-v4-flash-0731",
+    "openrouter/z-ai/glm-5.3",
 ]
 
 PING = "Reply with exactly: OK"

tests/test_orchestrator.py

@@ -1,235 +1,240 @@
-"""Tests for harness/orchestrator.run_day with fully faked I/O."""
-
-import json
-from dataclasses import dataclass
-
-from harness import orchestrator
-from harness.genome import VideoArtifact, MANIFEST_FILENAME
-from harness.scoreboard import ScoreRow
-
-
-@dataclass
-class FakePub:
-    video_id: str
-    upload_date: str
-
-
-def _make_variants(tmp_path, ids):
-    root = tmp_path / "variants"
-    for vid in ids:
-        d = root / vid
-        d.mkdir(parents=True)
-        (d / MANIFEST_FILENAME).write_text(json.dumps({"variant_id": vid, "genome": {"k": vid}}), encoding="utf-8")
-    return root
-
-
-def _artifact(i=1):
-    return VideoArtifact(video_path=f"/tmp/v{i}.mp4", title=f"title {i}", description="desc",
-                         music_name="m", music_attribution="attr")
-
-
-def test_run_day_allocates_produces_publishes_attributes(tmp_path):
-    root = _make_variants(tmp_path, ["A", "B"])
-    rows = [ScoreRow("v1", "2026-06-12", "A", "h", "seed", 90, 0.9, 9.0)]  # A scored, B newborn
-
-    recorded = []
-    produce_calls = []
-
-    def produce(manifest, n):
-        produce_calls.append((manifest.variant_id, n))
-        return [_artifact(i) for i in range(n)]
-
-    def record(**kw):
-        recorded.append(kw)
-
-    counter = {"n": 0}
-
-    def publish(manifest, artifact):
-        counter["n"] += 1
-        return FakePub(video_id=f"vid{counter['n']}", upload_date="2026-06-18")
-
-    report = orchestrator.run_day(
-        scoreboard_rows=rows,
-        produce=produce,
-        publish=publish,
-        record_attribution=record,
-        budget=3,
-        variants_dir=root,
-    )
-
-    assert report.slots == {"A": 2, "B": 1}            # A scored → soaks taper; B newborn → floor of 1
-    assert report.published_count == 3
-    assert ("A", 2) in produce_calls and ("B", 1) in produce_calls
-    # every published video was attributed to a real variant + its genome hash
-    assert len(recorded) == 3
-    assert all(r["variant_id"] in {"A", "B"} and r["genome_hash"] for r in recorded)
-
-
-def test_run_day_isolates_publish_failure(tmp_path):
-    root = _make_variants(tmp_path, ["A"])
-    rows = [ScoreRow("v1", "2026-06-12", "A", "h", "seed", 90, 0.9, 9.0)]
-
-    def publish(manifest, artifact):
-        raise RuntimeError("youtube down")
-
-    report = orchestrator.run_day(
-        scoreboard_rows=rows,
-        produce=lambda m, n: [_artifact(i) for i in range(n)],
-        publish=publish,
-        record_attribution=lambda **kw: None,
-        budget=2, variants_dir=root,
-    )
-    assert report.published_count == 0
-    assert any("publish" in e for e in report.errors)
-
-
-def test_run_day_isolates_produce_failure(tmp_path):
-    root = _make_variants(tmp_path, ["A", "B"])
-    rows = []  # both newborns → floor 1 each
-
-    def produce(manifest, n):
-        if manifest.variant_id == "A":
-            raise RuntimeError("render exploded")
-        return [_artifact(1)]
-
-    report = orchestrator.run_day(
-        scoreboard_rows=rows,
-        produce=produce,
-        publish=lambda m, a: FakePub("vidB", "2026-06-18"),
-        record_attribution=lambda **kw: None,
-        budget=2, variants_dir=root,
-    )
-    # A's failure is isolated; B still publishes.
-    assert report.published_count == 1
-    assert any("A: produce" in e for e in report.errors)
-
-
-def test_run_day_empty_produce_is_reported(tmp_path):
-    root = _make_variants(tmp_path, ["A"])
-    report = orchestrator.run_day(
-        scoreboard_rows=[],
-        produce=lambda m, n: [],
-        publish=lambda m, a: FakePub("x", "y"),
-        record_attribution=lambda **kw: None,
-        budget=2, variants_dir=root,
-    )
-    assert report.published_count == 0
-    assert any("no videos rendered" in e for e in report.errors)
-
-
-def test_run_day_parallel_produce_publishes_all(tmp_path):
-    import threading
-
-    root = _make_variants(tmp_path, ["A", "B"])
-    seen: list[str] = []
-    lock = threading.Lock()
-
-    def produce(manifest, n):
-        with lock:
-            seen.append(manifest.variant_id)
-        return [_artifact(1)]
-
-    report = orchestrator.run_day(
-        scoreboard_rows=[],                       # both newborns → 1 slot each
-        produce=produce,
-        publish=lambda m, a: FakePub("vid", "2026-06-18"),
-        record_attribution=lambda **kw: None,
-        budget=2, variants_dir=root, max_workers=2,
-    )
-    assert set(seen) == {"A", "B"}                # both variants produced
-    assert report.published_count == 2            # publishing stays correct under parallel produce
-
-
-def test_run_day_tracks_extinction_streak(tmp_path):
-    root = _make_variants(tmp_path, ["A", "B"])
-    rows = [ScoreRow("v1", "2026-06-12", "A", "h", "seed", 90, 0.9, 9.0)]  # A scored, B newborn
-
-    saved: dict[str, int] = {}
-
-    def save(streak):
-        saved.clear()
-        saved.update(streak)
-
-    report = orchestrator.run_day(
-        scoreboard_rows=rows,
-        produce=lambda m, n: [_artifact(1)],
-        publish=lambda m, a: FakePub("vid", "2026-06-18"),
-        record_attribution=lambda **kw: None,
-        budget=1, variants_dir=root,             # budget 1 → newborn B takes the floor slot, A starves
-        load_streak=lambda: {"A": 11},
-        save_streak=save,
-        extinction_k=12,
-    )
-    assert report.slots == {"A": 0, "B": 1}      # A got 0 slots this run
-    assert saved["A"] == 12 and saved["B"] == 0  # A's zero-streak ticks to 12; B resets
-    assert report.extinct == ["A"]               # crossed the threshold → flagged
-
-
-class _Readability:
-    def __init__(self, score, issues=()):
-        self.score = score
-        self.issues = list(issues)
-    @property
-    def assessed(self):
-        return self.score >= 0.0
-
-
-def test_run_day_skips_unreadable_and_records_score(tmp_path):
-    root = _make_variants(tmp_path, ["A"])
-    recorded = []
-
-    report = orchestrator.run_day(
-        scoreboard_rows=[],
-        produce=lambda m, n: [_artifact(i) for i in range(n)],   # 1 newborn → 1 slot → 1 video
-        publish=lambda m, a: FakePub("vidA", "2026-06-18"),
-        record_attribution=lambda **kw: recorded.append(kw),
-        budget=1, variants_dir=root,
-        assess_readability=lambda art: _Readability(0.1, ["text clipped"]),
-        readability_floor=0.35,
-    )
-    assert report.published_count == 0                 # skipped: 0.1 < floor 0.35
-    assert report.unreadable and "readability 0.10" in report.unreadable[0]
-    assert recorded == []                              # nothing published → nothing attributed
-
-
-def test_run_day_publishes_readable_and_carries_readability(tmp_path):
-    root = _make_variants(tmp_path, ["A"])
-    recorded = []
-
-    report = orchestrator.run_day(
-        scoreboard_rows=[],
-        produce=lambda m, n: [_artifact(1)],
-        publish=lambda m, a: FakePub("vidA", "2026-06-18"),
-        record_attribution=lambda **kw: recorded.append(kw),
-        budget=1, variants_dir=root,
-        assess_readability=lambda art: _Readability(0.9, []),
-        readability_floor=0.35,
-    )
-    assert report.published_count == 1
-    assert recorded[0]["readability"] == 0.9           # score rode into attribution
-    assert report.published[0].readability == 0.9
-
-
-def test_run_day_readability_fails_open_on_not_assessed(tmp_path):
-    root = _make_variants(tmp_path, ["A"])
-    report = orchestrator.run_day(
-        scoreboard_rows=[],
-        produce=lambda m, n: [_artifact(1)],
-        publish=lambda m, a: FakePub("vidA", "2026-06-18"),
-        record_attribution=lambda **kw: None,
-        budget=1, variants_dir=root,
-        assess_readability=lambda art: _Readability(-1.0),   # not assessed → must still publish
-        readability_floor=0.99,
-    )
-    assert report.published_count == 1                 # non-assessment never blocks
-
-
-def test_run_day_no_variants(tmp_path):
-    root = tmp_path / "empty"
-    root.mkdir()
-    report = orchestrator.run_day(
-        scoreboard_rows=[],
-        produce=lambda m, n: [], publish=lambda m, a: FakePub("", ""),
-        record_attribution=lambda **kw: None, budget=3, variants_dir=root,
-    )
-    assert report.errors == ["no living variants"]
+"""Tests for harness/orchestrator.run_day with fully faked I/O."""
+
+import json
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+
+from harness import orchestrator
+from harness.genome import VideoArtifact, MANIFEST_FILENAME
+from harness.scoreboard import ScoreRow
+
+
+def _recent_date(days_ago: int = 5) -> str:
+    return (datetime.now(timezone.utc) - timedelta(days=days_ago)).date().isoformat()
+
+
+@dataclass
+class FakePub:
+    video_id: str
+    upload_date: str
+
+
+def _make_variants(tmp_path, ids):
+    root = tmp_path / "variants"
+    for vid in ids:
+        d = root / vid
+        d.mkdir(parents=True)
+        (d / MANIFEST_FILENAME).write_text(json.dumps({"variant_id": vid, "genome": {"k": vid}}), encoding="utf-8")
+    return root
+
+
+def _artifact(i=1):
+    return VideoArtifact(video_path=f"/tmp/v{i}.mp4", title=f"title {i}", description="desc",
+                         music_name="m", music_attribution="attr")
+
+
+def test_run_day_allocates_produces_publishes_attributes(tmp_path):
+    root = _make_variants(tmp_path, ["A", "B"])
+    rows = [ScoreRow("v1", _recent_date(5), "A", "h", "seed", 90, 0.9, 9.0)]  # A scored, B newborn
+
+    recorded = []
+    produce_calls = []
+
+    def produce(manifest, n):
+        produce_calls.append((manifest.variant_id, n))
+        return [_artifact(i) for i in range(n)]
+
+    def record(**kw):
+        recorded.append(kw)
+
+    counter = {"n": 0}
+
+    def publish(manifest, artifact):
+        counter["n"] += 1
+        return FakePub(video_id=f"vid{counter['n']}", upload_date="2026-06-18")
+
+    report = orchestrator.run_day(
+        scoreboard_rows=rows,
+        produce=produce,
+        publish=publish,
+        record_attribution=record,
+        budget=3,
+        variants_dir=root,
+    )
+
+    assert report.slots == {"A": 2, "B": 1}            # A scored → soaks taper; B newborn → floor of 1
+    assert report.published_count == 3
+    assert ("A", 2) in produce_calls and ("B", 1) in produce_calls
+    # every published video was attributed to a real variant + its genome hash
+    assert len(recorded) == 3
+    assert all(r["variant_id"] in {"A", "B"} and r["genome_hash"] for r in recorded)
+
+
+def test_run_day_isolates_publish_failure(tmp_path):
+    root = _make_variants(tmp_path, ["A"])
+    rows = [ScoreRow("v1", _recent_date(5), "A", "h", "seed", 90, 0.9, 9.0)]
+
+    def publish(manifest, artifact):
+        raise RuntimeError("youtube down")
+
+    report = orchestrator.run_day(
+        scoreboard_rows=rows,
+        produce=lambda m, n: [_artifact(i) for i in range(n)],
+        publish=publish,
+        record_attribution=lambda **kw: None,
+        budget=2, variants_dir=root,
+    )
+    assert report.published_count == 0
+    assert any("publish" in e for e in report.errors)
+
+
+def test_run_day_isolates_produce_failure(tmp_path):
+    root = _make_variants(tmp_path, ["A", "B"])
+    rows = []  # both newborns → floor 1 each
+
+    def produce(manifest, n):
+        if manifest.variant_id == "A":
+            raise RuntimeError("render exploded")
+        return [_artifact(1)]
+
+    report = orchestrator.run_day(
+        scoreboard_rows=rows,
+        produce=produce,
+        publish=lambda m, a: FakePub("vidB", "2026-06-18"),
+        record_attribution=lambda **kw: None,
+        budget=2, variants_dir=root,
+    )
+    # A's failure is isolated; B still publishes.
+    assert report.published_count == 1
+    assert any("A: produce" in e for e in report.errors)
+
+
+def test_run_day_empty_produce_is_reported(tmp_path):
+    root = _make_variants(tmp_path, ["A"])
+    report = orchestrator.run_day(
+        scoreboard_rows=[],
+        produce=lambda m, n: [],
+        publish=lambda m, a: FakePub("x", "y"),
+        record_attribution=lambda **kw: None,
+        budget=2, variants_dir=root,
+    )
+    assert report.published_count == 0
+    assert any("no videos rendered" in e for e in report.errors)
+
+
+def test_run_day_parallel_produce_publishes_all(tmp_path):
+    import threading
+
+    root = _make_variants(tmp_path, ["A", "B"])
+    seen: list[str] = []
+    lock = threading.Lock()
+
+    def produce(manifest, n):
+        with lock:
+            seen.append(manifest.variant_id)
+        return [_artifact(1)]
+
+    report = orchestrator.run_day(
+        scoreboard_rows=[],                       # both newborns → 1 slot each
+        produce=produce,
+        publish=lambda m, a: FakePub("vid", "2026-06-18"),
+        record_attribution=lambda **kw: None,
+        budget=2, variants_dir=root, max_workers=2,
+    )
+    assert set(seen) == {"A", "B"}                # both variants produced
+    assert report.published_count == 2            # publishing stays correct under parallel produce
+
+
+def test_run_day_tracks_extinction_streak(tmp_path):
+    root = _make_variants(tmp_path, ["A", "B"])
+    rows = [ScoreRow("v1", _recent_date(5), "A", "h", "seed", 90, 0.9, 9.0)]  # A scored, B newborn
+
+    saved: dict[str, int] = {}
+
+    def save(streak):
+        saved.clear()
+        saved.update(streak)
+
+    report = orchestrator.run_day(
+        scoreboard_rows=rows,
+        produce=lambda m, n: [_artifact(1)],
+        publish=lambda m, a: FakePub("vid", "2026-06-18"),
+        record_attribution=lambda **kw: None,
+        budget=1, variants_dir=root,             # budget 1 → newborn B takes the floor slot, A starves
+        load_streak=lambda: {"A": 11},
+        save_streak=save,
+        extinction_k=12,
+    )
+    assert report.slots == {"A": 0, "B": 1}      # A got 0 slots this run
+    assert saved["A"] == 12 and saved["B"] == 0  # A's zero-streak ticks to 12; B resets
+    assert report.extinct == ["A"]               # crossed the threshold → flagged
+
+
+class _Readability:
+    def __init__(self, score, issues=()):
+        self.score = score
+        self.issues = list(issues)
+    @property
+    def assessed(self):
+        return self.score >= 0.0
+
+
+def test_run_day_skips_unreadable_and_records_score(tmp_path):
+    root = _make_variants(tmp_path, ["A"])
+    recorded = []
+
+    report = orchestrator.run_day(
+        scoreboard_rows=[],
+        produce=lambda m, n: [_artifact(i) for i in range(n)],   # 1 newborn → 1 slot → 1 video
+        publish=lambda m, a: FakePub("vidA", "2026-06-18"),
+        record_attribution=lambda **kw: recorded.append(kw),
+        budget=1, variants_dir=root,
+        assess_readability=lambda art: _Readability(0.1, ["text clipped"]),
+        readability_floor=0.35,
+    )
+    assert report.published_count == 0                 # skipped: 0.1 < floor 0.35
+    assert report.unreadable and "readability 0.10" in report.unreadable[0]
+    assert recorded == []                              # nothing published → nothing attributed
+
+
+def test_run_day_publishes_readable_and_carries_readability(tmp_path):
+    root = _make_variants(tmp_path, ["A"])
+    recorded = []
+
+    report = orchestrator.run_day(
+        scoreboard_rows=[],
+        produce=lambda m, n: [_artifact(1)],
+        publish=lambda m, a: FakePub("vidA", "2026-06-18"),
+        record_attribution=lambda **kw: recorded.append(kw),
+        budget=1, variants_dir=root,
+        assess_readability=lambda art: _Readability(0.9, []),
+        readability_floor=0.35,
+    )
+    assert report.published_count == 1
+    assert recorded[0]["readability"] == 0.9           # score rode into attribution
+    assert report.published[0].readability == 0.9
+
+
+def test_run_day_readability_fails_open_on_not_assessed(tmp_path):
+    root = _make_variants(tmp_path, ["A"])
+    report = orchestrator.run_day(
+        scoreboard_rows=[],
+        produce=lambda m, n: [_artifact(1)],
+        publish=lambda m, a: FakePub("vidA", "2026-06-18"),
+        record_attribution=lambda **kw: None,
+        budget=1, variants_dir=root,
+        assess_readability=lambda art: _Readability(-1.0),   # not assessed → must still publish
+        readability_floor=0.99,
+    )
+    assert report.published_count == 1                 # non-assessment never blocks
+
+
+def test_run_day_no_variants(tmp_path):
+    root = tmp_path / "empty"
+    root.mkdir()
+    report = orchestrator.run_day(
+        scoreboard_rows=[],
+        produce=lambda m, n: [], publish=lambda m, a: FakePub("", ""),
+        record_attribution=lambda **kw: None, budget=3, variants_dir=root,
+    )
+    assert report.errors == ["no living variants"]

variants/variant_1/manifest.json

@@ -14,6 +14,6 @@
     "keep_top_n": 2,
     "boldness": 0.9,
     "pipeline_version": 1,
-    "planner_prompt_version": 6
+    "planner_prompt_version": 5
   }
 }