feat(l2): 🧠 redesign experts into dynamic Neuro-Symbolic engines (Hegelian, Rigor Sentinel, Chain of Density)

Author: Arena AI Agent

epistemic_forge/experts/dialectic_expert.py

@@ -1,32 +1,27 @@
-"""Dialectic expert — philosophy/research tension mapping."""
-
-from __future__ import annotations
-
-from typing import Any, Dict
-
-from epistemic_forge.models import ProjectSpec
-
+"""L2 Epistemic Synthesis Engine: Hegelian Dialectic."""
+from epistemic_forge.models import ProjectSpec, HegelianDialecticOutput
+from epistemic_forge.llm import generate_structured
+from typing import Dict, Any
 
 def run_dialectic(spec: ProjectSpec, claims_bundle: Dict[str, Any]) -> Dict[str, Any]:
-    claims = claims_bundle.get("claims", [])
-    thesis = claims[0]["text"] if claims else spec.question
+    """Execute Hegelian Synthesis to destroy weak assumptions."""
+    thesis = spec.question
+    
+    messages = [
+        {"role": "system", "content": "You are a ruthless Hegelian philosopher and logician. Your goal is to take a premise, construct the most devastating 'Steelman' antithesis possible, and forge a synthesis that represents the nuanced truth."},
+        {"role": "user", "content": f"Core Premise/Thesis: {thesis}\nProject Domain: {spec.domain.value}\nDestroy this premise with logic, then synthesize."}
+    ]
+    
+    # Neuro-Symbolic Call: Forcing GPT to return the strict Hegelian schema
+    result: HegelianDialecticOutput = generate_structured(
+        messages=messages,
+        response_model=HegelianDialecticOutput,
+        model="gpt-4o-mini" # Cost-aware baseline
+    )
+    
     return {
         "thesis": thesis,
-        "antithesis": (
-            f"Counter: the best path on «{spec.title}» may be local craft and tacit skill, "
-            "not explicit lattices—over-formalization can freeze inquiry."
-        ),
-        "steelman": (
-            "Steelman of the counter: experts often succeed with pattern recognition under time "
-            "pressure; forcing explicit structure can slow delivery and invent false precision."
-        ),
-        "synthesis": (
-            "Use a *light* claim lattice as a scaffold, not a cage: make assumptions and "
-            "objections legible, then ship the smallest artifact that can be falsified in the world."
-        ),
-        "open_questions": [
-            "What is the cheapest falsifying observation?",
-            "Who is harmed if we are wrong?",
-            "What would count as enough certainty to act?",
-        ],
+        "antithesis": result.steelmanned_antithesis,
+        "synthesis": result.synthesis_resolution,
+        "open_questions": result.remaining_uncertainties,
     }

epistemic_forge/experts/kaggle_expert.py

@@ -1,82 +1,29 @@
-"""Kaggle / applied ML expert."""
-
-from __future__ import annotations
-
-from typing import Any, Dict, List
-
-from epistemic_forge.models import ProjectSpec
-
-
-def build_competition_kit(
-    spec: ProjectSpec, claims_bundle: Dict[str, Any], skills: List[str]
-) -> Dict[str, Any]:
-    notebook_md = f"""# {spec.title} — Kaggle Spine
-
-## Problem
-{spec.question}
-
-## Skills retrieved
-{', '.join(skills) or 'none'}
-
-## Plan
-1. **Define target & metric** — match leaderboard metric exactly.
-2. **Leakage audit** — time, group, target leakage checks.
-3. **EDA** — missingness, cardinality, target balance, simple slices.
-4. **Baseline** — linear/GBDT simple pipeline; record CV mean±std.
-5. **Error analysis** — where does baseline fail?
-6. **One improvement** — single ablated idea; measure lift.
-7. **Ship** — reproducible seeds, requirements, README.
-
-## Skeleton code
-```python
-import numpy as np
-import pandas as pd
-from sklearn.model_selection import StratifiedKFold, cross_val_score
-from sklearn.pipeline import Pipeline
-from sklearn.compose import ColumnTransformer
-from sklearn.preprocessing import OneHotEncoder
-from sklearn.impute import SimpleImputer
-from sklearn.ensemble import HistGradientBoostingClassifier
-
-# df = pd.read_csv('train.csv')
-# y = df['target']
-# X = df.drop(columns=['target'])
-
-# num_cols = X.select_dtypes(include='number').columns
-# cat_cols = X.select_dtypes(exclude='number').columns
-# pre = ColumnTransformer([
-#     ('num', SimpleImputer(strategy='median'), num_cols),
-#     ('cat', Pipeline([
-#         ('imp', SimpleImputer(strategy='most_frequent')),
-#         ('oh', OneHotEncoder(handle_unknown='ignore')),
-#     ]), cat_cols),
-# ])
-# clf = Pipeline([('pre', pre), ('model', HistGradientBoostingClassifier(random_state=42))])
-# cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
-# scores = cross_val_score(clf, X, y, cv=cv, scoring='roc_auc')
-# print(scores.mean(), scores.std())
-```
-
-## Honest claims checklist
-- [ ] Metric matches competition
-- [ ] Split policy documented
-- [ ] No target leakage features
-- [ ] Baseline before complexity
-"""
+"""L2 Epistemic Synthesis Engine: Leakage & Rigor Sentinel."""
+from epistemic_forge.models import ProjectSpec, RigorSentinelOutput
+from epistemic_forge.llm import generate_structured
+from typing import Dict, Any
+
+def build_competition_kit(spec: ProjectSpec, claims_bundle: Dict[str, Any], skills: list) -> Dict[str, Any]:
+    """Audit the premise for epistemic blind spots and target leakage."""
+    
+    messages = [
+        {"role": "system", "content": "You are a Grandmaster ML Auditor. Your job is to look at a proposed research or data problem and identify 'target leakage'—where the answer is implicitly baked into the question—and propose strict falsification metrics."},
+        {"role": "user", "content": f"Problem Statement: {spec.question}\nKeywords: {spec.keywords}\nFind the blind spots and establish a robust baseline."}
+    ]
+    
+    # Neuro-Symbolic Call
+    result: RigorSentinelOutput = generate_structured(
+        messages=messages,
+        response_model=RigorSentinelOutput,
+        model="gpt-4o-mini"
+    )
+    
     return {
-        "checklist": [
-            "metric alignment",
-            "leakage audit",
-            "baseline CV",
-            "error analysis",
-            "single ablation",
-        ],
-        "notebook_markdown": notebook_md,
+        "checklist": result.epistemic_blind_spots,
+        "metric_alignment": result.falsification_metric,
+        "baseline_architecture": result.robust_baseline,
         "experiment_log_template": {
-            "run_id": "baseline_001",
-            "model": "HGB",
-            "cv_mean": None,
-            "cv_std": None,
-            "notes": "",
-        },
+            "status": "Audited by Rigor Sentinel",
+            "notes": "Ensure no data from the future is used."
+        }
     }

