fix: repair invalid syntax + undefined names (CI was unrunnable)

Fixes for code quality issues revealed by enabling ruff in CI:

Syntax errors (prevented module from loading):
- skill_library.py:79: bare 'except:' with no handler -> 'except Exception:'
- arsenal_run.py:113: 'async for' had no indented body (missing 4 spaces)
- pipeline/l2_conductor.py / l3_search.py / router.py: same async-for pattern

Undefined names (NameErrors at import):
- arsenal_run.py:31: route_project() called but never imported
- arsenal_run.py:116: 'return result' for undefined name 'result'
- arsenal_run.py:76: RouteDecision used in mock branch but not imported
  (it is imported now via the models import line)

Dead code:
- llm.py: lower, prompt: assigned but never read in _offline_fallback

Style:
- bare 'except:' -> 'except Exception:' in economy.py
- super() modernization in economy.py
- ruff autofix for unsorted imports, UP rules

pyproject.toml:
- added [tool.ruff] config to ignore stylistic rules that don't apply
  to alpha code (BLE001, EXE001, C408, RUF013, S110, ISC004)

Net effect: 'ruff check .' now passes; the package can be parsed and
imported (deps still needed for full import, but syntax is valid).
PR #4 was supposed to fix some of this; this lands the same fixes
without the SSE merge that was the actual blocker.

Author: faresrafat3

epistemic_forge/__init__.py

@@ -1,14 +1,14 @@
 """Epistemic Forge — ARSENAL-powered research & writing kit."""
 
-from .pipeline.arsenal_run import ArsenalRun, run_pipeline
 from .models import Claim, ForgeResult, ProjectSpec
+from .pipeline.arsenal_run import ArsenalRun, run_pipeline
 
 __version__ = "0.1.0"
 __all__ = [
     "ArsenalRun",
-    "run_pipeline",
     "Claim",
     "ForgeResult",
     "ProjectSpec",
     "__version__",
+    "run_pipeline",
 ]

epistemic_forge/benchmark/baseline.py

@@ -2,10 +2,8 @@
 
 from __future__ import annotations
 
-from typing import List
 
-
-def baseline_answer(title: str, question: str, domain: str, keywords: List[str]) -> str:
+def baseline_answer(title: str, question: str, domain: str, keywords: list[str]) -> str:
     """Produce a short unstructured answer — typical one-shot Q&A quality."""
     kw = ", ".join(keywords) if keywords else "the main themes"
     # Deliberately thin: claim-ish sentence, weak support, no rebuttal structure

epistemic_forge/benchmark/llm_judge.py

@@ -1,10 +1,13 @@
 """LLM-as-a-Judge for Automated, Scientific Epistemic Evaluation (Toulmin Model)."""
-from typing import Dict, Any
-from epistemic_forge.models import JudgeEvaluation
-from epistemic_forge.llm import generate_structured
+from typing import Any
+
 from loguru import logger
 
-def evaluate_artifact_quality(question: str, artifact_text: str) -> Dict[str, Any]:
+from epistemic_forge.llm import generate_structured
+from epistemic_forge.models import JudgeEvaluation
+
+
+def evaluate_artifact_quality(question: str, artifact_text: str) -> dict[str, Any]:
     """Uses a stronger model to judge the output based strictly on Toulmin's Model of Argumentation."""
     logger.info("⚖️ Initiating strict Toulmin-based evaluation of the final artifact...")
 

epistemic_forge/benchmark/metrics.py

@@ -8,7 +8,7 @@
 
 import re
 from dataclasses import asdict, dataclass
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 
 @dataclass
@@ -44,26 +44,26 @@ def overall(self) -> float:
             total += getattr(self, k) * w
         return round(total, 4)
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         d = asdict(self)
         d["overall"] = self.overall()
         return d
 
 
-def _hit(text: str, patterns: List[str]) -> float:
+def _hit(text: str, patterns: list[str]) -> float:
     t = text.lower()
     return 1.0 if any(p in t for p in patterns) else 0.0
 
 
-def _count_hits(text: str, patterns: List[str]) -> int:
+def _count_hits(text: str, patterns: list[str]) -> int:
     t = text.lower()
     return sum(1 for p in patterns if p in t)
 
 
 def score_document(
     text: str,
     domain: str = "hybrid",
-    keywords: Optional[List[str]] = None,
+    keywords: list[str] | None = None,
 ) -> QualityScores:
     """Score a free-text answer for Toulmin completeness + packaging quality."""
     keywords = keywords or []

epistemic_forge/benchmark/suite.py

@@ -5,7 +5,7 @@
 import json
 from dataclasses import asdict, dataclass
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 from epistemic_forge.benchmark.baseline import baseline_answer
 from epistemic_forge.benchmark.metrics import score_document, toulmin_coverage
@@ -18,10 +18,10 @@ class BenchCase:
     title: str
     question: str
     domain: str
-    keywords: List[str]
+    keywords: list[str]
 
 
-BENCHMARK_CASES: List[BenchCase] = [
+BENCHMARK_CASES: list[BenchCase] = [
     BenchCase(
         "p1",
         "Predictive processing and blame",
@@ -106,8 +106,8 @@ class CaseResult:
     forge_toulmin: float
     lift_overall: float
     lift_toulmin: float
-    baseline_scores: Dict[str, Any]
-    forge_scores: Dict[str, Any]
+    baseline_scores: dict[str, Any]
+    forge_scores: dict[str, Any]
 
 
 def _forge_text(case: BenchCase) -> str:
@@ -125,9 +125,9 @@ def _forge_text(case: BenchCase) -> str:
     return "\n\n".join(a.content for a in result.artifacts)
 
 
-def run_benchmark(cases: Optional[List[BenchCase]] = None) -> Dict[str, Any]:
+def run_benchmark(cases: list[BenchCase] | None = None) -> dict[str, Any]:
     cases = cases or BENCHMARK_CASES
-    rows: List[CaseResult] = []
+    rows: list[CaseResult] = []
     for case in cases:
         base_txt = baseline_answer(
             case.title, case.question, case.domain, case.keywords
@@ -187,7 +187,7 @@ def run_benchmark(cases: Optional[List[BenchCase]] = None) -> Dict[str, Any]:
     }
 
 
-def write_benchmark_reports(out_dir: str | Path) -> Dict[str, Any]:
+def write_benchmark_reports(out_dir: str | Path) -> dict[str, Any]:
     out = Path(out_dir)
     out.mkdir(parents=True, exist_ok=True)
     report = run_benchmark()

epistemic_forge/cli.py

@@ -8,14 +8,15 @@
 
 import argparse
 import sys
+
 from rich.console import Console
 from rich.panel import Panel
 from rich.progress import Progress, SpinnerColumn, TextColumn
 from rich.tree import Tree
 
+from epistemic_forge.memory.economy import budget_manager
 from epistemic_forge.models import ProjectSpec
 from epistemic_forge.pipeline.arsenal_run import run_pipeline
-from epistemic_forge.memory.economy import budget_manager
 
 console = Console()
 

epistemic_forge/experts/base.py

@@ -6,8 +6,10 @@
 """
 
 from abc import ABC, abstractmethod
-from typing import Any, Dict
+from typing import Any
+
 from pydantic import BaseModel
+
 from epistemic_forge.models import ProjectSpec
 
 
@@ -18,10 +20,9 @@ class EpistemicExpert(ABC):
     @abstractmethod
     def expert_name(self) -> str:
         """The formal identifier of the expert (e.g., 'RigorSentinel')."""
-        pass
 
     @abstractmethod
-    def analyze(self, spec: ProjectSpec, context: Dict[str, Any]) -> BaseModel:
+    def analyze(self, spec: ProjectSpec, context: dict[str, Any]) -> BaseModel:
         """
         Executes the expert's specific neuro-symbolic logic.
 
@@ -32,4 +33,3 @@ def analyze(self, spec: ProjectSpec, context: Dict[str, Any]) -> BaseModel:
         Returns:
             A strictly typed Pydantic BaseModel representing the expert's conclusion.
         """
-        pass

epistemic_forge/experts/claim_expert.py

@@ -1,10 +1,13 @@
 """Claim Lattice Expert Implementation (Agentic RAG Grounded)."""
-from typing import Dict, Any
+from typing import Any
+
+from loguru import logger
+
 from epistemic_forge.experts.base import EpistemicExpert
-from epistemic_forge.models import ProjectSpec, ClaimLatticeOutput
 from epistemic_forge.llm import generate_structured
+from epistemic_forge.models import ClaimLatticeOutput, ProjectSpec
 from epistemic_forge.tools.search import multi_hop_search
-from loguru import logger
+
 
 class ClaimLatticeExpert(EpistemicExpert):
     """Deconstructs the question into a structured, epistemically grounded claim lattice."""
@@ -13,7 +16,7 @@ class ClaimLatticeExpert(EpistemicExpert):
     def expert_name(self) -> str:
         return "Grounded_Claim_Lattice_Generator"
 
-    def analyze(self, spec: ProjectSpec, context: Dict[str, Any]) -> ClaimLatticeOutput:
+    def analyze(self, spec: ProjectSpec, context: dict[str, Any]) -> ClaimLatticeOutput:
         """Uses Agentic Multi-Hop Web Search to ground the LLM's claims in reality."""
 
         # 1. Fetch real-world context using Multi-Hop Agentic RAG

epistemic_forge/experts/dialectic_expert.py

@@ -1,10 +1,10 @@
 """Hegelian Synthesis Expert Implementation."""
 
-from typing import Dict, Any
+from typing import Any
 
 from epistemic_forge.experts.base import EpistemicExpert
-from epistemic_forge.models import ProjectSpec, HegelianDialecticOutput
 from epistemic_forge.llm import generate_structured
+from epistemic_forge.models import HegelianDialecticOutput, ProjectSpec
 
 
 class HegelianExpert(EpistemicExpert):
@@ -15,7 +15,7 @@ def expert_name(self) -> str:
         return "Hegelian_Dialectic_Engine"
 
     def analyze(
-        self, spec: ProjectSpec, context: Dict[str, Any]
+        self, spec: ProjectSpec, context: dict[str, Any]
     ) -> HegelianDialecticOutput:
         """Synthesizes the core question by forcing a steelmanned antithesis."""
         messages = [

epistemic_forge/experts/freelance_expert.py

@@ -2,14 +2,14 @@
 
 from __future__ import annotations
 
-from typing import Any, Dict
+from typing import Any
 
 from epistemic_forge.models import ProjectSpec
 
 
 def build_client_pack(
-    spec: ProjectSpec, claims_bundle: Dict[str, Any]
-) -> Dict[str, Any]:
+    spec: ProjectSpec, claims_bundle: dict[str, Any]
+) -> dict[str, Any]:
     return {
         "client_brief": {
             "goal": spec.question,