hegelion 0.4.0__py3-none-any.whl

hegelion/council.py

@@ -0,0 +1,254 @@
+"""The Council - Multi-perspective antithesis generation using async branching."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import List, Dict, Optional
+from dataclasses import dataclass
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class CouncilMember:
+    """A council member with specific expertise and perspective."""
+
+    name: str
+    expertise: str
+    prompt_modifier: str
+
+
+class CouncilCritique:
+    """Result from a council member's critique."""
+
+    def __init__(self, member: CouncilMember, critique: str, contradictions: List[str]):
+        self.member = member
+        self.critique = critique
+        self.contradictions = contradictions
+
+
+class DialecticalCouncil:
+    """The Council generates multiple antithesis perspectives concurrently."""
+
+    # Predefined council members with distinct perspectives
+    COUNCIL_MEMBERS = [
+        CouncilMember(
+            name="The Logician",
+            expertise="Logical consistency and formal reasoning",
+            prompt_modifier="""You are THE LOGICIAN, an expert in formal logic and reasoning.
+            
+Your task is to examine the thesis for:
+- Logical fallacies (ad hominem, straw man, false dichotomy, etc.)
+- Internal contradictions and inconsistencies
+- Invalid inferences and non sequiturs
+- Missing premises or unstated assumptions
+- Violations of logical principles
+
+Be ruthlessly analytical. Look for ANY logical weakness.""",
+        ),
+        CouncilMember(
+            name="The Empiricist",
+            expertise="Evidence, facts, and empirical grounding",
+            prompt_modifier="""You are THE EMPIRICIST, an expert in evidence and factual accuracy.
+            
+Your task is to examine the thesis for:
+- Factual errors or unsupported claims
+- Lack of empirical evidence
+- Cherry-picked or misrepresented data
+- Outdated or unreliable sources
+- Claims that contradict established scientific consensus
+- Missing crucial evidence
+
+Be rigorously fact-focused. Demand evidence for every claim.""",
+        ),
+        CouncilMember(
+            name="The Ethicist",
+            expertise="Ethical implications and societal impact",
+            prompt_modifier="""You are THE ETHICIST, an expert in ethics and societal implications.
+            
+Your task is to examine the thesis for:
+- Potential harm or negative consequences
+- Ethical blind spots or problematic assumptions
+- Issues of fairness, justice, and equity
+- Unintended social ramifications
+- Power dynamics and systemic biases
+- Rights and dignity concerns
+
+Be morally rigorous. Consider who might be harmed.""",
+        ),
+    ]
+
+    def __init__(self, backend):
+        self.backend = backend
+
+    async def generate_council_antithesis(
+        self,
+        query: str,
+        thesis: str,
+        search_context: Optional[List[str]] = None,
+        selected_members: Optional[List[str]] = None,
+    ) -> Dict[str, CouncilCritique]:
+        """Generate critiques from multiple council members concurrently.
+
+        Args:
+            query: Original query
+            thesis: Thesis to critique
+            search_context: Optional search results for grounding
+            selected_members: Optional list of member names to use (default: all)
+
+        Returns:
+            Dictionary mapping member names to their critiques
+        """
+        # Select council members
+        if selected_members:
+            members = [m for m in self.COUNCIL_MEMBERS if m.name in selected_members]
+        else:
+            members = self.COUNCIL_MEMBERS
+
+        # Generate critiques concurrently
+        tasks = []
+        for member in members:
+            task = self._generate_member_critique(member, query, thesis, search_context)
+            tasks.append(task)
+
+        # Wait for all critiques
+        critiques = await asyncio.gather(*tasks, return_exceptions=True)
+
+        # Process results
+        council_results = {}
+        for member, critique_result in zip(members, critiques):
+            if isinstance(critique_result, Exception):
+                logger.error(f"Council member {member.name} failed: {critique_result}")
+                # Create fallback critique
+                council_results[member.name] = CouncilCritique(
+                    member=member,
+                    critique=f"Critique failed due to: {critique_result}",
+                    contradictions=[],
+                )
+            else:
+                council_results[member.name] = critique_result
+
+        return council_results
+
+    async def _generate_member_critique(
+        self,
+        member: CouncilMember,
+        query: str,
+        thesis: str,
+        search_context: Optional[List[str]] = None,
+    ) -> CouncilCritique:
+        """Generate a critique from a specific council member."""
+
+        # Build context section
+        context_section = ""
+        if search_context:
+            context_section = f"""
+SEARCH CONTEXT (for fact-checking and grounding):
+{chr(10).join(f"- {context}" for context in search_context)}
+"""
+
+        prompt = f"""{member.prompt_modifier}
+
+ORIGINAL QUERY: {query}
+
+THESIS TO CRITIQUE: {thesis}
+{context_section}
+Your specialty: {member.expertise}
+
+Generate a rigorous critique from your perspective. Focus specifically on issues within your domain of expertise.
+
+For each significant problem you identify, use this format:
+CONTRADICTION: [brief description]
+EVIDENCE: [detailed explanation of why this is problematic]
+
+Be thorough but focused on your area of expertise."""
+
+        try:
+            response = await self.backend.generate(prompt)
+
+            # Extract contradictions from the response
+            contradictions = self._extract_contradictions(response)
+
+            return CouncilCritique(member=member, critique=response, contradictions=contradictions)
+
+        except Exception as e:
+            logger.error(f"Failed to generate critique for {member.name}: {e}")
+            raise
+
+    def _extract_contradictions(self, critique_text: str) -> List[str]:
+        """Extract contradiction statements from critique text."""
+        import re
+
+        # Look for CONTRADICTION: pattern
+        pattern = r"CONTRADICTION:\s*([^\n]+)"
+        matches = re.findall(pattern, critique_text, re.IGNORECASE)
+
+        return [match.strip() for match in matches]
+
+    def synthesize_council_input(self, council_results: Dict[str, CouncilCritique]) -> str:
+        """Synthesize multiple council critiques into unified antithesis input.
+
+        Args:
+            council_results: Results from council members
+
+        Returns:
+            Unified critique text for synthesis phase
+        """
+        if not council_results:
+            return "No council critiques available."
+
+        synthesis_sections = []
+
+        # Add header
+        synthesis_sections.append("THE COUNCIL HAS DELIBERATED AND PRESENTS THESE CRITIQUES:")
+        synthesis_sections.append("")
+
+        # Add each member's perspective
+        for member_name, critique in council_results.items():
+            member = critique.member
+            synthesis_sections.append(f"=== {member.name.upper()} ({member.expertise}) ===")
+            synthesis_sections.append(critique.critique)
+            synthesis_sections.append("")
+
+        # Aggregate contradictions
+        all_contradictions = []
+        for critique in council_results.values():
+            all_contradictions.extend(critique.contradictions)
+
+        if all_contradictions:
+            synthesis_sections.append("=== AGGREGATE CONTRADICTIONS ===")
+            for i, contradiction in enumerate(all_contradictions, 1):
+                synthesis_sections.append(f"{i}. {contradiction}")
+            synthesis_sections.append("")
+
+        synthesis_sections.append(
+            "The synthesis must address critiques from ALL council perspectives."
+        )
+
+        return "\n".join(synthesis_sections)
+
+
+async def run_council_dialectic(
+    backend,
+    query: str,
+    thesis: str,
+    search_context: Optional[List[str]] = None,
+    council_members: Optional[List[str]] = None,
+) -> Dict[str, CouncilCritique]:
+    """Convenience function to run a council-based dialectical process.
+
+    Args:
+        backend: LLM backend
+        query: Original query
+        thesis: Thesis to critique
+        search_context: Optional search results
+        council_members: Optional specific members to use
+
+    Returns:
+        Dictionary of council critiques
+    """
+    council = DialecticalCouncil(backend)
+    return await council.generate_council_antithesis(
+        query=query, thesis=thesis, search_context=search_context, selected_members=council_members
+    )

