feat(core): 🛡️ enforce absolute truthfulness (no claim without an epistemic warrant and falsifier) and integrate real LLM Claim Expert

Author: Arena AI Agent

epistemic_forge/experts/claim_expert.py

@@ -1,55 +1,39 @@
-"""Claim lattice expert."""
+"""Claim Lattice Expert Implementation."""
+from typing import Dict, Any
+from epistemic_forge.experts.base import EpistemicExpert
+from epistemic_forge.models import ProjectSpec, ClaimLatticeOutput
+from epistemic_forge.llm import generate_structured
+from loguru import logger
 
-from __future__ import annotations
+class ClaimLatticeExpert(EpistemicExpert):
+    """Deconstructs the question into a structured, epistemically grounded claim lattice."""
+    
+    @property
+    def expert_name(self) -> str:
+        return "Epistemic_Claim_Lattice_Generator"
 
-from typing import Any, Dict, List
-
-from epistemic_forge.models import Claim, Confidence, ProjectSpec
-
-
-def extract_claims(spec: ProjectSpec, instruction: str) -> Dict[str, Any]:
-    q = spec.question.strip()
-    title = spec.title.strip()
-    # Deterministic structured extraction (no external LLM required)
-    core = Claim(
-        id="C1",
-        text=f"Core thesis addressing: {q}",
-        support=[
-            f"Aligned with instruction: {instruction[:120]}...",
-            f"Keywords in play: {', '.join(spec.keywords) or 'general domain cues'}",
-        ],
-        objections=[
-            "The framing may smuggle unstated assumptions about the audience.",
-            "Evidence quality is not yet measured; confidence should stay provisional.",
-        ],
-        confidence=Confidence.LIKELY,
-        sources=["user-question", "instruction"],
-        tags=["thesis"],
-    )
-    support_c = Claim(
-        id="C2",
-        text=f"Working support: a structured approach to «{title}» improves decision quality under uncertainty.",
-        support=[
-            "Decomposition reduces hidden tradeoffs.",
-            "Explicit objections prevent one-sided writing.",
-        ],
-        objections=["Structure without domain data can become cargo-cult rigor."],
-        confidence=Confidence.POSSIBLE,
-        tags=["support"],
-    )
-    residual = Claim(
-        id="C3",
-        text="Residual uncertainty: which single metric or stakeholder criterion should dominate tradeoffs?",
-        support=["Multi-objective problems need a declared primary criterion."],
-        objections=["Premature metric fixation can distort the inquiry."],
-        confidence=Confidence.WEAK,
-        tags=["uncertainty"],
-    )
-    claims: List[Claim] = [core, support_c, residual]
-    return {
-        "claims": [c.to_dict() for c in claims],
-        "lattice_summary": (
-            "Three-node lattice: thesis, support, residual uncertainty. "
-            "Ready for dialectic stress-test and packaging."
-        ),
-    }
+    def analyze(self, spec: ProjectSpec, context: Dict[str, Any]) -> ClaimLatticeOutput:
+        """Forces the LLM to generate claims ONLY if it can provide a warrant/explanation."""
+        
+        messages = [
+            {
+                "role": "system", 
+                "content": (
+                    "You are a rigorous analytical philosopher and scientist. Your task is to break down the user's premise into a 'Claim Lattice'. "
+                    "CRITICAL RULE: You are strictly forbidden from making ANY claim without providing an 'epistemic_warrant' (a clear logical explanation or evidence) "
+                    "and a 'potential_falsifier' (what would prove it wrong). No confident mush allowed."
+                )
+            },
+            {
+                "role": "user", 
+                "content": f"Core Premise: {spec.question}\nKeywords: {spec.keywords}\nDeconstruct this into rigorously grounded claims."
+            }
+        ]
+        
+        logger.debug("Dispatching to LLM for Claim Lattice Generation (Enforcing Truthfulness)...")
+        return generate_structured(
+            messages=messages,
+            response_model=ClaimLatticeOutput,
+            model=spec.target_model,
+            api_base=spec.api_base
+        )

epistemic_forge/models.py

@@ -45,15 +45,14 @@ class ProjectSpec(BaseModel):
 
 
 class Claim(BaseModel):
-    """Atomic epistemic unit."""
-
-    id: str
-    text: str
-    support: List[str] = Field(default_factory=list)
-    objections: List[str] = Field(default_factory=list)
-    confidence: Confidence = Confidence.LIKELY
-    sources: List[str] = Field(default_factory=list)
-    tags: List[str] = Field(default_factory=list)
+    """Atomic epistemic unit with absolute grounding."""
+    id: str = Field(description="Unique identifier, e.g., C1")
+    text: str = Field(description="The core claim or premise.")
+    epistemic_warrant: str = Field(description="MANDATORY: The exact logical deduction, explanation, or evidence that proves this claim. NO UNSUBSTANTIATED CLAIMS.")
+    potential_falsifier: str = Field(description="What specific evidence or scenario would prove this claim wrong?")
+    support: List[str] = Field(default_factory=list, description="Sub-arguments supporting this claim.")
+    objections: List[str] = Field(default_factory=list, description="Valid counter-arguments against this claim.")
+    confidence: Confidence = Field(default=Confidence.LIKELY)
 
 
 
@@ -174,3 +173,8 @@ class ChainOfDensityOutput(BaseModel):
     """Strict schema for the Chain of Density Architect."""
     information_density_score: float = Field(ge=0.0, le=10.0, description="Score of how dense the signal-to-noise ratio is.")
     crystallized_claim: str = Field(description="The final, hyper-dense output stripped of all filler words.")
+
+class ClaimLatticeOutput(BaseModel):
+    """A strict output schema containing multiple grounded claims."""
+    claims: List[Claim]
+    lattice_summary: str = Field(description="A short summary of how these claims interlock.")

epistemic_forge/pipeline/l2_conductor.py

@@ -9,6 +9,7 @@
 
 from epistemic_forge.models import ProjectSpec
 from epistemic_forge.experts.base import EpistemicExpert
+from epistemic_forge.experts.claim_expert import ClaimLatticeExpert
 from epistemic_forge.experts.dialectic_expert import HegelianExpert
 from epistemic_forge.experts.kaggle_expert import RigorSentinelExpert
 
@@ -22,7 +23,7 @@ def __init__(self):
 
     def _route_experts(self, domain: str) -> list[EpistemicExpert]:
         """Determines which experts are required based on the domain."""
-        active_experts = []
+        active_experts = [ClaimLatticeExpert()]
         if domain in ["philosophy", "research", "hybrid"]:
             active_experts.append(HegelianExpert())
         if domain in ["kaggle", "research", "hybrid"]: