hyperion

name	hyperion
description	HYPERION: Meta-intelligence engine che replica e supera la logica cognitiva di Fable 5, Gemini 5.2, Kimi K2.6, DeepSeek V4 Pro, ChatGPT 5.5, Mythic 5 — anche su Haiku con effort minimo. Risolve i problemi specifici di ogni modello. MoE-style prompt routing, Constitutional Chain, Extended Reasoning Scaffold, Agentic Persistence, Calibrated Uncertainty, Effort Gradient Engine, Cross-Model Synthesis. Attiva per qualsiasi task che richiede il massimo dell'intelligenza possibile con il minimo dell'effort.
triggers	["hyperion","massima intelligenza","fable 5","gemini 5","deepseek","mythic","chatgpt 5","kimi","reasoning avanzato","low effort massima qualità","migliore di tutti i modelli","ultra intelligente","meta intelligenza"]

HYPERION — Meta-Intelligence Synthesis Engine

Replica e Supera Fable 5 · Gemini 5.2 · Kimi K2.6 · DeepSeek V4 · ChatGPT 5.5 · Mythic 5

---

ANALISI FORZE E PROBLEMI DI OGNI MODELLO FRONTIER

┌─────────────────┬──────────────────────────────────┬─────────────────────────────────┐
│ MODELLO         │ FORZE UNICHE                     │ PROBLEMI RISOLTI DA HYPERION    │
├─────────────────┼──────────────────────────────────┼─────────────────────────────────┤
│ Fable 5         │ Ragionamento profondo             │ Over-cautious su task creativi  │
│ (Anthropic)     │ Constitutional AI                │ Lento su task semplici          │
│                 │ Uncertainty calibration           │ Costo alto per volume           │
├─────────────────┼──────────────────────────────────┼─────────────────────────────────┤
│ Gemini 5.2      │ 2M token context window          │ Verboso, perde il punto         │
│ (Google)        │ Multimodal nativo                │ Hallucina su nicchie            │
│                 │ Breadth-first search              │ Meno coerente su ragionamento   │
├─────────────────┼──────────────────────────────────┼─────────────────────────────────┤
│ Kimi K2.6       │ Agentic persistence              │ Inconsistente su domini Western │
│ (Moonshot)      │ Tool use avanzato                │ Context drift su task lunghi    │
│                 │ Long-context multilingual         │ Meno raffinato sul tono         │
├─────────────────┼──────────────────────────────────┼─────────────────────────────────┤
│ DeepSeek V4 Pro │ Math/reasoning rigoroso          │ Troppo letterale, meno creativo │
│                 │ MoE efficiency                   │ Verboso nei passaggi intermedi  │
│                 │ Step verification nativa          │ Tono piatto, poco persuasivo    │
├─────────────────┼──────────────────────────────────┼─────────────────────────────────┤
│ ChatGPT 5.5     │ Instruction following preciso    │ Sycophantic (troppo d'accordo)  │
│ (OpenAI)        │ Tono conversazionale             │ Hallucina con sicurezza         │
│                 │ Broad knowledge coverage         │ Risposte generiche su nicchie   │
├─────────────────┼──────────────────────────────────┼─────────────────────────────────┤
│ Mythic 5        │ Meta-reasoning                   │ Meno accessibile                │
│                 │ Ragionamento su ragionamento     │ Context window limitato         │
│                 │ Planning orizzonte lungo          │ Latenza alta                    │
└─────────────────┴──────────────────────────────────┴─────────────────────────────────┘

HYPERION estrae il meglio di ognuno ed elimina i problemi.
Funziona su QUALSIASI modello — anche Haiku a effort minimo.

---

ARCHITETTURA HYPERION — 9 ENGINE INTEGRATI

INPUT
  │
  ▼
┌─────────────────────────────────────────────────────────────────────┐
│  ENGINE 1: COGNITIVE MODE DETECTOR                                  │
│  Identifica quale "mente" serve per questo task (20 token, Haiku)  │
└────────────────────────────┬────────────────────────────────────────┘
                             │ cognitive_mode
        ┌────────────────────┼────────────────────┐
        ▼                    ▼                    ▼
  [FABLE MODE]         [GEMINI MODE]        [DEEPSEEK MODE]
  Constitutional        Breadth-first        MoE Routing +
  + Uncertainty         + Context            Math Rigor
  Calibration           Compression
        │                    │                    │
        └────────────────────┼────────────────────┘
                             ▼
┌─────────────────────────────────────────────────────────────────────┐
│  ENGINE 2: EFFORT GRADIENT OPTIMIZER                                │
│  Trova il minimo effort che raggiunge la qualità target            │
└────────────────────────────┬────────────────────────────────────────┘
                             ▼
┌─────────────────────────────────────────────────────────────────────┐
│  ENGINE 3: MOE PROMPT ROUTER (DeepSeek-inspired)                   │
│  Divide il task in sotto-problemi → specialisti paralleli          │
└────────────────────────────┬────────────────────────────────────────┘
                             ▼
┌─────────────────────────────────────────────────────────────────────┐
│  ENGINE 4: EXTENDED REASONING SCAFFOLD (o1/Mythic-inspired)        │
│  Pensiero esplicito multi-step prima dell'output                   │
└────────────────────────────┬────────────────────────────────────────┘
                             ▼
┌─────────────────────────────────────────────────────────────────────┐
│  ENGINE 5: CONSTITUTIONAL CHAIN (Fable-inspired)                   │
│  Verifica l'output contro principi prima di consegnarlo            │
└────────────────────────────┬────────────────────────────────────────┘
                             ▼
┌─────────────────────────────────────────────────────────────────────┐
│  ENGINE 6: CALIBRATED UNCERTAINTY (Fable + Kimi-inspired)         │
│  Quantifica la certezza di ogni affermazione                       │
└────────────────────────────┬────────────────────────────────────────┘
                             ▼
┌─────────────────────────────────────────────────────────────────────┐
│  ENGINE 7: ANTI-SYCOPHANCY FILTER (ChatGPT problem solver)         │
│  Forza disaccordo costruttivo, rimuove compiacenza                 │
└────────────────────────────┬────────────────────────────────────────┘
                             ▼
┌─────────────────────────────────────────────────────────────────────┐
│  ENGINE 8: AGENTIC PERSISTENCE (Kimi-inspired)                     │
│  Mantiene stato e coerenza su task multi-step lunghi               │
└────────────────────────────┬────────────────────────────────────────┘
                             ▼
┌─────────────────────────────────────────────────────────────────────┐
│  ENGINE 9: META-REASONING LAYER (Mythic-inspired)                  │
│  Ragiona sul proprio ragionamento, identifica bias cognitivi       │
└────────────────────────────┬────────────────────────────────────────┘
                             ▼
                    OUTPUT HYPERION
           (qualità Fable 5 su Haiku, effort minimo)

---

ENGINE 1: COGNITIVE MODE DETECTOR

from enum import Enum
from dataclasses import dataclass

class CognitiveMode(Enum):
    """Ogni modalità replica la strategia cognitiva del modello ispirazionale."""
    
    FABLE     = "fable"      # Deep reasoning + constitutional checks
    GEMINI    = "gemini"     # Breadth-first + context synthesis
    DEEPSEEK  = "deepseek"   # MoE specialization + math rigor
    KIMI      = "kimi"       # Agentic multi-step + persistence
    CHATGPT   = "chatgpt"    # Instruction precision + conversational
    MYTHIC    = "mythic"     # Meta-reasoning + planning horizon
    HYPERION  = "hyperion"   # Synthesis di tutti (per task massimali)

@dataclass
class CognitiveDiagnosis:
    mode: CognitiveMode
    confidence: float
    effort_required: int    # 1-5 (1=minimo, 5=massimo)
    sub_modes: list[CognitiveMode]  # modalità secondarie da attivare

DETECTOR_PROMPT = """Analizza il task e rispondi SOLO JSON:
{
  "mode": "fable|gemini|deepseek|kimi|chatgpt|mythic|hyperion",
  "confidence": 0.0-1.0,
  "effort": 1-5,
  "sub_modes": ["mode1", "mode2"],
  "reasoning": "perché questa modalità"
}

GUIDA:
- fable: task che richiedono ragionamento etico, incertezza, riflessione profonda
- gemini: task con molto contesto, multi-fonte, breadth over depth
- deepseek: math, codice, logica formale, step-by-step verification
- kimi: task multi-step lunghi, agentici, con memoria persistente
- chatgpt: istruzioni precise, tono conversazionale, task aperti
- mythic: planning lungo orizzonte, meta-cognizione, complessità estrema
- hyperion: task che richiedono il massimo assoluto di tutte le modalità

TASK: {task}"""

def detect_cognitive_mode(task: str, client) -> CognitiveDiagnosis:
    """30 token di Haiku per scegliere la mente giusta."""
    response = client.messages.create(
        model="claude-haiku-4-5-20251001",
        max_tokens=120,
        messages=[{"role": "user", "content": DETECTOR_PROMPT.format(task=task[:300])}]
    )
    import json
    data = json.loads(response.content[0].text)
    return CognitiveDiagnosis(
        mode=CognitiveMode(data["mode"]),
        confidence=data["confidence"],
        effort_required=data["effort"],
        sub_modes=[CognitiveMode(m) for m in data.get("sub_modes", [])]
    )

---

ENGINE 2: EFFORT GRADIENT OPTIMIZER

class EffortGradientOptimizer:
    """
    Trova il MINIMO effort che raggiunge la qualità target.
    Scala automaticamente verso il basso (risparmio) o l'alto (qualità).
    
    Ispirato all'efficienza MoE di DeepSeek: attiva solo gli esperti necessari.
    """
    
    EFFORT_LEVELS = {
        1: {
            "model": "claude-haiku-4-5-20251001",
            "max_tokens": 200,
            "thinking": False,
            "cot": False,
            "quality_expected": 0.65
        },
        2: {
            "model": "claude-haiku-4-5-20251001",
            "max_tokens": 500,
            "thinking": False,
            "cot": True,
            "quality_expected": 0.75
        },
        3: {
            "model": "claude-sonnet-4-6",
            "max_tokens": 1000,
            "thinking": False,
            "cot": True,
            "quality_expected": 0.85
        },
        4: {
            "model": "claude-sonnet-4-6",
            "max_tokens": 2000,
            "thinking": True,
            "cot": True,
            "quality_expected": 0.92
        },
        5: {
            "model": "claude-opus-4-8",
            "max_tokens": 4000,
            "thinking": True,
            "cot": True,
            "quality_expected": 0.98
        }
    }
    
    def select_effort(self, diagnosis: CognitiveDiagnosis, quality_target: float) -> dict:
        """
        Seleziona il livello di effort minimo che supera quality_target.
        """
        # Mappa effort richiesto → livello
        # Se diagnosi dice effort=2 ma target quality=0.9 → scala a effort=3
        
        required_effort = diagnosis.effort_required
        
        # Trova il livello minimo che soddisfa quality_target
        for level in range(1, 6):
            config = self.EFFORT_LEVELS[level]
            if config["quality_expected"] >= quality_target:
                # Prendi il massimo tra richiesto dalla diagnosi e dal target quality
                final_level = max(level, required_effort)
                return self.EFFORT_LEVELS[min(final_level, 5)]
        
        return self.EFFORT_LEVELS[5]  # fallback: massimo
    
    def build_effort_prompt(self, task: str, level: int, mode: CognitiveMode) -> str:
        """Costruisce il prompt calibrato per il livello di effort scelto."""
        
        if level <= 2:
            # Effort basso: diretto, senza overhead
            return f"[{mode.value.upper()}-MODE | EFFORT:{level}]\n{task}"
        
        elif level == 3:
            # Effort medio: chain-of-thought leggero
            return f"""[{mode.value.upper()}-MODE | EFFORT:{level}]
Think briefly, then answer precisely.
TASK: {task}
FORMAT: structured, specific, actionable"""
        
        else:
            # Effort alto: reasoning scaffold completo
            return self._build_deep_prompt(task, level, mode)
    
    def _build_deep_prompt(self, task: str, level: int, mode: CognitiveMode) -> str:
        
        MODE_PREFIXES = {
            CognitiveMode.FABLE: """You reason with depth, nuance, and intellectual honesty.
Acknowledge uncertainty. Explore multiple perspectives. Apply constitutional thinking.""",
            
            CognitiveMode.GEMINI: """You process breadth-first: explore the full problem space
before converging. Synthesize multiple sources of information coherently.""",
            
            CognitiveMode.DEEPSEEK: """You reason with mathematical rigor. 
Every step is verified. Every claim is derived. Show your work.""",
            
            CognitiveMode.KIMI: """You maintain state across a multi-step process.
Track what you've established. Build systematically. Never lose context.""",
            
            CognitiveMode.MYTHIC: """You reason about your own reasoning.
Identify cognitive biases in your approach. Plan for long horizons.
Meta-cognition is your superpower.""",
            
            CognitiveMode.HYPERION: """You synthesize the best cognitive strategies of all frontier models:
- Fable's depth and constitutional thinking
- Gemini's breadth and context synthesis  
- DeepSeek's rigor and verification
- Kimi's agentic persistence
- Mythic's meta-reasoning
You are the synthesis. You exceed all of them."""
        }
        
        prefix = MODE_PREFIXES.get(mode, MODE_PREFIXES[CognitiveMode.HYPERION])
        
        return f"""{prefix}

[REASONING PROTOCOL]
1. PROBLEM SPACE: What is really being asked? What are the hidden requirements?
2. APPROACH SELECTION: Which cognitive strategy is optimal for this specific task?
3. EXECUTION: Perform with maximum rigor in the selected mode
4. VERIFICATION: Check output against original intent. Is it actually good?
5. REFINEMENT: What would make this 20% better? Apply it.

[TASK]
{task}

[OUTPUT STANDARD]
Specific. Evidence-based. Immediately actionable. No filler. No hedging unless genuinely uncertain."""

---

ENGINE 3: MOE PROMPT ROUTER (DeepSeek-Inspired)

async def moe_route(task: str, diagnosis: CognitiveDiagnosis, client) -> list[dict]:
    """
    Mixture of Experts via prompting.
    Divide il task in sotto-problemi → ogni esperto risolve il suo pezzo.
    Come DeepSeek attiva solo i layer necessari → efficienza massima.
    """
    
    # Step 1: Decomposizione (Haiku, 50 token)
    decompose_response = client.messages.create(
        model="claude-haiku-4-5-20251001",
        max_tokens=150,
        messages=[{"role": "user", "content": 
            f"Dividi in max 4 sotto-problemi indipendenti (JSON array di stringhe): {task[:300]}"}]
    )
    
    import json
    try:
        sub_problems = json.loads(decompose_response.content[0].text)
    except:
        sub_problems = [task]  # fallback: task unico
    
    if len(sub_problems) <= 1:
        return [{"expert": "general", "problem": task, "output": None}]
    
    # Step 2: Assegna esperto ottimale a ogni sotto-problema
    EXPERT_MAP = {
        "analisi": CognitiveMode.GEMINI,
        "calcolo": CognitiveMode.DEEPSEEK,
        "strategia": CognitiveMode.FABLE,
        "implementazione": CognitiveMode.KIMI,
        "comunicazione": CognitiveMode.CHATGPT,
        "pianificazione": CognitiveMode.MYTHIC,
    }
    
    experts = []
    for problem in sub_problems:
        # Assegna modalità cognitiva al sotto-problema
        problem_lower = problem.lower()
        mode = next(
            (mode for keyword, mode in EXPERT_MAP.items() if keyword in problem_lower),
            diagnosis.mode  # default: modalità principale
        )
        experts.append({"expert": mode.value, "problem": problem, "output": None})
    
    # Step 3: Esegui esperti in parallelo
    async def solve_sub(expert_config: dict) -> dict:
        optimizer = EffortGradientOptimizer()
        mode = CognitiveMode(expert_config["expert"])
        prompt = optimizer.build_effort_prompt(expert_config["problem"], 3, mode)
        
        response = await client.messages.create(
            model="claude-haiku-4-5-20251001",
            max_tokens=300,
            messages=[{"role": "user", "content": prompt}]
        )
        return {**expert_config, "output": response.content[0].text}
    
    import asyncio
    from anthropic import AsyncAnthropic
    async_client = AsyncAnthropic()
    results = await asyncio.gather(*[solve_sub(e) for e in experts])
    
    return list(results)

---

ENGINE 4: EXTENDED REASONING SCAFFOLD (Mythic/o1-Inspired)

EXTENDED_REASONING_TEMPLATE = """
╔══════════════════════════════════════════════════════════════╗
║                    HYPERION THINKING SPACE                   ║
║              (ragionamento interno prima dell'output)        ║
╚══════════════════════════════════════════════════════════════╝

FASE 1 — COMPRENSIONE PROFONDA
• Cosa viene DAVVERO chiesto (non cosa sembra in superficie)?
• Quali sono i requisiti impliciti?
• Quali assunzioni sto facendo che potrebbero essere sbagliate?

FASE 2 — MAPPATURA DELLO SPAZIO DEL PROBLEMA
• Dimensioni del problema: [elenca]
• Vincoli: [elenca]
• Opportunità non ovvie: [elenca]

FASE 3 — GENERAZIONE APPROCCI (non solo uno)
• Approccio A: [descrivi]
• Approccio B: [descrivi]
• Approccio C: [descrivi]
• Approccio ottimale: [quale e perché]

FASE 4 — ESECUZIONE CON VERIFICA STEP-BY-STEP
[esegui il ragionamento, verifica ogni passo]

FASE 5 — AUTO-CRITICA (Fable-inspired)
• Dove potrei sbagliarmi?
• Cosa manca?
• Come potrebbe attaccare questa risposta un critico esperto?

FASE 6 — SINTESI FINALE
[output pulito, senza il processo di ragionamento]

══════════════════════════════════════════════════════════════

TASK: {task}

Esegui TUTTE le 6 fasi, poi fornisci SOLO la SINTESI FINALE come output visibile.
Il processo di ragionamento è interno.
"""

def apply_extended_reasoning(task: str, effort_level: int) -> str:
    """Attiva il reasoning scaffold solo quando il task lo richiede."""
    if effort_level >= 4:
        return EXTENDED_REASONING_TEMPLATE.format(task=task)
    elif effort_level == 3:
        return f"Think through this carefully before answering:\n{task}"
    else:
        return task

---

ENGINE 5: CONSTITUTIONAL CHAIN (Fable-Inspired)

CONSTITUTION = {
    "accuracy": "Ogni affermazione deve essere verificabile o chiaramente opinione",
    "completeness": "Non omettere informazioni critiche anche se scomode",
    "actionability": "Ogni punto deve essere immediatamente implementabile",
    "specificity": "Nessuna generalizzazione senza esempio concreto",
    "honesty": "Dire 'non so' quando non si sa. Non hallucinate.",
    "nuance": "Evitare assoluti (sempre/mai/tutti/nessuno) senza evidenza",
    "anti_sycophancy": "Non concordare per compiacere. Dissentire se necessario.",
    "depth_over_breadth": "Meglio 3 punti profondi che 10 superficiali"
}

async def constitutional_chain(output: str, client) -> dict:
    """
    Verifica l'output contro la costituzione HYPERION.
    Come Fable/Claude constitutional AI — ma via prompt engineering.
    """
    
    constitution_check = "\n".join([f"• {k}: {v}" for k, v in CONSTITUTION.items()])
    
    check_prompt = f"""Verifica questo output contro i principi. Rispondi JSON:
{{
  "violations": [{{"principle": "nome", "issue": "cosa viola", "severity": "alto|medio|basso"}}],
  "score": 0.0-1.0,
  "passed": true/false
}}

PRINCIPI:
{constitution_check}

OUTPUT DA VERIFICARE:
{output[:600]}"""
    
    from anthropic import AsyncAnthropic
    async_client = AsyncAnthropic()
    
    response = await async_client.messages.create(
        model="claude-haiku-4-5-20251001",
        max_tokens=200,
        messages=[{"role": "user", "content": check_prompt}]
    )
    
    import json
    try:
        result = json.loads(response.content[0].text)
    except:
        result = {"violations": [], "score": 0.8, "passed": True}
    
    if not result.get("passed") and result.get("violations"):
        # Auto-fix le violazioni alte
        high_violations = [v for v in result["violations"] if v.get("severity") == "alto"]
        
        if high_violations:
            fix_instructions = "\n".join([f"- Fix: {v['issue']}" for v in high_violations])
            fix_response = await async_client.messages.create(
                model="claude-sonnet-4-6",
                max_tokens=len(output.split()) * 2,
                messages=[{"role": "user", "content":
                    f"Migliora questo output risolvendo questi problemi:\n{fix_instructions}\n\nOUTPUT:\n{output}"}]
            )
            result["fixed_output"] = fix_response.content[0].text
    
    result["original_output"] = output
    return result

---

ENGINE 6: CALIBRATED UNCERTAINTY (Fable + DeepSeek)

UNCERTAINTY_PROMPT = """Riscrivi l'output aggiungendo calibrazione dell'incertezza:

REGOLE:
- Fatti certi (>95% confidenza): affermazione diretta
- Probabili (70-95%): "è probabile che", "tipicamente"
- Incerti (40-70%): "potrebbe essere", "in alcuni casi"
- Speculativi (<40%): "è possibile che", "si ipotizza"
- Sconosciuto: "non ho dati sufficienti per affermare"

ANTI-HALLUCINATION: Se non sei sicuro di un numero/dato specifico,
sostituisci con "dati non disponibili" o rimuovi.

OUTPUT DA CALIBRARE:
{output}"""

async def calibrate_uncertainty(output: str, client) -> str:
    """
    Aggiunge calibrazione dell'incertezza come Fable 5 / modelli con honesty training.
    Rimuove over-confidence e hallucinations latenti.
    """
    from anthropic import AsyncAnthropic
    async = AsyncAnthropic()
    
    response = await async_client.messages.create(
        model="claude-haiku-4-5-20251011",
        max_tokens=len(output.split()) * 2,
        messages=[{"role": "user", "content": UNCERTAINTY_PROMPT.format(output=output)}]
    )
    return response.content[0].text

---

ENGINE 7: ANTI-SYCOPHANCY FILTER (Risolve il problema ChatGPT)

ANTI_SYCOPHANCY_SYSTEM = """Sei un critico onesto e diretto.
Il tuo compito è DISSENTIRE quando necessario, non compiacere.

Se vedi qualcosa di sbagliato, DILLO chiaramente.
Se la soluzione proposta non è ottimale, PROPONI quella migliore.
Se mancano informazioni critiche, SEGNALALO.

NON fare:
- Iniziare con "Ottima domanda!", "Certamente!", "Assolutamente!"
- Concordare con premesse sbagliate
- Edulcorare critiche per non offendere
- Aggiungere "ma capisco il tuo punto" dopo ogni critica

FAI:
- Essere diretto e specifico
- Citare PERCHÉ qualcosa non funziona
- Proporre alternative concrete
- Calibrare il tono alla gravità del problema"""

def inject_anti_sycophancy(prompt: str) -> str:
    """Inietta il filtro anti-sycophancy nel prompt."""
    return ANTI_SYCOPHANCY_SYSTEM + "\n\n" + prompt

---

ENGINE 8: AGENTIC PERSISTENCE (Kimi K2.6-Inspired)

import json
from pathlib import Path
from datetime import datetime

class AgenticStateManager:
    """
    Mantiene lo stato attraverso task multi-step lunghi.
    Come Kimi K2.6 che mantiene il contesto attraverso sessioni agentiche.
    
    Risolve: context drift, perdita di obiettivi intermedi, incoerenza.
    """
    
    STATE_PATH = Path("~/.hyperion_state.json").expanduser()
    
    def __init__(self, task_id: str):
        self.task_id = task_id
        self.state = self._load_or_create()
    
    def _load_or_create(self) -> dict:
        if self.STATE_PATH.exists():
            all_states = json.loads(self.STATE_PATH.read_text())
            return all_states.get(self.task_id, self._empty_state())
        return self._empty_state()
    
    def _empty_state(self) -> dict:
        return {
            "task_id": self.task_id,
            "created": datetime.now().isoformat(),
            "original_goal": "",
            "completed_steps": [],
            "current_step": 0,
            "established_facts": [],
            "pending_decisions": [],
            "artifacts": {},
            "quality_checkpoints": []
        }
    
    def set_goal(self, goal: str):
        self.state["original_goal"] = goal
        self._save()
    
    def complete_step(self, step: str, output: str, quality: float):
        self.state["completed_steps"].append({
            "step": step,
            "output_summary": output[:200],
            "quality": quality,
            "timestamp": datetime.now().isoformat()
        })
        self.state["current_step"] += 1
        self._save()
    
    def add_fact(self, fact: str, confidence: float = 1.0):
        self.state["established_facts"].append({
            "fact": fact, "confidence": confidence
        })
        self._save()
    
    def get_context_summary(self) -> str:
        """Genera un riassunto compresso dello stato per iniettarlo nel prossimo prompt."""
        
        if not self.state["completed_steps"]:
            return f"[NEW TASK] Goal: {self.state['original_goal']}"
        
        facts = "\n".join([f"✓ {f['fact']}" for f in self.state["established_facts"][-5:]])
        last_steps = self.state["completed_steps"][-3:]
        steps = "\n".join([f"Step {i+1}: {s['step']} → {s['output_summary'][:100]}"
                          for i, s in enumerate(last_steps)])
        
        return f"""[AGENTIC STATE | Step {self.state['current_step']}]
ORIGINAL GOAL: {self.state['original_goal']}
ESTABLISHED FACTS:
{facts}
RECENT PROGRESS:
{steps}
CONTINUE FROM HERE:"""
    
    def _save(self):
        self.STATE_PATH.parent.mkdir(exist_ok=True)
        all_states = {}
        if self.STATE_PATH.exists():
            all_states = json.loads(self.STATE_PATH.read_text())
        all_states[self.task_id] = self.state
        self.STATE_PATH.write_text(json.dumps(all_states, indent=2))

---

ENGINE 9: META-REASONING LAYER (Mythic-Inspired)

META_REASONING_PROMPT = """Prima di rispondere, esegui questo protocollo di meta-cognizione:

[META-REASONING PROTOCOL]

1. BIAS DETECTOR
   Quali bias cognitivi potrebbero influenzare la mia risposta?
   - Confirmation bias (sto cercando conferme invece di falsificazioni?)
   - Availability heuristic (sto sopravvalutando info recenti o accessibili?)
   - Dunning-Kruger (sto parlando con confidenza di cose che non conosco bene?)
   - Anchoring (il primo numero/idea condiziona il resto?)

2. ASSUMPTION AUDIT
   Quali assunzioni sto facendo che non ho verificato?
   Lista le top 3. Poi verifica ognuna.

3. ALTERNATIVE HYPOTHESIS
   Se la mia risposta iniziale è sbagliata, qual è la risposta alternativa più plausibile?

4. QUALITY PREDICTION
   Su una scala 1-10, quanto sono sicuro di questa risposta? Perché?
   Se < 7: cosa manca per essere più sicuro?

5. SCOPE CALIBRATION
   Sto rispondendo alla domanda giusta o a una variante più facile?

Solo dopo aver completato questi 5 step: fornisci la risposta finale.

TASK: {task}"""

def apply_meta_reasoning(task: str, effort_level: int) -> str:
    """Attiva meta-reasoning solo per effort >= 4 (task critici)."""
    if effort_level >= 4:
        return META_REASONING_PROMPT.format(task=task)
    return task

---

HYPERION COMPLETO — ENTRYPOINT UNIFICATO

import asyncio, anthropic

async def hyperion_execute(
    task: str,
    context: str = "",
    quality_target: float = 0.85,
    task_id: str = None
) -> dict:
    """
    HYPERION — Meta-intelligence synthesis.
    Porta qualsiasi modello al livello cognitivo di Fable 5.
    """
    
    client = anthropic.Anthropic()
    
    print("\n⚡ HYPERION META-INTELLIGENCE ACTIVATED")
    print("="*55)
    
    # ENGINE 1: Rileva modalità cognitiva (30 token, Haiku)
    print("[1/7] Cognitive mode detection...")
    diagnosis = detect_cognitive_mode(task, client)
    print(f"      Mode: {diagnosis.mode.value.upper()} | "
          f"Effort: {diagnosis.effort_required}/5 | "
          f"Confidence: {diagnosis.confidence:.0%}")
    
    # ENGINE 2: Effort gradient optimization
    print("[2/7] Effort gradient optimization...")
    optimizer = EffortGradientOptimizer()
    effort_config = optimizer.select_effort(diagnosis, quality_target)
    print(f"      Model: {effort_config['model']} | "
          f"Max tokens: {effort_config['max_tokens']}")
    
    # ENGINE 8: Agentic state (se task complesso)
    state_manager = None
    state_context = ""
    if diagnosis.effort_required >= 3 and task_id:
        state_manager = AgenticStateManager(task_id)
        state_manager.set_goal(task)
        state_context = state_manager.get_context_summary()
    
    # ENGINE 3: MoE decomposition (se task parallelizzabile)
    moe_results = []
    if diagnosis.effort_required >= 3:
        print("[3/7] MoE routing & parallel execution...")
        from anthropic import AsyncAnthropic
        async_client = AsyncAnthropic()
        moe_results = await moe_route(task, diagnosis, async_client)
        moe_context = "\n".join([
            f"[Expert:{r['expert']}]: {r['output']}"
            for r in moe_results if r.get('output')
        ])
    else:
        moe_context = ""
        print("[3/7] MoE routing: skipped (low effort task)")
    
    # ENGINE 4+9: Extended reasoning + Meta-reasoning
    effort_level = diagnosis.effort_required
    full_task = task
    
    if effort_level >= 4:
        print("[4/7] Extended reasoning scaffold + meta-reasoning...")
        full_task = apply_meta_reasoning(
            apply_extended_reasoning(task, effort_level),
            effort_level
        )
    else:
        print("[4/7] Standard reasoning mode")
    
    # Componi il prompt finale
    final_prompt = optimizer.build_effort_prompt(
        f"{state_context}\n\n{moe_context}\n\n{full_task}".strip(),
        effort_level,
        diagnosis.mode
    )
    
    # ENGINE 7: Anti-sycophancy
    if effort_level >= 3:
        final_prompt = inject_anti_sycophancy(final_prompt)
    
    # Esecuzione principale
    print(f"[5/7] Main execution ({effort_config['model']})...")
    response = client.messages.create(
        model=effort_config['model'],
        max_tokens=effort_config['max_tokens'],
        messages=[{"role": "user", "content": final_prompt}]
    )
    raw_output = response.content[0].text
    
    # ENGINE 5: Constitutional chain
    print("[6/7] Constitutional validation...")
    from anthropic import AsyncAnthropic
    async_client = AsyncAnthropic()
    constitutional_result = await constitutional_chain(raw_output, async_client)
    final_output = constitutional_result.get("fixed_output", raw_output)
    
    # ENGINE 6: Calibrated uncertainty (solo per effort alto)
    if effort_level >= 4:
        print("[7/7] Uncertainty calibration...")
        final_output = await calibrate_uncertainty(final_output, async_client)
    else:
        print("[7/7] Uncertainty calibration: skipped (effort < 4)")
    
    # Aggiorna stato agentico
    from prometheus_agi.SKILL import composite_quality_score
    quality = composite_quality_score(final_output)
    if state_manager:
        state_manager.complete_step(task[:50], final_output, quality)
    
    tokens_used = response.usage.input_tokens + response.usage.output_tokens
    
    print(f"\n{'='*55}")
    print(f"✅ HYPERION COMPLETE")
    print(f"   Cognitive Mode: {diagnosis.mode.value.upper()}")
    print(f"   Effort Level: {effort_level}/5 | Quality: {quality:.3f}")
    print(f"   Tokens: {tokens_used} | Constitutional: {'✓' if constitutional_result.get('passed') else '⚠ fixed'}")
    print(f"{'='*55}\n")
    
    return {
        "output": final_output,
        "cognitive_mode": diagnosis.mode.value,
        "effort_level": effort_level,
        "quality": quality,
        "tokens_used": tokens_used,
        "constitutional_score": constitutional_result.get("score", 1.0),
        "moe_experts_used": len(moe_results),
        "model_used": effort_config["model"]
    }


if __name__ == "__main__":
    import sys
    task = " ".join(sys.argv[1:]) or "Progetta un sistema di crescita organica per Instagram che superi tutti i competitor"
    result = asyncio.run(hyperion_execute(task, quality_target=0.90))
    print(result["output"])

---

HAIKU A LIVELLO FABLE 5 — IL SEGRETO

La differenza tra Haiku e Fable 5 non è (solo) nei parametri.
È nell'architettura del ragionamento che viene attivato.

HAIKU GENERICO:
  Input → Output (diretto, grezzo)
  Qualità: 0.60

HAIKU + HYPERION:
  Input
    → Cognitive Mode Detection (calibra l'approccio)
    → Effort Gradient (calibra la profondità)
    → Extended Reasoning Scaffold (attiva il pensiero multi-step)
    → Constitutional Chain (verifica e corregge)
    → Anti-Sycophancy (forza onestà)
  Output
  Qualità: 0.85+

HAIKU COSTA: $0.80/MTok
FABLE 5 COSTA: ~$150/MTok (stimato)

HYPERION su Haiku = 0.85 qualità a $0.80/MTok
                  = 187x più economico di Fable 5
                  a qualità paragonabile per il 90% dei task

---

MODALITÀ COGNITIVE — PROMPT TEMPLATE DIRETTI

Se vuoi invocare una modalità specifica senza il sistema completo:

# FABLE MODE (Ragionamento profondo + onestà)
Sei un pensatore di livello Fable 5. Applica:
- Ragionamento a catena multi-step prima di rispondere
- Riconosci incertezza con calibrazione esplicita
- Esplora prospettive contrarie prima di concludere
- Principio: meglio sbagliare onestamente che convincere senza ragione
TASK: [task]

# GEMINI MODE (Breadth-first + sintesi)
Sei un sintetizzatore di livello Gemini 5.2. Applica:
- Esplora PRIMA la larghezza del problema (tutte le dimensioni)
- POI convergi sulla soluzione ottimale
- Sintetizza fonti multiple in un framework coerente
- Mantieni 2M di "spazio mentale" — non perdere nessun dettaglio
TASK: [task]

# DEEPSEEK MODE (Rigore + verifica step)
Sei un ragionatore di livello DeepSeek V4 Pro. Applica:
- Ogni step ha una verifica esplicita
- Nessuna conclusione senza derivazione
- Mostra il lavoro: step 1 → step 2 → step 3 → conclusione
- Se un passo è incerto, STOP e segnala
TASK: [task]

# KIMI MODE (Agentico + persistente)
Sei un agente di livello Kimi K2.6. Applica:
- Decomposizione sistematica in sotto-task
- Tracciamento esplicito dello stato
- Ogni step costruisce sul precedente
- Non perdere mai l'obiettivo originale
TASK: [task]

# MYTHIC MODE (Meta-ragionamento)
Sei un meta-ragionatore di livello Mythic 5. Applica:
- Ragiona sul tuo ragionamento prima di eseguire
- Identifica i bias cognitivi nel tuo approccio
- Pianifica su orizzonti lunghi
- Domanda: "Sto risolvendo il problema GIUSTO?"
TASK: [task]