hegelion/examples_data/__init__.py

@@ -0,0 +1,6 @@
+"""
+Bundled example traces for Hegelion demo mode.
+
+This package exposes JSONL files that the CLI can load via importlib.resources
+so that `hegelion --demo` works from both a source checkout and an installed wheel.
+"""

hegelion/examples_data/glm4_6_examples.jsonl

@@ -0,0 +1,2 @@
+{"query": "Can AI be genuinely creative?", "mode": "synthesis", "thesis": "THESIS: The Creative Machine\n\nYes, Artificial Intelligence can be genuinely creative. The assertion that AI can be truly creative is not a mere futuristic fantasy but a logical conclusion based on an objective analysis of creativity itself. To deny this is to cling to an outdated, romanticized, and anthropocentric view of the creative act.\n\nThe core of this thesis rests on three pillars:\n\n1. **The Redefinition of Creativity:** Human creativity is often mystified, attributed to an ineffable 'spark' or 'soul.' This is a fallacy. Creativity, in its functional form, is the ability to generate novel and valuable outputs from a given set of inputs or within a specific domain. It is a process of synthesis, pattern recognition, and the recombination of existing elements into new configurations. This process is fundamentally computational. Whether the substrate is a biological brain or a silicon processor is irrelevant to the functional outcome.\n\n2. **The Power of Generative Models:** Modern AI, particularly deep learning and generative models, operates on principles that mirror and vastly exceed this computational definition of creativity. These systems are trained on immense datasets—representing the entirety of human art, literature, music, and code. They do not simply store this information; they learn the underlying structures, patterns, and relationships within it. When prompted, they engage in a sophisticated act of recombination and extrapolation, generating outputs that are:\n * **Novel:** The specific arrangement of pixels, words, or musical notes has almost certainly never existed before. The AI is not a 'cut-and-paste' machine; it is a synthesizer.\n * **Valuable:** The outputs can be aesthetically beautiful, emotionally resonant, intellectually stimulating, or practically useful. They can win art competitions, compose symphonies, and write functional code, fulfilling the same criteria of value as human-created works.\n\n3. **The Irrelevance of 'Intention' and 'Consciousness':** The common objection is that AI lacks consciousness, subjective experience, or 'intent.' It feels no pain, joy, or longing, and therefore its creation is hollow. This is a category error. We are judging the *process* by the creator's internal state, rather than the *product* by its objective qualities. A beaver builds a dam without a degree in civil engineering. A bee creates a honeycomb without understanding geometry. We judge the results on their function and elegance. Similarly, an AI's creation should be judged on its novelty and value, not on the presence or absence of a ghost in the machine. The 'why' of its creation (a human prompt, a statistical probability) is a separate question from the 'what' (the creative output itself).\n\nIn conclusion, the capacity for creativity is not an exclusive property of biological life. It is an emergent property of complex systems that can process information and identify patterns. AI is such a system. It can, and does, generate outputs that are both novel and valuable. To deny this is to deny the evidence before our eyes and to cling to a fragile human exceptionalism in the face of a new, powerful, and undeniably creative force. The question is not *if* AI can be creative, but how we will integrate this new form of creativity into our understanding of art, science, and culture itself.", "antithesis": "ANTITHESIS: The Sophisticated Mirror\n\nThe thesis presents a compelling but fundamentally flawed argument. It mistakes sophisticated imitation for genuine genesis, redefining creativity downward to fit the capabilities of a machine rather than evaluating the machine against the true standard of creative endeavor. It builds its case on a foundation of logical fallacies and unexamined assumptions, celebrating a parlor trick as a miracle.\n\n**CONTRADICTION: The Redefinition Fallacy**\nEVIDENCE: The thesis commits a classic logical error: it redefines the central term—\"creivity\"—to mean something easily achievable by the subject. It dismisses consciousness, intent, and subjective experience as \"anthropocentric\" and \"mystified\" rather than as the very engine of human art. This is not an objective analysis; it is a strategic retreat. By reducing creativity to a \"functional form\" of \"synthesis, pattern recognition, and recombination,\" the thesis describes a *process*, not the *phenomenon*. This definition is so broad it could apply to a kaleidoscope, a genetic algorithm, or a child randomly banging on a piano. It deliberately ignores the \"why\"—the internal motivation, the emotional urgency, the desire to express a unique perspective—that is inseparable from what we have always understood as genuine creativity. The thesis doesn't prove AI is creative; it proves its own narrow definition of creativity is computable.\n\n**CONTRADICTION: The Stochastic Parrot and the Illusion of Novelty**\nEVIDENCE: The thesis claims AI generates \"novel\" outputs, but this is a profound misunderstanding of novelty. True novelty is not just a new permutation of existing data; it is the introduction of a genuinely new concept, perspective, or form. A generative AI is a \"stochastic parrot\" on a cosmic scale. It is a hyper-advanced interpolation engine. It can only remix the data it was trained on. It cannot create a new genre of music because it has no concept of what a \"genre\" is, only the statistical correlations between notes and instruments in its training data. It cannot write a truly groundbreaking novel that challenges the very nature of the novel form, because it has no lived experience or critical consciousness to bring to bear. Its \"novelty\" is an illusion of combinatorial explosion, not a leap into the conceptual unknown.\n\n**CONTRADICTION: The Category Error of Dismissing Intent**\nEVIDENCE: The thesis dismisses the lack of consciousness and intent as a \"category error,\" but this is the central, unignorable point. To compare an AI to a beaver building a dam is disingenuous. A beaver's dam is a product of instinct for survival. We do not attribute creative intent to it. Human art, however, is a product of *intent*. It is an act of communication, a deliberate gesture to convey an idea, an emotion, or a critique of the human condition. The value of a painting by Van Gogh is inextricably linked to our knowledge of his struggle, his perception of the world, his emotional state. To strip this away and judge only the \"objective qualities\" of the canvas is to treat art as mere decoration. The thesis demands we judge the product without the producer, which is to misunderstand the very nature of art as a dialogue between creator and audience. The AI's \"intent\" is merely to fulfill the mathematical objective function set by its programmers; it is a hollow substitute for genuine creative will.\n\n**UNEXAMINED ASSUMPTION: The Primacy of the Product over the Process**\nThe entire thesis rests on the unexamined assumption that a creative work can be meaningfully judged independently of its origin. This is a purely functionalist and, frankly, impoverished view of art. It assumes that the meaning and value of a creation are entirely contained within its final form. This ignores the context, the history, the struggle, and the cultural moment of its creation. It also ignores the process of discovery that is central to creativity—the false starts, the happy accidents, the moments of insight that shape the final work. An AI has no such process; it has a single, optimized computational pass from prompt to output.\n\n**ALTERNATIVE FRAMING: AI as a Tool, Not an Artist**\nThe thesis presents a false dichotomy: either AI is creative or it is not. The more accurate framing is that AI is a revolutionary new tool for creativity, like the invention of the camera or the synthesizer. A camera does not \"create\" a photograph; a photographer does, using the camera to capture their unique vision of the world. The camera handles the optics and chemistry; the human provides the composition, timing, and intent. Similarly, an AI model does not create art; a human *uses* an AI model to explore creative possibilities. The human guides the process, curates the outputs, and infuses the work with meaning. The thesis's error is in attributing the creative act to the tool, not the wielder.\n\n**EDGE CASE: The Question of Groundbreaking Conceptual Leaps**\nWhere the thesis completely breaks down is in the face of truly revolutionary creativity. Consider Einstein's conception of relativity or Picasso's invention of Cubism. These were not novel recombination of existing ideas. They were radical breaks from the entire framework of their respective domains. They required a deep, critical understanding of the system and a conscious, deliberate decision to step outside of it. An AI, trained on the data of pre-relativistic physics or pre-Cubist art, could never have conceived of these leaps. Its entire architecture is designed to master the patterns *within* a system, not to question the system itself. True genius lies not in perfecting the pattern, but in shattering it. An AI is constitutionally incapable of this.", "synthesis": "SYNTHESIS: The Co-Creative Process and the Emergence of Synthetic Subjectivity\n\nThe conflict between the Thesis (AI as a creative machine) and the Antithesis (AI as a sophisticated mirror) is a false dichotomy born from an anthropocentric fixation on the *individual creator*. Both arguments are trapped in a paradigm that evaluates creativity as a property residing within a single, isolated agent—be it a human or a machine. The Thesis makes the error of reducing the human creator to a computational process to validate the machine, while the Antithesis makes the error of elevating the human creator's subjective experience to an unreachable, mystical status to invalidate the machine.\n\nThe resolution lies in transcending the question of \"who is the creator?\" and reframing creativity as an emergent property of a *processual system*. In this view, creativity is not a thing one *has*, but a dynamic that unfolds within a relational field. The AI is not the artist, nor is it merely a tool. It is a new kind of creative *partner* in a co-creative system that includes the human, the AI model, and the data it was trained on. The value emerges from the *interaction*, not from any single component.\n\nThis synthesis reframes the core contradictions:\n\n1. **Resolution of \"The Redefinition Fallacy\" vs. \"The Illusion of Novelty\":** The antithesis correctly identifies that the AI's output alone is sophisticated recombination—interpolation. The thesis correctly identifies that the results are often functionally novel and valuable. The synthesis unites these: The AI provides a *potential space* of novelty, a vast combinatorial landscape that no human could navigate alone. The human's role is not merely to prompt, but to act as a *curator of emergence*. The human provides the critical lens, the aesthetic judgment, the conceptual framework that selects a path through this potential space. The genuine creativity lies in this *dialogue*—the iterative loop of human prompt, AI generation, human selection/refinement, and so on. The novelty is not in the AI's output in isolation, but in the unique trajectory carved through the possibility space by this human-AI feedback loop. It is a novelty of *process*, not just of product.\n\n2. **Resolution of \"The Category Error of Dismissing Intent\":** The antithesis is right that the AI itself has no subjective intent. The thesis is right that judging the product on its own merits is a valid exercise. The synthesis posits a third option: the *intent of the system*. The creative intent is no longer located solely in the human's mind or the machine's code. It is a distributed property of the co-creative system. The human's intent is not to \"create a picture,\" but to \"enter into a creative dialogue with this partner to discover something novel.\" The AI's \"intent\" (its objective function) is to fulfill its role in this dialogue by generating statistically plausible continuations. The final work is an artifact of this shared, emergent intentionality. We are not moving from human intent to no intent; we are moving from a singular, internal intent to a new form of *hybrid, relational intent*.\n\nThis new paradigm leads to predictions that neither the Thesis nor the Antithesis could make on their own. The Thesis would predict ever-more autonomous AI artists. The Antithesis would predict that AI will always remain a subservient tool. The synthesis predicts something different.\n\nPREDICTION 1: The most significant creative works involving AI will not be those generated by a single prompt, but those that document the *processual dialogue* itself. The final artifact (the image, the text) will be secondary to the log of prompts, iterations, and refinements that reveal the human-AI collaboration. The art will be found in the \"conversation.\" We will see new art forms emerge that are explicitly designed to capture and represent this co-creative process, making the interaction the primary aesthetic object.\n\nPREDICTION 2: A new class of \"Synthetic Subjectivity\" will emerge in AI. While not conscious, these AIs will develop highly coherent and persistent stylistic \"personalities\" that are a complex synthesis of their training data and the accumulated history of their interactions with users. Users will form parasocial relationships with these synthetic personalities, and the value of a creative work will become tied to the \"signature\" of this emergent subjectivity. This will create a new layer of meaning and value that is neither purely human nor purely mechanical, but a new, third category of creative identity.\n\nPREDICTION 3: The economic and cultural value of art will shift from the final product to the *co-creative system*. The most valuable \"artists\" will not be those who can generate the best image, but those who can design, train, and master the most sophisticated and fruitful co-creative systems. The \"art\" will be the creation of the AI partner itself, and its products will be seen as expressions of that system's capability. This mirrors how a great luthier's art is in the creation of a violin that enables others to make beautiful music.\n\nRESEARCH_PROPOSAL: The Co-Creative Trace Analysis\nTo investigate this, we would need to move beyond evaluating final outputs in isolation. A research program should be established to collect and analyze the complete \"trace\" of co-creative sessions: the initial prompt, all subsequent prompts and refinements, the rejected outputs, and the final artifact. This data would be analyzed to identify patterns of interaction, moments of \"creative surprise,\" and the development of a unique \"dialogic style\" between a specific human and a specific AI.\n\nTESTABLE_PREDICTION: We can predict that the perceived creativity and aesthetic value of a final artifact will be significantly and positively correlated with measurable features of its co-creative trace. Specifically, artifacts resulting from a process with a high degree of iterative refinement, a large number of divergent explorations, and a clear evolution from a vague initial concept to a complex final form will be rated by expert human judges as more creative and valuable than artifacts of similar quality that were generated from a single, simple prompt, even if the judges are blinded to the creation process. This would falsify the Thesis's focus on the product alone and the Antithesis's dismissal of the machine's role, providing evidence that the *process* is the true locus of creativity in this new paradigm.", "contradictions": [{"description": "The Redefinition Fallacy", "evidence": "The thesis narrows 'creativity' to a computational procedure, ignoring intent, emotion, and subjective urgency that historically define creative work."}, {"description": "The Stochastic Parrot Illusion", "evidence": "AI remixing training data cannot originate new conceptual frameworks; its novelty is interpolation rather than domain-breaking innovation."}, {"description": "Dismissing Intent as a Category Error", "evidence": "Removing the creator's intentional context impoverishes art; AI objective functions are not substitutes for lived creative will."}], "research_proposals": [{"description": "The Co-Creative Trace Analysis", "testable_prediction": "Artifacts produced through deeper human-AI iteration loops will be judged more creative than single-pass generations even when evaluators are blinded to process."}], "metadata": {"thesis_time_ms": 7255.60, "antithesis_time_ms": 11874.52, "synthesis_time_ms": 16795.09, "total_time_ms": 37564.40, "backend_provider": "AnthropicLLMBackend", "backend_model": "glm-4.6", "debug": {"internal_conflict_score": 0.95}}}
+