epistemic_forge/experts/writing_expert.py

@@ -1,48 +1,28 @@
-"""Writing expert — outlines and drafts."""
-
-from __future__ import annotations
-
-from typing import Any, Dict, List
-
-from epistemic_forge.models import ProjectSpec
-
-
-def outline_and_draft(
-    spec: ProjectSpec, claims_bundle: Dict[str, Any], instruction: str
-) -> Dict[str, Any]:
-    claims: List[Dict[str, Any]] = claims_bundle.get("claims", [])
-    outline = [
-        "Hook / stakes",
-        "Core question",
-        "Claim lattice",
-        "Objections & steelman",
-        "Working synthesis",
-        "Limits",
-        "Next actions",
+"""L2 Epistemic Synthesis Engine: Chain of Density Architect."""
+from epistemic_forge.models import ProjectSpec, ChainOfDensityOutput
+from epistemic_forge.llm import generate_structured
+from typing import Dict, Any
+
+def outline_and_draft(spec: ProjectSpec, claims_bundle: Dict[str, Any], instruction: str) -> Dict[str, Any]:
+    """Compress the dialectic into a hyper-dense, falsifiable artifact."""
+    
+    # Gather previous context to compress
+    raw_context = f"Question: {spec.question}\nClaims: {claims_bundle.get('claims', [])}"
+    
+    messages = [
+        {"role": "system", "content": "You are a Chain-of-Density Architect. Your goal is to take raw thoughts and compress them into a highly dense, signal-rich artifact stripped of all rhetorical fluff and confident mush. Every word must carry epistemic weight."},
+        {"role": "user", "content": f"Raw Context:\n{raw_context}\nCompress this."}
     ]
-    body_bits = []
-    for c in claims:
-        body_bits.append(f"### {c['id']}: {c['text']}\n")
-        if c.get("support"):
-            body_bits.append("Supports:\n" + "\n".join(f"- {s}" for s in c["support"]))
-        if c.get("objections"):
-            body_bits.append(
-                "\nObjections:\n" + "\n".join(f"- {o}" for o in c["objections"])
-            )
-        body_bits.append("")
-
-    draft = f"""# {spec.title}
-
-## Core question
-{spec.question}
-
-## Instruction in force
-{instruction}
-
-## Audience
-{spec.audience}
-
-## Outline
-""" + "\n".join(f"{i+1}. {x}" for i, x in enumerate(outline)) + "\n\n## Claim lattice\n\n" + "\n".join(body_bits)
-
-    return {"outline": outline, "draft_markdown": draft}
+    
+    # Neuro-Symbolic Call
+    result: ChainOfDensityOutput = generate_structured(
+        messages=messages,
+        response_model=ChainOfDensityOutput,
+        model="gpt-4o-mini"
+    )
+    
+    return {
+        "density_score": result.information_density_score,
+        "draft_markdown": f"# Crystallized Artifact\n\n{result.crystallized_claim}\n\n*Density Score: {result.information_density_score}/10*",
+        "outline": ["Crystallized Core"]
+    }

epistemic_forge/models.py

@@ -143,3 +143,27 @@ class WritingExpertOutput(BaseModel):
     tone_consistency_score: float
     structural_flow: str
     draft_paragraphs: List[str]
+
+
+# ==========================================
+# L2 SYNTHESIS ENGINE SCHEMAS (NEURO-SYMBOLIC)
+# ==========================================
+from pydantic import BaseModel, Field
+from typing import List
+
+class RigorSentinelOutput(BaseModel):
+    """Strict schema for the Leakage & Rigor Sentinel (formerly Kaggle Expert)."""
+    epistemic_blind_spots: List[str] = Field(description="Hidden assumptions or target leakage risks in the user's premise.")
+    falsification_metric: str = Field(description="The exact mathematical or logical metric that would prove this premise wrong.")
+    robust_baseline: str = Field(description="A highly resilient, low-complexity baseline approach.")
+
+class HegelianDialecticOutput(BaseModel):
+    """Strict schema for the Hegelian Synthesis Engine."""
+    steelmanned_antithesis: str = Field(description="The absolute strongest possible argument against the core thesis.")
+    synthesis_resolution: str = Field(description="The nuanced truth that reconciles the thesis and the antithesis.")
+    remaining_uncertainties: List[str] = Field(description="Questions that still lack sufficient evidence.")
+
+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.")