fix: pipeline v3 — remove dead imports, add --proven mode as primary, check token budget, honest behavior"

alpha_factory/orchestration/pipeline.py

@@ -1,33 +1,35 @@
 """
-Pipeline Orchestrator v2 — prevents theme repetition within a batch.
+Pipeline Orchestrator v3 — Honest implementation.
+Only runs steps that actually work: theme → hypothesis → compile → lint → store.
+Dead personas removed from active pipeline.
 """
 import asyncio
 from datetime import datetime
 from rich.console import Console
 from rich.panel import Panel
 
-from ..config import Config, load_config
-from ..infra import LLMClient, FactorStore, BrainClient
-from ..deterministic import lint, quick_dedup_hash, pick_theme, compute_fitness
+from ..config import Config
+from ..infra import LLMClient, FactorStore
+from ..deterministic import lint, quick_dedup_hash, pick_theme
 from ..deterministic.theme_sampler import THEME_FIELDS
-from ..personas import (
-    generate_hypothesis,
-    compile_expression,
-    scout_novelty,
-    diagnose_performance,
-    gate_alpha,
-)
+from ..personas.hypothesis_hunter import generate_hypothesis
+from ..personas.expression_compiler import compile_expression
 from ..schemas import Verdict
 
 console = Console()
 
 
 class AlphaPipeline:
+    """
+    Alpha generation pipeline.
+    Active steps: theme_pick → hypothesis → compile → lint → dedup → store.
+    BRAIN submission, crowd scout, surgeon, gatekeeper are NOT connected.
+    """
+
     def __init__(self, config: Config):
         self.config = config
         self.llm = LLMClient(config.llm)
         self.store = FactorStore(config.paths.factor_store / "alphas.duckdb")
-        self.brain: BrainClient | None = None
 
         self._consecutive_lint_fails = 0
         self._consecutive_kills = 0
@@ -46,8 +48,6 @@ class AlphaPipeline:
         existing_tags = self.store.get_all_anomaly_tags()
         dead_themes = self.store.get_dead_themes()
         existing_hashes = self.store.get_expression_hashes()
-
-        # Track themes used in THIS batch to force diversity
         batch_themes_used: list[str] = []
 
         promoted = 0
@@ -64,12 +64,9 @@ class AlphaPipeline:
             try:
                 result = await self._run_single_candidate(
                     existing_themes + batch_themes_used,
-                    existing_tags,
-                    dead_themes,
-                    existing_hashes,
+                    existing_tags, dead_themes, existing_hashes,
                     batch_themes_used,
                 )
-
                 if result == Verdict.PROMOTE:
                     promoted += 1
                 elif result == Verdict.ITERATE:
@@ -77,10 +74,8 @@ class AlphaPipeline:
                 else:
                     killed += 1
                     self._consecutive_kills += 1
-
                 if result != Verdict.KILL:
                     self._consecutive_kills = 0
-
             except Exception as e:
                 console.print(f"[red]Error: {e}[/]")
                 killed += 1
@@ -90,28 +85,19 @@ class AlphaPipeline:
             f"Tokens used: {self.llm.tokens_used:,}  |  BRAIN submissions: {self._daily_submissions}",
             title="Batch Complete"
         ))
-
         return {"promoted": promoted, "iterated": iterated, "killed": killed}
 
-    async def _run_single_candidate(
-        self,
-        existing_themes: list[str],
-        existing_tags: list[str],
-        dead_themes: list[str],
-        existing_hashes: set[str],
-        batch_themes_used: list[str],
-    ) -> Verdict:
-
-        # STEP 1: Pick theme — penalize themes already used in this batch
-        # By adding batch_themes_used to existing_themes, gap_score penalizes repeats
+    async def _run_single_candidate(self, existing_themes, existing_tags,
+                                     dead_themes, existing_hashes, batch_themes_used) -> Verdict:
+
+        # STEP 1: Pick theme
         theme = pick_theme(existing_themes, existing_tags, dead_themes)
         batch_themes_used.append(theme)
         console.print(f"  [cyan]Theme:[/] {theme}")
 
-        # STEP 2: Generate hypothesis
-        retrieved_papers = []
+        # STEP 2: Generate hypothesis (LLM)
         blueprint = await generate_hypothesis(
-            self.llm, theme, retrieved_papers, existing_tags
+            self.llm, theme, [], existing_tags
         )
         console.print(f"  [cyan]Blueprint:[/] {blueprint.archetype} | {blueprint.anomaly_tag.value}")
         console.print(f"  [dim]Novelty: {blueprint.novelty_claim[:80]}...[/]")
@@ -120,13 +106,12 @@ class AlphaPipeline:
         expression = await compile_expression(blueprint, self.llm)
         console.print(f"  [cyan]Expression:[/] {expression.expression[:80]}...")
 
-        # STEP 4: Static lint
+        # STEP 4: Lint
         lint_result = lint(expression.expression)
         if not lint_result.passed:
             console.print(f"  [red]LINT FAIL:[/] {lint_result.errors}")
             self._consecutive_lint_fails += 1
             return Verdict.KILL
-
         self._consecutive_lint_fails = 0
         if lint_result.warnings:
             console.print(f"  [yellow]Warnings:[/] {lint_result.warnings}")
@@ -138,7 +123,6 @@ class AlphaPipeline:
         if alpha_id in existing_hashes:
             console.print(f"  [red]DEDUP:[/] Already exists")
             return Verdict.KILL
-
         existing_hashes.add(alpha_id)
 
         # STEP 6: Store
@@ -155,12 +139,7 @@ class AlphaPipeline:
             academic_anchor=blueprint.academic_anchor,
         )
 
-        # STEP 7: BRAIN submission
-        if self.brain is None:
-            console.print("  [yellow]DRY RUN:[/] Skipping BRAIN submission")
-            console.print(f"  [green]+ Candidate {alpha_id} passed[/]")
-            return Verdict.ITERATE
-
+        console.print(f"  [green]+ Stored {alpha_id}[/]")
         return Verdict.ITERATE
 
     def _check_kill_switches(self) -> bool:
@@ -168,7 +147,9 @@ class AlphaPipeline:
             return True
         if self._consecutive_kills >= self.config.kill.consecutive_kill_verdict_max:
             return True
-        if self._daily_submissions >= self.config.kill.daily_brain_submissions_max:
+        # Token budget check
+        if self.llm.tokens_used >= self.config.kill.daily_llm_token_budget:
+            console.print("[red]Kill switch: token budget exhausted[/]")
             return True
         return False