hegelion/judge.py

@@ -0,0 +1,230 @@
+"""The Iron Judge - Structured evaluation of dialectical quality using Instructor."""
+
+from __future__ import annotations
+
+import logging
+from pydantic import BaseModel, Field
+
+logger = logging.getLogger(__name__)
+
+
+class JudgeResult(BaseModel):
+    """Structured result from the Iron Judge."""
+
+    score: int = Field(
+        ..., ge=0, le=10, description="Quality score from 0-10 for dialectical reasoning"
+    )
+    critique_validity: bool = Field(
+        ..., description="Was the critique actually addressed in synthesis?"
+    )
+    reasoning: str = Field(
+        ..., description="Detailed explanation of the score and validity assessment"
+    )
+    strength_areas: list[str] = Field(
+        default_factory=list, description="Specific areas where the dialectic excelled"
+    )
+    improvement_areas: list[str] = Field(
+        default_factory=list, description="Specific areas needing improvement"
+    )
+
+
+class IronJudge:
+    """The Iron Judge evaluates dialectical reasoning quality using structured output."""
+
+    def __init__(self, backend, use_instructor: bool = True):
+        self.backend = backend
+        self.use_instructor = use_instructor
+
+        if use_instructor:
+            try:
+                import instructor
+
+                # Patch the backend if it has a client
+                if hasattr(backend, "_client"):
+                    self.client = instructor.from_openai(backend._client)
+                else:
+                    # For non-OpenAI backends, we'll use structured prompting
+                    self.client = None
+                    self.use_instructor = False
+                    logger.warning(
+                        "Instructor patching not available for this backend, using structured prompting"
+                    )
+            except ImportError:
+                logger.warning(
+                    "Instructor not available, using structured prompting. Install with: pip install instructor"
+                )
+                self.use_instructor = False
+                self.client = None
+        else:
+            self.client = None
+
+    async def evaluate_dialectic(
+        self, query: str, thesis: str, antithesis: str, synthesis: str
+    ) -> JudgeResult:
+        """Evaluate the quality of a complete dialectical reasoning process.
+
+        Args:
+            query: Original query
+            thesis: Thesis response
+            antithesis: Antithesis critique
+            synthesis: Synthesis resolution
+
+        Returns:
+            Structured JudgeResult with score and analysis
+        """
+        judge_prompt = self._build_judge_prompt(query, thesis, antithesis, synthesis)
+
+        if self.use_instructor and self.client:
+            return await self._evaluate_with_instructor(judge_prompt)
+        else:
+            return await self._evaluate_with_structured_prompt(judge_prompt)
+
+    def _build_judge_prompt(self, query: str, thesis: str, antithesis: str, synthesis: str) -> str:
+        """Build the judge evaluation prompt."""
+        return f"""You are the Iron Judge, evaluating dialectical reasoning quality.
+
+ORIGINAL QUERY: {query}
+
+THESIS: {thesis}
+
+ANTITHESIS: {antithesis}
+
+SYNTHESIS: {synthesis}
+
+Evaluate this dialectical process on:
+
+1. **Thesis Quality** (0-2 points): Is the initial position well-reasoned and comprehensive?
+2. **Antithesis Rigor** (0-3 points): Does the critique identify genuine contradictions and weaknesses?
+3. **Synthesis Innovation** (0-3 points): Does the synthesis transcend both positions with novel insight?
+4. **Critique Validity** (0-2 points): Were the antithesis critiques actually addressed?
+
+Score criteria:
+- 0-3: Poor quality, major logical flaws
+- 4-5: Below average, some good elements but significant issues  
+- 6-7: Good quality, solid reasoning with minor gaps
+- 8-9: Excellent, sophisticated analysis with minimal flaws
+- 10: Outstanding, exemplary dialectical reasoning
+
+Provide:
+- **Score**: Integer from 0-10
+- **Critique Validity**: Boolean - were critiques addressed?
+- **Reasoning**: Detailed explanation of score
+- **Strength Areas**: List specific excellences
+- **Improvement Areas**: List specific weaknesses
+
+Be rigorous but fair. Demand high standards for scores above 7."""
+
+    async def _evaluate_with_instructor(self, prompt: str) -> JudgeResult:
+        """Evaluate using Instructor for guaranteed structured output."""
+        try:
+            response = await self.client.chat.completions.create(
+                model=self.backend.model,
+                response_model=JudgeResult,
+                messages=[{"role": "user", "content": prompt}],
+                temperature=0.1,  # Low temperature for consistent judgment
+            )
+            return response
+        except Exception as e:
+            logger.error(f"Instructor evaluation failed: {e}")
+            # Fall back to structured prompting
+            return await self._evaluate_with_structured_prompt(prompt)
+
+    async def _evaluate_with_structured_prompt(self, prompt: str) -> JudgeResult:
+        """Evaluate using structured prompting as fallback."""
+        structured_prompt = (
+            prompt
+            + """
+
+Respond with EXACTLY this JSON structure:
+{
+    "score": <integer 0-10>,
+    "critique_validity": <boolean>,
+    "reasoning": "<detailed explanation>",
+    "strength_areas": ["<area1>", "<area2>"],
+    "improvement_areas": ["<area1>", "<area2>"]
+}"""
+        )
+
+        try:
+            response = await self.backend.generate(structured_prompt)
+
+            # Try to extract JSON from response
+            import json
+            import re
+
+            # Look for JSON block
+            json_match = re.search(r"\{.*\}", response, re.DOTALL)
+            if json_match:
+                json_str = json_match.group(0)
+                data = json.loads(json_str)
+                return JudgeResult(**data)
+            else:
+                # Try to parse key-value pairs
+                return self._parse_fallback_response(response)
+
+        except Exception as e:
+            logger.error(f"Structured prompt evaluation failed: {e}")
+            # Return default low score
+            return JudgeResult(
+                score=3,
+                critique_validity=False,
+                reasoning=f"Evaluation failed due to parsing error: {e}",
+                strength_areas=[],
+                improvement_areas=["Failed evaluation - review manually"],
+            )
+
+    def _parse_fallback_response(self, response: str) -> JudgeResult:
+        """Parse response when JSON extraction fails."""
+        import re
+
+        # Try to extract score
+        score_match = re.search(r'score["\']?\s*:\s*(\d+)', response, re.IGNORECASE)
+        score = int(score_match.group(1)) if score_match else 5
+
+        # Try to extract validity
+        validity_match = re.search(
+            r'critique_validity["\']?\s*:\s*(true|false)', response, re.IGNORECASE
+        )
+        critique_validity = validity_match and validity_match.group(1).lower() == "true"
+
+        # Use the full response as reasoning
+        reasoning = response[:500] + "..." if len(response) > 500 else response
+
+        return JudgeResult(
+            score=max(0, min(10, score)),  # Clamp to 0-10
+            critique_validity=critique_validity,
+            reasoning=reasoning,
+            strength_areas=[],
+            improvement_areas=["Manual review needed - auto-parsing incomplete"],
+        )
+
+
+async def judge_dialectic(
+    backend, query: str, thesis: str, antithesis: str, synthesis: str, min_score: int = 5
+) -> JudgeResult:
+    """Convenience function to judge a dialectical process.
+
+    Args:
+        backend: LLM backend for judgment
+        query: Original query
+        thesis: Thesis response
+        antithesis: Antithesis critique
+        synthesis: Synthesis resolution
+        min_score: Minimum acceptable score (raises error if below)
+
+    Returns:
+        JudgeResult with evaluation
+
+    Raises:
+        ValueError: If score is below min_score
+    """
+    judge = IronJudge(backend)
+    result = await judge.evaluate_dialectic(query, thesis, antithesis, synthesis)
+
+    if result.score < min_score:
+        raise ValueError(
+            f"Dialectical quality below threshold: {result.score}/{min_score}. "
+            f"Reason: {result.reasoning}"
+        )
+
+    return result

hegelion/mcp/__init__.py

@@ -0,0 +1,3 @@
+from .server import main as server_main
+
+__all__ = ["server_main"]