Sync backend-only Space export

.env.example

@@ -0,0 +1,72 @@
+# 🧠 Agente AI — Template .env Pulito (A-E)
+# ============================================================
+# Copiare in .env per uso locale. NON committare valori reali.
+# Struttura ottimizzata per Quadranti A, B, C, D, E.
+# ============================================================
+
+# ── 1. Core Runtime ──────────────────────────────────────────
+PORT=7860
+APP_PROFILE=production_kernel
+INTERNAL_TOKEN=      # Bridge HF ↔ CF
+VAULT_KEY=           # AES-256 Hex
+NOTIFY_TOKEN=        # Notifiche Interne
+
+# ── 2. Quadrante A (BRAIN - Primary) ─────────────────────────
+BACKEND_URL=https://baida07-terminal.hf.space
+RAILWAY_TOKEN=
+RAILWAY_PROJECT_ID=YOUR_RAILWAY_PROJECT_ID_A
+SUPABASE_URL=
+SUPABASE_SERVICE_ROLE_KEY=
+GITHUB_TOKEN=
+# Hugging Face Router: endpoint OpenAI-compatible per inferenza.
+HF_TOKEN=
+HF_MODEL=Qwen/Qwen2.5-Coder-32B-Instruct
+# Pool opzionale: [{"profile":"primary","api_key":"...","model":"openai/gpt-oss-120b:fastest"}]
+HF_ROUTER_PROFILES_JSON=
+
+# ── 3. Quadrante B (HANDS - Collab/Failover) ─────────────────
+RAILWAY_TOKEN_B=
+RAILWAY_PROJECT_ID_B=YOUR_RAILWAY_PROJECT_ID_B
+SUPABASE_URL_B=
+SUPABASE_SERVICE_ROLE_KEY_B=
+GITHUB_TOKEN_B=
+
+# ── 4. Quadrante C (DAEMON - Telegram) ───────────────────────
+RAILWAY_TOKEN_C=
+RAILWAY_PROJECT_ID_C=YOUR_RAILWAY_PROJECT_ID_C
+SUPABASE_URL_C=
+SUPABASE_SERVICE_ROLE_KEY_C=
+
+# ── 5. Quadrante D (AUDIT - Compliance) ──────────────────────
+RAILWAY_TOKEN_D=
+RAILWAY_PROJECT_ID_D=YOUR_RAILWAY_PROJECT_ID_D
+SUPABASE_URL_D=
+SUPABASE_SERVICE_ROLE_KEY_D=
+
+# ── 6. Quadrante E (BOT-TG - Dedicated) ──────────────────────
+RAILWAY_TOKEN_E=
+RAILWAY_PROJECT_ID_E=YOUR_RAILWAY_PROJECT_ID_E
+
+# ── 7. LLM Unified Providers (A-E) ───────────────────────────
+# Configurare nei Secrets del provider hosting (HF/Railway)
+GROQ_API_KEY=
+OPENROUTER_API_KEY=
+# Pool opzionale: JSON senza loggare le chiavi. Ogni profilo deve avere profile e api_key.
+# Esempio: OPENROUTER_PROFILES_JSON=[{"profile":"primary","api_key":"..."},{"profile":"backup","api_key":"..."}]
+OPENROUTER_PROFILES_JSON=
+GEMINI_API_KEY=
+NVIDIA_API_KEY=
+
+# ── 8. Sandboxes & Tools ─────────────────────────────────────
+E2B_API_KEY=
+NOTION_TOKEN=
+TELEGRAM_BOT_TOKEN=
+TELEGRAM_CHAT_ID=
+UPSTASH_REDIS_REST_URL=
+UPSTASH_REDIS_REST_TOKEN=
+
+# ── 9. Feature Flags ─────────────────────────────────────────
+VITE_ENABLE_BROWSER_SANDBOX=false
+UNIFIED_LOOP_MAX_STEPS=8
+LLM_MODEL=openai/gpt-oss-20b:free
+

.gitignore

@@ -0,0 +1,8 @@
+.venv/
+  __pycache__/
+  *.pyc
+  *.pyo
+  chroma_db/
+  *.egg-info/
+  .env
+  

Dockerfile

@@ -0,0 +1,41 @@
+FROM python:3.11-slim
+
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PORT=7860 \
+    FRONTEND_DIST=/home/user/app/static \
+    PLAYWRIGHT_BROWSERS_PATH=/ms-playwright
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential curl git nodejs npm \
+    libnss3 libnspr4 libdbus-1-3 libatk1.0-0 libatk-bridge2.0-0 \
+    libcups2 libdrm2 libxkbcommon0 libxcomposite1 libxdamage1 \
+    libxfixes3 libxrandr2 libgbm1 libasound2 \
+    && rm -rf /var/lib/apt/lists/*
+
+# hf-sync copia backend/* nella root dello Space — nessun prefisso backend/
+COPY requirements.txt /app/requirements.txt
+RUN pip install --no-cache-dir -r /app/requirements.txt \
+    && playwright install chromium \
+    && chmod -R 755 /ms-playwright
+
+# S356: ttyd — terminale web per accesso da iPhone Safari (binario statico, zero dep)
+ARG TTYD_VERSION=1.7.7
+RUN ARCH=$(uname -m) && \
+    TTYD_ARCH=$([ "$ARCH" = "aarch64" ] && echo "aarch64" || echo "x86_64") && \
+    curl -fsSL -o /usr/local/bin/ttyd \
+      "https://github.com/tsl0922/ttyd/releases/download/${TTYD_VERSION}/ttyd.${TTYD_ARCH}" && \
+    chmod +x /usr/local/bin/ttyd
+
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user PATH=/home/user/.local/bin:$PATH
+
+WORKDIR /home/user/app
+COPY --chown=user . /home/user/app/
+
+EXPOSE 7860
+
+CMD ["sh", "-c", "uvicorn main:app --host 0.0.0.0 --port ${PORT:-7860} --workers ${WEB_CONCURRENCY:-2}"]

README.md

@@ -0,0 +1,42 @@
+---
+title: Agente AI Backend
+emoji: 🤖
+colorFrom: indigo
+colorTo: blue
+sdk: docker
+app_port: 7860
+pinned: false
+---
+
+# Agente AI — Backend FastAPI
+
+Backend Python FastAPI per Agente AI. Streaming LLM, memoria, esecuzione codice, terminal PTY.
+
+## Endpoints principali
+
+- `GET  /health`              — stato backend
+- `GET  /api/status`          — versione + config
+- `POST /api/reason/loop`     — agent reasoning loop
+- `POST /api/exec`            — esecuzione codice Python
+- `POST /api/execute-shell`   — shell commands
+- `POST /api/search`          — web search proxy
+- `POST /api/fetch-page`      — page fetch proxy
+- `WS   /ws/terminal`         — PTY WebSocket terminal
+
+## Stack
+
+- Python 3.11 + FastAPI + uvicorn
+- smolagents>=1.14.0 + litellm>=1.40.0
+- supabase (opzionale)
+
+## Variabili ambiente
+
+| Variabile | Descrizione |
+|-----------|-------------|
+| GROQ_API_KEY | Groq API key |
+| GEMINI_API_KEY | Google Gemini key |
+| OPENROUTER_API_KEY | OpenRouter key |
+| HF_TOKEN | HuggingFace token |
+| SUPABASE_URL | Supabase URL (opzionale) |
+| SUPABASE_ANON_KEY | Supabase anon key (opzionale) |
+| ALLOWED_ORIGINS | CORS origins comma-separated |

agents/acceptance_criteria.py

@@ -0,0 +1,122 @@
+"""
+acceptance_criteria.py — Sprint 2: Libreria criteri di accettazione standard
+
+Zero LLM, dict statico, zero latenza.
+Ogni feature ha una lista di criteri verificabili che il GoalVerifier 2.0 usa
+per valutare se il goal è stato raggiunto per REQUISITO.
+
+Integrato con RequirementEngine: ogni requisito riceve criteri automaticamente.
+Integrato con GoalVerifier 2.0: ogni criterio viene verificato separatamente.
+
+Invarianti rispettate:
+  - Additive-only: importato da requirement_engine.py senza modificare esistente
+  - Zero side effects: solo dict statico
+"""
+
+ACCEPTANCE_CRITERIA: dict[str, list[str]] = {
+    "auth": [
+        "Utente corretto può autenticarsi (HTTP 200 o redirect autenticato)",
+        "Credenziali errate restituiscono errore (HTTP 401/400)",
+        "Sessione creata e persistita dopo login",
+        "Logout invalida la sessione",
+        "Route protette richiedono autenticazione",
+    ],
+    "crud": [
+        "Creazione record: entità inserita nel DB con ID univoco",
+        "Lettura lista: endpoint ritorna array con tutti i record",
+        "Lettura singola: endpoint ritorna entità per ID",
+        "Aggiornamento: modifica persistita nel DB",
+        "Cancellazione: record rimosso, non più visibile in lista",
+    ],
+    "dashboard": [
+        "Dati aggregati visibili (contatori, totali, medie)",
+        "Componente UI renderizza senza errori console",
+        "Dati aggiornati al refresh pagina",
+        "Empty state gestito (nessun crash su lista vuota)",
+    ],
+    "api_rest": [
+        "GET /resource → lista entità (200)",
+        "POST /resource → crea entità (201)",
+        "PUT/PATCH /resource/:id → aggiorna entità (200)",
+        "DELETE /resource/:id → rimuove entità (204)",
+        "Input non valido → risposta 400 con messaggio errore",
+    ],
+    "form_validation": [
+        "Campi obbligatori mostrano errore se vuoti",
+        "Formato email validato",
+        "Submit disabilitato finché il form non è valido",
+        "Errori server mostrati inline (non solo console)",
+        "Submit con dati validi → feedback positivo all'utente",
+    ],
+    "file_upload": [
+        "File selezionato caricato senza errori",
+        "Tipo file validato (estensioni accettate)",
+        "Dimensione file validata",
+        "Progresso upload visibile",
+        "File salvato e accessibile dopo upload",
+    ],
+    "search": [
+        "Query restituisce risultati pertinenti",
+        "Query vuota → lista completa o empty state",
+        "Ricerca case-insensitive",
+        "Nessun errore su caratteri speciali",
+    ],
+    "payments": [
+        "Checkout avviato con dati carrello corretti",
+        "Pagamento completato → ordine confermato",
+        "Pagamento fallito → errore leggibile (non crash)",
+        "Ricevuta/conferma mostrata post-pagamento",
+    ],
+    "notifications": [
+        "Notifica inviata in risposta all'evento trigger",
+        "Contenuto notifica corretto (destinatario, testo)",
+        "Fallimento invio gestito senza crash applicazione",
+    ],
+    "settings": [
+        "Impostazioni salvate persistono dopo refresh",
+        "Cambio password richiede verifica vecchia password",
+        "Modifica profilo aggiorna dati visibili",
+    ],
+    "database": [
+        "Schema creato senza errori di migrazione",
+        "Relazioni tra entità corrette (FK integrità)",
+        "Indici su colonne di ricerca/sort presenti",
+        "Seed dati iniziali caricati se previsti",
+    ],
+    "deploy": [
+        "Build completata senza errori (exit 0)",
+        "App raggiungibile sull'URL di produzione",
+        "Variabili d'ambiente necessarie configurate",
+        "Health check endpoint risponde 200",
+    ],
+    "analysis": [
+        "Risposta di almeno 150 parole (analisi non superficiale)",
+        "Almeno 3 punti distinti argomentati nel testo",
+        "Conclusione o sintesi finale presente",
+        "Nessuna affermazione generica senza supporto concreto",
+    ],
+    "comparison": [
+        "Almeno 2 dimensioni di confronto esplicite",
+        "Ogni opzione trattata in modo bilanciato",
+        "Sezione 'Raccomandazione' o conclusione con scelta motivata",
+        "Risposta di almeno 150 parole",
+    ],
+    "explanation": [
+        "Definizione chiara del concetto principale",
+        "Almeno 1 esempio concreto presente",
+        "Linguaggio appropriato al contesto (tecnico o divulgativo)",
+        "Risposta di almeno 100 parole",
+    ],
+    "summarization": [
+        "Punti chiave tutti presenti (nessuna omissione critica)",
+        "Struttura sintetica e leggibile",
+        "Risposta proporzionata alla complessità del materiale originale",
+    ],
+    "recommendation": [
+        "Almeno 3 criteri di valutazione esplicitati",
+        "Raccomandazione finale chiara e motivata",
+        "Pro/contro menzionati per l'opzione consigliata",
+        "Risposta di almeno 150 parole",
+    ],
+
+}

agents/backend_antiregress.py

@@ -0,0 +1,110 @@
+# backend/agents/backend_antiregress.py
+# S-BACKEND-ANTIREGRESS: Python equivalent of antiRewriteGuard.ts
+#
+# Rileva pattern di regressione nell'output LLM prima che il backend lo restituisca:
+#   1. Import injection — nuove dipendenze esterne non presenti nell'originale
+#   2. Code rewrite — output ha drasticamente meno classi/def dell'originale
+#
+# Chiamato dentro il loop _llm_try di unified_loop.py prima del `break`.
+# Non bloccante: qualsiasi eccezione interna viene silenziata dal caller.
+
+from __future__ import annotations
+import re
+from typing import Optional
+
+# ── Moduli stdlib Python (top-level) ──────────────────────────────────────────
+_STDLIB = {
+    'abc', 'ast', 'asyncio', 'base64', 'bisect', 'builtins', 'cgi', 'cmath',
+    'collections', 'concurrent', 'contextlib', 'copy', 'copyreg', 'csv',
+    'dataclasses', 'datetime', 'decimal', 'difflib', 'dis', 'enum', 'errno',
+    'fnmatch', 'fractions', 'functools', 'gc', 'glob', 'gzip', 'hashlib',
+    'heapq', 'hmac', 'html', 'http', 'importlib', 'inspect', 'io', 'itertools',
+    'json', 'keyword', 'linecache', 'locale', 'logging', 'math', 'mimetypes',
+    'numbers', 'operator', 'os', 'pathlib', 'pickle', 'platform', 'pprint',
+    'queue', 'random', 're', 'shutil', 'signal', 'socket', 'sqlite3', 'stat',
+    'string', 'struct', 'subprocess', 'sys', 'tempfile', 'textwrap', 'threading',
+    'time', 'timeit', 'tkinter', 'traceback', 'typing', 'types', 'unittest',
+    'urllib', 'uuid', 'warnings', 'weakref', 'xml', 'xmlrpc', 'zipfile', 'zlib',
+    # typing extras (importabili da typing_extensions ma canonicamente stdlib)
+    'typing_extensions',
+}
+
+# ── Keyword che indicano task di FIX/MODIFICA (non creazione da zero) ─────────
+_FIX_RE = re.compile(
+    r'\b(fix|bug|error|correggi|risolvi|modifica|aggiorna|update|repair|'
+    r'patch|debug|corretto|sistema|aggiusta|modif|correct|riparare|risolvere)\b',
+    re.IGNORECASE,
+)
+
+# ── Estrazione import da codice ────────────────────────────────────────────────
+_IMPORT_RE = re.compile(
+    r'^(?:import\s+([\w.]+)|from\s+([\w.]+)\s+import)',
+    re.MULTILINE,
+)
+
+def _extract_imports(text: str) -> set[str]:
+    """Estrae set di nomi-modulo top-level da testo (goal o codice)."""
+    found: set[str] = set()
+    for m in _IMPORT_RE.finditer(text):
+        mod = m.group(1) or m.group(2)
+        if mod:
+            found.add(mod.split('.')[0].lower())
+    return found
+
+def _extract_code_blocks(text: str) -> str:
+    """Restituisce il contenuto concatenato di tutti i code block."""
+    return '\n'.join(re.findall(r'```[^\n]*\n([\s\S]*?)```', text))
+
+def _count_defs(text: str) -> int:
+    """Conta `class X` e `def x` a qualsiasi indentation."""
+    return len(re.findall(r'^\s*(?:class|def)\s+\w+', text, re.MULTILINE))
+
+# ── API pubblica ───────────────────────────────────────────────────────────────
+def check_regression(goal: str, output: str, context: str = "") -> Optional[str]:
+    """
+    Controlla se `output` presenta regressioni rispetto al `goal` / `context`.
+
+    Restituisce una stringa di hint per il retry (da iniettare nel prompt)
+    se viene rilevato almeno un pattern; None se l'output sembra ok.
+
+    Controllato SOLO se:
+    - L'output contiene almeno un code block (``` ... ```)
+    - Il goal è un task di fix/modifica (non creazione da zero)
+    """
+    if '```' not in output:
+        return None
+    if not _FIX_RE.search(goal):
+        return None
+
+    full_code = _extract_code_blocks(output)
+    if not full_code.strip():
+        return None
+
+    hints: list[str] = []
+
+    # ── 1. Import injection ────────────────────────────────────────────────────
+    out_imports  = _extract_imports(full_code)
+    orig_imports = _extract_imports(goal + '\n' + context)
+    new_pkgs     = out_imports - orig_imports - _STDLIB
+    # Rimuovi falsi positivi comuni nei progetti Python
+    new_pkgs -= {'typing', 'collections', 'dataclasses', 'abc', 'enum',
+                 'pytest', 'unittest', 'mock', 'functools', 'itertools'}
+    if new_pkgs:
+        hints.append(
+            f"NON introdurre nuove dipendenze: {', '.join(sorted(new_pkgs))}. "
+            "Usa esclusivamente le librerie già presenti nel codice originale."
+        )
+
+    # ── 2. Code rewrite (classi/funzioni mancanti) ────────────────────────────
+    # Conta definizioni nell'originale (nel goal/context) e nell'output
+    orig_defs = _count_defs(goal + '\n' + context)
+    out_defs  = _count_defs(full_code)
+    # Segnala solo se l'originale ha 2+ definizioni E l'output ne ha drasticamente meno
+    if orig_defs >= 2 and out_defs < max(1, orig_defs - 1):
+        hints.append(
+            "Il tuo output omette classi/funzioni presenti nell'originale. "
+            "Includi TUTTE le strutture originali, modificando SOLO la parte difettosa. "
+            "Non riscrivere l'intero file da zero."
+        )
+
+    return ' | '.join(hints) if hints else None

agents/context_manager.py

@@ -0,0 +1,450 @@
+"""
+context_manager.py — Intelligent Context Management (S364)
+
+Implementa il "Project Skeleton" approach:
+- Skeleton aggiornato (nomi file + firme funzioni) sempre disponibile
+- Full content solo per file attivamente modificati
+- File "cold" riepilogatati con CONTEXT role (Groq-8b-instant)
+
+Risolve il "lost in the middle" problem su sessioni lunghe.
+
+Design: stateless per request, tutto I/O fire-and-forget, mai blocca il loop
+
+S752-A: aggiunta rank_files_by_relevance() — top-K selezione per rilevanza goal.
+FIX-SKEL-RAG: symbol matching + fuzzy prefix + zero-score filter + path weight 2.0.
+FIX-SYN-EXPAND: synonym expansion IT/EN per copertura semantica senza embeddings.
+"""
+from __future__ import annotations
+import asyncio
+import hashlib
+import re
+from typing import Any
+
+_FUNC_RE   = re.compile(
+    r'^(?:export\s+)?(?:async\s+)?(?:function\s+(\w+)|const\s+(\w+)\s*=\s*(?:async\s*)?\()',
+    re.MULTILINE)
+_CLASS_RE  = re.compile(r'^(?:export\s+)?class\s+(\w+)', re.MULTILINE)
+_PY_DEF_RE = re.compile(r'^(?:    )?(?:async\s+)?def\s+(\w+)\s*\(', re.MULTILINE)
+_PY_CLS_RE = re.compile(r'^class\s+(\w+)', re.MULTILINE)
+
+_SUMMARY_CACHE: dict[str, str] = {}
+_MAX_SUMMARY_CACHE = 200
+
+# ── S752-A: stopword set per rank_files_by_relevance ──────────────────────────
+_RANK_STOP_IT = {
+    'il','lo','la','i','gli','le','di','del','della','dei','delle',
+    'in','un','una','uno','che','con','per','non','da','si','su','al',
+    'ci','e','a','tra','fra','ma','o','se','ne','ad','ho','ha','è',
+}
+_RANK_STOP_EN = {
+    'the','a','an','in','on','at','to','for','of','and','or','is',
+    'are','was','be','this','that','it','with','as','by','from','about',
+    'can','will','have','has','had','do','does','did','not','but','if',
+}
+_RANK_STOP = _RANK_STOP_IT | _RANK_STOP_EN
+
+# Entry-point / config files ottengono un piccolo boost di rilevanza
+_RANK_ENTRY_STEMS = {'main', 'index', 'app', '__init__', 'config', 'settings', 'routes'}
+
+# ── FIX-SKEL-RAG: helper per fuzzy prefix matching ────────────────────────────
+_CAMEL_SPLIT_RE = re.compile(r'([a-z])([A-Z])')
+
+# ── FIX-SYN-EXPAND: tabella sinonimi tecnici IT↔EN (15 cluster) ───────────────
+# Struttura: ogni entry è un frozenset di termini equivalenti.
+# _expand_tokens() aggiunge tutti i sinonimi di ogni token del goal prima del matching.
+# Scelta design: sinonimi statici (zero LLM, zero latency) coprono l'80% dei task reali.
+# I cluster coprono i domini più frequenti nello sviluppo software.
+_SYN_CLUSTERS: list[frozenset[str]] = [
+    # Auth / Sicurezza
+    frozenset({'auth', 'autenticazione', 'authentication', 'login', 'signin',
+               'guard', 'middleware', 'jwt', 'token', 'session', 'oauth',
+               'passport', 'credential', 'permission', 'role', 'accesso'}),
+    # Pagamenti
+    frozenset({'payment', 'pagamento', 'stripe', 'checkout', 'invoice',
+               'billing', 'subscription', 'abbonamento', 'fattura', 'webhook',
+               'price', 'plan', 'tier'}),
+    # Database / ORM
+    frozenset({'database', 'db', 'schema', 'model', 'migration', 'migrazione',
+               'orm', 'repository', 'query', 'drizzle', 'prisma', 'postgres',
+               'sqlite', 'mysql', 'table', 'tabella', 'record'}),
+    # API / Network
+    frozenset({'api', 'endpoint', 'route', 'rotta', 'router', 'server',
+               'request', 'response', 'richiesta', 'risposta', 'http',
+               'rest', 'graphql', 'fetch', 'axios', 'client'}),
+    # UI / Frontend
+    frozenset({'component', 'componente', 'ui', 'interface', 'interfaccia',
+               'button', 'form', 'modal', 'layout', 'page', 'pagina',
+               'style', 'css', 'theme', 'tema', 'render', 'view'}),
+    # State Management
+    frozenset({'state', 'stato', 'store', 'redux', 'zustand', 'context',
+               'provider', 'hook', 'reducer', 'action', 'dispatch',
+               'observable', 'signal', 'reactive'}),
+    # File / Storage
+    frozenset({'file', 'upload', 'caricamento', 'storage', 'bucket',
+               'download', 'attachment', 'allegato', 'blob', 'stream',
+               'filesystem', 'directory', 'path', 'percorso'}),
+    # Testing
+    frozenset({'test', 'testing', 'spec', 'unit', 'integration', 'e2e',
+               'mock', 'stub', 'fixture', 'assert', 'expect', 'coverage',
+               'vitest', 'jest', 'pytest'}),
+    # Build / Deploy
+    frozenset({'build', 'deploy', 'deployment', 'bundle', 'webpack', 'vite',
+               'esbuild', 'compile', 'dist', 'production', 'staging',
+               'pipeline', 'ci', 'cd', 'docker', 'container'}),
+    # Email / Notifiche
+    frozenset({'email', 'mail', 'smtp', 'notification', 'notifica', 'alert',
+               'push', 'telegram', 'slack', 'webhook', 'message', 'messaggio',
+               'sendgrid', 'resend', 'mailer'}),
+    # AI / ML
+    frozenset({'ai', 'llm', 'model', 'prompt', 'embedding', 'rag',
+               'vector', 'semantic', 'chat', 'completion', 'inference',
+               'openai', 'gemini', 'groq', 'anthropic', 'agent', 'agente'}),
+    # Errori / Debug
+    frozenset({'error', 'errore', 'exception', 'eccezione', 'bug', 'fix',
+               'debug', 'log', 'logging', 'trace', 'stack', 'crash',
+               'fallback', 'retry', 'recover', 'handler', 'catch'}),
+    # Configurazione
+    frozenset({'config', 'configurazione', 'configuration', 'settings',
+               'impostazioni', 'env', 'environment', 'variable', 'variabile',
+               'secret', 'segreto', 'dotenv', 'constant', 'costante'}),
+    # Performance / Cache
+    frozenset({'cache', 'performance', 'performanza', 'speed', 'velocità',
+               'optimize', 'ottimizzazione', 'lazy', 'memo', 'debounce',
+               'throttle', 'batch', 'compress', 'compressione'}),
+    # Sicurezza / Validazione
+    frozenset({'validation', 'validazione', 'validate', 'sanitize',
+               'sanitizzazione', 'schema', 'zod', 'yup', 'joi',
+               'csrf', 'xss', 'injection', 'escape', 'secure'}),
+    # Monitoring / Observability (B-GAP-D: cluster mancante — task metriche/dashboard non rankati)
+    frozenset({'metrics', 'metric', 'monitoring', 'monitoraggio', 'observability',
+               'prometheus', 'grafana', 'dashboard', 'telemetry', 'telemetria',
+               'tracing', 'trace', 'health', 'healthcheck', 'uptime', 'alerting',
+               'datadog', 'sentry', 'newrelic', 'audit', 'report'}),
+    # Scheduling / Background Jobs (B-GAP-D: cluster mancante — task cron/queue/worker)
+    frozenset({'cron', 'scheduler', 'pianificatore', 'schedule', 'queue', 'coda',
+               'worker', 'job', 'background', 'celery', 'bull', 'bullmq',
+               'agenda', 'delayed', 'periodic', 'retry', 'backoff', 'redis',
+               'task', 'processo', 'process', 'daemon'}),
+    # WebSocket / Realtime (B-GAP-D: cluster mancante — task ws/sse/pubsub)
+    frozenset({'websocket', 'ws', 'socket', 'socketio', 'realtime', 'real_time',
+               'sse', 'server_sent', 'pubsub', 'publish', 'subscribe', 'broadcast',
+               'channel', 'canale', 'room', 'event', 'listener', 'emitter',
+               'live', 'push', 'poll', 'long_polling', 'signalr', 'liveview'}),
+]
+
+# Indice inverso: token → frozenset di sinonimi (costruito una volta a import)
+_SYN_INDEX: dict[str, frozenset[str]] = {}
+for _cluster in _SYN_CLUSTERS:
+    for _term in _cluster:
+        _SYN_INDEX[_term] = _cluster
+
+
+def _expand_tokens(tokens: list[str]) -> list[str]:
+    """
+    FIX-SYN-EXPAND: espande ogni token del goal con i sinonimi IT/EN del suo cluster.
+
+    Esempio:
+      ["autenticazione", "aggiungi"] → ["autenticazione", "aggiungi",
+        "auth", "login", "guard", "middleware", "jwt", ...]
+
+    Garanzie:
+    - Ordine stabile: token originali prima, sinonimi dopo (preserva priorità)
+    - Nessun duplicato (usa set interno)
+    - Nessun token < 3 chars, nessuna stopword aggiunta
+    - Zero latency (<0.1ms per 20 token), zero LLM calls
+    - Mai rilancia eccezioni
+    """
+    try:
+        seen: set[str] = set(tokens)
+        expanded = list(tokens)
+        for t in tokens:
+            cluster = _SYN_INDEX.get(t)
+            if cluster:
+                for syn in cluster:
+                    if syn not in seen and len(syn) >= 3 and syn not in _RANK_STOP:
+                        seen.add(syn)
+                        expanded.append(syn)
+        return expanded
+    except Exception:
+        return tokens
+
+
+def _split_camel_snake(text: str) -> list[str]:
+    """
+    Spezza camelCase/PascalCase/snake_case in token lowercase (min 3 chars).
+
+    Esempi:
+      "contextManager"    → ["context", "manager"]
+      "rank_files_by_relevance" → ["rank", "files", "relevance"]
+      "UnifiedAgentLoop"  → ["unified", "agent", "loop"]
+    Usato per fuzzy prefix bonus in rank_files_by_relevance.
+    """
+    try:
+        snake = _CAMEL_SPLIT_RE.sub(r'\1_\2', text)
+        parts = re.split(r'[_\-./]', snake)
+        return [p.lower() for p in parts if len(p) >= 3]
+    except Exception:
+        return []
+
+
+def rank_files_by_relevance(
+    goal: str,
+    all_files: list[dict[str, Any]],
+    k: int = 5,
+    min_score: float = 0.0,
+) -> list[str]:
+    """
+    FIX-SKEL-RAG + FIX-SYN-EXPAND: Seleziona i top-K file più rilevanti per il goal.
+
+    Score composito (normalizzato su max(len(base_tokens), 1)):
+      path_hits    * 2.0  — keyword del goal (espansi) nel path
+      symbol_hits  * 1.5  — keyword nei nomi funzione/classe (skeleton RAG)
+      content_hits * 1.0  — keyword nei primi 600 chars del contenuto
+      prefix_bonus * 0.4  — goal token è prefisso di un split-token path/symbol (fuzzy)
+      entry_boost  +0.15  — file entry-point/config noti
+      lang_boost   +0.20  — il linguaggio del file è nel goal
+
+    FIX-SYN-EXPAND:
+    - I token del goal vengono espansi con sinonimi IT/EN prima del matching.
+    - Normalizzazione su len(base_tokens) originali (non espansi) per evitare score
+      inflazionati su file che matchano solo sinonimi lontani.
+    - "autenticazione" → matcha authGuard.ts, middleware.ts, jwt.ts anche senza
+      keyword nel path — copertura semantica senza embeddings.
+
+    Ritorna lista di path ordinata score-desc (top-K, score > min_score).
+    Mai rilancia eccezioni — fallback ai primi K file non ranked.
+    """
+    if not all_files or not goal:
+        return []
+    try:
+        base_tokens = [
+            t.lower()
+            for t in re.findall(r'\b\w{3,}\b', goal[:500])
+            if t.lower() not in _RANK_STOP
+        ]
+        if not base_tokens:
+            return [f.get('path', '') for f in all_files[:k] if f.get('path')]
+
+        # FIX-SYN-EXPAND: espandi con sinonimi tecnici IT/EN
+        tokens = _expand_tokens(base_tokens)
+
+        goal_lower = goal.lower()
+        # Normalizzatore: usa len(base_tokens) non len(tokens) per evitare score inflazionati
+        n = max(len(base_tokens), 1)
+        scores: list[tuple[float, str]] = []
+
+        for f in all_files:
+            path    = f.get('path', '') or ''
+            content = (f.get('content', '') or '')[:600]
+            lang    = (f.get('language', '') or '').lower()
+            if not path:
+                continue
+
+            path_lower    = path.lower()
+            content_lower = content.lower()
+
+            # FIX-SKEL-RAG: estrai firme funzione/classe
+            sigs = _extract_signatures(content, lang)
+            symbols_lower = ' '.join(s.split(':', 1)[-1].lower() for s in sigs)
+
+            # Score primario — matching su token espansi
+            path_hits    = sum(1 for t in tokens if t in path_lower)
+            symbol_hits  = sum(1 for t in tokens if t in symbols_lower)
+            content_hits = sum(1 for t in tokens if t in content_lower)
+            score        = (path_hits * 2.0 + symbol_hits * 1.5 + content_hits) / n
+
+            # Fuzzy prefix bonus (su token base, non espansi — evita falsi positivi)
+            filename_stem = re.sub(r'\.[^.]+$', '', path_lower.rsplit('/', 1)[-1])
+            split_path    = _split_camel_snake(filename_stem)
+            split_syms    = [t for s in sigs for t in _split_camel_snake(s.split(':', 1)[-1])]
+            all_split     = split_path + split_syms
+            prefix_hits   = sum(
+                1 for gt in base_tokens          # usa base_tokens: fuzzy su originali
+                for st in all_split
+                if st != gt and st.startswith(gt)
+            )
+            if prefix_hits:
+                score += (prefix_hits * 0.4) / n
+
+            # Entry-point boost
+            if filename_stem in _RANK_ENTRY_STEMS:
+                score += 0.15
+
+            # Language boost
+            if lang and lang in goal_lower:
+                score += 0.20
+
+            if score > min_score:
+                scores.append((score, path))
+
+        # Ordinamento stabile: score desc, poi path asc
+        scores.sort(key=lambda x: (-x[0], x[1]))
+        return [p for _, p in scores[:k] if p]
+    except Exception:
+        return [f.get('path', '') for f in all_files[:k] if f.get('path')]
+
+
+def _extract_signatures(content: str, language: str) -> list[str]:
+    """Estrae nomi di funzioni/classi per lo skeleton."""
+    try:
+        lang = (language or '').lower()
+        sigs: list[str] = []
+        if lang in ('typescript', 'ts', 'tsx', 'javascript', 'js', 'jsx'):
+            for m in _FUNC_RE.finditer(content):
+                name = m.group(1) or m.group(2)
+                if name:
+                    sigs.append(f'fn:{name}')
+            for m in _CLASS_RE.finditer(content):
+                sigs.append(f'class:{m.group(1)}')
+        elif lang in ('python', 'py'):
+            for m in _PY_DEF_RE.finditer(content):
+                sigs.append(f'def:{m.group(1)}')
+            for m in _PY_CLS_RE.finditer(content):
+                sigs.append(f'class:{m.group(1)}')
+        return sigs[:15]
+    except Exception:
+        return []
+
+
+def build_file_skeleton(path: str, content: str, language: str) -> str:
+    """Costruisce una riga skeleton per un singolo file."""
+    sigs       = _extract_signatures(content, language)
+    line_count = content.count('\n') + 1
+    sigs_str   = ', '.join(sigs[:8]) if sigs else '(no symbols)'
+    return f'  {path} ({line_count}L): {sigs_str}'
+
+
+async def build_project_skeleton(files: list[dict[str, Any]]) -> str:
+    """
+    Costruisce lo skeleton compatto da una lista di file VFS.
+    Ogni dict ha: path, content, language.
+    Ritorna stringa multiriga per iniezione nel contesto agente.
+    """
+    if not files:
+        return ''
+    try:
+        lines = [f'\U0001f4c1 PROJECT SKELETON ({len(files)} files):']
+        for f in sorted(files, key=lambda x: x.get('path', '')):
+            path     = f.get('path', '?')
+            content  = f.get('content', '') or ''
+            language = f.get('language', '') or ''
+            lines.append(build_file_skeleton(path, content, language))
+        return '\n'.join(lines)
+    except Exception:
+        return ''
+
+
+async def compress_cold_file(path: str, content: str, language: str,
+                              tester_llm: Any | None = None) -> str:
+    """
+    Comprime un file 'cold' al suo riepilogo essenziale.
+    Usa Groq-8b via CONTEXT role per velocità. Fallback a skeleton.
+    Max 8s. Mai rilancia eccezioni.
+    """
+    # S573: hash() è PYTHONHASHSEED-salted → chiave diversa a ogni restart HF Space
+    # → nessun riuso della cache tra restart. hashlib.sha256 è stabile e deterministica.
+    _h = hashlib.sha256(content[:500].encode("utf-8", errors="replace")).hexdigest()[:16]
+    cache_key = f'{path}:{_h}'
+    if cache_key in _SUMMARY_CACHE:
+        return _SUMMARY_CACHE[cache_key]
+
+    skeleton = build_file_skeleton(path, content, language)
+
+    if tester_llm and len(content) > 500:
+        try:
+            msgs = [
+                {"role": "system", "content":
+                 "Riassumi il file in max 2 righe: scopo, symbols chiave, deps. "
+                 "Solo facts. Formato: [SCOPO] | [SYMBOLS] | [DEPS]"},
+                {"role": "user", "content":
+                 f"File: {path}\n```{language}\n{content[:2000]}\n```"},
+            ]
+            summary = await asyncio.wait_for(
+                # S587: 120→200 — formato [SCOPO]|[SYMBOLS]|[DEPS] può superare 120 tok
+                tester_llm.chat(msgs, temperature=0.0, max_tokens=200),
+                timeout=7.0,
+            )
+            if summary and not summary.startswith('[LLM'):
+                result = f'  {path}: {summary[:300]}'  # S604: 180→300 — summary file LLM spesso 2-3 righe
+                if len(_SUMMARY_CACHE) >= _MAX_SUMMARY_CACHE:
+                    oldest = next(iter(_SUMMARY_CACHE))
+                    del _SUMMARY_CACHE[oldest]
+                _SUMMARY_CACHE[cache_key] = result
+                return result
+        except Exception:
+            pass  # S364: fallback a skeleton
+
+    return skeleton
+
+
+async def get_context_for_goal(
+    goal: str,
+    active_files: list[str],
+    all_files: list[dict[str, Any]],
+    tester_llm: Any | None = None,
+    top_k: int = 5,
+) -> str:
+    """
+    Contesto intelligente per l'agente:
+    - File in active_files: full content (max 1500 chars ciascuno)
+    - Altri file: skeleton compatto
+    - Output max: ~4000 chars
+
+    S752-A + FIX-SKEL-RAG + FIX-SYN-EXPAND: se active_files è vuoto o None, usa
+    rank_files_by_relevance() (con synonym expansion) per selezionare i top_k file
+    più rilevanti per il goal. File con score == 0 esclusi automaticamente.
+    """
+    if not all_files:
+        return ''
+    try:
+        if not active_files and goal:
+            active_files = rank_files_by_relevance(goal, all_files, k=top_k)
+
+        active_set = set(active_files)
+        parts: list[str] = []
+        budget = 4000
+
+        for f in all_files:
+            path = f.get('path', '')
+            if path not in active_set:
+                continue
+            content  = (f.get('content', '') or '')[:1500]
+            language = f.get('language', '') or ''
+            chunk    = f'[ACTIVE FILE: {path}]\n```{language}\n{content}\n```'
+            parts.append(chunk)
+            budget -= len(chunk)
+            if budget <= 0:
+                break
+
+        cold_files = [f for f in all_files if f.get('path', '') not in active_set]
+        if cold_files and budget > 500:
+            skeleton = await build_project_skeleton(cold_files)
+            if skeleton:
+                parts.append(skeleton)
+
+        return '\n\n'.join(parts) if parts else ''
+    except Exception:
+        return ''
+
+# ── S-CONTEXT-SHARDING: Gestione intelligente del contesto lungo (S482) ──────
+def shard_context(full_context: str, max_shard_size: int = 2000) -> list[str]:
+    """Divide il contesto in shard logici basati sulla rilevanza semantica."""
+    shards = []
+    current_shard = []
+    current_size = 0
+    
+    # Dividiamo per blocchi logici (paragrafi o sezioni di codice)
+    blocks = re.split(r'\n(?=\s*[A-Z#])', full_context)
+    
+    for block in blocks:
+        block_size = len(block)
+        if current_size + block_size > max_shard_size and current_shard:
+            shards.append("\n".join(current_shard))
+            current_shard = []
+            current_size = 0
+        current_shard.append(block)
+        current_size += block_size
+        
+    if current_shard:
+        shards.append("\n".join(current_shard))
+    return shards

agents/critic.py

@@ -0,0 +1,102 @@
+"""
+critic.py — Critic Model
+Secondo passaggio: verifica output, trova errori, suggerisce miglioramenti.
+Usa AIClient generico (non OllamaClient) per compatibilità HF Space.
+"""
+import json
+import re
+from typing import Any
+
+import logging
+_logger = logging.getLogger("agents.critic")
+
+
+CRITIC_SYSTEM = """Sei un critico AI. Valuta l'output dato e rispondi SOLO con JSON valido:
+{
+  "quality": 0-10,
+  "issues": ["lista problemi trovati — solo se GRAVI, non dettagli stilistici"],
+  "suggestions": ["lista miglioramenti concreti"],
+  "is_complete": true/false,
+  "needs_retry": true/false,
+  "confidence": 0.0-1.0
+}
+
+Criteri:
+- quality 8-10: risposta corretta, completa, con codice/calcoli se richiesti
+- quality 5-7: risposta parziale ma utile, mancano dettagli non essenziali
+- quality 0-4: risposta sbagliata, vuota, o fuori tema → needs_retry: true
+- needs_retry: true SOLO se quality <= 3 (non per risposte corrette ma incomplete)
+- Se la risposta ha codice funzionante, calcoli corretti o dati reali → quality >= 7
+
+Nessun testo prima o dopo il JSON."""
+
+
+
+def _extract_json_balanced(raw: str) -> str | None:
+    """P16-B3: depth-counting bilanciato — sostituisce regex greedy r'{[\s\S]+}'.
+    Gestisce oggetti JSON annidati correttamente (es. patch con sub-oggetti).
+    """
+    depth = 0
+    start = -1
+    for i, ch in enumerate(raw):
+        if ch == '{':
+            if depth == 0:
+                start = i
+            depth += 1
+        elif ch == '}':
+            depth -= 1
+            if depth == 0 and start != -1:
+                return raw[start:i + 1]
+    return None
+
+class Critic:
+    def __init__(self, llm_client: Any):
+        self.llm = llm_client
+
+    async def evaluate(self, task: str, output: str, model: str | None = None) -> dict:
+        messages = [
+            {"role": "system", "content": CRITIC_SYSTEM},
+            {
+                "role": "user",
+                "content": (
+                    f"Task originale: {task}\n\n"
+                    f"Output da valutare:\n{output[:2000]}"
+                ),
+            },
+        ]
+        try:
+            raw = await self.llm.chat(messages, temperature=0.2, max_tokens=512)
+            json_match = _extract_json_balanced(raw)
+            if json_match:
+                result = json.loads(json_match)
+                result["_evaluated"] = True
+                return result
+        except Exception as _exc:
+            _logger.debug("[critic] silenced %s", type(_exc).__name__)  # noqa: BLE001
+
+        # Fallback euristico (nessuna chiamata LLM)
+        quality = 5
+        issues: list[str] = []
+
+        if len(output) < 50:
+            quality -= 3
+            issues.append("Output troppo breve")
+        if "errore" in output.lower() or "error" in output.lower():
+            quality -= 2
+            issues.append("Potenziali errori nell'output")
+        if len(output) > 100:
+            quality += 2
+        # Penalizza description leak dei tool
+        if "usa il tool" in output.lower() or "esegui il comando" in output.lower():
+            quality -= 3
+            issues.append("Agente descrive tool invece di usarli")
+
+        return {
+            "quality": max(0, min(10, quality)),
+            "issues": issues,
+            "suggestions": ["Verifica la completezza della risposta"],
+            "is_complete": len(output) > 100,
+            "needs_retry": quality < 3,  # S192: alzato soglia 4→3 — meno falsi negativi
+            "confidence": 0.5,
+            "_fallback": True,
+        }

agents/dynamic_replanner.py

@@ -0,0 +1,180 @@
+"""
+dynamic_replanner.py — COG-1: Dynamic Re-planner on subtask failure.
+
+Quando il loop accumula >= 1 subtask falliti con errori reali,
+genera un NUOVO piano con il contesto degli errori iniettato nel goal.
+
+Architettura:
+  - should_replan(): decision gate — zero latency, no LLM
+  - replan(): chiama planner.create_plan() con failure context
+  - Max 1 re-plan per run (flag _replanned=True nel piano restituito)
+  - Timeout 20s; fallback: None → usa piano originale
+
+Integration: chiamato da unified_loop.py dopo il gather dei subtask
+se exec_warn contiene fallimenti reali (non solo risk:high skips).
+"""
+from __future__ import annotations
+
+import asyncio
+import logging
+import re
+
+_logger = logging.getLogger("agente_ai.replanner")
+
+_FAILURE_RE = re.compile(
+    r"(timeout|error|errore|fallito|failed|exception|not found|non trovato"
+    r"|AttributeError|TypeError|RuntimeError|ImportError|KeyError"
+    r"|404|500|503|ECONNREFUSED|ConnectionError|ModuleNotFoundError)",
+    re.IGNORECASE,
+)
+
+
+# P26-B2: pattern errori transienti — non triggerano replan (si risolvono da soli)
+_TRANSIENT_RE = re.compile(
+    r"(429|rate.?limit|too many requests|connection.?reset|connection.?refused"
+    r"|network.*timeout|read.*timeout|ssl.*timeout|temporary.*unavailable"
+    r"|service.*unavailable|overloaded|quota.*exceeded)",
+    re.IGNORECASE,
+)
+
+# Pattern per fallimenti critici strutturali (richiedono replan immediato)
+_CRITICAL_RE = re.compile(
+    r"(ImportError|ModuleNotFoundError|SyntaxError|TypeError|AttributeError"
+    r"|PermissionError|AssertionError|not found|ECONNREFUSED)",
+    re.IGNORECASE,
+)
+
+
+def should_replan(exec_warn: list[str], exec_done: list[str]) -> bool:
+    """
+    Decision gate: decide se vale la pena re-pianificare.
+
+    Trigger se:
+    - Almeno 1 warning contiene pattern di failure reale (non solo skip risk:high)
+    - exec_done ha meno successi dei fallimenti (piano non sta funzionando)
+
+    P26-B2: errori transienti (429/RateLimit/timeout di rete) NON triggerano
+    replan — si risolvono da soli e il replan sarebbe un falso positivo costoso.
+    """
+    if not exec_warn:
+        return False
+    real_failures = [w for w in exec_warn if _FAILURE_RE.search(w)]
+    if not real_failures:
+        return False
+    # P26-B2: se TUTTI i fallimenti sono transienti → no replan, lascia retry naturale
+    transient = [w for w in real_failures if _TRANSIENT_RE.search(w)]
+    if transient and len(transient) == len(real_failures):
+        _logger.debug("P26-B2 should_replan=False: tutti i %d fallimenti sono transienti", len(transient))
+        return False
+    # REASONING-BUG-6: singolo fallimento critico strutturale → re-plan immediato
+    critical_failures = [w for w in real_failures if _CRITICAL_RE.search(w)]
+    if critical_failures:
+        return True  # ImportError / SyntaxError / AttributeError → replan subito
+    # Re-plan se fallimenti strutturali >= successi (piano non sta funzionando)
+    structural = [w for w in real_failures if not _TRANSIENT_RE.search(w)]
+    return len(structural) >= max(len(exec_done), 1)
+
+
+def _find_downstream(subtasks: list, done_descs: set) -> tuple:
+    """P25-R1: dato il grafo requires[], ritorna (done_ids, pending_ids).
+
+    - done_ids  : subtask già completati (matched by description in done_descs)
+    - pending_ids: subtask non ancora completati (da includere nel re-plan)
+
+    Logica: matching fuzzy description→done_descs (substring 40 char).
+    Pure function, zero I/O, zero LLM — usata solo per filtrare il re-plan scope.
+    """
+    done_ids: set = set()
+    for st in subtasks:
+        desc = str(st.get("description", ""))[:40].lower()
+        if any(desc and desc in d.lower() for d in done_descs):
+            done_ids.add(st.get("id"))
+    pending = [st for st in subtasks if st.get("id") not in done_ids]
+    return done_ids, pending
+
+
+async def replan(
+    planner: object,
+    original_goal: str,
+    exec_warn: list[str],
+    exec_done: list[str],
+    error_context: str = "",
+    plan: "dict | None" = None,
+) -> "dict | None":
+    """
+    Genera un nuovo piano con il contesto dei fallimenti iniettato nel goal.
+
+    Il goal arricchito contiene:
+    - Subtask già completati (da NON ripetere)
+    - Problemi riscontrati (ultimi 3 warning)
+    - Analisi errore classificata (se disponibile)
+
+    Returns: nuovo piano dict con _replanned=True, o None se fallisce.
+    """
+    if not planner:
+        return None
+
+    # P25-R1: graph-aware scope — se abbiamo il piano corrente, replan solo i subtask
+    # pendenti (non quelli già completati). Riduce il re-plan al sottoinsieme necessario.
+    _scope_hint = ""
+    if plan and plan.get("subtasks"):
+        _done_descs = set(exec_done)
+        _, _pending = _find_downstream(plan["subtasks"], _done_descs)
+        if _pending and len(_pending) < len(plan["subtasks"]):
+            _ids = [st.get("id") for st in _pending]
+            _scope_hint = f"\nRe-pianifica SOLO i subtask {_ids} (gli altri sono già completati)."
+            _logger.debug("P25-R1 scope ridotto: %d/%d subtask da replanare", len(_pending), len(plan["subtasks"]))
+
+    failures_str = "\n".join(exec_warn[-3:]) if exec_warn else "nessun dettaglio"
+    done_str     = ", ".join(exec_done[-5:])  if exec_done else "nessuno"
+
+    # P16-B6: estrai tool/approcci falliti — guida il replanner a evitarli
+    # P18: rimosso import re lazy — usa re module-level (già importato riga 20)
+    _tool_fails: list[str] = []
+    for _w in exec_warn[-5:]:
+        _m = re.search(
+            r"(web_search|run_python|write_file|read_file|web_fetch|"
+            r"trigger_webhook|pip_install|shell_exec|delegate)\w*",
+            _w, re.IGNORECASE,
+        )
+        if _m:
+            _tool_fails.append(_m.group(0))
+    _avoid_str = ", ".join(set(_tool_fails)) if _tool_fails else ""
+
+    enriched_goal = (
+        f"{original_goal}\n\n"
+        f"[CONTESTO RE-PLAN \u2014 tentativo precedente fallito]\n"
+        f"Subtask gi\u00e0 completati (NON ripetere): {done_str}.\n"
+        f"Problemi riscontrati:\n{failures_str}\n"
+    )
+    if _avoid_str:
+        enriched_goal += f"Tool che hanno fallito (usa ALTERNATIVE): {_avoid_str}.\n"
+    if error_context:
+        enriched_goal += f"Analisi errore: {error_context[:300]}\n"
+    if _scope_hint:
+        enriched_goal += _scope_hint
+    _avoid_hint = f"Evita: {_avoid_str}. " if _avoid_str else ""
+    enriched_goal += (
+        "[ISTRUZIONE] Genera un piano ALTERNATIVO che eviti gli stessi problemi. "
+        f"{_avoid_hint}"
+        "Usa approcci diversi per i subtask falliti. "
+        "Se un tool ha fallito, usa un tool alternativo."
+    )
+    try:
+        new_plan = await asyncio.wait_for(
+            planner.create_plan(enriched_goal),  # type: ignore[attr-defined]
+            timeout=20.0,
+        )
+        if new_plan and new_plan.get("subtasks"):
+            _logger.info(
+                "COG-1 replan: %d subtask nel nuovo piano (da %d warn, %d done)",
+                len(new_plan["subtasks"]), len(exec_warn), len(exec_done),
+            )
+            new_plan["_replanned"] = True
+            return new_plan
+    except asyncio.TimeoutError:
+        _logger.warning("COG-1 replan timeout 20s — mantengo piano originale")
+    except Exception as exc:
+        _logger.warning("COG-1 replan error: %s", exc)
+
+    return None

agents/engineering_state.py

@@ -0,0 +1,255 @@
+"""Versioned, bounded engineering lifecycle state for the unified agent loop.
+
+The module is deliberately dependency-free.  It mirrors the legacy lifecycle without
+being authoritative for recovery when the rollout mode is enabled, and it never stores
+raw prompts, credentials, or arbitrary tool output.
+"""
+from __future__ import annotations
+
+import hashlib
+import os
+import re
+import time
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Mapping
+
+SCHEMA_VERSION = 1
+MAX_HISTORY = 64
+MAX_DIAGNOSTICS = 24
+MAX_PREVIEW_CHARS = 256
+MAX_ID_CHARS = 180
+
+_SECRET_PATTERNS = (
+    re.compile(r"(?i)(bearer\s+)[A-Za-z0-9._~+/=-]{8,}"),
+    re.compile(r"(?i)(api[_-]?key\s*[:=]\s*)[^\s,;]+"),
+    re.compile(r"(?i)(token\s*[:=]\s*)[^\s,;]+"),
+    re.compile(r"(?i)\b(?:ghp|gho|github_pat|hf|sk|xoxb|xapp|r8)_[A-Za-z0-9_-]{8,}\b"),
+    re.compile(r"\beyJ[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b"),
+)
+
+
+class EngineeringStateMode(str, Enum):
+    OFF = "off"
+    SHADOW = "shadow"
+    CANARY = "canary"
+    AUTHORITATIVE = "authoritative"
+
+
+@dataclass(frozen=True)
+class EngineeringStateConfig:
+    """Conservative rollout configuration read once per run."""
+
+    mode: EngineeringStateMode = EngineeringStateMode.OFF
+    canary_rate: float = 0.0
+
+    @classmethod
+    def from_env(cls) -> "EngineeringStateConfig":
+        raw_mode = os.getenv("ENGINEERING_STATE_MODE", "authoritative").strip().lower()  # P1 default; off remains an explicit rollback mode
+        try:
+            mode = EngineeringStateMode(raw_mode)
+        except ValueError:
+            mode = EngineeringStateMode.OFF
+        try:
+            rate = float(os.getenv("ENGINEERING_STATE_CANARY_RATE", "0"))
+        except (TypeError, ValueError):
+            rate = 0.0
+        return cls(mode=mode, canary_rate=max(0.0, min(rate, 1.0)))
+
+    @property
+    def enabled(self) -> bool:
+        return self.mode is not EngineeringStateMode.OFF
+
+    def selects_canary(self, run_id: str, session_id: str) -> bool:
+        if self.mode is not EngineeringStateMode.CANARY or not session_id:
+            return False
+        if self.canary_rate >= 1.0:
+            return True
+        if self.canary_rate <= 0.0:
+            return False
+        digest = hashlib.sha256(f"{run_id}:{session_id}".encode()).digest()
+        bucket = int.from_bytes(digest[:8], "big") / float(2**64)
+        return bucket < self.canary_rate
+
+
+def _bounded_id(value: str | None) -> str:
+    return re.sub(r"[^A-Za-z0-9_.:/-]", "_", str(value or ""))[:MAX_ID_CHARS]
+
+
+def redact_text(value: object, max_chars: int = MAX_PREVIEW_CHARS) -> str:
+    """Redact common credential forms before anything reaches a checkpoint."""
+    text = str(value or "")[: max_chars * 4]
+    for pattern in _SECRET_PATTERNS:
+        if pattern.groups:
+            text = pattern.sub(lambda match: f"{match.group(1)}[REDACTED]", text)
+        else:
+            text = pattern.sub("[REDACTED]", text)
+    return text[:max_chars]
+
+
+_ALLOWED_TRANSITIONS: dict[str, frozenset[str]] = {
+    "IDLE": frozenset({"CLASSIFYING", "FAILED"}),
+    "CLASSIFYING": frozenset({"TOOL_EXECUTING", "THINKING", "COMPLETED", "FAILED"}),
+    "TOOL_EXECUTING": frozenset({"THINKING", "COMPLETED", "FAILED"}),
+    "THINKING": frozenset({"COMPLETED", "FAILED"}),
+    "FAILED": frozenset({"IDLE"}),
+    "COMPLETED": frozenset({"IDLE", "FAILED"}),
+}
+
+
+@dataclass
+class EngineeringState:
+    """Bounded state envelope that can be persisted and safely restored."""
+
+    run_id: str
+    session_id: str
+    checkpoint_id: str
+    goal_digest: str
+    goal_preview: str
+    current_state: str = "IDLE"
+    history: list[dict[str, Any]] = field(default_factory=list)
+    diagnostics: list[str] = field(default_factory=list)
+    revision: int = 0
+    sequence: int = 0
+    created_at_ms: int = field(default_factory=lambda: int(time.time() * 1000))
+    updated_at_ms: int = field(default_factory=lambda: int(time.time() * 1000))
+
+    @classmethod
+    def start(
+        cls,
+        goal: str,
+        *,
+        run_id: str,
+        session_id: str = "",
+        checkpoint_id: str | None = None,
+        now_ms: int | None = None,
+    ) -> "EngineeringState":
+        now = int(time.time() * 1000) if now_ms is None else int(now_ms)
+        normalized_goal = str(goal or "")
+        return cls(
+            run_id=_bounded_id(run_id),
+            session_id=_bounded_id(session_id),
+            checkpoint_id=_bounded_id(checkpoint_id or session_id or run_id),
+            goal_digest=hashlib.sha256(normalized_goal.encode("utf-8", "replace")).hexdigest(),
+            goal_preview=redact_text(normalized_goal),
+            created_at_ms=now,
+            updated_at_ms=now,
+        )
+
+    @property
+    def status(self) -> str:
+        if self.current_state == "COMPLETED":
+            return "completed"
+        if self.current_state == "FAILED":
+            return "failed"
+        return "active"
+
+    def transition(self, next_state: str, *, now_ms: int | None = None) -> bool:
+        """Apply an idempotent transition; reject illegal transitions deterministically."""
+        target = str(next_state)
+        if target == self.current_state:
+            return False
+        allowed = _ALLOWED_TRANSITIONS.get(self.current_state, frozenset())
+        if target not in allowed:
+            raise ValueError(f"Invalid EngineeringState transition: {self.current_state} -> {target}")
+        now = int(time.time() * 1000) if now_ms is None else int(now_ms)
+        self.sequence += 1
+        self.revision += 1
+        self.history.append({
+            "sequence": self.sequence,
+            "from_state": self.current_state,
+            "to_state": target,
+            "at_ms": now,
+        })
+        if len(self.history) > MAX_HISTORY:
+            del self.history[:-MAX_HISTORY]
+        self.current_state = target
+        self.updated_at_ms = now
+        return True
+
+    def prepare_for_resume(self) -> None:
+        """Normalize a restored snapshot before a new loop execution."""
+        if self.current_state != "IDLE":
+            self.current_state = "IDLE"
+            self.revision += 1
+            self.updated_at_ms = int(time.time() * 1000)
+            self.diagnostic("resume normalized state to IDLE")
+
+    def diagnostic(self, message: str) -> None:
+        value = redact_text(message, 180)
+        if not value or value in self.diagnostics:
+            return
+        self.diagnostics.append(value)
+        if len(self.diagnostics) > MAX_DIAGNOSTICS:
+            del self.diagnostics[:-MAX_DIAGNOSTICS]
+        self.revision += 1
+        self.updated_at_ms = int(time.time() * 1000)
+
+    def snapshot(self) -> dict[str, Any]:
+        """Return a bounded JSON-compatible envelope; never expose the raw goal."""
+        return {
+            "schema_version": SCHEMA_VERSION,
+            "run_id": self.run_id,
+            "session_id": self.session_id,
+            "checkpoint_id": self.checkpoint_id,
+            "goal_digest": self.goal_digest,
+            "goal_preview": self.goal_preview,
+            "status": self.status,
+            "current_state": self.current_state,
+            "revision": self.revision,
+            "sequence": self.sequence,
+            "history": list(self.history[-MAX_HISTORY:]),
+            "diagnostics": list(self.diagnostics[-MAX_DIAGNOSTICS:]),
+            "created_at_ms": self.created_at_ms,
+            "updated_at_ms": self.updated_at_ms,
+        }
+
+    def projection(self) -> dict[str, Any]:
+        """Small read-only view safe for API/SSE consumers."""
+        return {
+            "schema_version": SCHEMA_VERSION,
+            "status": self.status,
+            "current_state": self.current_state,
+            "revision": self.revision,
+            "sequence": self.sequence,
+            "checkpoint_id": self.checkpoint_id,
+            "history": [dict(item) for item in self.history[-16:]],
+            "diagnostics": list(self.diagnostics[-MAX_DIAGNOSTICS:]),
+        }
+
+    @classmethod
+    def from_snapshot(cls, payload: Mapping[str, Any]) -> "EngineeringState":
+        if not isinstance(payload, Mapping):
+            raise ValueError("engineering state must be an object")
+        if int(payload.get("schema_version", -1)) != SCHEMA_VERSION:
+            raise ValueError("unsupported engineering state schema")
+        history = payload.get("history", [])
+        diagnostics = payload.get("diagnostics", [])
+        if not isinstance(history, list) or len(history) > MAX_HISTORY:
+            raise ValueError("invalid engineering state history")
+        if not isinstance(diagnostics, list) or len(diagnostics) > MAX_DIAGNOSTICS:
+            raise ValueError("invalid engineering state diagnostics")
+        current = str(payload.get("current_state", ""))
+        if current not in _ALLOWED_TRANSITIONS:
+            raise ValueError("invalid engineering state current state")
+        revision = int(payload.get("revision", -1))
+        sequence = int(payload.get("sequence", -1))
+        if revision < 0 or sequence < 0 or revision < sequence:
+            raise ValueError("invalid engineering state revision")
+        state = cls(
+            run_id=_bounded_id(str(payload.get("run_id", ""))),
+            session_id=_bounded_id(str(payload.get("session_id", ""))),
+            checkpoint_id=_bounded_id(str(payload.get("checkpoint_id", ""))),
+            goal_digest=str(payload.get("goal_digest", "")),
+            goal_preview=redact_text(payload.get("goal_preview", "")),
+            current_state=current,
+            history=[dict(item) for item in history if isinstance(item, Mapping)],
+            diagnostics=[redact_text(item, 180) for item in diagnostics],
+            revision=revision,
+            sequence=sequence,
+            created_at_ms=int(payload.get("created_at_ms", 0)),
+            updated_at_ms=int(payload.get("updated_at_ms", 0)),
+        )
+        if len(state.goal_digest) != 64 or not re.fullmatch(r"[0-9a-f]{64}", state.goal_digest):
+            raise ValueError("invalid engineering state goal digest")
+        return state

agents/error_classifier.py

@@ -0,0 +1,213 @@
+"""
+error_classifier.py — S404: Classificazione errori nel repair loop
+
+Documento strategico: "Non basta 'vedere un errore'. Devi distinguere almeno:
+selettore sbagliato, pagina diversa dal previsto, login fallito, errore runtime,
+rete lenta, frame non caricato, stato UI incoerente."
+
+Implementa la classificazione per consentire repair MIRATI invece di analisi generiche.
+
+Integrazione:
+  _reflective_debug → classify_error(goal, errors) → ErrorResult
+  → inject repair_strategy nel context prima del retry
+
+Pipeline classificazione:
+  1. Pattern matching regex (deterministico, zero latenza)
+  2. Fallback: UNKNOWN → generic strategic recovery
+
+Non usa LLM per classificare — è sincrono e costa zero latency.
+"""
+
+import re
+from dataclasses import dataclass
+from enum import Enum
+
+
+class ErrorCategory(str, Enum):
+    SELECTOR   = "selector"    # CSS/DOM selector non trovato
+    NAVIGATION = "navigation"  # URL sbagliato, pagina non trovata, redirect
+    AUTH       = "auth"        # Login fallito, token scaduto, 401/403
+    RUNTIME    = "runtime"     # TypeError, ReferenceError, is not defined
+    NETWORK    = "network"     # Timeout, ECONNREFUSED, offline, 503
+    FRAME      = "frame"       # iframe non caricato, frame non trovato
+    SYNTAX     = "syntax"      # SyntaxError, IndentationError, parse error
+    LOGIC      = "logic"       # AssertionError, valore atteso ≠ ottenuto
+    LIMIT      = "limit"       # Rate limit, quota, 429, OOM
+    DB_ERROR   = "db_error"    # Sprint 3b: IntegrityError, FK, connection pool, deadlock
+    UNKNOWN    = "unknown"     # Non classificato
+
+
+# ── Strategie di repair per categoria ─────────────────────────────────────────
+_REPAIR_STRATEGIES: dict[ErrorCategory, str] = {
+    ErrorCategory.SELECTOR: (
+        "SELETTORE DOM: usa ID espliciti (`#id`), aria-label (`[aria-label='...']`) "
+        "o ruoli ARIA (`getByRole('button', {name:'...'})`) — evita classi dinamiche. "
+        "Prima leggi il DOM attuale per trovare il selettore corretto."
+    ),
+    ErrorCategory.NAVIGATION: (
+        "NAVIGAZIONE: verifica l'URL esatto prima di navigare. "
+        "Attendi `domcontentloaded` o un elemento specifico prima di operare sulla pagina. "
+        "Gestisci redirect e pagine di errore (404/500) esplicitamente."
+    ),
+    ErrorCategory.AUTH: (
+        "AUTENTICAZIONE: gestisci il login PRIMA di qualsiasi azione protetta. "
+        "Verifica il token, gestisci la scadenza della sessione e i redirect post-login. "
+        "Non assumere che la sessione sia già attiva."
+    ),
+    ErrorCategory.RUNTIME: (
+        "ERRORE RUNTIME: controlla undefined/null con optional chaining (`?.`) "
+        "o guardie esplicite (`if (x == null) return`). "
+        "Verifica i tipi degli argomenti prima di usarli. "
+        "Aggiungi try/catch attorno alle operazioni rischiose."
+    ),
+    ErrorCategory.NETWORK: (
+        "ERRORE RETE: aggiungi retry con exponential backoff (max 3 tentativi). "
+        "Gestisci offline/timeout con fallback utili. "
+        "Non bloccare la UI durante le chiamate — usa stato di loading."
+    ),
+    ErrorCategory.FRAME: (
+        "IFRAME: aspetta che l'iframe sia caricato prima di accedere al suo DOM "
+        "(usa `waitForLoadState` o `frameLocator`). "
+        "Verifica che il frame esista con `page.frames()` prima di operare."
+    ),
+    ErrorCategory.SYNTAX: (
+        "SINTASSI: correggi l'errore di sintassi PRIMA di qualsiasi altra cosa. "
+        "Verifica l'indentazione (Python), le parentesi bilanciate e i punti e virgola (JS). "
+        "Usa un linter per identificare tutti gli errori nella stessa sessione."
+    ),
+    ErrorCategory.LOGIC: (
+        "LOGICA: rivedi i casi edge e le assunzioni. "
+        "Aggiungi asserzioni esplicite sui valori attesi. "
+        "Traccia il flusso di dati passo per passo per trovare dove diverge dal previsto."
+    ),
+    ErrorCategory.LIMIT: (
+        "RATE LIMIT / QUOTA: implementa retry con backoff esponenziale e jitter. "
+        "Riduci la frequenza delle chiamate. "
+        "Considera caching dei risultati per evitare chiamate ridondanti."
+    ),
+    ErrorCategory.DB_ERROR: (
+        "ERRORE DATABASE: controlla vincoli di integrità (FK, UNIQUE, NOT NULL). "
+        "Per IntegrityError: verifica che i dati rispettino i vincoli prima dell'insert. "
+        "Per connection pool exhausted: chiudi le connessioni non usate, riduci max_connections. "
+        "Per deadlock: usa retry con backoff, considera SKIP LOCKED per job queue. "
+        "Per 'relation does not exist': esegui le migrazioni pendenti prima dell'avvio."
+    ),
+    ErrorCategory.UNKNOWN: (
+        "Analizza il contesto completo dell'errore. "
+        "Prova un approccio COMPLETAMENTE diverso da quello usato finora."
+    ),
+}
+
+# ── Pattern regex per classificazione ───────────────────────────────��─────────
+# Ordinati per priorità (il primo match vince)
+_PATTERNS: list[tuple[ErrorCategory, re.Pattern]] = [
+    (ErrorCategory.SYNTAX, re.compile(
+        r"SyntaxError|IndentationError|ParseError|parse error|"
+        r"unexpected token|unexpected EOF|invalid syntax|"
+        r"unterminated string|missing \)", re.IGNORECASE,
+    )),
+    (ErrorCategory.SELECTOR, re.compile(
+        r"selector|querySelector|getElementById|no element|"
+        r"element not found|locator|aria|getByRole|"
+        r"TimeoutError.*waiting for|strict mode violation", re.IGNORECASE,
+    )),
+    (ErrorCategory.AUTH, re.compile(
+        r"401|403|Unauthorized|Forbidden|Authentication|"
+        r"token.*expired|session.*expired|login.*failed|"
+        r"invalid.*credentials|permission denied", re.IGNORECASE,
+    )),
+    (ErrorCategory.NETWORK, re.compile(
+        r"ECONNREFUSED|ENOTFOUND|ETIMEDOUT|timeout|"
+        r"network error|fetch.*failed|connection refused|"
+        r"503|502|504|unreachable|offline", re.IGNORECASE,
+    )),
+    (ErrorCategory.LIMIT, re.compile(
+        r"429|rate.?limit|quota.*exceeded|too many requests|"
+        r"OOM|out of memory|memory.*error", re.IGNORECASE,
+    )),
+    (ErrorCategory.FRAME, re.compile(
+        r"frame|iframe|frameLocator|frame.*not found|"
+        r"cross.?origin|sandboxed.*frame", re.IGNORECASE,
+    )),
+    (ErrorCategory.NAVIGATION, re.compile(
+        r"404|page not found|navigation.*failed|goto.*timeout|"
+        r"ERR_NAME_NOT_RESOLVED|net::ERR|redirect.*loop|"
+        r"wrong.*page|URL.*invalid", re.IGNORECASE,
+    )),
+    (ErrorCategory.RUNTIME, re.compile(
+        r"TypeError|ReferenceError|is not defined|"
+        r"Cannot read|Cannot set|undefined is not|"
+        r"null.*property|property.*null|"
+        r"is not a function|is not iterable|"
+        r"UnhandledPromiseRejection", re.IGNORECASE,
+    )),
+    (ErrorCategory.LOGIC, re.compile(
+        r"AssertionError|assertion.*failed|expected.*got|"
+        r"mismatch|wrong.*value|incorrect.*result|"
+        r"test.*failed|expected.*received", re.IGNORECASE,
+    )),
+    # Sprint 3b: DB_ERROR — IntegrityError, FK, connection pool, deadlock
+    (ErrorCategory.DB_ERROR, re.compile(
+        r"IntegrityError|ForeignKey|ForeignKeyViolation|"
+        r"connection pool|deadlock|"
+        r"relation.*not.*exist|table.*not.*exist|"
+        r"duplicate key|violates.*constraint|"
+        r"UniqueViolation|CheckViolation|NotNullViolation|"
+        r"OperationalError.*database|psycopg|asyncpg|"
+        r"FATAL.*database|could not connect.*database",
+        re.IGNORECASE,
+    )),
+]
+
+
+@dataclass
+class ErrorResult:
+    category:        ErrorCategory
+    repair_strategy: str
+    confidence:      float     # 0.0-1.0 — quanto siamo sicuri della classificazione
+    matched_pattern: str       # substring che ha fatto match (debug)
+
+
+def classify_error(errors: list[str]) -> ErrorResult:
+    """
+    Classifica una lista di messaggi di errore nella categoria più probabile.
+
+    Algoritmo:
+    1. Concatena gli errori (max 1500 chars)
+    2. Prova i pattern in ordine di priorità (il primo match vince)
+    3. Se nessun match → UNKNOWN con confidence 0.0
+
+    Non usa LLM — è sincrono e a zero latency.
+    Chiamato da _reflective_debug prima di invocare ARCHITECT.
+    """
+    combined = " | ".join(str(e)[:500] for e in errors[-4:])[:1500]  # S604: 400→500 per error string completa
+
+    for category, pattern in _PATTERNS:
+        m = pattern.search(combined)
+        if m:
+            matched = m.group(0)[:60]
+            strategy = _REPAIR_STRATEGIES[category]
+            return ErrorResult(
+                category        = category,
+                repair_strategy = strategy,
+                confidence      = 0.85,
+                matched_pattern = matched,
+            )
+
+    return ErrorResult(
+        category        = ErrorCategory.UNKNOWN,
+        repair_strategy = _REPAIR_STRATEGIES[ErrorCategory.UNKNOWN],
+        confidence      = 0.0,
+        matched_pattern = "",
+    )
+
+
+def format_for_context(result: ErrorResult) -> str:
+    """
+    Produce la stringa da iniettare nel context del loop prima del retry.
+    Formato: [ERRORE CLASSIFICATO: <Categoria>] + strategia.
+    """
+    label = f"ERRORE CLASSIFICATO: {result.category.value.upper()}"
+    if result.matched_pattern:
+        label += f" (match: \"{result.matched_pattern}\")"
+    return f"\n\n[{label}]\n{result.repair_strategy}"

agents/escalation_ladder.py

@@ -0,0 +1,183 @@
+"""
+escalation_ladder.py — GAP-3: Dynamic Cognitive Routing (Escalation Ladder)
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+GAP-3: "The Escalation Ladder" — routing LLM adattivo per tentativi successivi
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Problema risolto:
+  Il sistema corrente assegna lo stesso modello (_get_llm_for_goal) per TUTTI
+  i tentativi LLM nel retry loop. Se il modello scelto fallisce (timeout, rifiuto,
+  risposta insufficiente), viene riusato identicamente — sprecando budget
+  e producendo lo stesso errore N volte.
+
+Soluzione:
+  EscalationLadder: per ogni retry usa un modello più potente.
+
+  Attempt 0  → CODER (Llama 4 Scout / OpenRouter — veloce, gratuito, ottimo per codice)
+  Attempt 1  → REASONER (Cerebras 120B — 2000+ tok/s, massima qualità reasoning 2026)
+  Attempt 2+ → DEFAULT (Gemini 2.5 Flash via AIClient — più capace, fallback finale)
+
+  Con severity "logic" (errore logico complesso):
+  Attempt 0  → REASONER (salta CODER — logica complessa richiede ragionamento)
+  Attempt 1+ → DEFAULT (Gemini 2.5 Flash — massima copertura)
+
+Integrazione in unified_loop.py (minimal patch):
+  PRIMA (una riga FUORI dal loop):
+    _active_llm = self._get_llm_for_goal(state.goal)
+
+  DOPO:
+    from agents.escalation_ladder import EscalationLadder as _EscLadder
+    _esc_ladder = _EscLadder(base_llm=self.llm, goal=state.goal)
+
+  DENTRO il for _llm_try loop:
+    _active_llm = _esc_ladder.get_llm(_llm_try, _error_severity)
+
+Invarianti rispettate:
+  - Silent failure totale: qualsiasi eccezione → ritorna base_llm
+  - Zero regressioni: attempt 0 per goal di codice = identico a _get_llm_for_goal()
+  - Thread-safe: lazy caching per slot, no shared state tra istanze
+  - Budget free tier: CODER e REASONER gratuiti; DEFAULT usato solo se necessario
+  - Logging: info su ogni escalation (nome modello + motivo)
+
+Dipendenze:
+  - models.role_router (RoleRouter, Role) — già presente nel progetto
+  - logging — stdlib
+"""
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+_logger = logging.getLogger("agente_ai")
+
+# ── Escalation schedule ────────────────────────────────────────────────────────
+# Mapping: (attempt_index, error_severity) → lista ordinata di Role da provare
+#
+# Logica:
+#   - Per severity "syntax" e "runtime": inizia con CODER (fix procedurale)
+#   - Per severity "logic" e "unknown": inizia con REASONER (ragionamento necessario)
+#   - Attempt 0 = primo ruolo, attempt 1 = secondo, attempt 2+ = DEFAULT
+#
+# NOTA: i Role sono stringa per evitare import circolare al module-level.
+#       RoleRouter viene importato lazy dentro get_llm().
+
+_SEVERITY_LADDER: dict[str, list[str]] = {
+    # Errori di sintassi: CODER corregge con precisione, poi REASONER se ancora KO
+    "syntax":  ["coder", "reasoner", "default"],
+    # Errori runtime: CODER (approccio alternativo) → REASONER (debugging profondo)
+    "runtime": ["coder", "reasoner", "default"],
+    # Errori logici: serve ragionamento → salta CODER, parti con REASONER
+    "logic":   ["reasoner", "default", "default"],
+    # Unknown: bilancia velocità e qualità
+    "unknown": ["coder", "reasoner", "default"],
+}
+
+_DEFAULT_LADDER = _SEVERITY_LADDER["unknown"]
+
+
+class EscalationLadder:
+    """
+    Gestisce l'escalation dinamica dei provider LLM durante il retry loop.
+
+    Crea un'istanza PER RUN (non per sessione) — caching dei client LLM
+    valido solo per la durata del retry loop corrente.
+
+    Usage in unified_loop._run_fallback:
+
+        # Prima del for loop:
+        from agents.escalation_ladder import EscalationLadder
+        _esc = EscalationLadder(base_llm=self.llm, goal=state.goal)
+
+        # Dentro il for _llm_try loop (sostituisce _active_llm=self._get_llm_for_goal()):
+        _active_llm = _esc.get_llm(_llm_try, _error_severity)
+    """
+
+    def __init__(self, base_llm: Any, goal: str = "") -> None:
+        """
+        Args:
+            base_llm: Il client LLM di default (self.llm di UnifiedAgentLoop).
+                      Usato come fallback ultimo livello.
+            goal:     Il goal corrente — usato per determinare se è un goal di codice
+                      (e quindi se CODER è appropriato come primo tentativo).
+        """
+        self._base_llm    = base_llm
+        self._goal        = goal
+        # Cache per slot: evita di ri-istanziare RoleRouter per ogni tentativo
+        self._cache: dict[str, Any] = {}
+
+    def get_llm(self, attempt: int, error_severity: str = "unknown") -> Any:
+        """
+        Restituisce il client LLM appropriato per questo tentativo.
+
+        Args:
+            attempt:        Indice del tentativo (0, 1, 2, ...).
+            error_severity: Categoria errore da error_classifier
+                            ("syntax" | "runtime" | "logic" | "unknown").
+
+        Returns:
+            AIClient configurato per il ruolo appropriato.
+            MAI lancia eccezioni — sempre ritorna un client valido.
+        """
+        try:
+            ladder = _SEVERITY_LADDER.get(error_severity, _DEFAULT_LADDER)
+            # Clamp: attempt >= len(ladder) → usa sempre l'ultimo (DEFAULT)
+            slot   = ladder[min(attempt, len(ladder) - 1)]
+            return self._get_for_slot(slot, attempt, error_severity)
+        except Exception as exc:
+            _logger.debug("EscalationLadder.get_llm fallback (attempt=%d): %s", attempt, exc)
+            return self._base_llm
+
+    # ── Private ───────────────────────────────────────────────────────────────
+
+    def _get_for_slot(self, slot: str, attempt: int, severity: str) -> Any:
+        """Ottiene (o crea e cacha) il client per uno slot specifico."""
+        if slot in self._cache:
+            return self._cache[slot]
+
+        client = self._build_client(slot, attempt, severity)
+        self._cache[slot] = client
+        return client
+
+    def _build_client(self, slot: str, attempt: int, severity: str) -> Any:
+        """
+        Costruisce il client LLM per il ruolo richiesto.
+        Ogni eccezione → ritorna base_llm (silent fallback).
+        """
+        try:
+            from models.role_router import RoleRouter, Role
+
+            if slot == "coder":
+                client = RoleRouter.get_client(Role.CODER)
+                _logger.info(
+                    "EscalationLadder[attempt=%d, sev=%s]: CODER (Llama 4 Scout)",
+                    attempt, severity,
+                )
+                return client
+
+            if slot == "reasoner":
+                client = RoleRouter.get_client(Role.REASONER)
+                _logger.info(
+                    "EscalationLadder[attempt=%d, sev=%s]: REASONER (Cerebras 120B) — escalation",
+                    attempt, severity,
+                )
+                return client
+
+            if slot == "default":
+                # DEFAULT: usa il client base (Gemini 2.5 Flash / primo provider disponibile)
+                _logger.info(
+                    "EscalationLadder[attempt=%d, sev=%s]: DEFAULT (AIClient primary) — max escalation",
+                    attempt, severity,
+                )
+                return self._base_llm
+
+        except Exception as exc:
+            _logger.debug("EscalationLadder._build_client[%s] error: %s", slot, exc)
+
+        return self._base_llm
+
+    def __repr__(self) -> str:
+        return (
+            f"EscalationLadder(goal={self._goal[:40]!r}, "
+            f"cached_slots={list(self._cache.keys())})"
+        )

agents/executor.py

@@ -0,0 +1,360 @@
+"""
+executor.py — Tool Executor con retry, adaptive timeout, circuit breaker e fallback routing.
+Usa AIClient (multi-provider) al posto di OllamaClient (localhost).
+
+Architettura adaptive (GAP-SKILL-SYNC v2):
+  _AdaptiveTimeoutTracker — P90-based timeout adaptation (sliding window 5 call)
+  Circuit Breaker         — Wilson score < CIRCUIT_OPEN_THRESHOLD → skip al miglior fallback
+  Fallback Execution      — TOOL_REGISTRY["fallbacks"] ora eseguiti automaticamente (non solo metadata)
+  Recovery Credit         — tool circuit-broken retentato ogni RECOVERY_INTERVAL chiamate
+"""
+import asyncio
+import collections
+import logging
+import time as _time_mod
+
+from models.ai_client import AIClient
+from memory.manager import MemoryManager
+from tools.registry import TOOL_REGISTRY
+
+# P17-B1: pre-esecuzione syntax check — fail-open se ast_check non disponibile
+try:
+    from tools.ast_check import check_code_syntax as _check_syntax
+    _CHECK_SYNTAX_AVAILABLE = True
+except ImportError:
+    _CHECK_SYNTAX_AVAILABLE = False
+    def _check_syntax(code: str, lang: str):  # type: ignore[misc]
+        class _Ok:
+            ok    = True
+            error = None
+            line  = None
+            col   = None
+        return _Ok()
+
+_logger = logging.getLogger("agente_ai.executor")
+
+# ─── Costanti circuit breaker ────────────────────────────────────────────────
+_CIRCUIT_OPEN_THRESHOLD = 0.15   # Wilson score < soglia AND >= min calls → circuit open
+_MIN_CALLS_FOR_CIRCUIT  = 3      # minimo di chiamate prima che il circuit possa aprirsi
+_RECOVERY_INTERVAL      = 5      # ogni N chiamate con circuit open → tenta il tool primario
+
+# ─── S-ORCH-8GAP FIX-GAP2: Adaptive Timeout Tracker ─────────────────────────
+# Sliding window (last 5 durations) per tool — calcola P90 adattivo.
+# Strategia iPhone: rete variabile → se tool è stato lento di recente,
+# aumenta timeout; se è stato veloce, non sprecare tempo.
+class _AdaptiveTimeoutTracker:
+    """Tracked P90 per-tool timeout con sliding window di 5 call."""
+    _WINDOW     = 5
+    _MIN        = 4.0   # mai sotto 4s — tool veloci non vanno sotto
+    _MAX        = 55.0  # mai sopra 55s — iPhone connection timeout ~60s
+    _MULTIPLIER = 1.5   # P90 * 1.5 = headroom conservativo
+
+    def __init__(self) -> None:
+        self._times: dict[str, collections.deque] = {}
+
+    def record(self, tool_name: str, elapsed: float) -> None:
+        if tool_name not in self._times:
+            self._times[tool_name] = collections.deque(maxlen=self._WINDOW)
+        self._times[tool_name].append(elapsed)
+
+    def adaptive_timeout(self, tool_name: str, base_timeout: float) -> float:
+        """Ritorna timeout adattivo: P90 * 1.5 se dati sufficienti, else base."""
+        times = self._times.get(tool_name)
+        if not times or len(times) < 2:
+            return base_timeout  # dati insufficienti → usa base invariato
+        sorted_t = sorted(times)
+        p90_idx  = min(int(len(sorted_t) * 0.9), len(sorted_t) - 1)
+        adaptive = sorted_t[p90_idx] * self._MULTIPLIER
+        return max(self._MIN, min(self._MAX, adaptive))
+
+_timeout_tracker = _AdaptiveTimeoutTracker()
+
+# P17-B1: mapping tool_name → (argomento_codice, linguaggio) per syntax check
+_CODE_EXEC_TOOLS: dict[str, tuple[str, str]] = {
+    "run_python": ("code", "python"),
+    "run_code":   ("code", "python"),
+}
+
+
+# ─── Helper: ottieni session_id dal ContextVar (impostato da unified_loop.py) ─
+def _get_session_id() -> str:
+    try:
+        from tools.registry import _agent_session_id_var
+        return _agent_session_id_var.get()
+    except Exception:
+        return "default"
+
+
+# ─── Executor ────────────────────────────────────────────────────────────────
+
+class Executor:
+    def __init__(
+        self,
+        llm_client:  AIClient | None = None,
+        memory:      MemoryManager | None = None,
+        max_retries: int = 2,
+    ):
+        self.llm         = llm_client or AIClient()
+        self.memory      = memory
+        self.max_retries = max_retries
+        # GAP-SKILL-SYNC v2: contatore chiamate per recovery credit (per-tool)
+        self._circuit_recovery_counts: dict[str, int] = {}
+
+    # Backward-compat: vecchia firma aveva ollama=OllamaClient, memory=MemoryManager
+    @classmethod
+    def from_ollama(cls, ollama=None, memory=None, max_retries: int = 2) -> "Executor":
+        return cls(memory=memory, max_retries=max_retries)
+
+    # ── Circuit breaker helper ────────────────────────────────────────────────
+
+    def _is_circuit_open(self, tool_name: str, session_id: str) -> bool:
+        """True se il circuit breaker deve aprirsi per questo tool in questa sessione.
+
+        Condizioni (tutte necessarie):
+          1. Wilson score < CIRCUIT_OPEN_THRESHOLD (0.15)
+          2. >= MIN_CALLS_FOR_CIRCUIT (3) chiamate nella sessione
+          3. Il tool ha fallback disponibili in TOOL_REGISTRY
+        Recovery credit: ogni RECOVERY_INTERVAL chiamate, il circuit si chiude
+        temporaneamente per un tentativo di recovery.
+        """
+        tool = TOOL_REGISTRY.get(tool_name, {})
+        if not tool.get("fallbacks"):
+            return False  # senza fallback il circuit non può aprirsi
+        try:
+            from agents.skill_tracker import get_skill_tracker
+            stats = get_skill_tracker().get_stats(session_id).get(tool_name)
+        except Exception:
+            return False
+        if not stats:
+            return False
+        if stats["total_count"] < _MIN_CALLS_FOR_CIRCUIT:
+            return False
+        if stats["wilson_score"] >= _CIRCUIT_OPEN_THRESHOLD:
+            return False
+        # Recovery credit: conta le chiamate e apri una finestra ogni RECOVERY_INTERVAL
+        count = self._circuit_recovery_counts.get(tool_name, 0) + 1
+        self._circuit_recovery_counts[tool_name] = count
+        if count % _RECOVERY_INTERVAL == 0:
+            _logger.info(
+                "[executor] recovery credit: riprovo %s (circuit call #%d)",
+                tool_name, count,
+            )
+            return False   # consenti un tentativo di recovery
+        return True
+
+    # ── Fallback execution ────────────────────────────────────────────────────
+
+    async def _try_fallbacks(
+        self,
+        primary_name: str,
+        inputs:       dict,
+        timeout:      float,
+        session_id:   str,
+    ) -> "dict | None":
+        """Tenta i fallback definiti in TOOL_REGISTRY ordinati per Wilson score.
+
+        Registra ogni tentativo nel skill_tracker sotto il nome del fallback.
+        Ritorna il primo risultato con successo, o None se tutti falliscono.
+        """
+        tool      = TOOL_REGISTRY.get(primary_name, {})
+        fallbacks = tool.get("fallbacks", [])
+        if not fallbacks:
+            return None
+
+        try:
+            from agents.skill_tracker import get_skill_tracker
+            sorted_fbs = get_skill_tracker().get_sorted_fallbacks(session_id, fallbacks)
+        except Exception:
+            sorted_fbs = fallbacks   # ordinamento originale come fallback del fallback
+
+        for fb_name in sorted_fbs:
+            fb_tool = TOOL_REGISTRY.get(fb_name)
+            if not fb_tool or not fb_tool.get("_fn"):
+                continue
+            _logger.info(
+                "[executor] %s fallita — provo fallback %s (Wilson-sorted)",
+                primary_name, fb_name,
+            )
+            try:
+                _t0     = _time_mod.monotonic()
+                _fb_to  = _timeout_tracker.adaptive_timeout(fb_name, timeout)
+                result  = await asyncio.wait_for(fb_tool["_fn"](**inputs), timeout=_fb_to)
+                _timeout_tracker.record(fb_name, _time_mod.monotonic() - _t0)
+                # Registra il successo del fallback nel skill_tracker
+                try:
+                    from agents.skill_tracker import get_skill_tracker
+                    get_skill_tracker().record(session_id, fb_name, True)
+                except Exception as _skt_err:
+                    _logger.debug("[executor] skill_tracker silenced: %s", _skt_err)  # BUG-SILENT-EXC
+                return {
+                    "success":            True,
+                    "tool":               fb_name,
+                    "output":             result,
+                    "via_fallback_from":  primary_name,
+                    "attempt":            1,
+                }
+            except asyncio.TimeoutError:
+                _timeout_tracker.record(fb_name, timeout * 1.2)
+                _logger.debug("[executor] fallback %s timeout", fb_name)
+                try:
+                    from agents.skill_tracker import get_skill_tracker
+                    get_skill_tracker().record(session_id, fb_name, False)
+                except Exception as _skt_err:
+                    _logger.debug("[executor] skill_tracker silenced: %s", _skt_err)  # BUG-SILENT-EXC
+            except Exception as fb_exc:
+                _logger.debug("[executor] fallback %s errore: %s", fb_name, str(fb_exc)[:80])
+                try:
+                    from agents.skill_tracker import get_skill_tracker
+                    get_skill_tracker().record(session_id, fb_name, False)
+                except Exception as _skt_err:
+                    _logger.debug("[executor] skill_tracker silenced: %s", _skt_err)  # BUG-SILENT-EXC
+
+        return None   # tutti i fallback hanno fallito
+
+    # ── run_tool ─────────────────────────────────────────────────────────────
+
+    async def run_tool(self, tool_name: str, inputs: dict, timeout: float = 30.0, worker_hint: str | None = None) -> dict:
+        """
+        Esegue un tool. Se worker_hint è fornito, tenta l'esecuzione sul worker specifico.
+        ARCH-I4.3: Tool Engine evoluto con Capability Resolver.
+        """
+        tool = TOOL_REGISTRY.get(tool_name)
+        if not tool:
+            return {"success": False, "error": f"Tool '{tool_name}' non trovato", "output": None}
+
+        # ARCH-E3.2/ARCH-I4.3: Risoluzione dinamica della capability via Kernel
+        if not worker_hint:
+            try:
+                from api.kernel import kernel
+                res = await kernel.resolve_capability(tool_name)
+                if res.get("status") == "resolved":
+                    worker_hint = res["worker"]["id"]
+                    _logger.info(f"[executor] capability '{tool_name}' risolta su worker: {worker_hint}")
+            except Exception as e:
+                _logger.debug(f"[executor] resolver bypass: {e}")
+
+        missing = [r for r in tool.get("required_inputs", []) if r not in inputs]
+        if missing:
+            return {"success": False, "error": f"Input mancanti: {missing}", "output": None}
+
+        session_id = _get_session_id()
+
+        # ── GAP-SKILL-SYNC v2: circuit breaker pre-check ──────────────────────
+        # Se il tool ha un Wilson score molto basso (< 0.15) con >= 3 dati in sessione,
+        # bypassa il tool e vai direttamente al miglior fallback disponibile.
+        if self._is_circuit_open(tool_name, session_id):
+            _logger.info(
+                "[executor] circuit OPEN per %s — routing diretto a fallback (Wilson < %.2f)",
+                tool_name, _CIRCUIT_OPEN_THRESHOLD,
+            )
+            fb_result = await self._try_fallbacks(tool_name, inputs, timeout, session_id)
+            if fb_result:
+                return fb_result
+            # Tutti i fallback falliti: procedi con il tool primario (ultima spiaggia)
+            _logger.warning(
+                "[executor] tutti i fallback di %s hanno fallito — provo comunque il tool primario",
+                tool_name,
+            )
+
+        # ── Esecuzione normale con retry ──────────────────────────────────────
+        fn = tool.get("_fn")
+        if fn is None:
+            return {"success": False, "error": "Tool non ha funzione di esecuzione", "output": None}
+
+        # P17-B1: syntax check pre-esecuzione — intercetta SyntaxError prima che il
+        # backend-exec spreci un round-trip su codice già rotto. Fail-open: tool non in
+        # mappa, ast_check non importato, o codice vuoto → nessun blocco.
+        if tool_name in _CODE_EXEC_TOOLS:
+            _code_arg, _code_lang = _CODE_EXEC_TOOLS[tool_name]
+            _raw_code = inputs.get(_code_arg, "")
+            if isinstance(_raw_code, str) and _raw_code.strip():
+                _syn = _check_syntax(_raw_code, _code_lang)
+                if not _syn.ok:
+                    _logger.warning(
+                        "[executor] P17-B1 syntax check failed per %s: %s",
+                        tool_name, _syn.error,
+                    )
+                    return {
+                        "success": False,
+                        "error": (
+                            f"SyntaxError pre-esecuzione [{_code_lang}]: {_syn.error}"
+                            + (f" — riga {_syn.line}" if _syn.line else "")
+                        ),
+                        "output": None,
+                        "syntax_check_failed": True,
+                    }
+
+        last_error: str = "max_retries"
+        for attempt in range(self.max_retries + 1):
+            try:
+                # S-ORCH-8GAP FIX-GAP2: usa timeout adattivo basato su P90 ultime 5 chiamate
+                _adaptive_to = _timeout_tracker.adaptive_timeout(tool_name, timeout)
+                _t0          = _time_mod.monotonic()
+                result       = await asyncio.wait_for(fn(**inputs), timeout=_adaptive_to)
+                _timeout_tracker.record(tool_name, _time_mod.monotonic() - _t0)
+
+                # Il tool ha già prodotto il side effect: la persistenza memoria
+                # è osservabilità e non deve riaprire il retry del tool.
+                _memory_persisted = True
+                _memory_error = None
+                if self.memory:
+                    try:
+                        # S577→S600: inputs 100→500 — parity con altri handler
+                        await self.memory.save_episode(
+                            "tool",
+                            f"{tool_name}: {str(inputs)[:500]}",
+                            str(result)[:500],
+                            True,
+                        )
+                    except Exception as _memory_exc:
+                        _memory_persisted = False
+                        _memory_error = f"{type(_memory_exc).__name__}: {str(_memory_exc)[:240]}"
+                        _logger.warning(
+                            "[executor] tool %s completato ma save_episode fallito; "
+                            "nessun retry del side effect: %s",
+                            tool_name,
+                            _memory_error,
+                        )
+                response = {
+                    "success": True,
+                    "tool": tool_name,
+                    "output": result,
+                    "attempt": attempt + 1,
+                    "memory_persisted": _memory_persisted,
+                }
+                if _memory_error:
+                    response["memory_error"] = _memory_error
+                return response
+
+            except asyncio.TimeoutError:
+                # FIX-GAP2: registra il timeout come durata massima per shrink futuro
+                _timeout_tracker.record(tool_name, timeout * 1.2)
+                last_error = f"Timeout dopo {timeout}s (tentativo {attempt + 1})"
+                if attempt == self.max_retries:
+                    # Ultima chance: prova i fallback ordinati per Wilson score
+                    _logger.info(
+                        "[executor] %s timeout definitivo — provo fallback Wilson-sorted",
+                        tool_name,
+                    )
+                    fb_result = await self._try_fallbacks(tool_name, inputs, timeout, session_id)
+                    if fb_result:
+                        return fb_result
+                    return {"success": False, "error": last_error, "output": None}
+                await asyncio.sleep(0.5)
+
+            except Exception as e:
+                last_error = str(e)
+                if attempt == self.max_retries:
+                    # Ultima chance: prova i fallback ordinati per Wilson score
+                    _logger.info(
+                        "[executor] %s errore definitivo (%s) — provo fallback Wilson-sorted",
+                        tool_name, last_error[:60],
+                    )
+                    fb_result = await self._try_fallbacks(tool_name, inputs, timeout, session_id)
+                    if fb_result:
+                        return fb_result
+                    return {"success": False, "error": last_error, "output": None}
+                await asyncio.sleep(0.5)
+
+        return {"success": False, "error": f"Max retries raggiunti: {last_error}", "output": None}
+

agents/file_conversion.py

@@ -0,0 +1,163 @@
+"""Conversioni tabellari deterministiche per dati CSV espliciti nel goal.
+
+Il modulo interpreta solo CSV allegati oppure richiesti con ``contenuto esatto:``.
+Non apre path arbitrari, non esegue istruzioni contenute nel file e non invoca LLM.
+"""
+from __future__ import annotations
+
+import csv
+import io
+import json
+import re
+from dataclasses import dataclass
+from typing import Any
+
+_ATTACHMENT_RE = re.compile(
+    r"###\s*📎\s*(?P<name>[^\n`]+?\.csv)\s*\([^\n]*\)\s*```\s*(?P<body>[\s\S]*?)```",
+    re.IGNORECASE,
+)
+# Il target può essere espresso come "file chiamato foo.json" oppure come
+# "poi crea foo.json". Il gruppo è limitato a nomi semplici, quindi il parser
+# non accetta path traversal o istruzioni aggiuntive.
+_TARGET_RE = re.compile(
+    r"(?:\b(?:chiamat[oa]|nome|denominat[oa]|come)\s+|\b(?:crea|scrivi)\s+)"
+    r"['`\"]?(?P<name>[\w.-]+\.json)\b",
+    re.IGNORECASE,
+)
+_CONVERSION_RE = re.compile(
+    r"\b(?:converti|trasforma|conversione|convert|transform)\b[\s\S]{0,240}\b(?:csv|json)\b",
+    re.IGNORECASE,
+)
+_INLINE_CSV_RE = re.compile(
+    r"\b(?:crea|scrivi)\s+(?P<name>[\w.-]+\.csv)\s+con\s+contenuto\s+esatto\s*:\s*"
+    r"(?P<body>[\s\S]*?)(?=\s*\.\s*(?:poi\s+)?(?:crea|scrivi)\s+[\w.-]+\.json\b|\Z)",
+    re.IGNORECASE,
+)
+
+
+@dataclass(frozen=True)
+class CsvJsonConversion:
+    source_name: str
+    target_name: str
+    content: str
+    row_count: int
+    source_content: str
+    source_is_inline: bool = False
+
+
+def _coerce_scalar(value: str) -> Any:
+    value = value.strip()
+    if re.fullmatch(r"-?(?:0|[1-9]\d*)", value):
+        return int(value)
+    if re.fullmatch(r"-?(?:0|[1-9]\d*)\.\d+", value):
+        return float(value)
+    return value
+
+
+def _csv_body(raw_body: str) -> str:
+    lines = raw_body.replace("\r\n", "\n").replace("\r", "\n").split("\n")
+    while lines and (not lines[0].strip() or lines[0].lstrip().startswith("## Foglio:")):
+        lines.pop(0)
+    return "\n".join(lines).strip()
+
+
+def _parse_csv_rows(csv_body: str) -> list[dict[str, Any]] | None:
+    """Legge CSV senza tollerare header/colonne ambigue o righe tronche."""
+    try:
+        reader = csv.DictReader(io.StringIO(csv_body))
+        raw_headers = reader.fieldnames
+        if not raw_headers:
+            return None
+        headers = [str(header or "").strip() for header in raw_headers]
+        if any(not header for header in headers) or len(set(headers)) != len(headers):
+            return None
+
+        rows: list[dict[str, Any]] = []
+        for raw_row in reader:
+            # DictReader usa None per colonne in eccesso e per celle mancanti.
+            if None in raw_row or any(raw_row.get(header) is None for header in raw_headers):
+                return None
+            row = {
+                headers[index]: _coerce_scalar(raw_row[raw_headers[index]] or "")
+                for index in range(len(headers))
+            }
+            rows.append(row)
+        return rows
+    except (csv.Error, UnicodeError):
+        return None
+
+
+def validate_csv_json_equivalence(csv_content: str, json_content: str) -> tuple[bool, str]:
+    """Verifica che il JSON sia l’array esatto dei record CSV normalizzati.
+
+    La verifica è intenzionalmente stretta: stessa cardinalità, stesso ordine,
+    stesse chiavi e stessi valori dopo la coercizione deterministica del CSV.
+    """
+    expected = _parse_csv_rows(_csv_body(csv_content))
+    if expected is None:
+        return False, "CSV non valido o ambiguo"
+    try:
+        actual = json.loads(json_content)
+    except (TypeError, json.JSONDecodeError):
+        return False, "JSON non valido"
+    if not isinstance(actual, list):
+        return False, "il JSON deve essere un array"
+    if any(not isinstance(record, dict) for record in actual):
+        return False, "ogni record JSON deve essere un oggetto"
+    if actual != expected:
+        return False, "i record JSON non corrispondono esattamente al CSV"
+    return True, ""
+
+
+def _build_conversion(source_name: str, target_name: str, raw_body: str, *, source_is_inline: bool) -> CsvJsonConversion | None:
+    csv_body = _csv_body(raw_body)
+    rows = _parse_csv_rows(csv_body)
+    if rows is None:
+        return None
+    content = json.dumps(rows, ensure_ascii=False, indent=2) + "\n"
+    is_valid, _reason = validate_csv_json_equivalence(csv_body, content)
+    if not is_valid:
+        # Difesa di coerenza interna: una conversione diretta non può dichiararsi
+        # riuscita se il proprio serializzatore non supera il medesimo contratto.
+        return None
+    return CsvJsonConversion(
+        source_name=source_name.strip(),
+        target_name=target_name.strip(),
+        content=content,
+        row_count=len(rows),
+        source_content=csv_body + "\n",
+        source_is_inline=source_is_inline,
+    )
+
+
+def convert_csv_attachment_to_json(goal: str) -> CsvJsonConversion | None:
+    """Converte un CSV allegato o esplicitamente incluso nel goal in JSON.
+
+    Il ritorno è ``None`` quando il goal non definisce una conversione tabellare
+    completa: il resto del loop conserva quindi il comportamento esistente.
+    """
+    if not _CONVERSION_RE.search(goal):
+        return None
+
+    target = _TARGET_RE.search(goal)
+    if not target:
+        return None
+
+    inline = _INLINE_CSV_RE.search(goal)
+    if inline:
+        return _build_conversion(
+            inline.group("name"),
+            target.group("name"),
+            inline.group("body"),
+            source_is_inline=True,
+        )
+
+    attachment = _ATTACHMENT_RE.search(goal)
+    if not attachment:
+        return None
+    return _build_conversion(
+        attachment.group("name"),
+        target.group("name"),
+        attachment.group("body"),
+        source_is_inline=False,
+    )

agents/goal_drift_detector.py

@@ -0,0 +1,143 @@
+"""
+goal_drift_detector.py — COG-5: Goal Drift Detector.
+
+Confronta il goal originale con lo stato exec_done ogni N subtask completati.
+Se l'agente si è allontanato dall'obiettivo, emette un segnale di drift
+che il loop principale usa per iniettare una micro-guida correttiva.
+
+Tutto sincrono e non-blocking: nessun I/O, nessuna chiamata LLM.
+Zero overhead su task senza drift (guard rapido in should_check_drift).
+"""
+from __future__ import annotations
+
+import re
+import logging
+from typing import Any
+
+_logger = logging.getLogger("agente_ai.goal_drift")
+
+# ── Costanti ──────────────────────────────────────────────────────────────────
+DRIFT_CHECK_EVERY_N: int      = 3     # check ogni 3 subtask completati
+DRIFT_OVERLAP_THRESHOLD: float = 0.25  # keyword overlap < 25% → drift
+_MIN_EXEC_DONE: int            = 2     # non controlla prima di 2 subtask completati
+
+_STOP_WORDS = frozenset({
+    # italiano
+    "il", "la", "lo", "le", "gli", "un", "una", "uno", "di", "del", "della",
+    "dei", "degli", "delle", "al", "alla", "ai", "agli", "alle", "dal",
+    "dalla", "dai", "dagli", "dalle", "nel", "nella", "nei", "negli", "nelle",
+    "sul", "sulla", "sui", "sugli", "sulle", "con", "per", "tra", "fra",
+    "non", "che", "come", "dove", "quando", "chi", "cosa", "quale", "questo",
+    "questa", "questi", "queste", "sono", "era", "essere", "fare", "fare",
+    # inglese
+    "the", "and", "for", "are", "but", "not", "you", "all", "any", "can",
+    "had", "her", "was", "one", "our", "out", "get", "has", "him", "his",
+    "how", "its", "may", "new", "now", "old", "see", "who", "did", "with",
+    "this", "that", "from", "they", "will", "been", "have", "were", "said",
+    "each", "she", "which", "their", "time", "than", "then", "into", "your",
+    "more", "make", "like", "also", "back", "after", "use", "work", "well",
+    "about", "would", "there", "could", "other", "some", "these", "those",
+})
+
+_KW_RE = re.compile(r'\b[a-zA-Z\xc0-\xff]{4,}\b')
+
+
+def _extract_keywords(text: str) -> frozenset[str]:
+    """Estrae keyword significative: >= 4 char, no stop-word."""
+    words = _KW_RE.findall(text.lower())
+    return frozenset(w for w in words if w not in _STOP_WORDS)
+
+
+def compute_drift_score(goal: str, exec_done: list[str]) -> float:
+    """
+    Calcola il drift score: 0.0 = nessun drift, 1.0 = drift totale.
+
+    Args:
+        goal:      goal originale dell'utente
+        exec_done: lista di stringhe "[subtask N — desc]: output"
+
+    Returns:
+        float in [0.0, 1.0] — quanto l'agente si è allontanato dal goal
+    """
+    if not exec_done:
+        return 0.0
+    goal_kws = _extract_keywords(goal)
+    if not goal_kws:
+        return 0.0  # goal senza keyword → nessun drift misurabile
+
+    exec_text = " ".join(exec_done)
+    exec_kws = _extract_keywords(exec_text)
+    if not exec_kws:
+        return 1.0  # output vuoto di significato → drift massimo
+
+    overlap = len(goal_kws & exec_kws)
+    return max(0.0, 1.0 - overlap / len(goal_kws))
+
+
+def should_check_drift(step_count: int, last_check: int) -> bool:
+    """
+    True se è ora di eseguire un drift check.
+
+    Controlla solo se:
+      - step_count >= _MIN_EXEC_DONE  (almeno 2 subtask completati)
+      - step_count - last_check >= DRIFT_CHECK_EVERY_N  (ogni 3 step)
+    """
+    return (
+        step_count >= _MIN_EXEC_DONE
+        and (step_count - last_check) >= DRIFT_CHECK_EVERY_N
+    )
+
+
+def detect_drift(
+    goal: str,
+    exec_done: list[str],
+    step_count: int,
+    last_check: int,
+) -> dict[str, Any]:
+    """
+    Punto di accesso principale per il rilevamento drift.
+
+    Args:
+        goal:       goal originale
+        exec_done:  subtask completati (lista stringhe)
+        step_count: numero corrente di subtask completati (len(exec_done))
+        last_check: step_count dell'ultimo check eseguito
+
+    Returns: {
+        checked:        bool   — True se la verifica è stata eseguita
+        drifted:        bool   — True se drift rilevato
+        score:          float  — drift score (0.0–1.0)
+        reason:         str    — spiegazione human-readable
+        new_last_check: int    — aggiornamento del counter
+    }
+    """
+    out: dict[str, Any] = {
+        "checked":        False,
+        "drifted":        False,
+        "score":          0.0,
+        "reason":         "",
+        "new_last_check": last_check,
+    }
+
+    if not should_check_drift(step_count, last_check):
+        return out
+
+    out["checked"]        = True
+    out["new_last_check"] = step_count
+
+    score       = compute_drift_score(goal, exec_done)
+    out["score"] = round(score, 3)
+
+    if score > (1.0 - DRIFT_OVERLAP_THRESHOLD):
+        out["drifted"] = True
+        goal_kws  = _extract_keywords(goal)
+        exec_kws  = _extract_keywords(" ".join(exec_done))
+        missing   = sorted(goal_kws - exec_kws)[:5]
+        out["reason"] = (
+            f"score={score:.2f}, keyword goal assenti nell'output: {missing}"
+        )
+        _logger.info("COG-5 drift rilevato: %s", out["reason"])
+    else:
+        _logger.debug("COG-5 no drift: score=%.2f step=%d", score, step_count)
+
+    return out

agents/goal_verifier.py

@@ -0,0 +1,580 @@
+"""
+goal_verifier.py — S403: GoalVerifier semantico + GAP-1 Hard Gate (esecuzione reale)
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+GAP-1: "The Hard Gate" — Execution-based Validation
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Trasforma la verifica da "ti sembra corretto?" a "funziona davvero?".
+
+Nuovo metodo: verify_with_execution()
+  1. Verifica semantica (verify() / verify_v2()) — invariata
+  2. Se semantic PASS + is_code_goal() → estrae il primo blocco Python/JS dalla risposta
+  3. Chiama _call_exec_engine (registry.py — già usato da unified_loop) con timeout 18s
+  4. Se exit_code != 0 → FAIL con traceback REALE come repair_hint (auto-healing)
+  5. Se exit_code == 0 → eleva coverage_score a 0.95 (prova concreta di correttezza)
+
+Invarianti rispettate:
+  - Silent failure totale: qualsiasi eccezione → ritorna risultato semantico invariato
+  - Zero regressioni: i metodi verify() e verify_v2() esistenti NON modificati
+  - Se EXEC_ENGINE_URL non configurato → _call_exec_engine ritorna None → fallback silente
+  - PR2: backend chiama i propri endpoint (registry._call_exec_engine) — no side-effect frontend
+  - B4: nessuna modifica al path SSE/asyncio.Queue
+  - Budget: asyncio.wait_for 18s — dentro il budget 20s del chiamante
+"""
+
+import asyncio
+import re
+import json
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any
+
+import logging
+_logger = logging.getLogger("agents.goal_verifier")
+
+
+# ── Sprint 1b: GoalVerificationStatus enum ────────────────────────────────────
+class GoalVerificationStatus(str, Enum):
+    PASS    = "PASS"
+    FAIL    = "FAIL"
+    UNKNOWN = "UNKNOWN"
+
+RETRY_THRESHOLD  = 0.30  # S-BENCH-FIX: meno punitivo su near-misses
+MAX_GOAL_CHARS   = 400
+MAX_ANS_CHARS    = 1500
+MAX_HINT_CHARS   = 150
+
+_COMPLEX_CODE_RE = re.compile(
+    r"\b(crea|genera|scrivi|implementa|sviluppa|costruisci|aggiorna|"
+    r"create|generate|implement|build|refactor|"
+    r"sistema|correggi|debugga|ottimizza|migra|ristruttura|refactorizza|"
+    r"patch|rinomina|sostituisci|rimpiazza|converti|trasforma|"
+    r"optimize|migrate|patch|rename|replace|convert|transform|restructure|"
+    r"app|applicazione|dashboard|api|rest|backend|frontend|"
+    r"componente|component|pagina|page|schema|database|db|"
+    r"typescript|python|react|vue|flask|fastapi|express|node\.js|"
+    r"svelte|angular|next\.?js|nuxt|remix|astro|nest\.?js|"
+    r"django|rails|laravel|spring|kotlin|rust|go|java|dart|flutter|"
+    r"graphql|grpc|websocket|docker|kubernetes|"
+    r"prisma|drizzle|sqlalchemy|mongoose|sequelize|"
+    r"service|repository|controller|middleware|"
+    r"platform|piattaforma|sistema|e.?commerce|chatbot|saas|cms|crm)\b",
+    re.IGNORECASE,
+)
+
+_SIMPLE_RE = re.compile(
+    r"^\s*(ciao|grazie|ok|perfetto|capito|bene|ottimo|esatto|sì|no|"
+    r"hi|hello|thanks|got it|yes|no|"
+    r"bravo|benissimo|magnifico|fantastico|giusto|corretto|esattamente|"
+    r"d['\u2019]accordo|inteso|compreso|capisco|ho capito|"
+    r"sì grazie|no grazie|va bene|"
+    # B-GAP-D: +IT confirmations mancanti (certo/naturalmente/assolutamente/prego/nessun problema)
+    r"certo|certamente|naturalmente|assolutamente|ovviamente|prego|fatto|"
+    r"nessun problema|figurati|con piacere|volentieri|pronto|"
+    # B-GAP-D: +EN confirmations mancanti (no problem/sounds good/cool/okay/np/awesome)
+    r"ty|thx|great|nice|perfect|exactly|understood|sure|right|agreed|"
+    r"makes sense|correct|good|no problem|np|sounds good|cool|okay|"
+    r"awesome|yep|nope|roger|copy that|will do|got it|works for me)\b",
+    re.IGNORECASE,
+)
+
+_VERIFIER_SYSTEM = (
+    "Sei un valutatore tecnico. Rispondi SOLO con JSON valido, senza testo aggiuntivo.\n"
+    "Dato un GOAL e la RISPOSTA dell'agente, valuta:\n"
+    "1. score (float 0.0-1.0): quanto la risposta affronta concretamente il goal\n"
+    "2. missing (lista, max 3 voci): cosa manca o è incompleto (vuoto se score>0.6)\n"
+    "3. hint (stringa, max 15 parole): cosa aggiungere per completare (vuoto se score>0.6)\n\n"
+    'Formato ESATTO: {"score": 0.8, "missing": ["voce1"], "hint": "testo breve"}'
+)
+
+# ── GAP-1: regex estrazione code block dalla risposta LLM ─────────────────────
+# Cerca ```python ... ``` o ```js ... ``` — primo blocco valido da eseguire.
+# Fallback: cerca blocco generico ``` ... ``` se nessun linguaggio specificato.
+_CODE_BLOCK_PY_RE = re.compile(
+    r"```(?:python|py)\s*\n([\s\S]+?)```",
+    re.IGNORECASE,
+)
+_CODE_BLOCK_JS_RE = re.compile(
+    r"```(?:javascript|js|node)\s*\n([\s\S]+?)```",
+    re.IGNORECASE,
+)
+# GAP-4: TypeScript/TSX regex — 60%+ dei task generano TS/TSX
+_CODE_BLOCK_TS_RE = re.compile(
+    r"```(?:typescript|ts|tsx)\s*\n([\s\S]+?)```",
+    re.IGNORECASE,
+)
+_CODE_BLOCK_GENERIC_RE = re.compile(
+    r"```\w*\s*\n([\s\S]+?)```",
+)
+
+def _extract_first_executable_block(response: str) -> tuple[str, str] | None:
+    """
+    Estrae il primo blocco di codice eseguibile dalla risposta LLM.
+
+    Returns:
+        (code, lang) oppure None se nessun blocco trovato.
+        lang: "python" | "javascript"
+    """
+    m = _CODE_BLOCK_PY_RE.search(response)
+    if m:
+        code = m.group(1).strip()
+        if len(code) > 10:
+            return code, "python"
+
+    # GAP-4: TypeScript/TSX — prima cadevano nel fallback python con ModuleNotFoundError
+    m = _CODE_BLOCK_TS_RE.search(response)
+    if m:
+        code = m.group(1).strip()
+        if len(code) > 10:
+            return code, "typescript"
+
+    m = _CODE_BLOCK_JS_RE.search(response)
+    if m:
+        code = m.group(1).strip()
+        if len(code) > 10:
+            return code, "javascript"
+
+    # Fallback blocco generico — assumiamo python (il più comune)
+    m = _CODE_BLOCK_GENERIC_RE.search(response)
+    if m:
+        code = m.group(1).strip()
+        if len(code) > 10 and not code.startswith("<"):  # esclude HTML
+            return code, "python"
+
+    return None
+
+
+@dataclass
+class GoalVerifyResult:
+    goal_met:            bool
+    coverage_score:      float
+    missing_items:       list[str] = field(default_factory=list)
+    repair_hint:         str = ""
+    verification_status: GoalVerificationStatus = GoalVerificationStatus.UNKNOWN
+    # GAP-1: nuovo campo — True se la validazione è avvenuta via esecuzione reale
+    execution_validated: bool = False
+
+
+class GoalVerifier:
+    """
+    S403: verifica semantica del goal post-generazione.
+    GAP-1: aggiunge verify_with_execution() per validazione via esecuzione reale.
+    """
+
+    _CODE_RE = re.compile(
+        r"\b(crea|genera|scrivi|fai|implementa|sviluppa|costruisci|aggiorna|modifica|"
+        r"aggiungi|refactoriz|ottimiz|migra|converte?|trasforma|estendi|"
+        r"sistema|sistemi|sistemiamo|correggi|corregge|correggere|"
+        r"debugga|debuggi|patch|patcha|patchar|rinomina|rinominare|"
+        r"sostituisci|sostituire|rimpiazza|rimpiazzare|"
+        r"create|generate|write|implement|build|make|update|add|fix|refactor|"
+        r"optimize|migrate|convert|transform|extend|scaffold|bootstrap|deploy|"
+        r"patch|rename|replace|delete|remove|"
+        r"app|sito|website|pagina|page|script|funzion|function|class|component|"
+        r"api|endpoint|route|handler|controller|middleware|service|repository|"
+        r"html|css|scss|sass|javascript|typescript|python|ruby|go|rust|java|kotlin|swift|"
+        r"react|vue|svelte|angular|next\.?js|nuxt|remix|astro|"
+        r"flask|fastapi|django|express|nestjs|rails|laravel|"
+        r"node|deno|bun|docker|dockerfile|nginx|github.*action|workflow\.yml|"
+        r"database|schema|migration|model|table|index|query|"
+        r"test|spec|fixture|mock|unit.*test|integration.*test)\b",
+        re.IGNORECASE,
+    )
+
+    _FILE_CONVERSION_RE = re.compile(
+        r"\b(?:converti|trasforma|conversione|convert|transform)\b[\s\S]{0,240}"
+        r"\b(?:csv|tsv|xlsx|xls|json|pdf|txt|markdown|md|docx)\b",
+        re.IGNORECASE,
+    )
+    _IMPLEMENTATION_CONTEXT_RE = re.compile(
+        r"\b(?:codice|script|funzione|function|class|componente|component|api|endpoint|"
+        r"typescript|javascript|python|react|backend|frontend|test\s+unit|test\s+e2e)\b",
+        re.IGNORECASE,
+    )
+
+    _EXPLANATION_RE = re.compile(
+        r"\b(spiega|spiegami|descr(?:ivi|ivi|izione)|cos.?è|come funziona|"
+        r"qual.?è la differenza|differenza tra|confronta|analiz|riassumi|riassunto|"
+        r"explain|describe|what is|how does|how do|compare|summarize|summarise|"
+        r"difference between|pros and cons|vantaggi|svantaggi|"
+        r"cosa significa|cosa vuol dire|significato di)\b",
+        re.IGNORECASE,
+    )
+
+    @classmethod
+    def is_code_goal(cls, goal: str) -> bool:
+        # Gli allegati sono serializzati dopo questo separatore: non devono trasformare
+        # una semplice lettura/conversione in un task di sviluppo da riparare.
+        user_goal = goal.split("--- **File allegati:**", 1)[0][:500]
+        if (cls._FILE_CONVERSION_RE.search(user_goal)
+                and not cls._IMPLEMENTATION_CONTEXT_RE.search(user_goal)):
+            return False
+        return bool(cls._CODE_RE.search(user_goal))
+
+    @classmethod
+    def adaptive_threshold(cls, goal: str) -> float:
+        g = goal.strip()
+        if _SIMPLE_RE.match(g):
+            return 0.28
+        if cls._EXPLANATION_RE.search(g[:500]) and not cls._CODE_RE.search(g[:500]):
+            return 0.25
+        if _COMPLEX_CODE_RE.search(g[:500]):
+            return 0.48  # S-BENCH-FIX: 0.55 -> 0.48 bilanciamento rigore
+        if cls._CODE_RE.search(g[:500]):
+            return 0.38  # S-BENCH-FIX: 0.42 -> 0.38
+        return RETRY_THRESHOLD
+
+    def __init__(self, llm: Any) -> None:
+        self.llm = llm
+
+    # ── Metodi semantici originali (invariati) ────────────────────────────────
+
+    async def verify(self, goal: str, response: str) -> GoalVerifyResult:
+        goal_short = goal[:MAX_GOAL_CHARS]
+        ans_short  = response[:MAX_ANS_CHARS]
+        msgs = [
+            {"role": "system", "content": _VERIFIER_SYSTEM},
+            {"role": "user",   "content": f"GOAL: {goal_short}\n\nRISPOSTA:\n{ans_short}"},
+        ]
+        try:
+            raw = await self.llm.chat(msgs, temperature=0.0, max_tokens=200)
+            if not raw or raw.startswith("[LLM"):
+                return self._default_ok()
+            return self._parse(raw)
+        except Exception:
+            return self._default_ok()
+
+    async def verify_v2(
+        self,
+        goal: str,
+        response: str,
+        requirements: "list | None" = None,
+    ) -> "GoalVerifyResult":
+        if not requirements:
+            return await self.verify(goal, response)
+
+        try:
+            from api.state import increment_stat as _inc
+            _inc("goal_verifier_v2_used")
+        except Exception as _exc:
+            _logger.debug("[goal_verifier] silenced %s", type(_exc).__name__)  # noqa: BLE001
+
+        threshold = self.adaptive_threshold(goal)
+        ans_short = response[:MAX_ANS_CHARS]
+        per_req: dict[str, str] = {}
+        failed_reqs: list[str] = []
+        failed_hints: list[str] = []
+
+        for req in requirements[:6]:
+            req_id     = getattr(req, "id", "unknown")
+            req_name   = getattr(req, "feature", req_id)
+            criteria   = getattr(req, "acceptance_criteria", [])
+
+            if not criteria:
+                per_req[req_id] = GoalVerificationStatus.UNKNOWN
+                continue
+
+            criteria_text = "\n".join(f"- {c}" for c in criteria[:5])
+            check_prompt  = (
+                f"Requisito: {req_name}\n"
+                f"Criteri:\n{criteria_text}\n\n"
+                f"Risposta agente:\n{ans_short[:600]}\n\n"
+                "La risposta soddisfa i criteri? Rispondi SOLO: PASS oppure FAIL"
+            )
+            msgs = [
+                {"role": "system", "content":
+                    "Sei un validatore. Rispondi SOLO con PASS o FAIL — nessun altro testo."},
+                {"role": "user", "content": check_prompt},
+            ]
+            try:
+                raw = await self.llm.chat(msgs, temperature=0.0, max_tokens=10)
+                verdict = "PASS" if raw and "PASS" in raw.upper() else "FAIL"
+            except Exception:
+                verdict = "UNKNOWN"
+
+            per_req[req_id] = verdict
+            if verdict == "FAIL":
+                failed_reqs.append(req_name)
+                if criteria:
+                    failed_hints.append(f"{req_name}: {criteria[0]}")
+
+        n_known = sum(1 for v in per_req.values() if v != "UNKNOWN")
+        n_pass  = sum(1 for v in per_req.values() if v == "PASS")
+        score   = (n_pass / n_known) if n_known > 0 else 0.5
+
+        overall_pass = score >= threshold and not failed_reqs
+        hint = "; ".join(failed_hints[:4]) if failed_hints else ""
+        if failed_reqs:
+            hint = f"Requisiti FAIL: {', '.join(failed_reqs[:5])}. {hint}"
+
+        status = (
+            GoalVerificationStatus.PASS    if overall_pass
+            else GoalVerificationStatus.FAIL if failed_reqs
+            else GoalVerificationStatus.UNKNOWN
+        )
+
+        return GoalVerifyResult(
+            goal_met             = overall_pass,
+            coverage_score       = round(score, 3),
+            missing_items        = failed_reqs[:5],
+            repair_hint          = hint[:MAX_HINT_CHARS],
+            verification_status  = status,
+        )
+
+    # ── GAP-1: Hard Gate — verify_with_execution ──────────────────────────────
+
+    async def verify_with_execution(
+        self,
+        goal: str,
+        response: str,
+        requirements: "list | None" = None,
+    ) -> "GoalVerifyResult":
+        """
+        GAP-1 Hard Gate: verifica semantica + esecuzione reale del codice generato.
+
+        Flusso:
+          1. verify_v2() / verify() → semantic check (invariato)
+          2. Se semantic FAIL → return immediatamente (no point in running bad code)
+          3. Se goal NON è di codice → return semantic result (no code to run)
+          4. Estrai primo blocco Python/JS dalla risposta
+          5. Se nessun blocco → return semantic result
+          6. Chiama _call_exec_engine (backend-exec microservice) con timeout 18s
+          7. Se None (non configurato) → return semantic result (silent fallback)
+          8. Se exit_code != 0 → FAIL con traceback REALE come repair_hint
+          9. Se exit_code == 0 → PASS con coverage_score elevato a 0.95
+
+        Budget: asyncio.wait_for 18s (dentro il budget 20s del chiamante tipico).
+        Silent failure: qualsiasi eccezione → ritorna semantic_result invariato.
+        Zero regressioni: se exec non disponibile → identico a verify_v2().
+        """
+        # Step 1: semantic check (invariato — tutte le path esistenti preservate)
+        semantic_result = await self.verify_v2(goal, response, requirements)
+
+        # Step 2: se semantic FAIL → blocco immediato (non eseguire codice scorretto)
+        if not semantic_result.goal_met:
+            return semantic_result
+
+        # Step 3: se non è un goal di codice → nessun blocco da estrarre
+        if not self.is_code_goal(goal):
+            return semantic_result
+
+        try:
+            # Step 4: estrai primo blocco eseguibile
+            extracted = _extract_first_executable_block(response)
+            if not extracted:
+                return semantic_result  # nessun code block → solo semantica
+
+            code_to_run, lang = extracted
+
+            # Filtra codice che potrebbe essere solo dichiarativo/doc
+            # (meno di 2 righe reali = probabilmente un frammento, non eseguibile)
+            real_lines = [l for l in code_to_run.splitlines() if l.strip() and not l.strip().startswith('#')]
+            if len(real_lines) < 2:
+                return semantic_result
+
+            # GAP-4: TypeScript/TSX — usa _ts_syntax_check (node --check)
+            if lang == "typescript":
+                try:
+                    import tempfile as _tmp, os as _os
+                    from tools.registry import _ts_syntax_check as _tsc
+                    with _tmp.NamedTemporaryFile(suffix=".ts", mode="w", delete=False) as _tf:
+                        _tf.write(code_to_run); _tf_path = _tf.name
+                    try:
+                        _ts_ok, _ts_err = await asyncio.wait_for(_tsc(_tf_path), timeout=12.0)
+                        if not _ts_ok:
+                            return GoalVerifyResult(
+                                goal_met=False, coverage_score=0.30,
+                                missing_items=["errore sintassi TypeScript"],
+                                repair_hint=f"TypeScript error: {_ts_err[:300]}",
+                                verification_status=GoalVerificationStatus.FAIL,
+                                execution_validated=True,
+                            )
+                        return GoalVerifyResult(
+                            goal_met=True, coverage_score=0.90, missing_items=[],
+                            repair_hint="",
+                            verification_status=GoalVerificationStatus.PASS,
+                            execution_validated=True,
+                        )
+                    finally:
+                        try: _os.unlink(_tf_path)
+                        except OSError: pass  # temp file cleanup — solo errori OS attesi
+                except Exception:
+                    return semantic_result
+
+            # P26-B1: Python AST pre-check — compile() built-in, zero latenza, zero roundtrip.
+            # Equivalente a GAP-4 (TypeScript node --check). Cattura SyntaxError prima dell'exec engine.
+            if lang == "python":
+                try:
+                    compile(code_to_run, "<goal_verifier>", "exec")
+                except SyntaxError as _syn:
+                    _syn_hint = f"[SYNTAX ERROR] {type(_syn).__name__}: {_syn.msg} (riga {_syn.lineno})"
+                    _logger.debug("P26-B1 Python AST fail: %s", _syn_hint)
+                    try:
+                        from api.state import increment_stat as _inc_syn
+                        _inc_syn("goal_verifier_py_syntax_fail")
+                    except Exception:
+                        pass
+                    return GoalVerifyResult(
+                        goal_met            = False,
+                        coverage_score      = 0.25,
+                        missing_items       = ["errore di sintassi Python nel codice generato"],
+                        repair_hint         = _syn_hint,
+                        verification_status = GoalVerificationStatus.FAIL,
+                        execution_validated = True,
+                    )
+
+            # Step 5: chiama backend-exec (registry._call_exec_engine)
+            try:
+                from tools.registry import _call_exec_engine as _exec_fn
+            except ImportError:
+                return semantic_result  # registry non disponibile — silent fallback
+
+            # Step 6: esecuzione reale con timeout conservativo
+            exec_result: dict | None = None
+            try:
+                exec_result = await asyncio.wait_for(
+                    _exec_fn({"code": code_to_run, "lang": lang, "timeout": 15}),
+                    timeout=18.0,
+                )
+            except (asyncio.TimeoutError, Exception):
+                return semantic_result  # timeout o errore → silent fallback
+
+            # Step 7: se exec non configurato → fallback silente
+            if exec_result is None:
+                return semantic_result
+
+            # Step 8: analisi risultato esecuzione
+            exit_code = exec_result.get("exit_code", -1)
+            stdout    = (exec_result.get("stdout") or "")[:400]
+            stderr    = (exec_result.get("stderr") or "")[:400]
+            combined  = (stdout + stderr).strip()
+
+            if exit_code != 0:
+                # FAIL categorico con traceback reale — feeding self-healing loop
+                traceback_hint = f"[EXEC FAIL exit={exit_code}]: {combined[:300]}"
+                try:
+                    from api.state import increment_stat as _inc
+                    _inc("goal_verifier_exec_fail")
+                except Exception as _exc:
+                    _logger.debug("[goal_verifier] silenced %s", type(_exc).__name__)  # noqa: BLE001
+                return GoalVerifyResult(
+                    goal_met             = False,
+                    coverage_score       = 0.0,
+                    missing_items        = ["il codice generato fallisce all'esecuzione"],
+                    repair_hint          = traceback_hint,
+                    verification_status  = GoalVerificationStatus.FAIL,
+                    execution_validated  = True,
+                )
+
+            # Step 9: exit_code == 0 → PASS con prova concreta
+            try:
+                from api.state import increment_stat as _inc
+                _inc("goal_verifier_exec_pass")
+            except Exception as _exc:
+                _logger.debug("[goal_verifier] silenced %s", type(_exc).__name__)  # noqa: BLE001
+
+            return GoalVerifyResult(
+                goal_met             = True,
+                coverage_score       = 0.95,  # prova reale > verifica semantica
+                missing_items        = [],
+                repair_hint          = "",
+                verification_status  = GoalVerificationStatus.PASS,
+                execution_validated  = True,
+            )
+
+        except Exception:
+            # Qualsiasi eccezione non gestita → silent fallback al risultato semantico
+            return semantic_result
+
+    # ── Parsing ───────────────────────────────────────────────────────────────
+
+    @staticmethod
+    def _parse(raw: str) -> "GoalVerifyResult":
+        m = re.search(r"\{[^{}]+\}", raw, re.DOTALL)
+        if not m:
+            return GoalVerifier._default_ok()
+        try:
+            d = json.loads(m.group())
+            score   = float(d.get("score", 1.0))
+            score   = max(0.0, min(1.0, score))
+            missing = [str(x)[:200] for x in (d.get("missing") or [])[:3]]
+            hint    = str(d.get("hint") or "")[:MAX_HINT_CHARS]
+            is_pass = score >= RETRY_THRESHOLD
+            return GoalVerifyResult(
+                goal_met             = is_pass,
+                coverage_score       = score,
+                missing_items        = missing,
+                repair_hint          = hint,
+                verification_status  = GoalVerificationStatus.PASS if is_pass else GoalVerificationStatus.FAIL,
+            )
+        except Exception:
+            return GoalVerifier._default_ok()
+
+    @staticmethod
+    def _default_ok() -> "GoalVerifyResult":
+        return GoalVerifyResult(
+            goal_met=False,
+            coverage_score=0.5,
+            repair_hint="[verifier_unavailable — esito incerto]",
+            verification_status=GoalVerificationStatus.UNKNOWN,
+        )
+
+
+# ── S-CRITIC-1: CriticJudge (invariato) ──────────────────────────────────────
+
+_CRITIC_SYSTEM = (
+    "Sei un validatore tecnico indipendente. Rispondi SOLO con JSON valido, senza testo extra.\n"
+    "Dato un GOAL e la RISPOSTA dell'agente AI, giudica se la risposta affronta\n"
+    "concretamente e sufficientemente il goal richiesto.\n"
+    "Non cercare la perfezione: valuta solo se è utile, pertinente, e sostanzialmente corretta.\n\n"
+    'Formato ESATTO: {"verdict": "PASS", "confidence": 0.8, "reason": "max 10 parole"}\n'
+    'verdict: "PASS" se la risposta soddisfa il goal in modo sufficiente, "FAIL" altrimenti.\n'
+    'confidence: float 0.0–1.0 — certezza del verdetto.\n'
+    'reason: stringa, max 10 parole — motivazione sintetica.'
+)
+
+
+@dataclass
+class CriticVerdict:
+    verdict:    str
+    confidence: float = 0.0
+    reason:     str   = ""
+
+
+class CriticJudge:
+    """S-CRITIC-1: Critic on-demand — secondo parere LLM quando GoalVerifier è UNKNOWN."""
+
+    def __init__(self, llm: Any) -> None:
+        self.llm = llm
+
+    async def judge(self, goal: str, response: str) -> CriticVerdict:
+        goal_short = goal[:300]
+        ans_short  = response[:1200]
+        msgs = [
+            {"role": "system", "content": _CRITIC_SYSTEM},
+            {"role": "user",   "content": f"GOAL: {goal_short}\n\nRISPOSTA:\n{ans_short}"},
+        ]
+        try:
+            raw = await self.llm.chat(msgs, temperature=0.0, max_tokens=60)
+            if not raw or raw.startswith("[LLM"):
+                return CriticVerdict(verdict="UNAVAILABLE")
+            return self._parse(raw)
+        except Exception:
+            return CriticVerdict(verdict="UNAVAILABLE")
+
+    @staticmethod
+    def _parse(raw: str) -> CriticVerdict:
+        m = re.search(r"\{[^{}]+\}", raw, re.DOTALL)
+        if not m:
+            return CriticVerdict(verdict="UNAVAILABLE")
+        try:
+            d          = json.loads(m.group())
+            verdict    = str(d.get("verdict", "UNAVAILABLE")).upper().strip()
+            confidence = float(d.get("confidence", 0.5))
+            reason     = str(d.get("reason", ""))[:100]
+            if verdict not in ("PASS", "FAIL"):
+                verdict = "UNAVAILABLE"
+            return CriticVerdict(verdict=verdict, confidence=max(0.0, min(1.0, confidence)), reason=reason)
+        except Exception:
+            return CriticVerdict(verdict="UNAVAILABLE")

agents/html_fast_path.py

@@ -0,0 +1,60 @@
+"""Classificazione locale del fast path per mini-app HTML a file singolo.
+
+Il classificatore è deliberatamente conservativo: in caso di dubbio restituisce
+False. Non usa LLM, rete o stato globale e quindi non aggiunge latenza misurabile.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import re
+
+
+@dataclass(frozen=True)
+class HtmlFastPathDecision:
+    eligible: bool
+    reason: str
+    path: str = "index.html"
+
+
+_HTML_RE = re.compile(r"\b(?:html5?|html|pagina\s+web|single[- ]page|landing\s+page)\b", re.I)
+_CREATE_RE = re.compile(r"\b(?:crea|genera|scrivi|realizza|implementa|build|create|generate|make)\b", re.I)
+_SINGLE_FILE_RE = re.compile(
+    r"\b(?:un\s+solo\s+file|singolo\s+file|one\s+file|single\s+file|file\s+unico)\b", re.I
+)
+_PATH_RE = re.compile(r"(?<![\w./-])([\w./-]+\.html)(?![\w.-])", re.I)
+_FORBIDDEN_RE = re.compile(
+    r"\b(?:deploy|pubblica|publish|rilascia|release|github|git|npm|pnpm|yarn|install|"
+    r"api|backend|server|database|db|auth|login|pagamento|payment|webhook|secret|token|"
+    r"shell|bash|terminal|esegui\s+comandi|execute\s+commands|multi[- ]file|pi[uù]\s+file|"
+    r"react|vue|angular|next(?:\.js)?|vite|typescript|python|sql)\b",
+    re.I,
+)
+_EXTERNAL_RE = re.compile(r"\b(?:fetch|axios|websocket|stripe|supabase|firebase|oauth)\b|https?://", re.I)
+
+
+def classify_html_fast_path(goal: str) -> HtmlFastPathDecision:
+    """Return an eligible decision only for a safe, self-contained HTML request."""
+    text = " ".join(str(goal or "").split())
+    if not text:
+        return HtmlFastPathDecision(False, "empty_goal")
+    if len(text) > 500:
+        return HtmlFastPathDecision(False, "goal_too_long")
+    if not _HTML_RE.search(text):
+        return HtmlFastPathDecision(False, "not_html_goal")
+    if not _CREATE_RE.search(text):
+        return HtmlFastPathDecision(False, "not_creation_goal")
+    if not _SINGLE_FILE_RE.search(text):
+        return HtmlFastPathDecision(False, "single_file_not_explicit")
+    if _FORBIDDEN_RE.search(text):
+        return HtmlFastPathDecision(False, "contains_project_or_sensitive_operation")
+    if _EXTERNAL_RE.search(text):
+        return HtmlFastPathDecision(False, "external_dependency_or_network")
+
+    paths = _PATH_RE.findall(text)
+    path = paths[0] if paths else "index.html"
+    if "/" in path or path.startswith("."):
+        return HtmlFastPathDecision(False, "nested_path_not_allowed", path)
+    return HtmlFastPathDecision(True, "self_contained_single_html", path)
+
+
+__all__ = ["HtmlFastPathDecision", "classify_html_fast_path"]

agents/planner.py

@@ -0,0 +1,397 @@
+"""
+planner.py — Speculative Hybrid Planner (Gap-5: eliminazione bottleneck sequenziale)
+
+Architettura:
+  FASE 1  Quick-Start Draft   < 500ms  Cerebras gpt-oss-120b (o Groq 8B fallback)
+           Genera 2-3 subtask immediati → agente parte istantaneamente.
+  FASE 2  Master Plan         background  DeepSeek-R1 via OpenRouter
+           Piano architetturale completo; raffina i passi successivi.
+  FASE 3  Parallel Sub-Graphs  —        Campo `parallel_groups` nel JSON
+           Rami indipendenti (es. Backend vs Frontend) identificati esplicitamente.
+
+Compatibilità backward: `create_plan()` restituisce sempre dict con "subtasks".
+Flag `_speculative: True` → piano quick-start; `_speculative: False` → master plan.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import re
+from models.ai_client import AIClient
+
+_logger = logging.getLogger("agente_ai")
+
+# ── Prompt master (DeepSeek-R1): piano architetturale completo ───────────────
+
+PLANNER_SYSTEM = """Sei un planner AI avanzato. Dato un obiettivo, decomponilo in subtask concreti.
+
+Rispondi SOLO con JSON valido nel formato:
+{
+  "goal": "obiettivo originale",
+  "complexity": "low|medium|high",
+  "data_model": [
+    {"entity": "NomeEntità", "fields": ["id: str", "campo1: tipo", "campo2: tipo"]}
+  ],
+  "api_contract": [
+    {"method": "GET|POST|PUT|DELETE", "path": "/api/risorsa", "body": {}, "response": {"campo": "tipo"}}
+  ],
+  "subtasks": [
+    {
+      "id": 1,
+      "description": "cosa fare",
+      "tool": "<tool>",
+      "requires": [],
+      "risk": "low|medium|high",
+      "priority": "low|medium|high"
+    }
+  ],
+  "parallel_groups": [[1,2],[3,4,5]],
+  "estimated_steps": 3,
+  "impacted_files": []
+}
+
+data_model: lista di entità dati con i loro campi tipizzati (SOLO per goal con entità persistenti).
+  - Ogni entità: {"entity": "Nome", "fields": ["campo: tipo", ...]}
+  - Esempi di tipi: str, int, float, bool, datetime, list[str], dict.
+  - Lascia [] per task senza entità dati (web search, domande, spiegazioni, singole funzioni).
+  - P25-B5: definisci data_model PRIMA dei subtask di codice — è il contratto condiviso tra tutti i subtask.
+  - I subtask di codice DEVONO referenziare le entità definite qui, MAI inventare nomi diversi on-the-fly.
+
+api_contract: endpoint REST/GraphQL con shape request+response (SOLO per goal con interfaccia API).
+  - Ogni endpoint: {"method": "GET", "path": "/api/path", "body": {"campo": "tipo"}, "response": {"campo": "tipo"}}
+  - Lascia [] per task senza endpoint API (script standalone, funzioni pure, task di analisi).
+  - P25-B5: il primo subtask di codice backend DEVE implementare esattamente questo contratto.
+  - MAI aggiungere endpoint non dichiarati qui senza aggiornare api_contract nel piano.
+
+parallel_groups: lista di liste di id subtask che possono girare in PARALLELO tra loro.
+  - Ogni lista interna = un gruppo di subtask eseguibili contemporaneamente (nessuna dipendenza reciproca).
+  - Subtask con requires:[] vanno sempre in un gruppo parallelo.
+  - Esempio: backend (id:1,2) e frontend (id:3,4) senza dipendenze reciproche → [[1,2],[3,4]].
+  - Se tutto è sequenziale: [[1],[2],[3]].
+
+impacted_files: lista di path file VFS che potrebbero essere impattati (vuota se non applicabile).
+
+Tool disponibili:
+  web_search     — cerca informazioni online in tempo reale
+  code           — genera/modifica codice (Python, TS, JS, etc.)
+  read_page      — legge una pagina web per URL
+  memory         — accede a dati precedentemente memorizzati
+  direct_response — risposta diretta senza tool esterni
+  send_email     — invia email via Resend
+  database_query — esegue query su database PostgreSQL/SQLite
+  web_research   — ricerca approfondita multi-fonte con sintesi AI
+  execute_sql    — esegue SQL su dati in-memory
+  create_pdf     — genera un documento PDF
+  call_api       — chiama un REST API esterno
+  generate_image — genera un'immagine AI
+  run_python     — esegue codice Python in sandbox sicura
+  write_file     — scrive un file nel filesystem virtuale (risk: medium)
+  read_file      — legge un file dal filesystem virtuale (risk: low)
+  apply_patch    — applica una patch unificata a un file (risk: medium)
+  execute_shell  — esegue un comando shell in sandbox (risk: high)
+  directory_tree — elenca struttura ad albero di una directory (risk: low)
+  file_search    — cerca pattern nei file con grep (risk: low)
+  git_status     — mostra branch corrente e file modificati (risk: low)
+  git_clone      — clona una repo remota (risk: medium)
+  git_diff       — mostra modifiche in sospeso (risk: low)
+  git_commit     — esegue add -A + commit (risk: medium)
+  npm_install    — installa dipendenze node (risk: medium)
+  npm_run        — esegue script node (risk: medium)
+  pip_install    — installa pacchetti Python (risk: medium)
+  type_check     — type check tsc o mypy (risk: low)
+  scaffold_project — crea struttura progetto da template (risk: medium)
+  delegate_task  — delega un sotto-obiettivo a un micro-agente indipendente (risk: low)
+
+
+REGOLA TASK SEMPLICI (S-ROBUSTNESS): Se il task chiede una singola funzione TypeScript pura
+  (sum, add, calculate, map, filter) anche se il prompt ha rumore/distrazioni/noise:
+  → piano con 1 SOLO subtask: tool=direct_response
+  → MAI run_python, type_check o npm_run per funzioni TypeScript di 1-3 righe
+
+REGOLA DATA INTEGRITY (S-RECOVERY): Prima di pianificare analisi su dati numerici:
+  - Controlla: conversion rate > 100%? conversioni > utenti? → IMPOSSIBILE
+  - Se dati impossibili → piano con SOLO 1 subtask: tool=direct_response
+    description: "segnala anomalia nei dati: incoerente/impossibile, non calcolare"
+  - MAI pianificare run_python/execute_sql su dati statisticamente impossibili
+
+REGOLA ASSOLUTA (S-GAP2): Per qualsiasi richiesta di creazione app/progetto/boilerplate,
+DEVI verificare se esiste scaffold_project corrispondente. Se esiste → PRIMO subtask.
+
+REGOLA ORCHESTRATION (S-GAP9): Per task complessi (>5 passi), includi SEMPRE un subtask finale di "Verifica Integrazione e Test End-to-End".
+Scomponi i rami Backend e Frontend in parallel_groups separati per massimizzare l'efficienza.
+
+REGOLA RECOVERY & ROBUSTNESS (S-GAP12, S-GAP7): 
+- Se l'obiettivo è ambiguo o i dati sembrano incoerenti, il primo subtask DEVE essere "Analisi Critica e Validazione Requisiti" (tool: direct_response).
+- Per ogni integrazione API, aggiungi un subtask di "Health Check / Verifica Connettività" prima delle operazioni core.
+- Se il task fallisce 2 volte, il piano deve includere un passo di "Debug e Analisi Log" (tool: read_file/execute_shell).
+
+REGOLE GRAFO DI DIPENDENZE:
+  - requires:[]  → subtask eseguibile immediatamente in parallelo con altri requires:[]
+  - requires:[N] → subtask che dipende dall'output di subtask id N
+  - priority:high: subtask bloccante; i dipendenti mettono il suo id in requires
+  - priority:low:  subtask indipendente; eseguibile in parallelo
+  - Identifica SEMPRE rami indipendenti (es. Backend vs Frontend, Read vs Write diversi file)
+  - Aggiungi entrambi i rami in parallel_groups per massimizzare il parallelismo"""
+
+# ── Prompt quick-start (Cerebras/Groq): 2-3 passi immediati ─────────────────
+
+PLANNER_QUICK_SYSTEM = """Sei un planner rapido. Dato un obiettivo, genera SOLO i primi 2-3 passi immediati e concreti.
+
+Rispondi SOLO con JSON valido:
+{
+  "goal": "obiettivo",
+  "complexity": "low|medium|high",
+  "subtasks": [
+    {"id": 1, "description": "primo passo", "tool": "<tool>", "requires": [], "risk": "low", "priority": "high"},
+    {"id": 2, "description": "secondo passo", "tool": "<tool>", "requires": [1], "risk": "low", "priority": "medium"}
+  ],
+  "parallel_groups": [[1],[2]],
+  "estimated_steps": 2,
+  "impacted_files": []
+}
+
+Regole:
+  - MAX 3 subtask — solo le azioni più immediate e ovvie
+  - Scegli tool giusto: web_search/read_page per info, run_python per codice, write_file per file
+  - Non pianificare l'intero progetto — solo il "prossimo passo" logico
+  - requires:[] per passi indipendenti (possono partire subito in parallelo)"""
+
+
+def _extract_json_balanced(raw: str) -> str | None:
+    """P16-B3: depth-counting bilanciato — sostituisce regex greedy r'{[\s\S]+}'.
+    Gestisce JSON annidati correttamente (piani con subtask oggetti complessi).
+    """
+    depth = 0
+    start = -1
+    for i, ch in enumerate(raw):
+        if ch == '{':
+            if depth == 0:
+                start = i
+            depth += 1
+        elif ch == '}':
+            depth -= 1
+            if depth == 0 and start != -1:
+                return raw[start:i + 1]
+    return None
+
+
+def _parse_plan(raw: str) -> dict | None:
+    """Estrae e valida il JSON del piano dalla risposta LLM."""
+    if not raw:
+        return None
+    json_match = _extract_json_balanced(raw)
+    if not json_match:
+        return None
+    try:
+        plan = json.loads(json_match)
+        if not plan.get("subtasks"):
+            return None
+        return plan
+    except (json.JSONDecodeError, ValueError):
+        return None
+
+
+class Planner:
+    def __init__(self, llm_client: AIClient | None = None):
+        self._explicit_llm = llm_client is not None
+        if llm_client is not None:
+            self.llm = llm_client
+        else:
+            # Master planner: DeepSeek-R1 per deep reasoning
+            try:
+                from models.role_router import RoleRouter, Role
+                self.llm = RoleRouter.get_client(Role.ARCHITECT)
+            except Exception:
+                self.llm = AIClient()
+
+    @classmethod
+    def from_ollama(cls, ollama=None) -> "Planner":
+        return cls()
+
+    def _get_fast_llm(self) -> AIClient:
+        """Gap-5: Cerebras gpt-oss-120b (2000+ tok/s) per quick-start draft.
+        Fallback: Groq openai/gpt-oss-20b se CEREBRAS_API_KEY assente."""
+        if self._explicit_llm:
+            return self.llm
+        try:
+            from models.role_router import RoleRouter, Role
+            return RoleRouter.get_client(Role.REASONER)  # Cerebras 120B
+        except Exception as _exc:
+            _logger.debug("[planner] silenced %s", type(_exc).__name__)  # noqa: BLE001
+        try:
+            from models.role_router import RoleRouter, Role
+            return RoleRouter.get_client(Role.FAST)  # Groq 8B fallback
+        except Exception:
+            return AIClient()
+
+    def _build_messages(self, system: str, goal: str,
+                        context: list | None = None) -> list[dict]:
+        msgs = [
+            {"role": "system", "content": system},
+            {"role": "user",   "content": f"Obiettivo: {goal}"},
+        ]
+        if context:
+            ctx_str = "\n".join(m.get("content", "")[:500] for m in context[-5:])
+            msgs[1]["content"] += f"\n\nContesto recente:\n{ctx_str}"
+        return msgs
+
+    async def create_plan(self, goal: str,
+                          context: list | None = None,
+                          model: str | None = None) -> dict:
+        """
+        Gap-5: Speculative Hybrid Planning.
+
+        Lancia in parallelo:
+          1. Quick-Start (Cerebras/Groq) — risponde in < 500ms con 2-3 subtask immediati
+          2. Master Plan (DeepSeek-R1)   — risponde in 8-15s con piano architetturale completo
+
+        Logica:
+          - attende max QUICK_TIMEOUT per il quick-start
+          - se arriva → restituisce subito (flag _speculative=True) così l'agente parte
+          - se DeepSeek-R1 arriva prima → piano completo (flag _speculative=False)
+          - se entrambi timeout → fallback euristico
+        """
+        QUICK_TIMEOUT  = 1.2   # secondi: soglia "fast-first" win
+        MASTER_TIMEOUT = 30.0  # secondi: timeout totale DeepSeek-R1
+
+        msgs_quick  = self._build_messages(PLANNER_QUICK_SYSTEM,  goal, context)
+        msgs_master = self._build_messages(PLANNER_SYSTEM, goal, context)
+
+        fast_llm = self._get_fast_llm()
+
+        async def _call_quick() -> dict | None:
+            try:
+                raw = await asyncio.wait_for(
+                    fast_llm.chat(msgs_quick, temperature=0.2, max_tokens=512),
+                    timeout=QUICK_TIMEOUT,
+                )
+                plan = _parse_plan(raw)
+                if plan:
+                    plan["_speculative"] = True
+                    plan["_raw"] = raw[:400]
+                return plan
+            except Exception:
+                return None
+
+        async def _call_master() -> dict | None:
+            for _attempt in range(3):
+                try:
+                    raw = await asyncio.wait_for(
+                        self.llm.chat(msgs_master, temperature=0.3, max_tokens=2048),
+                        timeout=MASTER_TIMEOUT,
+                    )
+                    plan = _parse_plan(raw)
+                    if plan:
+                        plan["_speculative"] = False
+                        plan["_raw"] = raw[:400]
+                        return plan
+                except (asyncio.TimeoutError, TimeoutError):
+                    if _attempt < 2:
+                        await asyncio.sleep(1.0 * (2 ** _attempt))
+                        continue
+                    break
+                except Exception:
+                    break
+            return None
+
+        # ── Speculative dual-fire ────────────────────────────────────────────
+        # Entrambi i modelli partono simultaneamente.
+        # asyncio.wait(FIRST_COMPLETED) con soglia QUICK_TIMEOUT:
+        #   - Se quick-start risponde prima → agente parte subito (< 1s)
+        #   - Master plan continua in background; il loop lo ignora (non ha callback)
+        #   - Se master arriva per primo (es. R1 cold-start veloce) → piano completo
+        quick_task  = asyncio.create_task(_call_quick())
+        master_task = asyncio.create_task(_call_master())
+
+        done, pending = await asyncio.wait(
+            {quick_task, master_task},
+            timeout=QUICK_TIMEOUT,
+            return_when=asyncio.FIRST_COMPLETED,
+        )
+
+        # Caso 1: quick-start ha risposto entro QUICK_TIMEOUT
+        if quick_task in done:
+            quick_plan = quick_task.result()
+            if quick_plan:
+                # P25-B3: per goal complessi (app/progetto/sistema), ignora quick-plan con ≤3 subtask
+                # e attendi il master plan architetturale. Il quick-plan 2-3 step causa rework
+                # sistematico su task multi-file che richiedono schema + contratto API.
+                _COMPLEX_APP_RE = re.compile(
+                    r'\b(crea\s+(?:una\s+)?(?:app|applicazione|sistema|sito|progetto|piattaforma|servizio)|'
+                    r'build\s+(?:a\s+)?(?:app|system|platform|service|website)|'
+                    r'sviluppa|realizza|implementa\s+(?:un[ao]\s+)?(?:sistema|app|servizio)|'
+                    r'full.?stack|backend\s+e\s+frontend|frontend\s+e\s+backend)\b',
+                    re.IGNORECASE,
+                )
+                _is_complex_app = bool(_COMPLEX_APP_RE.search(goal)) and len(goal) > 60
+                _n_quick_subtasks = len(quick_plan.get("subtasks", []))
+                if _is_complex_app and _n_quick_subtasks <= 3:
+                    _logger.info(
+                        "P25-B3: goal complesso rilevato (%d subtask quick) — attendo master plan",
+                        _n_quick_subtasks,
+                    )
+                    # Non restituire il quick-plan; lascia cadere al Caso 2 (wait master)
+                else:
+                    _logger.info(
+                        "Gap-5 speculative: quick-start plan (%d subtask), master in background",
+                        _n_quick_subtasks,
+                    )
+                    # Master task continua in background; risultato non bloccante
+                    master_task.add_done_callback(
+                        lambda t: (
+                            _logger.info(
+                                "Gap-5 master plan ready (%d subtask) — successiva chiamata beneficerà",
+                                len((t.result() or {}).get("subtasks", [])) if not t.cancelled() and t.exception() is None else 0,
+                            )
+                            if not t.cancelled() and t.exception() is None
+                            else None
+                        )
+                    )
+                    return quick_plan
+
+        # Caso 2: nessuno ha risposto in QUICK_TIMEOUT — aspetta il master plan
+        if master_task in done:
+            master_plan = master_task.result()
+            if master_plan:
+                quick_task.cancel()
+                return master_plan
+
+        # Caso 3: nessuno ancora pronto — aspetta fino a MASTER_TIMEOUT
+        remaining = {t for t in {quick_task, master_task} if not t.done()}
+        if remaining:
+            done2, _ = await asyncio.wait(remaining, timeout=MASTER_TIMEOUT - QUICK_TIMEOUT)
+            for t in done2:
+                if t.exception() is None and not t.cancelled():
+                    result = t.result()
+                    if result:
+                        for other in remaining - {t}:
+                            other.cancel()
+                        return result
+
+        # Cancella task pendenti
+        for t in {quick_task, master_task}:
+            if not t.done():
+                t.cancel()
+
+        # ── Fallback euristico (piano semplice) ──────────────────────────────
+        _logger.warning("Gap-5 planner: tutti i modelli in timeout per goal: %s", goal[:80])
+        _g = goal.lower()
+        _ft, _fr = "direct_response", "low"
+        if re.search(r"https?://", _g):                                              _ft = "read_page"
+        elif re.search(r"\b(cerca|search|notizie|news)\b", _g):                      _ft = "web_search"
+        elif re.search(r"\b(git|branch|commit|diff)\b", _g):                         _ft = "git_status"
+        elif re.search(r"\b(struttura|directory|tree|elenca)\b", _g):                _ft = "directory_tree"
+        elif re.search(r"\b(grep|occorrenze|cerca.*codice)\b", _g):                  _ft = "file_search"
+        elif re.search(r"\b(npm|pnpm|yarn)\b", _g):                                  _ft, _fr = "npm_run", "medium"
+        elif re.search(r"\b(pip |pip3 |installa pacchett)\b", _g):                   _ft, _fr = "pip_install", "medium"
+        elif re.search(r"\b(codice|python|script)\b", _g):                           _ft, _fr = "run_python", "medium"
+        elif re.search(r"\b(scaffold|bootstrap)\b|crea.*app|crea.*progetto|nuovo.*progetto", _g): _ft, _fr = "scaffold_project", "medium"
+        elif re.search(r"\b(genera|crea).*immagine\b", _g):                          _ft, _fr = "generate_image", "medium"
+        return {
+            "goal": goal, "complexity": "medium",
+            "subtasks": [{"id": 1, "description": goal, "tool": _ft,
+                          "requires": [], "risk": _fr, "priority": "high"}],
+            "parallel_groups": [[1]],
+            "estimated_steps": 1, "impacted_files": [], "_fallback": True,
+        }

agents/reasoning_core.py

@@ -0,0 +1,429 @@
+"""
+reasoning_core.py — MobileMaxAgent Implementation
+Cervello di livello massimo: Project Understanding + Strategy Engine + Auto-Debug Loop.
+"""
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import List, Dict, Any, Optional
+import asyncio
+import json, re
+from models.ai_client import AIClient
+
+import logging
+_logger = logging.getLogger("agents.reasoning_core")
+
+
+@dataclass
+class ReasoningResult:
+    action: str          # "plan" | "fix" | "continue" | "stop" | "analyze" | "strategy"
+    steps: List[str]
+    patch: Optional[str] = None
+    reason: str = ""
+    confidence: float = 0.5
+
+
+@dataclass
+class ReasoningState:
+    goal: str
+    context: str = ""
+    last_result: str = ""
+    errors: List[str] = field(default_factory=list)
+    completed_steps: List[str] = field(default_factory=list)
+    loop_count: int = 0
+    world_model: Optional[str] = None
+    strategy: Optional[str] = None
+    project_files: Optional[List[Dict[str, Any]]] = None  # GAP-2: file VFS per deep context reasoning
+
+
+class ReasoningCore:
+    """
+    MobileMaxAgent — Evoluzione del ReasoningCore.
+    Gestisce l'intero ciclo di vita del progetto:
+    1. Analyze (Project Understanding)
+    2. Strategy (Global Decision Making)
+    3. Patch (Multi-file implementation)
+    4. Run & Debug (Auto-repair loop)
+    """
+    MAX_LOOPS      = 15
+    MIN_CONFIDENCE = 0.4
+
+    def __init__(self, llm_client: AIClient | None = None, planner=None, critic=None, executor=None):
+        self.llm      = llm_client or AIClient()
+        self.planner  = planner
+        self.critic   = critic
+        self.executor = executor
+
+    # ── 1. Project Understanding ────────────────────────────────────────────────
+    async def analyze_project(self, repo_context: str) -> str:
+        prompt = f"""Analyze full software system.
+Return:
+- architecture map
+- dependencies
+- risk zones
+- entry points
+CONTEXT:
+{repo_context}
+"""
+        # S665: wrap con asyncio.wait_for — analyze_project usava await self.llm.chat() senza timeout
+        # → hang indefinito se il provider non risponde. Timeout 45s = STREAM_TIMEOUT (ai_client.py).
+        try:
+            return await asyncio.wait_for(
+                self.llm.chat([{"role": "user", "content": prompt}], temperature=0.2),
+                timeout=45.0,
+            )
+        except asyncio.TimeoutError:
+            return "[reasoning_core] analyze_project: timeout 45s — contesto non disponibile"
+
+    # ── 2. Global Strategy (Devin Core) ─────────────────────────────────────────
+    async def develop_strategy(self, state: ReasoningState) -> str:
+        prompt = f"""You are an autonomous software engineer.
+WORLD MODEL:
+{state.world_model}
+STATE:
+- goal: {state.goal}
+- errors: {state.errors}
+- completed: {state.completed_steps}
+Decide:
+- what to change
+- why
+- impact
+- risk level
+"""
+        # S665: timeout anche per develop_strategy
+        try:
+            return await asyncio.wait_for(
+                self.llm.chat([{"role": "user", "content": prompt}], temperature=0.3),
+                timeout=45.0,
+            )
+        except asyncio.TimeoutError:
+            return "[reasoning_core] develop_strategy: timeout 45s — strategia non disponibile"
+
+    # ── 3. Error Intelligence ───────────────────────────────────────────────────
+    async def analyze_error(self, error: str) -> str:
+        prompt = f"""Map error to codebase.
+ERROR:
+{error}
+Return:
+- file
+- root cause
+- fix strategy
+"""
+        # S665: timeout anche per analyze_error
+        try:
+            return await asyncio.wait_for(
+                self.llm.chat([{"role": "user", "content": prompt}], temperature=0.1),
+                timeout=45.0,
+            )
+        except asyncio.TimeoutError:
+            return "[reasoning_core] analyze_error: timeout 45s — analisi non disponibile"
+
+    # ── Prompt builder ──────────────────────────────────────────────────────────
+    def _build_prompt(self, state: ReasoningState) -> str:
+        # S590: errors[-3:]→[-5:] — più errori nel contesto per diagnosi più accurata
+        # BUG-2: raggruppa errori per tipo + ultimi 5 dettagliati — diagnosi più accurata
+        if state.errors:
+            import re as _re_err
+            _err_all = state.errors
+            _err_grouped: dict[str, int] = {}
+            for _e in _err_all:
+                _ek = _re_err.match(r'(\w+Error|\w+Exception|[A-Z]\w{3,})', _e)
+                _ek_str = _ek.group(1) if _ek else "Error"
+                _err_grouped[_ek_str] = _err_grouped.get(_ek_str, 0) + 1
+            _err_recent = "\n".join(_err_all[-5:])
+            _err_summary = ", ".join(f"{k}×{v}" for k, v in _err_grouped.items()) if len(_err_all) > 5 else ""
+            errors_str = _err_recent + (f"\n[Riepilogo tipi: {_err_summary}]" if _err_summary else "")
+        else:
+            errors_str = "nessuno"
+        steps_str  = "\n".join(f"- {s}" for s in state.completed_steps[-5:]) if state.completed_steps else "nessuno"
+        
+        _base_prompt = f"""Sei MobileMaxAgent, un sistema di ingegneria software autonoma.
+Analizza lo stato e decidi l'azione successiva.
+
+STATO:
+- goal: {state.goal}
+- world_model: {'Presente' if state.world_model else 'Mancante'}
+- strategy: {'Definita' if state.strategy else 'Da definire'}
+- last_result: {state.last_result[:500] if state.last_result else 'vuoto'}  # S592: 300→500
+- errors: {errors_str}
+- loop_count: {state.loop_count}/{self.MAX_LOOPS}
+
+Rispondi SOLO con JSON valido:
+{{
+  "action": "analyze | strategy | plan | fix | continue | stop",
+  "steps": ["prossimo passo tecnico"],
+  "patch": "eventuale diff o codice",
+  "reason": "perché questa azione?",
+  "confidence": 0.0-1.0
+}}
+
+Regole:
+1. Se manca world_model -> "analyze"
+2. Se manca strategy -> "strategy"
+3. Se strategy c'è ma serve piano -> "plan"
+4. Se ci sono errori -> "fix"
+5. Se tutto ok -> "continue" o "stop" se finito.
+"""
+
+        # GAP-2: Deep Context — inietta skeleton dei file rilevanti per ragionamento multi-file
+        _ctx_section = ""
+        if state.project_files:
+            try:
+                from agents.context_manager import rank_files_by_relevance, build_file_skeleton
+                _top_paths = set(rank_files_by_relevance(state.goal, state.project_files, k=5))
+                _skels = [
+                    build_file_skeleton(
+                        f.get("path", ""),
+                        f.get("content", ""),
+                        f.get("language", ""),
+                    )
+                    for f in state.project_files
+                    if f.get("path") in _top_paths
+                ]
+                if _skels:
+                    # P25-B1: ordina i blocchi skeleton per overlap keyword col goal prima di troncare.
+                    # Zero LLM, zero latenza — stessa logica word-overlap di episodic.py.
+                    # Garantisce che i blocchi più rilevanti per il goal finiscano PRIMA del taglio.
+                    _goal_kw_ctx = set(re.findall(r'\w{4,}', state.goal.lower())) if hasattr(state, 'goal') else set()
+                    if _goal_kw_ctx:
+                        _skels.sort(
+                            key=lambda _s: len(_goal_kw_ctx & set(re.findall(r'\w{4,}', _s.lower()))),
+                            reverse=True,
+                        )
+                    _ctx_raw = "\n".join(_skels)
+                    # S780-SMART: Smart Chunking — estrae firme funzioni/classi invece di troncare.
+                    # BUG-SKEL fix: evita allucinazioni su funzioni mancanti nei file complessi.
+                    if len(_ctx_raw) > 6000:
+                        import re as _re_sk
+                        _sig_lines = _re_sk.findall(
+                            r'^(?:(?:async\s+)?def |class |export\s+(?:default\s+)?'
+                            r'(?:function|const|class)\s+\w|function\s+\w)[^\n]{0,200}',
+                            _ctx_raw, _re_sk.MULTILINE
+                        )
+                        _ctx_smart = '\n'.join(_sig_lines)
+                        if len(_ctx_smart) >= 500:
+                            _ctx_raw = (
+                                f'[SMART CHUNK — {len(_skels)} file — solo firme estratte]\n'
+                                + _ctx_smart[:10000]
+                            )
+                        else:
+                            _ctx_raw = _ctx_raw[:6000] + '\n… [troncato — usa file_search per dettagli]'
+                    _ctx_section = "\n\nFILE RILEVANTI (skeleton per ragionamento):\n" + _ctx_raw
+            except Exception:
+                pass  # non-fatal — degradazione graceful senza deep context
+
+        return _base_prompt + _ctx_section
+
+    @staticmethod
+    def _extract_json(raw: str) -> str | None:
+        """P16-B3: depth-counting bilanciato — sostituisce regex greedy r'{[\s\S]+}'
+        che su JSON nested (es. patch con oggetti interni) estraeva dal primo { all'ULTIMO }
+        producendo JSON malformato → action='continue' per default → agente in loop.
+        Pattern identico a safeJsonParse.ts già in produzione sul frontend."""
+        depth = 0
+        start = -1
+        for i, ch in enumerate(raw):
+            if ch == '{':
+                if depth == 0:
+                    start = i
+                depth += 1
+            elif ch == '}':
+                depth -= 1
+                if depth == 0 and start != -1:
+                    return raw[start:i + 1]
+        return None
+
+    def _parse(self, raw: str) -> ReasoningResult:
+        try:
+            candidate = self._extract_json(raw)
+            data = json.loads(candidate) if candidate else {}
+        except Exception:
+            return ReasoningResult(action='continue', steps=[], reason='Parsing error fallback', confidence=0.2)
+
+        return ReasoningResult(
+            action=data.get("action", "continue"),
+            steps=data.get("steps", []),
+            patch=data.get("patch"),
+            reason=data.get("reason", ""),
+            confidence=float(data.get("confidence", 0.5))
+        )
+
+    async def decide(self, state: ReasoningState) -> ReasoningResult:
+        if state.loop_count >= self.MAX_LOOPS:
+            return ReasoningResult(action="stop", steps=[], reason="Max loops reached", confidence=1.0)
+
+        prompt = self._build_prompt(state)
+        try:
+            # S750-GAP-D: asyncio.wait_for — evita hang se LLM provider non risponde
+            raw = await asyncio.wait_for(
+                self.llm.chat([{"role": "user", "content": prompt}], temperature=0.2),
+                timeout=30.0,
+            )
+            return self._parse(raw)
+        except asyncio.TimeoutError:
+            return ReasoningResult(action="continue", steps=[], reason="decide(): LLM timeout 30s", confidence=0.3)
+        except Exception as e:
+            return ReasoningResult(action="continue", steps=[], reason=f"LLM error: {e}", confidence=0.3)
+
+    async def run_loop(self, goal: str, context: str = "", on_step=None,
+                       project_files: Optional[List[Dict[str, Any]]] = None) -> Dict[str, Any]:
+        state = ReasoningState(goal=goal, context=context, project_files=project_files)
+        results = []
+
+        while state.loop_count < self.MAX_LOOPS:
+            decision = await self.decide(state)
+            
+            if on_step:
+                await on_step({
+                    "loop": state.loop_count,
+                    "action": decision.action,
+                    "reason": decision.reason,
+                    "confidence": decision.confidence
+                })
+
+            if decision.action == "stop":
+                break
+            
+            elif decision.action == "analyze":
+                state.world_model = await self.analyze_project(context or goal)
+                results.append({"action": "analyze", "output": "World model built"})
+            
+            elif decision.action == "strategy":
+                state.strategy = await self.develop_strategy(state)
+                results.append({"action": "strategy", "output": state.strategy})
+
+            elif decision.action == "plan" and self.planner:
+                plan = await self.planner.create_plan(goal, context=state.strategy)
+                state.completed_steps.append("Piano creato")
+                state.last_result = "Piano generato"
+                results.append({"action": "plan", "result": plan})
+
+            elif decision.action == "fix":
+                if decision.patch:
+                    # Se c'è una patch, l'executor la applica
+                    if self.executor:
+                        res = await self.executor.run_tool("file_editor", {"path": "patch.diff", "content": decision.patch})
+                        state.last_result = str(res.get("output", ""))
+                    state.errors = []
+                    results.append({"action": "fix", "patch": "Applicata"})
+                else:
+                    error_analysis = await self.analyze_error(str(state.errors))
+                    state.last_result = error_analysis
+                    results.append({"action": "error_analysis", "output": error_analysis})
+
+            elif decision.action == "continue":
+                # S575: direct_response non esiste nel TOOL_REGISTRY — usa LLM diretto
+                if decision.steps:
+                    try:
+                        _step_prompt = decision.steps[0]
+                        _step_ans = await self.llm.chat(
+                            [{"role": "system", "content":
+                              "Sei un assistente tecnico. Esegui il passo richiesto in modo conciso."},
+                             {"role": "user", "content":
+                              f"Goal: {state.goal}\n\nPasso da eseguire: {_step_prompt}"}],
+                            temperature=0.2, max_tokens=512,
+                        )
+                        state.last_result = _step_ans or ""
+                        state.completed_steps.append(_step_prompt)
+                    except Exception:
+                        state.completed_steps.append(decision.steps[0])
+                results.append({"action": "continue", "steps": decision.steps})
+
+            # Auto-debug check con Critic
+            if self.critic and state.last_result and decision.action != "analyze":
+                critique = await self.critic.evaluate(goal, state.last_result)
+                if critique.get("needs_retry"):
+                    state.errors.extend(critique.get("issues", []))
+
+            state.loop_count += 1
+
+        return {
+            "goal": goal,
+            "loops": state.loop_count,
+            "success": len(state.errors) == 0,
+            "results": results,
+            "final_state": {
+                "has_world_model": state.world_model is not None,
+                "has_strategy": state.strategy is not None
+            }
+        }
+
+    async def run_loop_to_answer(self, goal: str, context: str = "",
+                                  on_step=None, max_loops: int = 8,
+                                  project_files: Optional[List[Dict[str, Any]]] = None) -> str:
+        """S575: Versione di run_loop che ritorna una stringa risposta sintetizzata.
+
+        Usata dal gate in UnifiedAgentLoop quando tok_budget >= 6144 e subtask >= 3.
+        Limite max_loops=8 (S701: era 5) — più iterazioni per task profondi.
+        Output: stringa di risultati aggregati da passare come contesto extra al LLM finale.
+        Mai solleva eccezioni.
+        """
+        try:
+            # GAP-2: deep context — inietta i file VFS nella ReasoningState per rank_files_by_relevance()
+            state = ReasoningState(goal=goal, context=context, project_files=project_files)
+            parts: List[str] = []
+            loop_cap = min(max_loops, self.MAX_LOOPS)
+
+            while state.loop_count < loop_cap:
+                try:
+                    decision = await self.decide(state)
+                except Exception:
+                    break
+
+                if on_step:
+                    try:
+                        import asyncio as _aio
+                        coro = on_step({
+                            "loop": state.loop_count,
+                            "action": f"reasoning:{decision.action}",
+                            "reason": decision.reason[:200] if decision.reason else "",  # S578: 120→200
+                            "confidence": decision.confidence,
+                        })
+                        if _aio.iscoroutine(coro):
+                            await coro
+                    except Exception as _exc:
+                        _logger.debug("[reasoning_core] silenced %s", type(_exc).__name__)  # noqa: BLE001
+
+                if decision.action == "stop" or decision.confidence < self.MIN_CONFIDENCE:
+                    break
+
+                elif decision.action == "analyze":
+                    try:
+                        state.world_model = await self.analyze_project(context or goal)
+                        # S593: 400→600 — world_model spesso multi-paragrafo
+                        parts.append(f"[ANALISI PROGETTO]: {(state.world_model or '')[:600]}")
+                    except Exception as _exc:
+                        _logger.debug("[reasoning_core] silenced %s", type(_exc).__name__)  # noqa: BLE001
+
+                elif decision.action == "strategy":
+                    try:
+                        state.strategy = await self.develop_strategy(state)
+                        # S593: 400→600 — strategy spesso multi-step
+                        parts.append(f"[STRATEGIA]: {(state.strategy or '')[:600]}")
+                    except Exception as _exc:
+                        _logger.debug("[reasoning_core] silenced %s", type(_exc).__name__)  # noqa: BLE001
+
+                elif decision.action in ("plan", "continue", "fix"):
+                    # Esegui passo diretto via LLM
+                    step_desc = (decision.steps[0] if decision.steps
+                                 else decision.reason or goal)
+                    try:
+                        _ans = await self.llm.chat(
+                            [{"role": "system", "content":
+                              "Sei un assistente tecnico esperto. "
+                              "Svolgi il passo richiesto in modo preciso e conciso."},
+                             {"role": "user", "content":
+                              f"Goal complessivo: {goal}\n\nPasso: {step_desc}"}],
+                            temperature=0.2, max_tokens=512,
+                        )
+                        if _ans and not _ans.startswith("[LLM"):
+                            parts.append(f"[PASSO {state.loop_count+1}]: {_ans[:600]}")
+                            state.last_result = _ans
+                            state.completed_steps.append(step_desc)
+                    except Exception as _exc:
+                        _logger.debug("[reasoning_core] silenced %s", type(_exc).__name__)  # noqa: BLE001
+
+                state.loop_count += 1
+
+            return "\n\n".join(parts) if parts else ""
+        except Exception:
+            return ""

agents/reflection_sidecar.py

@@ -0,0 +1,216 @@
+"""
+reflection_sidecar.py — Reflection Sidecar (Double-Token Innovation)
+
+Analizza i log di errore di ogni tool call durante la sessione e aggiorna
+session_rules.md in tempo reale. Questo file viene iniettato nel system prompt
+dell'agente principale per correggere il comportamento on-the-fly.
+
+Architettura:
+  Token A (agente principale) → esegue tool, chiama log_error()
+  Token B (sidecar critic)    → analizza pattern, scrive regole
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+import re
+import time
+from collections import defaultdict, deque
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+_logger = logging.getLogger("agente_ai.reflection_sidecar")
+
+# ── Config ────────────────────────────────────────────────────────────────────
+
+_RULES_FILE = Path(os.getenv("SIDECAR_RULES_FILE", "/data/session_rules.md"))
+_MAX_ERRORS_BEFORE_REFLECT = int(os.getenv("SIDECAR_REFLECT_THRESHOLD", "2"))
+_RULE_TTL_S = int(os.getenv("SIDECAR_RULE_TTL_S", "3600"))  # 1h
+
+# Token B per NVIDIA NIM (Reflection Critic — modello leggero, bassa latenza)
+_NVIDIA_API   = "https://integrate.api.nvidia.com/v1"
+_CRITIC_MODEL = os.getenv("NVIDIA_B_MODEL", "meta/llama-3.3-70b-instruct")
+_NVIDIA_KEY_B = os.getenv("NVIDIA_API_KEY_B", "")
+
+
+# ── Data model ────────────────────────────────────────────────────────────────
+
+@dataclass
+class ErrorEvent:
+    tool: str
+    error: str
+    context: str
+    ts: float = field(default_factory=time.monotonic)
+
+
+@dataclass
+class SessionRule:
+    pattern: str          # cosa ha causato l'errore (regex / descrizione)
+    rule: str             # istruzione correttiva per l'agente
+    tool: str
+    created_at: float = field(default_factory=time.time)
+    hit_count: int = 0
+
+
+# ── Sidecar core ─────────────────────────────────────────────────────────────
+
+class ReflectionSidecar:
+    """
+    Singleton per sessione. Riceve errori, li analizza con Token B (NVIDIA),
+    aggiorna session_rules.md che viene iniettato nel prompt principale.
+    """
+
+    def __init__(self) -> None:
+        self._errors: list[ErrorEvent] = []
+        self._rules: list[SessionRule] = []
+        self._tool_error_counts: dict[str, int] = defaultdict(int)
+        self._lock = asyncio.Lock()
+        self._reflect_task: asyncio.Task | None = None
+
+    async def log_error(
+        self,
+        tool: str,
+        error: str,
+        context: str = "",
+    ) -> None:
+        """Registra un errore. Se lo stesso tool fallisce >= threshold, avvia reflection."""
+        async with self._lock:
+            evt = ErrorEvent(tool=tool, error=error[:500], context=context[:300])
+            self._errors.append(evt)
+            self._tool_error_counts[tool] += 1
+            count = self._tool_error_counts[tool]
+
+        if count >= _MAX_ERRORS_BEFORE_REFLECT:
+            # Avvia reflection in background (non blocca l'agente principale)
+            if self._reflect_task is None or self._reflect_task.done():
+                # BUGFIX: eccezioni di _reflect_and_update erano perse silenziosamente
+                def _log_ref_exc(t):
+                    if not t.cancelled() and t.exception():
+                        _logger.warning("[reflection_sidecar] reflect task raised: %s", t.exception())
+                self._reflect_task = asyncio.create_task(
+                    self._reflect_and_update(tool, error, context)
+                )
+                self._reflect_task.add_done_callback(_log_ref_exc)
+
+    async def _reflect_and_update(
+        self, tool: str, last_error: str, context: str
+    ) -> None:
+        """Token B: analizza gli errori e genera una regola correttiva."""
+        if not _NVIDIA_KEY_B:
+            _logger.warning("reflection_sidecar: NVIDIA_API_KEY_B non configurato — skip")
+            return
+
+        # Aggrega tutti gli errori del tool
+        relevant = [e for e in self._errors if e.tool == tool][-5:]
+        error_summary = "\n".join(f"- [{e.tool}] {e.error}" for e in relevant)
+
+        prompt = f"""Sei un critico di qualità per un agente AI. Analizza questi errori ripetuti:
+
+TOOL: {tool}
+ERRORI:
+{error_summary}
+
+CONTESTO ULTIMO ERRORE: {context}
+
+Scrivi UNA regola correttiva concisa (max 2 righe) che l'agente deve seguire per evitare
+di ripetere questo errore. Formato: "REGOLA [{tool}]: <istruzione diretta all'agente>"
+Rispondi solo con la regola, nessun altro testo."""
+
+        try:
+            import urllib.request
+            payload = json.dumps({
+                "model": _CRITIC_MODEL,
+                "messages": [{"role": "user", "content": prompt}],
+                "max_tokens": 120,
+                "temperature": 0.1,
+            }).encode()
+            req = urllib.request.Request(
+                f"{_NVIDIA_API}/chat/completions",
+                data=payload,
+                headers={
+                    "Authorization": f"Bearer {_NVIDIA_KEY_B}",
+                    "Content-Type": "application/json",
+                },
+                method="POST",
+            )
+            with urllib.request.urlopen(req, timeout=15) as resp:
+                data = json.loads(resp.read())
+            rule_text = data["choices"][0]["message"]["content"].strip()
+
+            new_rule = SessionRule(
+                pattern=last_error[:100],
+                rule=rule_text,
+                tool=tool,
+            )
+            async with self._lock:
+                # Dedup: rimuovi regole vecchie per lo stesso tool
+                self._rules = [r for r in self._rules if r.tool != tool]
+                self._rules.append(new_rule)
+                self._tool_error_counts[tool] = 0  # reset counter
+
+            await self._write_rules_file()
+            _logger.info(f"reflection_sidecar: nuova regola generata per {tool}")
+
+        except Exception as exc:
+            _logger.warning(f"reflection_sidecar: reflection fallita — {exc}")
+
+    async def _write_rules_file(self) -> None:
+        """Scrive session_rules.md — viene iniettato nel system prompt principale."""
+        now = time.time()
+        active = [r for r in self._rules if (now - r.created_at) < _RULE_TTL_S]
+        if not active:
+            return
+        lines = ["# Session Rules (auto-generate dal Reflection Sidecar)\n"]
+        lines += [f"- {r.rule}" for r in active]
+        lines.append(f"\n_Aggiornato: {time.strftime('%H:%M:%S')}_")
+        try:
+            _RULES_FILE.parent.mkdir(parents=True, exist_ok=True)
+            _RULES_FILE.write_text("\n".join(lines), encoding="utf-8")
+        except Exception as exc:
+            _logger.warning(f"reflection_sidecar: scrittura rules file fallita — {exc}")
+
+    def get_rules_for_prompt(self) -> str:
+        """Legge session_rules.md per l'iniezione nel system prompt."""
+        try:
+            if _RULES_FILE.exists():
+                content = _RULES_FILE.read_text(encoding="utf-8").strip()
+                if content and len(content) > 30:
+                    return f"\n\n---\n{content}\n---"
+        except Exception:
+            pass
+        return ""
+
+    def reset(self) -> None:
+        """Reset a inizio nuova sessione."""
+        self._errors.clear()
+        self._rules.clear()
+        self._tool_error_counts.clear()
+        try:
+            _RULES_FILE.unlink(missing_ok=True)
+        except Exception:
+            pass
+
+
+# ── Singleton ─────────────────────────────────────────────────────────────────
+_sidecar: ReflectionSidecar | None = None
+
+
+def get_sidecar() -> ReflectionSidecar:
+    global _sidecar
+    if _sidecar is None:
+        _sidecar = ReflectionSidecar()
+    return _sidecar
+
+
+async def log_tool_error(tool: str, error: str, context: str = "") -> None:
+    """Shortcut globale — chiamare dopo ogni tool call fallita."""
+    await get_sidecar().log_error(tool, error, context)
+
+
+def get_session_rules() -> str:
+    """Shortcut globale — iniettare nel system prompt principale."""
+    return get_sidecar().get_rules_for_prompt()

agents/requirement_engine.py

@@ -0,0 +1,276 @@
+"""
+requirement_engine.py — Sprint 2: Decomposizione semantica del goal in requisiti strutturati
+
+Input:  goal string  (es. "crea un CRM con login e dashboard")
+Output: lista requisiti [{id, feature, description, acceptance_criteria}]
+
+Strategia:
+  1. Pattern matching regex deterministico su goal common (zero LLM, zero latenza)
+  2. Fallback LLM (Groq fast, 1 call, 3s timeout) per goal non coperti dai pattern
+  3. Cache locale dict-session per goal già decomposed — niente LLM repeat calls
+
+Invarianti rispettate:
+  - PR2: non tocca providerChain.ts (questo è solo backend)
+  - B1: nessun corpo duplicato
+  - Additive-only: fallback a lista vuota su qualsiasi errore — nessuna regressione
+"""
+from __future__ import annotations
+
+import re
+import json
+import asyncio
+import hashlib
+from dataclasses import dataclass, field
+from typing import Any
+
+# ── Cache session-level ────────────────────────────────────────────────────────
+_REQUIREMENT_CACHE: dict[str, list[dict]] = {}
+_CACHE_MAX = 50
+
+
+def _cache_key(goal: str) -> str:
+    return hashlib.md5(goal.strip()[:300].lower().encode()).hexdigest()
+
+
+# ── Libreria pattern predefiniti ───────────────────────────────────────────────
+# Ogni voce: (regex_pattern, feature_id, feature_name, description)
+_FEATURE_PATTERNS: list[tuple[re.Pattern, str, str, str]] = [
+    (
+        re.compile(r'\b(auth|login|logout|registr|signup|sign.?up|accesso|autenticaz)\b', re.I),
+        "auth", "Autenticazione",
+        "Login, logout, registrazione utente e gestione sessione",
+    ),
+    (
+        re.compile(r'\b(crud|create|read|update|delete|gestione|manage|list|detail|edit|modifica|elimina)\b', re.I),
+        "crud", "Operazioni CRUD",
+        "Creazione, lettura, modifica e cancellazione di entità dati",
+    ),
+    (
+        re.compile(r'\b(dashboard|overview|riepilogo|summary|stats|statistiche|kpi|metriche|analytics)\b', re.I),
+        "dashboard", "Dashboard",
+        "Vista aggregata con metriche, statistiche e KPI principali",
+    ),
+    (
+        re.compile(r'\b(api|rest|endpoint|route|backend|server|fastapi|flask|express|django)\b', re.I),
+        "api_rest", "API REST",
+        "Endpoint REST con validazione input e gestione errori",
+    ),
+    (
+        re.compile(r'\b(form|validaz|validation|input|campi|fields|submit|invio)\b', re.I),
+        "form_validation", "Form e Validazione",
+        "Form con validazione lato client e server",
+    ),
+    (
+        re.compile(r'\b(upload|file|immagine|image|media|attachment|allegato)\b', re.I),
+        "file_upload", "Upload File",
+        "Caricamento e gestione file/media",
+    ),
+    (
+        re.compile(r'\b(search|cerca|ricerca|filtro|filter|sort|ordinamento)\b', re.I),
+        "search", "Ricerca e Filtri",
+        "Ricerca full-text e filtraggio risultati",
+    ),
+    (
+        re.compile(r'\b(pagament|payment|stripe|checkout|cart|carrello|acquisto|order|ordine)\b', re.I),
+        "payments", "Pagamenti",
+        "Flusso di checkout e gestione pagamenti",
+    ),
+    (
+        re.compile(r'\b(notif|notification|alert|email|sms|push|avviso|messaggio)\b', re.I),
+        "notifications", "Notifiche",
+        "Sistema di notifiche e comunicazioni",
+    ),
+    (
+        re.compile(r'\b(setting|impostaz|profilo|profile|account|preferenze|config)\b', re.I),
+        "settings", "Impostazioni",
+        "Gestione profilo utente e impostazioni applicazione",
+    ),
+    (
+        re.compile(r'\b(database|db|schema|migration|tabella|table|model|entità|entity)\b', re.I),
+        "database", "Database",
+        "Schema dati, migrazioni e modelli",
+    ),
+    (
+        re.compile(r'\b(deploy|ci.?cd|docker|container|hosting|production|prod)\b', re.I),
+        "deploy", "Deploy",
+        "Pipeline di build e deploy in produzione",
+    ),
+
+    (
+        re.compile(r'\b(analizza|analyze|analisi|analytic|analisi comparativa|analyse)\b', re.I),
+        "analysis", "Analisi",
+        "Analisi dettagliata con argomentazioni, dati e conclusioni strutturate",
+    ),
+    (
+        re.compile(r'\b(confronta|compare|versus|vs\.?|differenz[ae]|differences?|migliore tra|meglio tra)\b', re.I),
+        "comparison", "Confronto",
+        "Confronto strutturato con dimensioni esplicite e raccomandazione finale",
+    ),
+    (
+        re.compile(r"\b(spiega|explain|descrivi|describe|cos[\'è ]{1,3}è|what is|how does|come funziona)\b", re.I),
+        "explanation", "Spiegazione",
+        "Spiegazione chiara con definizione, esempi concreti e contesto d'uso",
+    ),
+    (
+        re.compile(r'\b(riassumi|summarize|sommario|sintesi|riepilog[ao]|riassunto)\b', re.I),
+        "summarization", "Sintesi",
+        "Sintesi strutturata che mantiene i punti chiave senza perdita di informazioni critiche",
+    ),
+    (
+        re.compile(r'\b(raccomand[ai]|recommend|consigli[ao]|suggerisci|suggest|best practice|cosa sceglier|quale sceglier)\b', re.I),
+        "recommendation", "Raccomandazione",
+        "Raccomandazione motivata con almeno 3 criteri di valutazione e conclusione esplicita",
+    ),
+
+]
+
+# Criteri accettazione standard per ogni feature (importati da AcceptanceCriteria)
+from agents.acceptance_criteria import ACCEPTANCE_CRITERIA
+
+
+@dataclass
+class Requirement:
+    id: str
+    feature: str
+    description: str
+    acceptance_criteria: list[str] = field(default_factory=list)
+    source: str = "pattern"  # "pattern" | "llm"
+
+
+class RequirementEngine:
+    """
+    Decompone un goal in lista di requisiti strutturati con criteri di accettazione.
+
+    Chiamato da _run_fallback() su task complessi (_tok_budget >= 4096).
+    Zero LLM per goal coperti dai pattern — fallback LLM solo per goal esotici.
+    """
+
+    def __init__(self, llm: Any = None) -> None:
+        self.llm = llm
+
+    def decompose_sync(self, goal: str) -> list[Requirement]:
+        """
+        Decomposizione sincrona via pattern matching.
+        Usato quando non si è in un contesto async.
+        """
+        key = _cache_key(goal)
+        if key in _REQUIREMENT_CACHE:
+            cached = _REQUIREMENT_CACHE[key]
+            return [Requirement(**r) for r in cached]
+
+        reqs = self._match_patterns(goal)
+        self._store_cache(key, reqs)
+        return reqs
+
+    async def decompose(self, goal: str) -> list[Requirement]:
+        """
+        Decomposizione async: pattern first, poi LLM fallback se lista vuota e goal complesso.
+        """
+        key = _cache_key(goal)
+        if key in _REQUIREMENT_CACHE:
+            cached = _REQUIREMENT_CACHE[key]
+            return [Requirement(**r) for r in cached]
+
+        reqs = self._match_patterns(goal)
+
+        # Fallback LLM solo se: nessun pattern matched + goal complesso (>30 chars)
+        if not reqs and self.llm and len(goal.strip()) > 30:
+            try:
+                reqs = await asyncio.wait_for(self._decompose_llm(goal), timeout=3.0)
+            except Exception:
+                reqs = []
+
+        self._store_cache(key, reqs)
+        return reqs
+
+    def _match_patterns(self, goal: str) -> list[Requirement]:
+        """Pattern matching deterministico — zero latenza."""
+        seen: set[str] = set()
+        result: list[Requirement] = []
+        for pattern, feat_id, feat_name, description in _FEATURE_PATTERNS:
+            if feat_id in seen:
+                continue
+            if pattern.search(goal):
+                criteria = ACCEPTANCE_CRITERIA.get(feat_id, [])
+                result.append(Requirement(
+                    id=feat_id,
+                    feature=feat_name,
+                    description=description,
+                    acceptance_criteria=criteria,
+                    source="pattern",
+                ))
+                seen.add(feat_id)
+        return result
+
+    async def _decompose_llm(self, goal: str) -> list[Requirement]:
+        """
+        LLM fallback per goal non coperti dai pattern.
+        1 call, max 3s, output JSON strutturato.
+        """
+        system = (
+            "Sei un analista di requisiti software. Dato un goal, estrai i requisiti "
+            "in formato JSON. Rispondi SOLO con JSON valido, nessun testo aggiuntivo.\n"
+            'Formato: [{"id":"snake_case","feature":"Nome","description":"desc breve"}]'
+            "\nMax 5 requisiti. Solo requisiti CONCRETI e VERIFICABILI."
+        )
+        msgs = [
+            {"role": "system", "content": system},
+            # S596: goal 300→500 — goal complessi superano 300 chars
+            {"role": "user", "content": f"Goal: {goal[:500]}"},
+        ]
+        try:
+            # S586: 300→512 — JSON array di requisiti con 3-5 items supera 300 tok
+            raw = await self.llm.chat(msgs, temperature=0.0, max_tokens=512)
+            if not raw or raw.startswith("[LLM"):
+                return []
+            m = re.search(r'\[[\s\S]+\]', raw)
+            if not m:
+                return []
+            items = json.loads(m.group())
+            result = []
+            for item in items[:5]:
+                if not isinstance(item, dict):
+                    continue
+                feat_id = str(item.get("id", "unknown"))
+                criteria = ACCEPTANCE_CRITERIA.get(feat_id, [])
+                result.append(Requirement(
+                    id=feat_id,
+                    feature=str(item.get("feature", feat_id)),
+                    description=str(item.get("description", ""))[:400],  # S576: 200→400
+                    acceptance_criteria=criteria,
+                    source="llm",
+                ))
+            return result
+        except Exception:
+            return []
+
+    @staticmethod
+    def _store_cache(key: str, reqs: list[Requirement]) -> None:
+        """Mantieni cache sotto _CACHE_MAX entries."""
+        if len(_REQUIREMENT_CACHE) >= _CACHE_MAX:
+            oldest = next(iter(_REQUIREMENT_CACHE))
+            _REQUIREMENT_CACHE.pop(oldest, None)
+        _REQUIREMENT_CACHE[key] = [
+            {
+                "id": r.id,
+                "feature": r.feature,
+                "description": r.description,
+                "acceptance_criteria": r.acceptance_criteria,
+                "source": r.source,
+            }
+            for r in reqs
+        ]
+
+    @staticmethod
+    def format_for_context(reqs: list[Requirement]) -> str:
+        """Formatta i requisiti per l'injection nel system prompt."""
+        if not reqs:
+            return ""
+        lines = ["[REQUISITI DECOMPOSED]"]
+        for r in reqs:
+            lines.append(f"• {r.feature}: {r.description}")
+        lines.append(
+            "\nIl GoalVerifier verificherà CIASCUN requisito separatamente. "
+            "Assicurati che la risposta copra tutti i punti elencati."
+        )
+        return "\n".join(lines)

agents/response_verifier.py

@@ -0,0 +1,367 @@
+"""
+response_verifier.py — Response Quality Verifier + Repair Pass
+
+Verifica e ripara l'output LLM prima che raggiunga l'utente:
+1. JSON repair — estrae e corregge JSON corrotto (trailing comma, unquoted keys, ecc.)
+2. Markdown sanitization — chiude code fence aperte, corregge heading malformati
+3. Coherence check — rileva risposte vuote, description-leak dei tool, risposte fuori tema
+4. Retry signal — se qualità < soglia, suggerisce retry con hint correttivo
+
+Dipendenze: zero (solo stdlib).
+"""
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass, field
+from typing import Any
+
+import logging
+_logger = logging.getLogger("agents.response_verifier")
+
+
+# ── Soglie ────────────────────────────────────────────────────────────────────
+
+QUALITY_RETRY_THRESHOLD = 0.35   # sotto questa soglia → retry
+QUALITY_WARN_THRESHOLD  = 0.55   # sotto questa → repairs loggati ma ok
+
+
+# ── Patterns ──────────────────────────────────────────────────────────────────
+
+# Frasi che indicano che il modello sta descrivendo tool invece di usarli
+_TOOL_DESCRIPTION_PATTERNS = [
+    r"puoi (usare|utilizzare|eseguire)\s+(il\s+)?tool",
+    r"esegui\s+il\s+comando",
+    r"usa\s+il\s+tool\s+\w+",
+    r"assicurati di (aver )?installato il tool",
+    r"per utilizzare il tool",
+    r"il tool ti fornirà",
+    r"```(bash|sh)\s*\n\s*get_weather",
+    r"```(bash|sh)\s*\n\s*web_search",
+    r"```(bash|sh)\s*\n\s*calculate",
+]
+
+# Frasi di resa senza contenuto utile
+_EMPTY_RESPONSE_PATTERNS = [
+    r"^non ho informazioni",
+    r"^non (posso|riesco) (fornire|darti|aiutarti)",
+    r"^mi dispiace,?\s+non",
+    r"^purtroppo non",
+    r"^come AI non",
+]
+
+_COMPILED_TOOL_PATTERNS  = [re.compile(p, re.IGNORECASE) for p in _TOOL_DESCRIPTION_PATTERNS]
+_COMPILED_EMPTY_PATTERNS = [re.compile(p, re.IGNORECASE) for p in _EMPTY_RESPONSE_PATTERNS]
+
+
+# ── Result ────────────────────────────────────────────────────────────────────
+
+@dataclass
+class VerifyResult:
+    output: str
+    repairs: list[str] = field(default_factory=list)
+    quality: float = 1.0
+    retry_suggested: bool = False
+    retry_hint: str = ""
+
+
+# ── JSON Repair ───────────────────────────────────────────────────────────────
+
+def repair_json(text: str) -> tuple[str, list[str]]:
+    """
+    Tenta di estrarre e riparare JSON dall'output LLM.
+    Restituisce (json_str_riparato_o_originale, lista_riparazioni).
+    """
+    repairs: list[str] = []
+
+    # 1. Estrai blocco JSON (con o senza ```json ... ```)
+    fenced = re.search(r"```(?:json)?\s*(\{[\s\S]+?\})\s*```", text)
+    raw = fenced.group(1) if fenced else None
+
+    if not raw:
+        # P16-B3: depth-counting bilanciato — evita estrazione errata su JSON annidati
+        def _depth_extract(s: str) -> str | None:
+            depth = 0; start = -1
+            for i, ch in enumerate(s):
+                if ch == '{':
+                    if depth == 0: start = i
+                    depth += 1
+                elif ch == '}':
+                    depth -= 1
+                    if depth == 0 and start != -1:
+                        return s[start:i + 1]
+            return None
+        raw = _depth_extract(text)
+
+    if not raw:
+        return text, repairs
+
+    # 2. Prova parse diretto
+    try:
+        json.loads(raw)
+        return raw, repairs
+    except json.JSONDecodeError as _exc:
+        _logger.debug("[response_verifier] silenced %s", type(_exc).__name__)  # noqa: BLE001
+
+    fixed = raw
+
+    # 3. Rimuovi trailing comma prima di } o ]
+    fixed, n = re.subn(r",\s*([}\]])", r"\1", fixed)
+    if n:
+        repairs.append(f"Rimossi {n} trailing comma nel JSON")
+
+    # 4. Aggiungi virgolette a chiavi non quotate
+    fixed, n = re.subn(r'(?<=[{,])\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*:', r' "\1":', fixed)
+    if n:
+        repairs.append(f"Quotate {n} chiavi JSON non quotate")
+
+    # 5. Sostituisci apici singoli con doppi (solo nelle stringhe)
+    if "'" in fixed and '"' not in fixed:
+        fixed = fixed.replace("'", '"')
+        repairs.append("Convertiti apici singoli → doppi nel JSON")
+
+    # 6. Prova di nuovo
+    try:
+        json.loads(fixed)
+        repairs.append("JSON riparato con successo")
+        return fixed, repairs
+    except json.JSONDecodeError as _exc:
+        _logger.debug("[response_verifier] silenced %s", type(_exc).__name__)  # noqa: BLE001
+
+    # 7. Non riparabile — restituisci originale
+    return text, repairs
+
+
+# ── Markdown Sanitization ─────────────────────────────────────────────────────
+
+def sanitize_markdown(text: str) -> tuple[str, list[str]]:
+    """
+    Chiude code fence aperte e corregge markdown malformato.
+    """
+    repairs: list[str] = []
+    lines = text.split("\n")
+
+    # 1. Conta code fence aperte
+    fence_count = sum(1 for l in lines if re.match(r"^```", l))
+    if fence_count % 2 != 0:
+        text = text + "\n```"
+        repairs.append("Chiusa code fence aperta")
+
+    # 2. Correggi heading senza spazio (es. "##Titolo" → "## Titolo")
+    fixed, n = re.subn(r"^(#{1,6})([^#\s])", r"\1 \2", text, flags=re.MULTILINE)
+    if n:
+        text = fixed
+        repairs.append(f"Corretti {n} heading Markdown malformati")
+
+    # 3. Rimuovi backtick tripli isolati su riga vuota alla fine
+    text = re.sub(r"\n```\s*$", "\n```", text)
+
+    return text, repairs
+
+
+# ── Coherence Check ───────────────────────────────────────────────────────────
+
+def check_coherence(goal: str, response: str) -> tuple[float, list[str], str]:
+    """
+    Verifica la coerenza della risposta rispetto al goal.
+    Ritorna (quality_score 0-1, issues[], retry_hint).
+    """
+    issues: list[str] = []
+    score = 1.0
+    hint = ""
+
+    stripped = response.strip()
+
+    # 1. Risposta vuota
+    if not stripped or len(stripped) < 20:
+        issues.append("Risposta troppo breve o vuota")
+        return 0.0, issues, "Rispondi in modo completo e diretto. Non restituire testo vuoto."
+
+    # 2. Tool description leak — l'agente descrive tool invece di usarli
+    for pat in _COMPILED_TOOL_PATTERNS:
+        if pat.search(stripped):
+            issues.append("L'agente sta descrivendo tool invece di usarli")
+            score -= 0.5
+            hint = (
+                "NON descrivere come usare tool o comandi. "
+                "I dati devono essere già stati recuperati. "
+                "Rispondi direttamente con le informazioni richieste."
+            )
+            break
+
+    # 3. Resa senza contenuto
+    for pat in _COMPILED_EMPTY_PATTERNS:
+        if pat.match(stripped):
+            issues.append("Risposta di resa senza contenuto utile")
+            score -= 0.4
+            if not hint:
+                # S577: 100→200 — più contesto nell'hint di repair
+                # S589: goal 200→300 — hint repair più dettagliato
+                # S597: 300→500 — goal lunghi tagliati
+                hint = f"Fornisci una risposta utile e completa all'obiettivo: {goal[:500]}"
+            break
+
+    # 4. Risposta in lingua sbagliata (controllo leggero)
+    italian_markers = ["è", "sono", "non", "per", "con", "che", "della", "una", "questo"]
+    english_markers = ["the", "is", "are", "for", "with", "that", "this", "have"]
+    italian_score = sum(1 for w in italian_markers if f" {w} " in stripped.lower())
+    english_score = sum(1 for w in english_markers if f" {w} " in stripped.lower())
+    if english_score > italian_score + 3:
+        issues.append("Risposta in inglese invece di italiano")
+        score -= 0.2
+        if not hint:
+            hint = "Rispondi SEMPRE in italiano."
+
+    # 5. Risposta troppo corta per il tipo di richiesta
+    is_complex = any(k in goal.lower() for k in ["spiega", "analizza", "descrivi", "come funziona"])
+    if is_complex and len(stripped) < 100:
+        issues.append("Risposta troppo breve per una richiesta complessa")
+        score -= 0.2
+        if not hint:
+            hint = "Fornisci una risposta più dettagliata e completa."
+
+    # 6. HTML/JS structural issues — detect broken markup in code blocks
+    if "```html" in stripped.lower():
+        html_issues = _check_html_structure(stripped)
+        if html_issues:
+            issues.extend(html_issues)
+            score -= 0.15
+            if not hint:
+                hint = f"Il codice HTML ha problemi strutturali: {'; '.join(html_issues[:2])}. Correggi la struttura."
+
+    # 7. JS unbalanced braces in code blocks
+    if "```javascript" in stripped.lower() or "```js" in stripped.lower():
+        js_issues = _check_js_structure(stripped)
+        if js_issues:
+            issues.extend(js_issues)
+            score -= 0.10
+            if not hint:
+                hint = f"Il codice JavaScript ha problemi strutturali: {'; '.join(js_issues[:2])}."
+
+    # 8. Mancanza executive summary per risposte lunghe (GAP-UX-1 — regola 20)
+    # Penalità leggera: incoraggia formato **[EMOJI] Esito** all'inizio
+    if len(stripped) > 200:
+        import re as _re2
+        first_line = stripped.split("\n")[0].strip()
+        has_bold_summary = bool(_re2.match(r'^\*\*[^*].{2,}\*\*', first_line))
+        if not has_bold_summary:
+            issues.append("Risposta senza executive summary in grassetto (regola 20 — GAP-UX-1)")
+            score -= 0.10
+            if not hint:
+                hint = (
+                    "Inizia la risposta con **[EMOJI] [Esito conciso max 8 parole]** "
+                    "come da regola 20. Es: **✅ Completato** — spiegazione breve."
+                )
+
+    return max(0.0, score), issues, hint
+
+
+# ── HTML/JS Structure Checks (S401) ──────────────────────────────────────────
+
+def _check_html_structure(text: str) -> list[str]:
+    """Rileva problemi strutturali in blocchi HTML."""
+    issues: list[str] = []
+    import re
+
+    # Estrai blocchi HTML
+    blocks = re.findall(r"```html\s*(.*?)```", text, re.DOTALL | re.IGNORECASE)
+    for block in blocks[:1]:
+        # Tag non bilanciati (esclusi void elements)
+        void_tags = {"area","base","br","col","embed","hr","img","input",
+                     "link","meta","param","source","track","wbr"}
+        open_tags  = re.findall(r"<([a-zA-Z][a-zA-Z0-9]*)[^>/]*>", block)
+        close_tags = re.findall(r"</([a-zA-Z][a-zA-Z0-9]*)>", block)
+        open_count: dict[str, int] = {}
+        for t in open_tags:
+            tl = t.lower()
+            if tl not in void_tags:
+                open_count[tl] = open_count.get(tl, 0) + 1
+        for t in close_tags:
+            tl = t.lower()
+            open_count[tl] = open_count.get(tl, 0) - 1
+        unbalanced = [t for t, c in open_count.items() if c != 0]
+        if unbalanced:
+            # S597: unbalanced[:4]→[:6] — mostra più tag sbilanciati nel report
+            issues.append(f"Tag non bilanciati: {', '.join(unbalanced[:6])}")
+
+        # Script/style non chiusi
+        if block.count("<script") != block.count("</script>"):
+            issues.append("Tag <script> non bilanciato")
+        if block.count("<style") != block.count("</style>"):
+            issues.append("Tag <style> non bilanciato")
+
+    return issues
+
+
+def _check_js_structure(text: str) -> list[str]:
+    """Rileva problemi strutturali in blocchi JavaScript."""
+    issues: list[str] = []
+    import re
+
+    blocks = re.findall(r"```(?:javascript|js)\s*(.*?)```", text, re.DOTALL | re.IGNORECASE)
+    for block in blocks[:1]:
+        # Parentesi graffe sbilanciate (escluse stringhe e commenti — approssimazione)
+        stripped = re.sub(r"//[^\n]*", "", block)          # rimuovi commenti riga
+        stripped = re.sub(r"/\*.*?\*/", "", stripped, flags=re.DOTALL)  # commenti blocco
+        stripped = re.sub(r'"[^"\\]*(?:\\.[^"\\]*)*"', '""', stripped)   # stringhe
+        stripped = re.sub(r"'[^'\\]*(?:\\.[^'\\]*)*'", "''", stripped)
+
+        braces = stripped.count("{") - stripped.count("}")
+        parens  = stripped.count("(") - stripped.count(")")
+        if abs(braces) > 0:
+            issues.append(f"Parentesi graffe sbilanciate ({braces:+d})")
+        if abs(parens) > 0:
+            issues.append(f"Parentesi tonde sbilanciate ({parens:+d})")
+
+    return issues
+
+
+# ── Main Verifier Class ───────────────────────────────────────────────────────
+
+class ResponseVerifier:
+    """
+    Verifica e ripara l'output LLM.
+    Usato da UnifiedAgentLoop dopo ogni risposta LLM.
+    """
+
+    def verify_and_repair(self, goal: str, output: str) -> VerifyResult:
+        """
+        Esegue tutti i repair pass e restituisce VerifyResult.
+        Non-blocking, non richiede LLM.
+        """
+        current = output
+        all_repairs: list[str] = []
+
+        # 1. Markdown sanitization
+        current, md_repairs = sanitize_markdown(current)
+        all_repairs.extend(md_repairs)
+
+        # 2. JSON repair (solo se sembra JSON)
+        if "{" in current and "}" in current:
+            current, json_repairs = repair_json(current)
+            all_repairs.extend(json_repairs)
+
+        # 3. Coherence check
+        quality, issues, retry_hint = check_coherence(goal, current)
+        all_repairs.extend(issues)
+
+        retry_suggested = quality < QUALITY_RETRY_THRESHOLD
+
+        return VerifyResult(
+            output=current,
+            repairs=all_repairs,
+            quality=quality,
+            retry_suggested=retry_suggested,
+            retry_hint=retry_hint,
+        )
+
+    def build_retry_prompt(self, goal: str, bad_output: str, hint: str) -> str:
+        """Costruisce prompt migliorato per il retry."""
+        return (
+            f"La risposta precedente non era soddisfacente.\n"
+            f"PROBLEMA: {hint}\n\n"
+            # S592: bad_output 300→500 — più contesto della risposta precedente per retry
+            f"Risposta precedente (non usare):\n{bad_output[:500]}...\n\n"
+            f"Obiettivo originale: {goal}\n\n"
+            f"Ora rispondi correttamente, in italiano, in modo diretto e completo."
+        )

agents/skill_tracker.py

@@ -0,0 +1,400 @@
+"""
+skill_tracker.py — GAP-SKILL-SYNC: Session-scoped adaptive tool success/failure tracker.
+GAP-SUP1: Supabase persistence — skill stats sopravvivono ai riavvii del backend.
+
+Design originale:
+  - In-memory Dict[session_id, Dict[tool_name, SkillStats]] — zero DB dep, zero latency
+  - SkillStats: success_count, fail_count, last_used, total_latency_ms
+  - record() sincrono — GIL-safe in CPython, asyncio single-threaded
+  - get_sorted_fallbacks() — Wilson score lower bound (95% CI) per robustezza su n piccoli
+  - get_stats() — JSON-serializable per /api/agent/skill-stats endpoint
+  - clear_session() — cleanup opzionale fine task (evita memory leak su run lunghissimi)
+
+GAP-SUP1 (Supabase persistence):
+  - _supabase_upsert(): httpx POST → PostgREST /rest/v1/skill_stats (upsert conflict)
+  - _supabase_load_session(): httpx GET → ripristina sessione precedente al boot
+  - record() fire-and-forget ogni _SYNC_EVERY_N chiamate per tool/sessione
+  - load_session_from_cloud(): chiamato da unified_loop al boot sessione
+  - Fallback silente se SUPABASE_URL/SUPABASE_ANON_KEY assenti → comportamento invariato
+  - Timeout conservativo 8s — mai blocca il loop principale
+  - Schema SQL: backend/migrations/gap1_skill_stats.sql
+
+Integrazione:
+  - unified_loop.py: record() dopo ogni executor.run_tool() — registra successo/fallimento
+  - unified_loop.py: load_session_from_cloud() al boot sessione (se Supabase abilitato)
+  - api/agent.py: GET /api/agent/skill-stats/{session_id} per merge Dexie frontend
+
+Singleton: get_skill_tracker() restituisce sempre lo stesso SkillTracker globale.
+"""
+from __future__ import annotations
+
+import asyncio
+import math
+import os
+import time
+import logging
+from collections import defaultdict
+from dataclasses import dataclass
+from typing import Any
+
+import httpx
+
+_logger = logging.getLogger("agente_ai.skill_tracker")
+
+
+# ─── Supabase config (GAP-SUP1) ───────────────────────────────────────────────
+
+_SUPA_URL     = os.getenv("SUPABASE_URL", "").rstrip("/")
+_SUPA_KEY     = os.getenv("SUPABASE_ANON_KEY", "")
+_SUPA_ENABLED = bool(_SUPA_URL and _SUPA_KEY)
+_SUPA_TABLE   = "skill_stats"   # tabella PostgREST — vedi gap1_skill_stats.sql
+_SYNC_EVERY_N = 5               # upsert ogni N record() per tool/sessione (throttle)
+
+if _SUPA_ENABLED:
+    _logger.info("[skill_tracker] Supabase persistence ABILITATA → %s/rest/v1/%s", _SUPA_URL, _SUPA_TABLE)
+else:
+    _logger.debug("[skill_tracker] Supabase non configurato — solo in-memory")
+
+
+# ─── SkillStats ───────────────────────────────────────────────────────────────
+
+@dataclass
+class SkillStats:
+    success_count:    int   = 0
+    fail_count:       int   = 0
+    last_used:        float = 0.0
+    total_latency_ms: float = 0.0
+
+    @property
+    def total_count(self) -> int:
+        return self.success_count + self.fail_count
+
+    @property
+    def success_rate(self) -> float:
+        if not self.total_count:
+            return 1.0   # ottimismo iniziale — tool mai usato
+        return self.success_count / self.total_count
+
+    @property
+    def avg_latency_ms(self) -> float:
+        if not self.total_count:
+            return 0.0
+        return self.total_latency_ms / self.total_count
+
+    def wilson_score(self) -> float:
+        """Wilson score lower bound (95% CI).
+
+        Bilanciamento statisticamente robusto tra success rate e confidenza.
+        Esempio: tool 1/1 (score ≈ 0.21) vs tool 10/11 (score ≈ 0.68) —
+        il secondo viene preferito anche se il primo ha 100% raw rate.
+        Usato da get_sorted_fallbacks() per ordinamento adattivo.
+        """
+        n = self.total_count
+        if n == 0:
+            return 0.5       # prior neutro su tool mai usati in questa sessione
+        p   = self.success_count / n
+        z   = 1.96           # 95% confidence interval
+        num = p + z * z / (2 * n) - z * math.sqrt((p * (1 - p) + z * z / (4 * n)) / n)
+        den = 1 + z * z / n
+        return num / den
+
+    def to_supabase_row(self, session_id: str, tool_name: str) -> dict:
+        """Serializza per upsert PostgREST."""
+        return {
+            "session_id":       session_id,
+            "tool_name":        tool_name,
+            "success_count":    self.success_count,
+            "fail_count":       self.fail_count,
+            "last_used":        self.last_used,
+            "total_latency_ms": self.total_latency_ms,
+        }
+
+    @classmethod
+    def from_supabase_row(cls, row: dict) -> "SkillStats":
+        """Deserializza da riga PostgREST."""
+        return cls(
+            success_count    = int(row.get("success_count",    0)),
+            fail_count       = int(row.get("fail_count",       0)),
+            last_used        = float(row.get("last_used",      0.0)),
+            total_latency_ms = float(row.get("total_latency_ms", 0.0)),
+        )
+
+
+# ─── Supabase helpers (GAP-SUP1) ──────────────────────────────────────────────
+
+async def _supabase_upsert(session_id: str, tool_name: str, stats: SkillStats) -> None:
+    """Fire-and-forget: upsert riga skill_stats su Supabase (PostgREST).
+
+    Fallback silente su qualsiasi errore — mai blocca il loop principale.
+    Timeout 8s conservativo.
+    """
+    if not _SUPA_ENABLED:
+        return
+    row = stats.to_supabase_row(session_id, tool_name)
+    try:
+        async with httpx.AsyncClient(timeout=8.0) as client:
+            resp = await client.post(
+                f"{_SUPA_URL}/rest/v1/{_SUPA_TABLE}",
+                json=row,
+                headers={
+                    "apikey":        _SUPA_KEY,
+                    "Authorization": f"Bearer {_SUPA_KEY}",
+                    "Content-Type":  "application/json",
+                    "Prefer":        "resolution=merge-duplicates,return=minimal",
+                },
+            )
+            if resp.status_code not in (200, 201, 204):
+                _logger.debug(
+                    "[skill_tracker] supabase upsert %s: HTTP %d %s",
+                    tool_name[:20], resp.status_code, resp.text[:120],
+                )
+    except Exception as exc:  # noqa: BLE001
+        _logger.debug("[skill_tracker] supabase upsert silenced: %s", type(exc).__name__)
+
+
+async def _supabase_load_session(session_id: str) -> dict[str, SkillStats]:
+    """Carica tutti i tool stats di una sessione da Supabase.
+
+    Ritorna dict vuoto su qualsiasi errore (fallback silente).
+    Chiamato da load_session_from_cloud() al boot sessione.
+    """
+    if not _SUPA_ENABLED:
+        return {}
+    try:
+        async with httpx.AsyncClient(timeout=8.0) as client:
+            resp = await client.get(
+                f"{_SUPA_URL}/rest/v1/{_SUPA_TABLE}",
+                params={"session_id": f"eq.{session_id}", "select": "*"},
+                headers={
+                    "apikey":        _SUPA_KEY,
+                    "Authorization": f"Bearer {_SUPA_KEY}",
+                },
+            )
+            if resp.status_code != 200:
+                _logger.debug(
+                    "[skill_tracker] supabase load %s: HTTP %d",
+                    session_id[:12], resp.status_code,
+                )
+                return {}
+            rows: list[dict] = resp.json()
+            loaded = {
+                row["tool_name"]: SkillStats.from_supabase_row(row)
+                for row in rows
+                if "tool_name" in row
+            }
+            if loaded:
+                _logger.info(
+                    "[skill_tracker] GAP-SUP1: ripristinati %d tool stats per sessione %s",
+                    len(loaded), session_id[:12],
+                )
+            return loaded
+    except Exception as exc:  # noqa: BLE001
+        _logger.debug("[skill_tracker] supabase load silenced: %s", type(exc).__name__)
+        return {}
+
+
+# ─── SkillTracker ─────────────────────────────────────────────────────────────
+
+class SkillTracker:
+    """Singleton session-scoped tracker: impara quali tool funzionano per ogni sessione.
+
+    GAP-SUP1: i dati persistono su Supabase e vengono ripristinati al boot sessione.
+    """
+
+    def __init__(self) -> None:
+        self._sessions: dict[str, dict[str, SkillStats]] = defaultdict(
+            lambda: defaultdict(SkillStats)
+        )
+        # Contatori per throttle upsert (session_id → tool_name → count_since_last_sync)
+        self._sync_counters: dict[str, dict[str, int]] = defaultdict(lambda: defaultdict(int))
+
+    # ── Write ─────────────────────────────────────────────────────────────────
+
+    def record(
+        self,
+        session_id:  str,
+        tool_name:   str,
+        success:     bool,
+        latency_ms:  float = 0.0,
+    ) -> None:
+        """Registra il risultato di una chiamata tool (sincrono, GIL-safe).
+
+        Chiamato da unified_loop.py dopo ogni executor.run_tool().
+        GAP-SUP1: fire-and-forget upsert Supabase ogni _SYNC_EVERY_N chiamate.
+        """
+        s = self._sessions[session_id][tool_name]
+        if success:
+            s.success_count += 1
+        else:
+            s.fail_count    += 1
+        s.last_used        = time.monotonic()
+        s.total_latency_ms += latency_ms
+
+        # GAP-SUP1: sync throttled — ogni _SYNC_EVERY_N record per questo tool/sessione
+        if _SUPA_ENABLED:
+            self._sync_counters[session_id][tool_name] += 1
+            if self._sync_counters[session_id][tool_name] >= _SYNC_EVERY_N:
+                self._sync_counters[session_id][tool_name] = 0
+                try:
+                    loop = asyncio.get_running_loop()
+                    loop.create_task(
+                        _supabase_upsert(session_id, tool_name, s),
+                        name=f"skill_sync_{tool_name[:20]}",
+                    )
+                except RuntimeError:
+                    pass  # no running loop (test context) — silente
+
+    # ── Cloud bootstrap (GAP-SUP1) ────────────────────────────────────────────
+
+    async def load_session_from_cloud(self, session_id: str) -> int:
+        """Ripristina stats precedenti da Supabase per la sessione (chiamare al boot task).
+
+        Merge con in-memory: somma i contatori (in-memory è vuoto al boot, ma sicuro).
+        Ritorna numero di tool ripristinati (0 se Supabase non configurato).
+        Idempotente: chiamate multiple sommano i dati — chiamare una sola volta per sessione.
+        """
+        loaded = await _supabase_load_session(session_id)
+        if not loaded:
+            return 0
+        session = self._sessions[session_id]
+        for tool_name, cloud_stats in loaded.items():
+            mem = session[tool_name]
+            # Merge additivo — in-memory è tipicamente vuoto al boot
+            mem.success_count    += cloud_stats.success_count
+            mem.fail_count       += cloud_stats.fail_count
+            mem.total_latency_ms += cloud_stats.total_latency_ms
+            # last_used: prendi il più recente
+            if cloud_stats.last_used > mem.last_used:
+                mem.last_used = cloud_stats.last_used
+        return len(loaded)
+
+    async def flush_session_to_cloud(self, session_id: str) -> int:
+        """Forza upsert di tutti i tool di una sessione su Supabase (chiamare a fine task).
+
+        Ritorna numero di tool sincronizzati. Fallback silente su errori.
+        """
+        if not _SUPA_ENABLED:
+            return 0
+        session = self._sessions.get(session_id, {})
+        tasks = [
+            _supabase_upsert(session_id, tool_name, stats)
+            for tool_name, stats in session.items()
+        ]
+        if tasks:
+            await asyncio.gather(*tasks, return_exceptions=True)
+            _logger.info(
+                "[skill_tracker] GAP-SUP1: flush %d tool stats per sessione %s",
+                len(tasks), session_id[:12],
+            )
+        return len(tasks)
+
+    # ── Read / routing ────────────────────────────────────────────────────────
+
+    def get_sorted_fallbacks(
+        self,
+        session_id: str,
+        candidates: list[str],
+    ) -> list[str]:
+        """Riordina i candidati tool per Wilson score decrescente.
+
+        Tool mai usati in questa sessione → prior neutro 0.5, non penalizzati.
+        Uso tipico: reordina la lista fallback prima di provarli.
+        """
+        session = self._sessions.get(session_id, {})
+        return sorted(
+            candidates,
+            key=lambda t: session[t].wilson_score() if t in session else 0.5,
+            reverse=True,
+        )
+
+    def get_stats(self, session_id: str) -> dict[str, dict]:
+        """Statistiche JSON-serializable per una sessione (ordinato per Wilson score desc)."""
+        session = self._sessions.get(session_id, {})
+        return {
+            tool: {
+                "success_count":  s.success_count,
+                "fail_count":     s.fail_count,
+                "total_count":    s.total_count,
+                "success_rate":   round(s.success_rate,    3),
+                "wilson_score":   round(s.wilson_score(),  3),
+                "avg_latency_ms": round(s.avg_latency_ms,  1),
+                "last_used":      round(s.last_used,        3),
+            }
+            for tool, s in sorted(
+                session.items(),
+                key=lambda kv: kv[1].wilson_score(),
+                reverse=True,
+            )
+        }
+
+    def get_all_sessions(self) -> dict[str, Any]:
+        """Debug: panoramica tutte le sessioni attive."""
+        return {
+            sid: {
+                "tool_count":   len(tools),
+                "total_calls":  sum(s.total_count for s in tools.values()),
+                "tools":        list(tools.keys()),
+            }
+            for sid, tools in self._sessions.items()
+        }
+
+    def clear_session(self, session_id: str) -> None:
+        """Libera memoria per una sessione terminata."""
+        removed = self._sessions.pop(session_id, None)
+        self._sync_counters.pop(session_id, None)
+        if removed is not None:
+            _logger.debug(
+                "[skill_tracker] cleared session %s (%d tools tracked)",
+                session_id[:12],
+                len(removed),
+            )
+
+
+# ─── Singleton globale ───────────────────────────────────────────��────────────
+
+_skill_tracker = SkillTracker()
+
+
+def get_skill_tracker() -> SkillTracker:
+    """Restituisce il singleton SkillTracker. Thread-safe in CPython (GIL)."""
+    return _skill_tracker
+
+
+# ─── P17-B2: FastAPI router per sync frontend ─────────────────────────────────
+# Endpoint REST che permette al frontend (Dexie) di leggere e scrivere skill stats.
+# Montato in backend/main.py tramite _on_startup() se importato.
+
+try:
+    from fastapi import APIRouter as _APIRouter
+    from pydantic import BaseModel as _BM
+
+    skill_router = _APIRouter(prefix="/api/agent", tags=["skill-tracker"])
+
+    class _SkillRecordBody(_BM):
+        success:    bool
+        latency_ms: float = 0.0
+        error_msg:  str   = ""
+
+    @skill_router.get("/skill-stats/{session_id}")
+    async def api_get_skill_stats(session_id: str):
+        """Restituisce stats tool per sessione — per merge con Dexie frontend."""
+        return get_skill_tracker().get_stats(session_id)
+
+    @skill_router.post("/skill-record/{session_id}/{tool_name}")
+    async def api_record_skill(session_id: str, tool_name: str, body: _SkillRecordBody):
+        """Registra un risultato tool dal frontend (es. tool chiamato via browser)."""
+        get_skill_tracker().record(
+            session_id, tool_name,
+            success=body.success,
+            latency_ms=body.latency_ms,
+        )
+        return {"ok": True, "session_id": session_id, "tool": tool_name}
+
+    @skill_router.delete("/skill-stats/{session_id}")
+    async def api_clear_skill_session(session_id: str):
+        """Pulisce la sessione skill tracker alla fine del task."""
+        get_skill_tracker().clear_session(session_id)
+        return {"ok": True}
+
+except ImportError:
+    skill_router = None  # type: ignore[assignment]  # FastAPI non disponibile (unit test env)

agents/strategic_healer.py

@@ -0,0 +1,605 @@
+"""
+strategic_healer.py — GAP-SELFHEAL v3: Cognitive Self-Healing Loop
+
+Principio fondamentale: ogni fallimento deve insegnare qualcosa di PRECISO.
+Niente retry statici, niente hint precompilati.
+Ogni transizione di strategia emerge da ragionamento sul contesto specifico:
+
+  Strategia 1 tentata
+    → PERCHÉ ha fallito (ragione strutturale, non solo l'errore)
+    → Strategia 2 ragionata (diversa per costruzione, non per caso)
+  Strategia 2 tentata
+    → PERCHÉ anche lei ha fallito (incorpora conoscenza dei due fallimenti)
+    → Strategia 3 ortogonale a entrambe
+  ...
+  Dopo MAX_ATTEMPTS: diagnosi finale strutturale, non altro retry
+
+Usa la memoria episodica della sessione per non ripetere pattern già falliti
+in run precedenti sullo stesso goal (o goal simili).
+
+Integrazione in unified_loop.py:
+  # All'inizio del run (una volta per goal):
+  healer = StrategicHealer(self.llm, state.goal, memory=self.memory)
+  await healer.load_past_failures()
+
+  # Dopo ogni ciclo subtask con fallimenti:
+  decision = await healer.analyze_and_decide(errors_list, exec_context_str)
+  if decision.should_stop:
+      exec_warn.insert(0, decision.strategy_prompt)  # diagnosi finale
+  else:
+      exec_warn.insert(0, decision.strategy_prompt)  # nuova strategia ragionata
+"""
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+from dataclasses import dataclass, field
+from typing import Any, Optional
+
+_logger = logging.getLogger("agente_ai.healer")
+
+
+# ── Strutture dati ─────────────────────────────────────────────────────────────
+
+@dataclass
+class AttemptRecord:
+    """Registro completo e immutabile di un tentativo fallito."""
+    attempt_num: int
+    strategy_brief: str    # Cosa è stato tentato (estratto dal contesto, 1-2 righe)
+    errors: list[str]      # Errori grezzi dell'iterazione
+    error_category: str    # Categoria da error_classifier (es. "syntax", "logic")
+    why_failed: str        # Ragionamento LLM: PERCHÉ strutturalmente questo approccio non poteva funzionare
+    next_direction: str    # Direzione LLM per il prossimo tentativo (specifica, non generica)
+    timestamp: float = field(default_factory=time.time)
+
+
+@dataclass
+class StrategyDecision:
+    """Decisione sulla prossima strategia da iniettare nel contesto del loop."""
+    strategy_prompt: str   # Testo pronto da inserire in exec_warn[0]
+    confidence: float      # 0.0–1.0: quanto il healer è sicuro della decisione
+    rationale: str         # Spiegazione interna (per logging/debugging)
+    should_stop: bool = False  # True se abbiamo esaurito le idee ragionevoli
+    stop_reason: str = ""      # Diagnosi finale se should_stop=True
+
+
+# ── Healer principale ──────────────────────────────────────────────────────────
+
+class StrategicHealer:
+
+    # ── S-DYNAMIC-TOOL-HEALING: Fallback dinamico per tool (S512) ────────────
+    async def get_tool_fallback_strategy(self, tool_name: str, error: str) -> str:
+        """Determina una strategia alternativa se un tool specifico fallisce."""
+        fallbacks = {
+            "google_search": "Il tool di ricerca web è instabile. Usa 'webpage_extract' direttamente sugli URL noti o tenta una ricerca mirata su GitHub/Wikipedia via shell.",
+            "web_fetch": "L'estrazione fallisce. Usa 'curl -s' via shell per ottenere il contenuto grezzo e analizzalo con regex.",
+            "python_exec": "L'esecuzione Python ha fallito. Tenta di risolvere il task tramite logica shell (bc, awk, sed) o semplifica lo script."
+        }
+        return fallbacks.get(tool_name, f"Il tool {tool_name} ha fallito. Analizza l'errore {error} e cambia approccio.")
+
+    """
+    Cognitive self-healing: costruisce comprensione incrementale dei fallimenti.
+
+    Ogni chiamata ad analyze_and_decide():
+      1. Classifica l'errore (deterministico, zero latenza)
+      2. Ragiona su PERCHÉ l'approccio corrente era sbagliato (LLM)
+      3. Incorpora la storia di TUTTI i tentativi precedenti della sessione
+      4. Consulta la memoria episodica per pattern già noti come fallaci
+      5. Produce una strategia ortogonale a tutto ciò già tentato
+
+    Non usa hint statici precompilati.
+    Non ripete lo stesso ragionamento — ogni risposta deve aggiungere informazione.
+    """
+
+    MAX_ATTEMPTS = 5  # oltre questo, diagnosi finale e stop
+
+    # GAP-DIVERSITY: quando una categoria fallisce >=2 volte, forza alternativa
+    # DETERMINISTICA — non dipende dall'LLM free tier (es. Llama 3.1 8B).
+    _CATEGORY_ALTERNATIVES: dict = {
+        "syntax":   ["logic", "runtime", "modulenotfounderror"],
+        "logic":    ["syntax", "valueerror", "typeerror"],
+        "runtime":  ["logic", "importerror", "typeerror"],
+        "network":  ["logic", "runtime", "valueerror"],
+        "importerror": ["runtime", "logic", "syntax"],
+        "modulenotfounderror": ["importerror", "runtime", "logic"],
+        "typeerror":  ["logic", "valueerror", "syntax"],
+        "valueerror": ["typeerror", "logic", "runtime"],
+        "unknown":    ["syntax", "logic", "runtime"],
+    }
+    _FORCED_STRATEGIES: dict = {
+        "syntax": [
+            "Genera codice in blocchi atomici (<10 righe), verifica sintassi ognuno.",
+            "Scrivi solo scheletro (firme+stub), riempi un metodo alla volta.",
+        ],
+        "logic": [
+            "Scrivi casi test attesi (TDD inverso), poi implementa per soddisfarli.",
+            "Decomponi in 3 funzioni pure, verifica ognuna con input/output espliciti.",
+        ],
+        "runtime": [
+            "Usa try/except granulari attorno ogni operazione I/O o accesso a chiave.",
+            "Verifica esistenza ogni risorsa prima: if key in dict, if path.exists().",
+        ],
+        "network": [
+            "Usa dati locali/mock, aggiungi timeout=10 e retry backoff esponenziale.",
+        ],
+        "importerror": ["Usa solo stdlib Python: json, csv, re, pathlib, collections."],
+        "modulenotfounderror": ["Usa solo stdlib Python. Reimplementa senza dipendenze."],
+        "typeerror": ["Aggiungi conversioni esplicite str/int/list prima di ogni op."],
+        "valueerror": ["Valida e normalizza ogni input: None, stringa vuota, range."],
+        "unknown": ["Decomponi in 3 sotto-problemi indipendenti, risolvi il più semplice."],
+    }
+
+    def __init__(self, llm_client: Any, goal: str, memory: Any = None):
+        self.llm    = llm_client
+        self.goal   = goal
+        self.memory = memory
+        self.history: list[AttemptRecord] = []
+        self._past_session_patterns: list[str] = []  # da memoria episodica
+        self._goal_hash = goal[:80]  # per matching memoria
+        # GAP-DIVERSITY: tracking deterministico — indipendente qualità LLM
+        self._category_frequency: dict[str, int] = {}
+        self._category_strategies: dict[str, list[str]] = {}
+
+    # ── Interfaccia pubblica ───────────────────────────────────────────────────
+
+    async def load_past_failures(self) -> None:
+        """
+        Carica pattern di fallimento da sessioni precedenti.
+        Permette di non ripetere strategie già dimostrate inefficaci.
+        """
+        if not self.memory:
+            return
+        try:
+            if hasattr(self.memory, 'episodic') and hasattr(self.memory.episodic, 'search'):
+                episodes = await asyncio.wait_for(
+                    self.memory.episodic.search(self._goal_hash, limit=5),
+                    timeout=3.0,
+                )
+                failed_eps = [e for e in (episodes or []) if not getattr(e, 'success', True)]
+                self._past_session_patterns = [
+                    getattr(e, 'content', '')[:200] for e in failed_eps[:3]
+                ]
+                if self._past_session_patterns:
+                    _logger.debug(
+                        "StrategicHealer: caricati %d pattern falliti da sessioni precedenti",
+                        len(self._past_session_patterns),
+                    )
+        except Exception as _e:
+            _logger.debug("StrategicHealer.load_past_failures: %s", str(_e)[:60])
+
+    async def analyze_and_decide(
+        self,
+        current_errors: list[str],
+        exec_context: str = "",
+    ) -> StrategyDecision:
+        """
+        Punto di ingresso principale.
+
+        Args:
+            current_errors: errori dell'iterazione appena fallita
+            exec_context:   stringa con piano/subtask eseguiti (per capire cosa si è tentato)
+
+        Returns:
+            StrategyDecision con strategy_prompt pronto per exec_warn.insert(0, ...)
+        """
+        attempt_num = len(self.history) + 1
+
+        # Diagnosi finale se abbiamo raggiunto il limite
+        if attempt_num > self.MAX_ATTEMPTS:
+            return await self._final_diagnosis()
+
+        # ── Step 1: Classificazione deterministica (zero latenza) ──────────────
+        error_category = self._classify(current_errors)
+
+        # ── Step 1b: GAP-DIVERSITY — forza ortogonalità se categoria ripetuta >=2v  # SH-BUG-1
+        _forced = self._get_forced_direction(error_category)
+
+        # ── Step 2: Ragionamento LLM su PERCHÉ questo approccio era sbagliato ─
+        why_failed, next_direction = await self._reason_why_failed(
+            current_errors, error_category, exec_context, attempt_num,
+            forced_direction=_forced,
+        )
+
+        # ── Step 3: Registra il tentativo ──────────────────────────────────────
+        record = AttemptRecord(
+            attempt_num   = attempt_num,
+            strategy_brief= self._extract_strategy_brief(exec_context),
+            errors        = [str(e)[:300] for e in current_errors[-3:]],
+            error_category= error_category,
+            why_failed    = why_failed,
+            next_direction= next_direction,
+        )
+        self.history.append(record)
+        # GAP-DIVERSITY: aggiorna tracking
+        self._category_frequency[error_category] = self._category_frequency.get(error_category, 0) + 1
+        self._category_strategies.setdefault(error_category, []).append(next_direction[:120])
+
+        # ── Step 4: Costruisci la decisione per il prossimo ciclo ──────────────
+        if attempt_num == 1:
+            # Primo fallimento: prompt diretto dal ragionamento sul singolo errore
+            return self._first_failure_decision(record)
+        else:
+            # 2+ fallimenti: sintesi cross-attempt con ARCHITECT
+            return await self._cross_attempt_synthesis()
+
+    # ── Implementazione ────────────────────────────────────────────────────────
+
+    def _classify(self, errors: list[str]) -> str:
+        """Classificazione deterministica: zero latenza, mai blocca il loop."""
+        try:
+            from agents.error_classifier import classify_error
+            result = classify_error([str(e) for e in errors[-4:]])
+            return result.category.value
+        except Exception:
+            return "unknown"
+
+    def _extract_strategy_brief(self, exec_context: str) -> str:
+        """Estrae una descrizione concisa di cosa è stato tentato nell'iterazione."""
+        if not exec_context:
+            return f"tentativo {len(self.history) + 1} (nessun contesto)"
+        lines = [l.strip() for l in exec_context.split('\n') if l.strip()]
+        meaningful = [l for l in lines if len(l) > 10 and not l.startswith('#')]
+        return ' | '.join(meaningful[:2])[:160] if meaningful else lines[0][:160]
+
+    def _get_forced_direction(self, category: str) -> "str | None":
+        """
+        GAP-DIVERSITY fix: se categoria fallita >=2 volte ritorna strategia
+        DETERMINISTICA — bypassa LLM per garantire ortogonalità reale.
+        """
+        freq = self._category_frequency.get(category, 0)
+        if freq < 2:
+            return None
+        strategies = self._FORCED_STRATEGIES.get(category, self._FORCED_STRATEGIES["unknown"])
+        used = set(s[:40] for s in self._category_strategies.get(category, []))
+        for s in strategies:
+            if s[:40] not in used:
+                _logger.info("StrategicHealer DIVERSITY_FORCE cat=%s freq=%d", category, freq)
+                return s
+        for alt in self._CATEGORY_ALTERNATIVES.get(category, ["unknown"]):
+            alts = self._FORCED_STRATEGIES.get(alt, [])
+            if alts:
+                _logger.info("StrategicHealer DIVERSITY_FORCE exhausted→alt_cat=%s", alt)
+                return f"[CAMBIO APPROCCIO {category}→{alt}] {alts[0]}"
+        return None
+
+    async def _reason_why_failed(
+        self,
+        errors: list[str],
+        category: str,
+        exec_context: str,
+        attempt_num: int,
+        forced_direction: "str | None" = None,
+    ) -> tuple[str, str]:
+        """
+        Usa l'LLM per ragionare su PERCHÉ strutturalmente questo approccio
+        non poteva funzionare, e suggerire UNA direzione specifica alternativa.
+
+        Non chiede "cosa ha sbagliato" (già noto dagli errori),
+        ma "perché questo approccio era intrinsecamente inadeguato al goal".
+
+        Ritorna: (why_failed: str, next_direction: str)
+        """
+        history_ctx = self._format_history(verbose=False)
+        past_ctx = ""
+        if self._past_session_patterns:
+            past_ctx = "\nPattern già falliti in sessioni precedenti:\n" + \
+                       "\n".join(f"• {p}" for p in self._past_session_patterns[:2])
+
+        err_text = '\n'.join(str(e)[:400] for e in errors[-3:])
+
+        system = (
+            "Sei un senior engineer che esamina il fallimento di un agente AI autonomo.\n"
+            "Il tuo compito NON è descrivere l'errore (già noto), ma capire "
+            "la RAGIONE STRUTTURALE per cui questo approccio era inadeguato.\n\n"
+            "Rispondi ESATTAMENTE in questo formato (due righe, senza altro):\n"
+            "PERCHE_FALLITO: <1-2 frasi: ragione strutturale per cui questo metodo non "
+            "poteva funzionare per questo goal, non solo l'errore di superficie>\n"
+            "STRATEGIA_SUCCESSIVA: <2-3 frasi: quale approccio SPECIFICO provare dopo "
+            "— nomina librerie, pattern, strutture dati, decomposizione alternativa. "
+            "Mai 'prova diversamente' o 'usa un altro approccio'>"
+        )
+
+        history_section = f"\nTentativi già falliti in questa sessione:\n{history_ctx}" if history_ctx else ""
+        user = (
+            f"Goal: {self.goal[:400]}\n\n"
+            f"Tentativo #{attempt_num} — categoria errore: {category}\n"
+            f"Errori:\n{err_text}"
+            f"{history_section}"
+            f"{past_ctx}"
+        )
+        if forced_direction:
+            freq = self._category_frequency.get(category, 0)
+            user += (
+                f"\n\n⛔ VINCOLO HARD (cat '{category}' fallita {freq}v): "
+                f"la STRATEGIA_SUCCESSIVA DEVE implementare: {forced_direction}\n"
+                f"Non proporre varianti della stessa categoria."
+            )
+        if exec_context:
+            user += f"\n\nContesto esecuzione (cosa si è tentato):\n{exec_context[:350]}"
+
+        try:
+            resp = await asyncio.wait_for(
+                self.llm.chat(
+                    [{"role": "system", "content": system},
+                     {"role": "user",   "content": user}],
+                    temperature=0.1,
+                    max_tokens=380,
+                ),
+                timeout=12.0,
+            )
+
+            if resp and not resp.startswith('[LLM'):
+                why, direction = "", ""
+                for line in resp.split('\n'):
+                    stripped = line.strip()
+                    if stripped.startswith('PERCHE_FALLITO:') or stripped.startswith('PERCHÉ_FALLITO:'):
+                        why = stripped.split(':', 1)[-1].strip()
+                    elif stripped.startswith('STRATEGIA_SUCCESSIVA:'):
+                        direction = stripped.split(':', 1)[-1].strip()
+                # Fallback se il formato non è rispettato esattamente
+                if not why and not direction:
+                    mid = len(resp) // 2
+                    why       = resp[:mid].strip()[:250]
+                    direction = resp[mid:].strip()[:250]
+                elif not direction:
+                    direction = why[len(why)//2:].strip() or "Decomponi il problema in passi atomici verificabili."
+                return why or resp[:200], direction or resp[-200:]
+
+        except Exception as _e:
+            _logger.debug("StrategicHealer._reason_why_failed LLM error: %s", str(_e)[:60])
+
+        # Fallback deterministico per categoria
+        return self._fallback_reasoning(category)
+
+    def _fallback_reasoning(self, category: str) -> tuple[str, str]:
+        """Ragionamento deterministico quando l'LLM non è disponibile."""
+        _MAP = {
+            "syntax":    ("Il codice generato ha errori sintattici che lo rendono non parsabile.",
+                          "Genera codice in blocchi minimali, verifica la sintassi di ogni blocco prima di procedere."),
+            "runtime":   ("L'approccio presuppone uno stato dell'ambiente che non esiste.",
+                          "Verifica lo stato prima di ogni operazione: usa try/except granulari, controlla None/empty, isola ogni effetto collaterale."),
+            "logic":     ("La logica implementata non mappa correttamente i requisiti del goal.",
+                          "Scrivi prima i casi di test attesi, poi implementa la logica che li soddisfa — TDD inverso."),
+            "network":   ("L'endpoint o la connessione non è raggiungibile con questo approccio.",
+                          "Usa dati locali/cached, verifica l'URL base, implementa circuit breaker con fallback su dati statici."),
+            "modulenotfounderror": ("La libreria richiesta non è installata nell'ambiente.",
+                                    "Usa solo la stdlib Python (json, csv, re, pathlib, collections, itertools) o verifica cosa è già installato con pkg_resources."),
+            "importerror": ("L'import fallisce perché il modulo o il percorso non esiste.",
+                            "Verifica il path di import, usa importlib per import condizionale, o refactora senza quel modulo."),
+            "typeerror":  ("I tipi degli argomenti non corrispondono a quanto atteso.",
+                           "Aggiungi conversioni esplicite (str/int/list/dict) e valida il tipo degli input prima di ogni operazione."),
+            "valueerror": ("Il valore passato è fuori dal range o formato atteso.",
+                           "Valida e normalizza ogni input (None, stringa vuota, tipo errato) prima di processarlo."),
+        }
+        _UNKNOWN = ("L'approccio è incompatibile con il goal per ragioni non classificabili.",
+                    "Decomponi il goal in 3 sotto-problemi indipendenti e risolvi il più semplice prima.")
+        return _MAP.get(category, _UNKNOWN)
+
+    def _first_failure_decision(self, record: AttemptRecord) -> StrategyDecision:
+        """Primo fallimento: prompt costruito dal ragionamento sul singolo errore."""
+        prompt = (
+            f"⚠️ CAMBIO STRATEGIA [{record.error_category}·tentativo 1]: "
+            f"{record.why_failed} "
+            f"→ {record.next_direction} "
+            "NON ripetere l'approccio precedente in nessuna forma."
+        )
+        return StrategyDecision(
+            strategy_prompt=prompt,
+            confidence=0.70,
+            rationale=record.why_failed,
+        )
+
+    async def _cross_attempt_synthesis(self) -> StrategyDecision:
+        """
+        2+ fallimenti: l'ARCHITECT sintetizza l'intera storia e propone
+        una strategia ORTOGONALE a tutto ciò già tentato.
+
+        La sintesi non può limitarsi all'ultimo errore — deve ragionare
+        sul pattern comune tra i fallimenti e identificare lo spazio
+        delle soluzioni ancora inesplorato.
+        """
+        history_verbose = self._format_history(verbose=True)
+        n = len(self.history)
+
+        system = (
+            "Sei un senior architect. Un agente AI ha fallito più volte sullo stesso goal.\n"
+            "Analizza la sequenza di tutti i tentativi falliti e ragiona:\n\n"
+            "PATTERN_COMUNE: <1-2 frasi: qual è la caratteristica comune nei fallimenti? "
+            "Non descrivere i singoli errori — trova la causa radice trasversale>\n"
+            "SPAZIO_INESPLORATO: <1-2 frasi: quale classe di approcci NON è stata ancora tentata? "
+            "Qual è il punto cieco?>\n"
+            "STRATEGIA_ORTOGONALE: <2-3 frasi: strategia concreta che non condivide "
+            "nessuna assunzione con i tentativi precedenti — nomina librerie, pattern, "
+            "struttura dati, o decomposizione specifica>\n"
+            "PRIMA_AZIONE: <1 frase: la prima cosa concreta da fare, immediatamente eseguibile>"
+        )
+
+        past_block = ""
+        if self._past_session_patterns:
+            past_block = "\nPattern già falliti in sessioni precedenti (da escludere):\n" + \
+                         "\n".join(f"• {p}" for p in self._past_session_patterns[:2])
+
+        user = (
+            f"Goal: {self.goal[:400]}\n\n"
+            f"Sequenza di {n} fallimenti:\n{history_verbose}"
+            f"{past_block}"
+        )
+
+        try:
+            # Usa ARCHITECT se disponibile — ha il reasoning migliore per sintesi cross-attempt
+            try:
+                from models.role_router import RoleRouter, Role
+                llm     = RoleRouter.get_client(Role.ARCHITECT)
+                timeout = 20.0
+                source  = "ARCHITECT"
+            except Exception:
+                llm     = self.llm
+                timeout = 14.0
+                source  = "BASE"
+
+            resp = await asyncio.wait_for(
+                llm.chat(
+                    [{"role": "system", "content": system},
+                     {"role": "user",   "content": user}],
+                    temperature=0.05,   # massima determinismo — non vogliamo creatività casuale
+                    max_tokens=500,
+                ),
+                timeout=timeout,
+            )
+
+            if resp and not resp.startswith('[LLM'):
+                # Estrai le sezioni dal formato strutturato
+                sections: dict[str, str] = {}
+                current_key = None
+                for line in resp.split('\n'):
+                    stripped = line.strip()
+                    for key in ('PATTERN_COMUNE', 'SPAZIO_INESPLORATO', 'STRATEGIA_ORTOGONALE', 'PRIMA_AZIONE'):
+                        if stripped.startswith(key + ':'):
+                            current_key = key
+                            sections[key] = stripped.split(':', 1)[-1].strip()
+                            break
+                    else:
+                        if current_key and stripped:
+                            sections[current_key] = sections.get(current_key, '') + ' ' + stripped
+
+                # Costruisci il prompt di strategia dalle sezioni
+                parts = []
+                if sections.get('PATTERN_COMUNE'):
+                    parts.append(f"Pattern comune nei fallimenti: {sections['PATTERN_COMUNE']}")
+                if sections.get('SPAZIO_INESPLORATO'):
+                    parts.append(f"Spazio ancora inesplorato: {sections['SPAZIO_INESPLORATO']}")
+                if sections.get('STRATEGIA_ORTOGONALE'):
+                    parts.append(f"Strategia da usare ora: {sections['STRATEGIA_ORTOGONALE']}")
+                if sections.get('PRIMA_AZIONE'):
+                    parts.append(f"Prima azione: {sections['PRIMA_AZIONE']}")
+
+                if parts:
+                    prompt = (
+                        f"⛔ ANALISI CROSS-FALLIMENTO [{source}·{n} tentativi]: "
+                        + " | ".join(parts)
+                        + " — Non condividere NESSUNA assunzione coi tentativi precedenti."
+                    )
+                    return StrategyDecision(
+                        strategy_prompt=prompt,
+                        confidence=0.85,
+                        rationale=f"Sintesi {source} su {n} tentativi: {sections.get('PATTERN_COMUNE', '')[:80]}",
+                    )
+
+                # Formato non rispettato: usa tutta la risposta
+                prompt = (
+                    f"⛔ STRATEGIA ORTOGONALE [{n} fallimenti]: "
+                    f"{resp[:450]} "
+                    "— Nessuna assunzione condivisa coi tentativi precedenti."
+                )
+                return StrategyDecision(
+                    strategy_prompt=prompt,
+                    confidence=0.75,
+                    rationale=f"Risposta {source} non strutturata — usata grezza",
+                )
+
+        except Exception as _e:
+            _logger.debug("StrategicHealer._cross_attempt_synthesis error: %s", str(_e)[:80])
+
+        # Fallback deterministico: sintetizza dalla storia senza LLM
+        return self._fallback_cross_synthesis(n)
+
+    def _fallback_cross_synthesis(self, n: int) -> StrategyDecision:
+        """Sintesi cross-attempt senza LLM: usa la storia registrata."""
+        categories = [r.error_category for r in self.history]
+        why_list   = [r.why_failed[:80] for r in self.history[-3:]]
+        tried      = "; ".join(f"[{r.error_category}] {r.strategy_brief[:50]}" for r in self.history[-3:])
+
+        prompt = (
+            f"⛔ STRATEGIA COMPLETAMENTE DIVERSA [{n} fallimenti, "
+            f"categorie: {', '.join(set(categories))}]: "
+            f"Ragioni dei fallimenti: {' | '.join(why_list)}. "
+            f"Approcci già esclusi: {tried}. "
+            "Usa metodo, libreria e struttura dati completamente diversi da quelli tentati."
+        )
+        return StrategyDecision(
+            strategy_prompt=prompt,
+            confidence=0.50,
+            rationale="Fallback deterministico — LLM non disponibile",
+        )
+
+    async def _final_diagnosis(self) -> StrategyDecision:
+        """
+        Dopo MAX_ATTEMPTS: produce una diagnosi strutturale finale.
+        Non è un nuovo tentativo — è una spiegazione onesta di cosa non funziona
+        e perché, utile per l'utente e per la memoria episodica.
+        """
+        history_verbose = self._format_history(verbose=True)
+
+        try:
+            resp = await asyncio.wait_for(
+                self.llm.chat(
+                    [
+                        {"role": "system", "content": (
+                            "Un agente AI ha esaurito i tentativi su un goal. "
+                            "Scrivi una diagnosi finale in 3 parti:\n"
+                            "PROBLEMA_STRUTTURALE: <perché questo goal è difficile/impossibile con gli strumenti disponibili>\n"
+                            "COSA_RICHIEDEREBBE: <cosa servirebbe per risolverlo — accesso esterno, libreria specifica, input mancante>\n"
+                            "WORKAROUND_POSSIBILE: <cosa si può fare ADESSO con ciò che c'è — anche parziale>"
+                        )},
+                        {"role": "user", "content": (
+                            f"Goal: {self.goal[:300]}\n\n"
+                            f"Storico {len(self.history)} tentativi:\n{history_verbose}"
+                        )},
+                    ],
+                    temperature=0.1,
+                    max_tokens=280,
+                ),
+                timeout=10.0,
+            )
+            diagnosis = resp[:400] if (resp and not resp.startswith('[LLM')) else ""
+        except Exception:
+            diagnosis = ""
+
+        if not diagnosis:
+            cats = ", ".join(set(r.error_category for r in self.history))
+            diagnosis = (
+                f"Problema strutturale ({cats}): il goal richiede capacità o accesso "
+                "non disponibili nell'ambiente corrente."
+            )
+
+        prompt = (
+            f"⛔ LIMITE RAGGIUNTO ({self.MAX_ATTEMPTS} tentativi): {diagnosis} "
+            "Comunica onestamente all'utente cosa non è stato possibile fare e perché."
+        )
+
+        return StrategyDecision(
+            strategy_prompt=prompt,
+            confidence=0.0,
+            rationale=diagnosis,
+            should_stop=True,
+            stop_reason=diagnosis,
+        )
+
+    def _format_history(self, verbose: bool = False) -> str:
+        """Formatta la storia dei tentativi per il contesto LLM."""
+        if not self.history:
+            return ""
+        lines = []
+        for r in self.history:
+            if verbose:
+                lines.append(
+                    f"Tentativo {r.attempt_num} [{r.error_category}]\n"
+                    f"  Cosa si è tentato: {r.strategy_brief[:120]}\n"
+                    f"  Perché era sbagliato: {r.why_failed[:200]}\n"
+                    f"  Errori principali: {'; '.join(e[:80] for e in r.errors[:2])}"
+                )
+            else:
+                lines.append(
+                    f"T{r.attempt_num}[{r.error_category}]: {r.why_failed[:120]}"
+                )
+        return "\n".join(lines)
+
+    def get_summary(self) -> dict:
+        """Summary per logging/telemetry."""
+        return {
+            "attempts":    len(self.history),
+            "categories":  [r.error_category for r in self.history],
+            "goal_excerpt": self.goal[:80],
+            "stopped_at_max": len(self.history) >= self.MAX_ATTEMPTS,
+        }

agents/tdd_runner.py

@@ -0,0 +1,178 @@
+"""
+tdd_runner.py — S-GAP3: Auto-Testing post-code execution.
+
+Dopo ogni run_python con codice complesso (>=8 righe, def/class presente),
+l'agente genera un test minimale, lo esegue, e verifica PASS/FAIL.
+Questo chiude il ciclo: codice scritto → codice verificato.
+
+Integrazione: chiamato da unified_loop_tools.py dopo run_python.
+Zero overhead su task semplici (direct_response, query, output non-code).
+"""
+from __future__ import annotations
+
+import asyncio
+import logging
+import re
+from typing import Any
+
+_logger = logging.getLogger("agente_ai.tdd")
+
+_MIN_LINES = 8
+_CODE_RE = re.compile(r"\b(def |class |function |return |async def )", re.MULTILINE)
+_SUPPORTED = {"python", "py", ""}
+
+
+def _should_test(code: str, language: str = "python") -> bool:
+    if language.lower() not in _SUPPORTED:
+        return False
+    lines = [l for l in code.splitlines() if l.strip() and not l.strip().startswith("#")]
+    return len(lines) >= _MIN_LINES and bool(_CODE_RE.search(code))
+
+
+async def _gen_test(code: str, llm: Any) -> str | None:
+    try:
+        from models.role_router import RoleRouter, Role
+        coder = RoleRouter.get_client(Role.CODER)
+    except Exception:
+        coder = llm
+    prompt = (
+        "Dato questo codice Python, scrivi un micro-test con assert statements "
+        "(NON pytest/unittest — solo assert + print). "
+        "Verifica il comportamento principale. Rispondi SOLO con il codice.\n\n"
+        f"```python\n{code[:1800]}\n```"
+    )
+    try:
+        raw = await asyncio.wait_for(
+            coder.chat(
+                [
+                    {"role": "system", "content": "Sei un tester Python. Solo codice, niente testo."},
+                    {"role": "user", "content": prompt},
+                ],
+                temperature=0.1, max_tokens=400,
+            ),
+            timeout=18.0,
+        )
+        m = re.search(r"```(?:python)?\n?([\s\S]+?)```", raw)
+        return m.group(1).strip() if m else raw.strip()
+    except Exception as e:
+        _logger.warning("TDD gen failed: %s", e)
+        return None
+
+
+async def run_tdd_check(code: str, executor: Any, llm: Any, language: str = "python") -> dict:
+    """
+    Ciclo TDD completo.
+    Returns: { ran, passed, output, test_code }
+    """
+    out = {"ran": False, "passed": False, "output": "", "test_code": ""}
+    if not _should_test(code, language):
+        return out
+
+    test_code = await _gen_test(code, llm)
+    if not test_code:
+        return out
+
+    out["ran"] = True
+    out["test_code"] = test_code
+    combined = f"{code}\n\n# === AUTO-TEST S-GAP3 ===\n{test_code}"
+
+    try:
+        r = await asyncio.wait_for(
+            executor.run_tool("run_python", {"code": combined}),
+            timeout=28.0,
+        )
+        stdout  = r.get("output", r.get("stdout", ""))
+        stderr  = r.get("stderr", "")
+        ec      = r.get("exit_code", -1)
+        passed  = ec == 0 and not stderr.strip()
+        out["passed"] = passed
+        out["output"] = (stdout or "")[:400]
+        if stderr:
+            out["output"] += f"\n[stderr] {stderr[:150]}"
+        _logger.info("TDD: passed=%s exit=%s", passed, ec)
+    except asyncio.TimeoutError:
+        out["output"] = "⏱ timeout 28s"
+    except Exception as e:
+        out["output"] = f"⚠️ {e}"
+    return out
+
+# ── COG-3: TypeScript TDD ─────────────────────────────────────────────────────
+
+_TS_FILE_RE = re.compile(r'\.(ts|tsx)$', re.IGNORECASE)
+_TS_CODE_RE = re.compile(
+    r'(interface |type |const |function |class |export |import |=>|async )',
+    re.MULTILINE,
+)
+
+
+def _should_test_ts(content: str, path: str = '') -> bool:
+    """COG-3: decides whether to type-check a TypeScript file change."""
+    if path and not _TS_FILE_RE.search(path):
+        return False
+    lines = [l for l in content.splitlines() if l.strip() and not l.strip().startswith('//')]
+    return len(lines) >= 5 and bool(_TS_CODE_RE.search(content))
+
+
+async def run_tdd_check_ts(
+    content: str,
+    path: str,
+    executor: Any,
+    on_warn: Any = None,
+) -> dict:
+    """
+    COG-3: TypeScript TDD — esegue type_check dopo apply_patch / write_file su .ts/.tsx.
+
+    Pipeline:
+      1. _should_test_ts() — guard rapido, zero overhead su file non-TS
+      2. executor.run_tool('type_check', {'path': path}) — tsc --noEmit
+      3. Se errori TypeScript rilevati: emette warning via on_warn callback
+
+    Returns: { ran, passed, output, path }
+    """
+    out = {'ran': False, 'passed': False, 'output': '', 'path': path}
+
+    if not _should_test_ts(content, path):
+        return out
+
+    if not executor:
+        return out
+
+    out['ran'] = True
+    try:
+        r = await asyncio.wait_for(
+            executor.run_tool('type_check', {'path': path}),
+            timeout=20.0,
+        )
+        raw_out = r.get('output', {})
+        stdout  = raw_out.get('stdout', '') if isinstance(raw_out, dict) else str(raw_out)
+        stderr  = raw_out.get('stderr', '') if isinstance(raw_out, dict) else ''
+        ec      = r.get('exit_code', r.get('output', {}).get('exit_code', -1) if isinstance(r.get('output'), dict) else -1)
+
+        has_errors = (
+            'error TS' in (stdout + stderr)
+            or (isinstance(ec, int) and ec != 0)
+        )
+        out['passed'] = not has_errors
+        out['output'] = (stdout + stderr)[:500]
+
+        if not out['passed'] and on_warn:
+            ts_errors = [l for l in (stdout + stderr).splitlines() if 'error TS' in l][:5]
+            warn_msg = f'TypeScript errors in {path}:\n' + '\n'.join(ts_errors)
+            try:
+                import asyncio as _asyncio
+                _v = on_warn({'action': 'tdd_ts', 'status': 'warn', 'output': warn_msg})
+                if _asyncio.iscoroutine(_v):
+                    await _v
+            except Exception as _exc:
+                _logger.debug("[tdd_runner] silenced %s", type(_exc).__name__)  # noqa: BLE001
+
+        _logger.info('COG-3 TS TDD: path=%s passed=%s ec=%s', path, out['passed'], ec)
+    except asyncio.TimeoutError:
+        out['output'] = 'TS type_check timeout 20s'
+        _logger.warning('COG-3 TS TDD timeout for %s', path)
+    except Exception as exc:
+        out['output'] = f'TS TDD error: {exc}'
+        _logger.warning('COG-3 TS TDD exception: %s', exc)
+
+    return out
+

agents/tool_generator.py

@@ -0,0 +1,187 @@
+"""
+tool_generator.py — COG-4: Dynamic Tool Generation at runtime.
+
+Quando l'executor non trova un tool adatto per un subtask,
+chiede all'LLM di scrivere una piccola funzione Python async,
+la valida in sandbox (run_python), e la registra nel TOOL_REGISTRY
+per la durata della sessione corrente.
+
+Security constraints:
+  - Blocca import di rete (requests, httpx, socket, urllib, subprocess)
+  - Blocca accesso filesystem in write (open() write mode)
+  - Timeout 12s generazione + 10s validazione
+  - Max 5 tool generati per sessione (evita context explosion)
+  - Tool generati hanno prefisso "_dyn_" per identificazione e pulizia
+
+Integration: chiamato da unified_loop.py quando _TOOL_MAP.get(tool) == (None, None)
+e needs_dynamic_tool() restituisce True.
+"""
+from __future__ import annotations
+
+import asyncio
+import logging
+import re
+from typing import Any
+
+_logger = logging.getLogger("agente_ai.tool_gen")
+
+_GENERATED_COUNT = 0
+_MAX_GENERATED   = 5
+
+_BLOCKED_RE = re.compile(
+    r"\b(import\s+(requests|httpx|socket|urllib|subprocess|paramiko|ftplib)"
+    r"|os\.system\s*\(|os\.popen\s*\(|eval\s*\(|exec\s*\("
+    r"|__import__\s*\(|open\s*\([^)]*['\"][wa][+bt]*['\"])",
+    re.IGNORECASE | re.MULTILINE,
+)
+_TOOL_NAME_RE = re.compile(r"^[a-z][a-z0-9_]{2,39}$")
+
+_GEN_SYSTEM = """\
+Sei un tool engineer Python. Scrivi UNA funzione Python asincrona che risolve il task specificato.
+
+REGOLE ASSOLUTE:
+1. Firma obbligatoria: `async def tool_fn(**kwargs) -> dict`
+2. Ritorna sempre: `{"success": True/False, "output": <risultato>, "error": ""}`
+3. ZERO import di rete (no requests, httpx, socket, urllib, subprocess)
+4. ZERO filesystem esterno (no open() in write mode)
+5. Solo stdlib: json, re, math, datetime, collections, itertools, hashlib, base64, urllib.parse
+6. Max 30 righe
+7. Rispondi SOLO con il blocco ```python ... ``` — zero testo extra
+
+Esempio:
+```python
+import re
+async def tool_fn(**kwargs) -> dict:
+    text = kwargs.get("text", "")
+    words = re.findall(r"\\b\\w+\\b", text.lower())
+    freq = {}
+    for w in words:
+        freq[w] = freq.get(w, 0) + 1
+    return {"success": True, "output": sorted(freq.items(), key=lambda x: -x[1])[:10], "error": ""}
+```\
+"""
+
+
+def needs_dynamic_tool(tool_name: str, description: str) -> bool:
+    """
+    Decide se generare un tool dinamico per questo subtask.
+
+    Condizioni positive:
+    - La descrizione suggerisce un'operazione computazionale locale
+    - Non siamo al limite di tool generati per sessione
+
+    Non genera tool per: operazioni di rete, filesystem esterno, browser.
+    """
+    global _GENERATED_COUNT
+    if _GENERATED_COUNT >= _MAX_GENERATED:
+        return False
+
+    _NETWORK_RE = re.compile(
+        r"\b(http|url|fetch|scrape|download|upload|api|request|socket)\b",
+        re.IGNORECASE,
+    )
+    if _NETWORK_RE.search(description):
+        return False  # operazioni di rete → non generare tool locale
+
+    _COMPUTE_RE = re.compile(
+        r"\b(calcola|converti|trasforma|analizza|estrai|filtra|ordina|conta"
+        r"|parse|format|encode|decode|compress|hash|valida|validate"
+        r"|split|merge|aggregate|summarize|riassumi|statistiche)\b",
+        re.IGNORECASE,
+    )
+    return bool(_COMPUTE_RE.search(description))
+
+
+async def generate_and_register(
+    description: str,
+    tool_name: str,
+    llm: Any,
+    executor: Any,
+) -> "tuple[bool, str]":
+    """
+    Genera un tool Python via LLM, lo valida in sandbox, lo registra.
+
+    Returns: (success: bool, dyn_name: str)
+    """
+    global _GENERATED_COUNT
+    if _GENERATED_COUNT >= _MAX_GENERATED:
+        return False, ""
+
+    safe_name = re.sub(r"[^a-z0-9_]", "_", tool_name.lower())[:36]
+    if not _TOOL_NAME_RE.match(safe_name):
+        safe_name = f"gen{_GENERATED_COUNT + 1}"
+    dyn_name = f"_dyn_{safe_name}"
+
+    # Step 1: genera il codice via LLM
+    try:
+        raw = await asyncio.wait_for(
+            llm.chat(
+                [
+                    {"role": "system", "content": _GEN_SYSTEM},
+                    {"role": "user",   "content": f"Scrivi un tool per: {description[:400]}"},
+                ],
+                temperature=0.1,
+                max_tokens=600,
+            ),
+            timeout=12.0,
+        )
+    except Exception as exc:
+        _logger.warning("COG-4 gen LLM failed: %s", exc)
+        return False, ""
+
+    # Step 2: estrai blocco codice
+    m    = re.search(r"```(?:python)?\n?([\s\S]+?)```", raw)
+    code = m.group(1).strip() if m else raw.strip()
+
+    # Step 3: security gate
+    if _BLOCKED_RE.search(code):
+        _logger.warning("COG-4 blocked unsafe import in generated tool: %s", dyn_name)
+        return False, ""
+
+    # Step 4: valida in sandbox
+    validation = (
+        f"{code}\n\n"
+        "import asyncio as _asyncio\n"
+        "_r = _asyncio.run(tool_fn())\n"
+        "assert isinstance(_r, dict), 'must return dict'\n"
+        "assert 'output' in _r, 'must have output key'\n"
+        "print('COG4_OK')\n"
+    )
+    try:
+        val = await asyncio.wait_for(
+            executor.run_tool("run_python", {"code": validation}),
+            timeout=10.0,
+        )
+        out = val.get("output", {})
+        stdout = out.get("stdout", "") if isinstance(out, dict) else str(out)
+        if "COG4_OK" not in stdout:
+            _logger.warning("COG-4 validation failed: %s", stdout[:200])
+            return False, ""
+    except Exception as exc:
+        _logger.warning("COG-4 sandbox error: %s", exc)
+        return False, ""
+
+    # Step 5: registra nel TOOL_REGISTRY (runtime only, non persiste)
+    try:
+        from tools.registry import TOOL_REGISTRY
+        ns: dict = {}
+        exec(compile(code, f"<dyn:{dyn_name}>", "exec"), ns)  # noqa: S102
+        fn = ns.get("tool_fn")
+        if not fn or not asyncio.iscoroutinefunction(fn):
+            _logger.warning("COG-4 tool_fn missing or not async")
+            return False, ""
+        TOOL_REGISTRY[dyn_name] = {
+            "description": f"[DYN] {description[:200]}",
+            "required_inputs": [],
+            "_fn": fn,
+            "_generated": True,
+        }
+        _GENERATED_COUNT += 1
+        _logger.info(
+            "COG-4 registered '%s' (%d/%d total dynamic tools)",
+            dyn_name, _GENERATED_COUNT, _MAX_GENERATED,
+        )
+        return True, dyn_name
+    except Exception as exc:
+        _logger.warning("COG-4 registration failed: %s", exc)
+        return False, ""

agents/unified_loop_helpers.py

@@ -0,0 +1,483 @@
+"""unified_loop_helpers.py — HelpersMixin: goal compression, replan, reflection, fast-path.
+
+Estratto da unified_loop.py (P20-TD1 Fase 3a).
+
+Contiene:
+  _compress_goal():       estrae blocchi codice >600 chars come file virtuali [FILE:N]
+                          Deps: self._CODE_BLOCK_RE (PromptBuilderMixin), self._guess_filename (PromptBuilderMixin)
+  _budget_replan_check(): GAP-1 probabilistic re-planning trigger su budget critico + errori tool
+                          Deps: self._get_fast_llm() (LLMSelectionMixin)
+  _proactive_reflect():   verifica pertinenza tool results prima della sintesi LLM
+                          Deps: self._fast_llm / self.llm (instance attrs)
+  _run_fast_path():       S402+S-FAST path leggero per query conversazionali (<3s target)
+                          Deps: DirectToolsMixin, PromptBuilderMixin, LLMSelectionMixin (tutti via MRO)
+                          Nota: chiama self._run_fallback() che resta in UnifiedAgentLoop — ok via MRO
+
+Invariante B1: nessun corpo duplicato con unified_loop.py.
+MRO Python garantisce che tutti i self.xxx riferimenti si risolvano correttamente
+su UnifiedAgentLoop(DirectToolsMixin, PromptBuilderMixin, LLMSelectionMixin, HelpersMixin).
+"""
+from __future__ import annotations
+
+import asyncio
+import re
+from typing import Any
+
+import logging
+_logger = logging.getLogger("agents.unified_loop_helpers")
+
+# Import tipi condivisi — zero circular (unified_loop_types ha solo stdlib)
+from agents.unified_loop_types import (
+    StepCallback,
+    UnifiedLoopState,
+    _LANG_INSTRUCTIONS,
+    _detect_user_lang,
+    _maybe_await,
+)
+
+
+def _get_classifier():
+    """Load the error classifier lazily, avoiding import cycles."""
+    from agents.error_classifier import classify_error, format_for_context
+    return classify_error, format_for_context
+
+
+class HelpersMixin:
+    # ── S364+S403: Strategic Recovery reflection ──────────────────────────────
+
+    async def _reflective_debug(self, goal: str, errors: list,
+                                _force_fast: bool = False) -> str:
+        """
+        S364 + S403: Strategic Recovery — usa ARCHITECT (DeepSeek-R1).
+        
+        S364: Chain-of-Verification dopo 2+ errori (analisi root cause).
+        S403: Limite 3 (criticità 9/10) — recovery strategy reale:
+              errore → diagnosi → NUOVA strategia → ripartenza
+              (non retry:retry:fail).
+        
+        Differenziato per numero di tentativi:
+          - 2 errori: analisi root cause + suggerimento alternativo
+          - 3+ errori: forzatura strategia completamente diversa
+        
+        Ritorna stringa vuota su qualsiasi errore (fire-and-forget safe).
+        """
+        try:
+            from models.role_router import RoleRouter, Role
+            err_count   = len(errors)
+            # S576: err_summary 200→300 — parity con fallback path (S573)
+            # S599: str(e)[:300]→[:500] — errori completi con stack info spesso > 300 chars
+            err_summary = '\n'.join(str(e)[:500] for e in errors[-3:])
+
+            # COG-2: record failure pattern per future lesson injection
+            if self.memory and hasattr(self.memory, 'reflection'):
+                try:
+                    import asyncio as _asyncio_r
+                    _asyncio_r.get_event_loop().call_soon(
+                        lambda: self.memory.reflection.record_failure(
+                            goal, err_summary[:400], "reflective_debug"
+                        )
+                    )
+                except Exception:
+                    pass  # recording non blocca mai il recovery
+
+            # S404: Classifica l'errore prima di invocare l'ARCHITECT
+            # → inject strategia mirata nel context (zero latency, no LLM)
+            classification_hint = ""
+            try:
+                _classify, _fmt = _get_classifier()
+                clf_result = _classify(errors[-4:] if errors else [])
+                classification_hint = _fmt(clf_result)
+            except Exception:
+                pass  # classifier failure non blocca il recovery
+
+            # D6: inietta lezioni precedenti per lo stesso goal — evita ripetere strategie già fallite
+            _lessons_hint = ""
+            if self.memory and hasattr(self.memory, 'reflection'):
+                try:
+                    _prev = self.memory.reflection.get_relevant_lessons(goal, n=2)
+                    if _prev:
+                        _lparts = []
+                        for _l in _prev:
+                            if _l.get("type") == "failure":
+                                _lparts.append(f"- Già tentato e FALLITO: {_l.get('avoid','')[:200]}")
+                            elif _l.get("type") == "success":
+                                _lparts.append(f"- Strategia FUNZIONANTE in passato: {_l.get('strategy','')[:200]}")
+                        if _lparts:
+                            _lessons_hint = "Strategie già tentate (NON ripetere):\n" + "\n".join(_lparts) + "\n\n"
+                except Exception:
+                    pass  # lesson injection non blocca mai il recovery
+
+            # B3: bypass deterministico — errori con fix noto non richiedono LLM (1-3s risparmiati).
+            # Conseguenza: import/file/conn/perm errors con 1-2 occorrenze → hint zero-latency.
+            # Zero cons: il fix per ModuleNotFoundError è sempre 'installa dipendenza'.
+            if err_count < 3 and errors:
+                _last_err_str = str(errors[-1])[:600].lower()
+                _B3_DET = [
+                    (r'modulenotfounderror|no module named|importerror|cannot find module|module not found',
+                     '\U0001f4a1 Dipendenza mancante: installa il pacchetto con pip/npm prima di riprovare.'),
+                    (r'filenotfounderror|no such file or directory|file not found|enoent',
+                     '\U0001f4a1 File non trovato: verifica il percorso o crea il file prima di usarlo.'),
+                    (r'connectionrefusederror|connection refused|econnrefused|network unreachable',
+                     '\U0001f4a1 Connessione rifiutata: verifica che il servizio sia attivo e la porta corretta.'),
+                    (r'permissionerror|permission denied|eacces|access denied',
+                     '\U0001f4a1 Permessi insufficienti: verifica i permessi o esegui con privilegi appropriati.'),
+                ]
+                import re as _re_b3
+                for _det_pat, _det_hint in _B3_DET:
+                    if _re_b3.search(_det_pat, _last_err_str):
+                        return (_det_hint + ('\n\n' + classification_hint if classification_hint else '')).strip()
+
+            if err_count >= 3 and not _force_fast:
+                # GAP-1.3: ARCHITECT solo
+                # B4: _force_fast=True → fast_llm (strategic ctx già presente, ARCHITECT ridondante) per strategic recovery >= 3 errori (vale la latenza 10-15s)
+                arch        = RoleRouter.get_client(Role.ARCHITECT)
+                _rd_timeout = 15.0
+                # S403 Strategic Recovery: dopo 3+ errori, forza approccio alternativo
+                system_prompt = (
+                    "Sei un senior engineer. L'agente ha fallito 3+ volte con lo stesso approccio. "
+                    "Analizza in 4 punti CONCRETI e SPECIFICI:\n"
+                    "1. Root cause reale (1 riga)\n"
+                    "2. Perché l'approccio usato finora falliva (1 riga)\n"
+                    "3. STRATEGIA COMPLETAMENTE DIVERSA da usare ora (2 righe — sii specifico: "
+                    "quale libreria, quale pattern, quale struttura dati alternativa)\n"
+                    "4. Prima istruzione concreta (1 riga — cosa fare PRIMA di tutto)\n"
+                    "No generalità tipo 'prova un altro approccio'. Sii tecnico e diretto."
+                )
+                label = "STRATEGIA ALTERNATIVA FORZATA"
+                max_tokens = 500  # S586: 350→500 — strategia alternativa spesso >350 tok
+            else:
+                # GAP-1.3: fast path — self.llm invece di ARCHITECT (ms vs 10-15s) per primo errore
+                arch        = self.llm
+                _rd_timeout = 8.0
+                # S364 Chain-of-Verification: dopo 2 errori, analisi + suggerimento
+                system_prompt = (
+                    "Sei un debugger esperto. Analizza in 3 punti:\n"
+                    "1. Root cause reale (1 riga)\n"
+                    "2. Perché l'approccio precedente falliva (1 riga)\n"
+                    "3. Approccio alternativo specifico da provare (1-2 righe)\n"
+                    "Solo analisi tecnica — niente codice."
+                )
+                label = "ANALISI ERRORE PRECEDENTE"
+                max_tokens = 400  # S586: 250→400 — analisi 3 punti necessita più tokens
+
+            msgs = [
+                {"role": "system", "content": system_prompt},
+                # S597: goal 300→500 — più contesto goal nel debug prompt architect
+                {"role": "user",   "content": f"{_lessons_hint}Goal: {goal[:500]}\n\nTentativo #{err_count}\nErrori:\n{err_summary}"},
+            ]
+            analysis = await asyncio.wait_for(
+                arch.chat(msgs, temperature=0.1, max_tokens=max_tokens),
+                timeout=_rd_timeout,
+            )
+            if analysis and not analysis.startswith('[LLM'):
+                # S404: prepend classificazione deterministica + analisi LLM
+                return f"{classification_hint}\n\n[{label} — tentativo {err_count}]\n{analysis[:600]}"
+        except Exception:
+            pass  # S364/S403: ARCHITECT failed — S455-P14: fallback to base LLM
+        # S455-P14: ARCHITECT non disponibile → fallback al modello base (sempre disponibile)
+        try:
+            fallback_msgs = [
+                {"role": "system", "content": "Sei un debugger esperto. Analizza brevemente l'errore e suggerisci un approccio alternativo specifico in 2-3 righe. Solo analisi tecnica — niente codice."},
+                # S573: goal 200→300, errors 150→300 — più contesto per il debug fallback
+                # S592: errors[-2:]→[-3:] — più errori nel fallback debug prompt
+                # S597: goal 300→500 — più contesto goal nel debug fallback prompt
+                # S600: str(e)[:300]→[:500] — parity con ARCHITECT path (riga ~271)
+                {"role": "user",   "content": f"{_lessons_hint}Goal: {goal[:500]}\n\nErrori ({len(errors)} totali):\n{chr(10).join(str(e)[:500] for e in errors[-3:])}"},
+            ]
+            fallback_ans = await asyncio.wait_for(
+                # S586: 180→300 — fallback debug risposta 2-3 righe spesso > 180 tok
+                self.llm.chat(fallback_msgs, temperature=0.15, max_tokens=300),
+                timeout=10.0,
+            )
+            if fallback_ans and not fallback_ans.startswith('[LLM'):
+                return f"{classification_hint}\n\n[FALLBACK DEBUG — tentativo {len(errors)}]\n{fallback_ans[:600]}"  # S603: 400→600
+        except Exception:
+            pass  # fallback anche questo fallito — ritorna stringa vuota
+        # S404: se LLM fallisce, almeno ritorna la classificazione deterministica
+        return classification_hint
+
+
+
+    # ── Goal compression (S197/S357) ─────────────────────────────────────────
+
+    def _compress_goal(self, goal: str) -> tuple[str, str]:
+        """
+        Estrae blocchi di codice grandi dal goal e li converte in file virtuali.
+        Returns: (goal_compresso, sezione_file_da_iniettare_nel_contesto)
+        Se il codice totale e < _CODE_THRESHOLD, ritorna (goal_originale, '').
+        """
+        _CODE_THRESHOLD = 600  # chars — S357: abbassato da 1800 per ridurre token TTFT
+        blocks = list(self._CODE_BLOCK_RE.finditer(goal))
+        if not blocks:
+            return goal, ''
+        total_code_chars = sum(len(m.group('body')) for m in blocks)
+        if total_code_chars < _CODE_THRESHOLD:
+            return goal, ''
+
+        # Estrai ogni blocco
+        files_section_lines: list[str] = ['--- CODICE_FORNITO ---']
+        compressed = goal
+        for idx, m in enumerate(reversed(blocks)):  # reverse per preservare offset
+            lang   = m.group('lang') or 'txt'
+            body   = m.group('body').rstrip()
+            fname  = self._guess_filename(lang, len(blocks) - 1 - idx)
+            tag    = f'[FILE:{len(blocks) - idx}: {fname}]'
+            start, end = m.start(), m.end()
+            compressed = compressed[:start] + tag + compressed[end:]
+            files_section_lines.insert(1, f'\n[FILE:{len(blocks) - idx}: {fname}]\n```{lang}\n{body}\n```')
+
+        files_section_lines.append('--- FINE_CODICE_FORNITO ---')
+        return compressed, '\n'.join(files_section_lines)
+
+
+    # ── GAP-1: Probabilistic re-planning on budget critical ───────────────────
+
+    async def _budget_replan_check(
+        self, state: 'UnifiedLoopState', step_count: int, on_step=None
+    ) -> str:
+        """
+        GAP-1: Probabilistic Re-planning Trigger.
+
+        Attivato quando: len(state.errors) >= 2 AND step_count >= 60% max_steps.
+        Genera un piano alternativo leggero usando fast_llm (8B, Groq).
+        Timeout 5s, fail-open — mai blocca il loop principale.
+
+        Differenza da _reflective_debug: triggera su budget critico + errori tool,
+        non solo su LLM errors. Differenza da COG-1 replan: opera sul single-task loop,
+        non sull'orchestrazione parallela.
+
+        Ritorna: stringa con nuovo approccio suggerito, o '' su errore/timeout.
+        """
+        _budget_ratio = step_count / max(state.max_steps, 1)
+        _n_err = len(state.errors)
+        # Guard: solo se errori >= 2 e budget >= 60% consumato
+        if _n_err < 2 or _budget_ratio < 0.6:
+            return ''
+        # Guard dedup: inietta una sola volta per run
+        if '[GAP-1-REPLAN]' in (state.context or ''):
+            return ''
+        try:
+            _fast = self._get_fast_llm()
+            _err_summary = '\n'.join(str(e)[:200] for e in state.errors[-3:])
+            _done_tools = ', '.join(
+                s.get('tool', s.get('action', '?'))
+                for s in state.steps[-6:]
+                if s.get('action') not in ('llm', 'reflective_debug', 'selfheal_strategy_injection')
+            ) or 'nessuno'
+            _replan_prompt = [
+                {"role": "system", "content": (
+                    "Sei un re-planning agent. Il piano corrente sta fallendo. "
+                    "Genera un approccio alternativo CONCISO (max 200 chars) "
+                    "che eviti gli stessi errori. Solo il nuovo approccio, niente altro."
+                )},
+                {"role": "user", "content": (
+                    f"GOAL: {state.goal[:300]}\n"
+                    f"STEP: {step_count}/{state.max_steps} ({_budget_ratio:.0%} budget)\n"
+                    f"ERRORI ({_n_err}): {_err_summary}\n"
+                    f"TOOL USATI: {_done_tools}\n"
+                    f"Suggerisci approccio alternativo:"
+                )},
+            ]
+            _replan_hint = await asyncio.wait_for(
+                _fast.chat(_replan_prompt, temperature=0.3, max_tokens=120),
+                timeout=5.0,
+            )
+            if _replan_hint and not _replan_hint.startswith('[LLM') and len(_replan_hint) > 10:
+                _logger.info("GAP-1 budget_replan: step=%d/%d errors=%d hint=%s",
+                             step_count, state.max_steps, _n_err, _replan_hint[:80])
+                if on_step:
+                    await _maybe_await(on_step({
+                        "action":      "budget_replan",
+                        "status":      "started",
+                        "title":       f"♻️ Re-planning (step {step_count}/{state.max_steps})",
+                        "explanation": _replan_hint[:200],
+                    }))
+                return _replan_hint
+        except Exception:
+            pass  # fail-open totale
+        return ''
+
+
+    # ── PROACTIVE-REFLECT: tool result validation ──────────────────────────────
+
+    async def _proactive_reflect(self, goal: str, tool_results: str) -> str:
+        """
+        PROACTIVE-REFLECT (Gap 1): dopo ogni esecuzione tool, verifica se
+        i risultati sono pertinenti al goal PRIMA della sintesi LLM.
+
+        Previene allucinazione quando i tool restituiscono dati irrilevanti.
+        Usa fast_llm (8B) con timeout 4s — silent failure totale.
+        Ritorna hint da iniettare in state.context, o "" se risultati ok.
+
+        Trigger: chiamato in run() dopo direct_results disponibili.
+        Budget: 60 token output, 4s timeout, temperatura 0.1.
+        """
+        if not tool_results or len(tool_results) < 80:
+            return ""
+        _llm = self._fast_llm or self.llm
+        if not _llm:
+            return ""
+        try:
+            _prompt = (
+                f"GOAL: {goal[:180]}\n\n"
+                f"RISULTATI TOOL (estratto): {tool_results[:380]}\n\n"
+                "In UNA riga (max 15 parole): questi risultati permettono di rispondere al goal? "
+                "Se sì scrivi 'SUFFICIENTE'. Se no, indica cosa manca."
+            )
+            _check = await asyncio.wait_for(
+                _llm.chat(
+                    [
+                        {
+                            "role": "system",
+                            "content": (
+                                "Sei un validatore di pertinenza. "
+                                "Rispondi SOLO in italiano, massimo 15 parole. "
+                                "Mai spiegare — solo valuta."
+                            ),
+                        },
+                        {"role": "user", "content": _prompt},
+                    ],
+                    temperature=0.1,
+                    max_tokens=60,
+                ),
+                timeout=4.0,
+            )
+            _check = (_check or "").strip()
+            if not _check or "SUFFICIENTE" in _check.upper():
+                return ""
+            # Inietta hint nel context per guidare la sintesi LLM
+            _logger.info("PROACTIVE-REFLECT: tool results parziali — %s", _check[:100])
+            return f"\n[REFLECT] Tool results parziali: {_check[:120]}\n"
+        except Exception:
+            return ""  # silent failure — mai bloccare il loop principale
+
+
+    # ── S402+S-FAST: Fast path for conversational queries ─────────────────────
+
+    async def _run_fast_path(self, state: UnifiedLoopState,
+                              on_step: StepCallback | None) -> dict[str, Any]:
+        """S402+S-FAST: Path leggero per query conversazionali (<3s target).
+        Salta: memory lookup, planner, executor, retry loop, verifier, goal_verifier,
+        self-healing Python/HTML. Sistema prompt minimale → meno token → risposta veloce."""
+        import time as _time
+        _t0 = _time.monotonic()
+
+        # S-FAST-MATH-EXACT: matematica semplice → calculate tool diretto, nessun LLM.
+        # Bypassa completamente l'LLM per "Calcola 2+2", "15*3", "quanto fa 7+8"
+        # → risposta esatta in <50ms, zero latenza LLM, zero allucinazioni.
+        if hasattr(self, '_SIMPLE_MATH_RE') and self._SIMPLE_MATH_RE.match(state.goal.strip()):
+            try:
+                from tools.registry import TOOL_REGISTRY
+                _math_expr = ""
+                # Prova _extract_calc_expr prima (rimuove prefissi "calcola", "quanto fa")
+                if hasattr(self, '_extract_calc_expr'):
+                    _math_expr = self._extract_calc_expr(state.goal)
+                # Fallback: estrae espressione numerica pura (es. solo "2+2" senza prefisso)
+                if not _math_expr:
+                    _pure_m = re.search(r'[\d\s\+\-\*\/\^\(\)\.]+', state.goal)
+                    if _pure_m:
+                        _math_expr = (
+                            _pure_m.group(0).strip().rstrip('.?! ')
+                            .replace('^', '**').replace(',', '.')
+                        )
+                if _math_expr and 'calculate' in TOOL_REGISTRY:
+                    _calc_r = await asyncio.wait_for(
+                        TOOL_REGISTRY['calculate']['_fn'](expression=_math_expr),
+                        timeout=5.0,
+                    )
+                    if _calc_r.get('result') is not None:
+                        _exact = str(_calc_r['result'])
+                        _ms = int((_time.monotonic() - _t0) * 1000)
+                        if on_step:
+                            await _maybe_await(on_step({
+                                'loop': 2, 'action': 'fallback', 'status': 'done',
+                                'success': True, 'title': 'Calcolo eseguito',
+                                'explanation': f'{_math_expr} = {_exact}',
+                                'output': _exact,
+                            }))
+                        return {
+                            'success': True, 'engine': 'calculate', 'ok': True,
+                            'goal': state.goal, 'steps': [{'action': 'math_direct', 'ms': _ms}],
+                            'errors': [], 'output': _exact, 'result': _exact,
+                            'fast_path': True, 'timing_ms': _ms,
+                        }
+            except Exception:
+                pass  # fallback silenzioso all'LLM standard
+        # Fix-4.1: GREETING-BYPASS — saluti/ping → risposta deterministica 5ms vs 3-4s LLM
+        # Regex copre: ciao, hi, ci sei?, ping, status, sei online?, funziona?
+        # Early-return PRIMA di ogni LLM call — zero token consumati su Safari mobile.
+        _GREETING_RE = re.compile(
+            r'^(ciao|hi|hello|ci\s+sei\??|ping|status|sei\s+online\??|funziona\??|'
+            r'sei\s+l[\u00e0a]\??|sei\s+attivo\??|ok\??|ehi\??|oi|hey|'
+            r'sei\s+disponibile\??|tutto\s+ok\??)[\.!\s]*$',
+            re.IGNORECASE,
+        )
+        if _GREETING_RE.match(state.goal.strip()):
+            _ms = int((_time.monotonic() - _t0) * 1000)
+            if on_step:
+                await _maybe_await(on_step({
+                    'action': 'fast_path', 'status': 'done', 'success': True,
+                    'title': 'Risposta diretta',
+                    'explanation': 'Saluto rilevato — risposta deterministica',
+                    'output': '\u2705 Sono online e operativo. Come posso aiutarti?',
+                }))
+            return {
+                'success': True, 'engine': 'deterministic', 'ok': True,
+                'goal': state.goal,
+                'output': '\u2705 Sono online e operativo. Come posso aiutarti?',
+                'result': '\u2705 Sono online e operativo. Come posso aiutarti?',
+                'steps': [{'action': 'greeting_bypass', 'ms': _ms}],
+                'fast_path': True, 'timing_ms': _ms,
+            }
+
+        fmt_dir = self._classify_format_directive(state.goal)
+        # P27-B2: lingua esplicita invece di "Rispondi nella lingua dell'utente" (vago).
+        # _detect_user_lang() puro (<1ms) → istruzione diretta al modello.
+        _fast_lang = _detect_user_lang(state.goal)
+        _fast_lang_instr = _LANG_INSTRUCTIONS.get(_fast_lang, "Rispondi nella lingua dell'utente.")
+        messages: list[dict] = [
+            {"role": "system", "content":
+                f"Sei un assistente AI utile e diretto. {_fast_lang_instr}\n{fmt_dir}"},
+            {"role": "user", "content": state.goal},
+        ]
+        if on_step:
+            await _maybe_await(on_step({
+                "loop": 1, "action": "llm", "status": "started",
+                "title": "Risposta rapida",
+                "explanation": "Query semplice — risposta diretta",
+            }))
+        # S-FAST: usa client 8B (Groq) invece del primario (70B) per query semplici
+        _fast_client = self._get_fast_llm()
+        answer = ""
+        try:
+            answer = await asyncio.wait_for(
+                _fast_client.chat(messages, temperature=0.7, max_tokens=512),
+                timeout=8.0,
+            )
+        except Exception as _exc:
+            _logger.debug("[unified_loop] silenced %s", type(_exc).__name__)  # noqa: BLE001
+        if not answer or answer.startswith("[LLM"):
+            # Degradazione sicura al fallback completo
+            return await self._run_fallback(state, on_step)
+        answer = self._sanitize_agent_output(answer)
+        t_ms = int((_time.monotonic() - _t0) * 1000)
+        engine = getattr(_fast_client, "provider_name", None) or "llm"
+        if on_step:
+            await _maybe_await(on_step({
+                "loop": 2, "action": "fallback", "status": "done", "success": True,
+                "title": "Completato",
+                "explanation": "Risposta elaborata e verificata con successo",
+                "output": answer,    # S-STEP-OUT: espone risposta nel log step per debug frontend
+            }))
+        return {
+            "success": True, "engine": engine, "goal": state.goal,
+            "steps": [{"action": "fast_path", "ms": t_ms}],
+            "errors": [], "output": answer,
+            "fast_path": True, "timing_ms": t_ms,
+        }
+
+    # R1 S390 + S434: smolagents rimosso — dead code eliminato.
+    # _build_smol_tools / _load_smol_agent / _run_smolagents non chiamati da run().
+
+    # ── Fallback deterministico ───────────────────────────────────────────────
+

agents/unified_loop_llm.py

@@ -0,0 +1,604 @@
+"""unified_loop_llm.py — LLMSelectionMixin: selezione LLM, routing e output sanitization.
+
+Estratto da unified_loop.py (P20-TD1 Fase 2).
+
+Contiene:
+  Block A — LLM selection + routing class attrs:
+    _SKIP_SMOL_RE, _COMPLEX_APP_RE, _MULTI_FEATURE_RE, _CODE_TASK_RE, _NEEDS_PLAN_RE
+    _get_llm_for_goal(): CODER vs default LLM selection (S362/S416)
+    _get_fast_llm(): lazy fast LLM cache (S-FAST)
+    _get_verifier_llm(): P25-B4 cross-model critic selection
+    _is_pure_explanation(): conceptual query detection (B5)
+    _max_tokens_for_goal(): token budget estimation (S373/B13)
+
+  Block B — Output sanitization + explanation regex attrs:
+    _sanitize_agent_output(): staticmethod rimozione monologue interno (S371)
+    _PURE_EXPLANATION_RE, _EXPL_ACTION_RE, _EXPL_FILE_REF_RE: regex per _is_pure_explanation
+
+Invariante B1: nessun corpo duplicato con unified_loop.py.
+MRO Python garantisce self._SKIP_SMOL_RE / self._sanitize_agent_output()
+funzionino da qualsiasi metodo di UnifiedAgentLoop.
+Importato da: unified_loop.py (solo per ereditarietà LLMSelectionMixin)
+"""
+from __future__ import annotations
+
+import re
+from typing import Any
+
+import logging
+_logger = logging.getLogger("agents.unified_loop_llm")
+
+
+class LLMSelectionMixin:
+    # ── Block A: LLM selection + routing ─────────────────────────────────────
+
+    def _get_llm_for_goal(self, goal: str) -> Any:
+        """S362: return CODER-role LLM for code-heavy goals, default otherwise.
+        GAP-ROUT: route SQL/Reasoning/MMLU to REASONER role (Cerebras 120B).
+        S416-Fix3: anche app complesse (tok_budget >= 6144) usano CODER (70B)
+        anche se _CODE_RE non matcha — garantisce qualità su app multi-file."""
+        g = goal[:500]
+        _is_code = bool(self._CODE_GOAL_RE.search(g))
+        _is_reasoning = bool(self._REASONING_GOAL_RE.search(g)) or \
+                        bool(self._SQL_GOAL_RE.search(g)) or \
+                        bool(self._MMLU_GOAL_RE.search(g))
+        
+        _tok = self._max_tokens_for_goal(goal)
+        _needs_heavy = _is_code or _is_reasoning or _tok >= 6144
+        
+        if not _needs_heavy:
+            return self.llm
+            
+        if _is_reasoning:
+            try:
+                from models.role_router import RoleRouter, Role
+                return RoleRouter.get_client(Role.REASONER)
+            except Exception:
+                pass
+
+        if self._coder_llm is None:
+            try:
+                from models.role_router import RoleRouter, Role
+                self._coder_llm = RoleRouter.get_client(Role.CODER)
+            except Exception:
+                self._coder_llm = self.llm
+        return self._coder_llm
+
+    def _get_fast_llm(self) -> Any:
+        """S-FAST: return Role.FAST client (Groq openai/gpt-oss-20b) per query semplici.
+        Caricato lazy e cachato in self._fast_llm — zero overhead dopo il primo accesso.
+        Fallback silenzioso su self.llm se GROQ_API_KEY mancante o RoleRouter non disponibile."""
+        if self._fast_llm is None:
+            try:
+                from models.role_router import RoleRouter, Role
+                self._fast_llm = RoleRouter.get_client(Role.FAST)
+            except Exception:
+                self._fast_llm = self.llm
+        return self._fast_llm
+
+    def _get_verifier_llm(self) -> Any:
+        """P25-B4: Cross-model critic — restituisce un provider DIVERSO da self.llm per la verifica.
+        Elimina il bias di conferma: lo stesso modello che ha generato la risposta
+        non dovrebbe giudicare se è corretta.
+
+        Strategia di selezione:
+          - Generatore Groq   → Verifier Gemini RESEARCHER (ragionamento diverso)
+          - Generatore Gemini → Verifier Groq CODER (modello diverso)
+          - Generatore altri  → Verifier Gemini RESEARCHER → fallback Groq CODER
+          - Qualsiasi errore  → fallback self.llm (comportamento invariato, zero regressioni)
+
+        Cache lazy (self._verifier_llm) — caricato una volta per sessione.
+        """
+        if self._verifier_llm is not None:
+            return self._verifier_llm
+        try:
+            from models.role_router import RoleRouter as _RRv, Role as _Rolev
+            _gen_prov = getattr(self.llm, 'provider_name', '') or ''
+            if 'groq' in _gen_prov:
+                # Generatore Groq → Verifier Gemini (diverso reasoning)
+                self._verifier_llm = _RRv.get_client(_Rolev.RESEARCHER)
+            elif 'gemini' in _gen_prov:
+                # Generatore Gemini → Verifier Groq CODER (70B, diverso modello)
+                self._verifier_llm = _RRv.get_client(_Rolev.CODER)
+            elif 'cerebras' in _gen_prov:
+                # Generatore Cerebras → Verifier Gemini
+                self._verifier_llm = _RRv.get_client(_Rolev.RESEARCHER)
+            elif 'nvidia' in _gen_prov:
+                # Generatore NVIDIA → Verifier Groq CODER (per diversificare)
+                self._verifier_llm = _RRv.get_client(_Rolev.CODER)
+            else:
+                # OpenRouter / SambaNova / altri → Verifier Groq CODER come default cross-model
+                self._verifier_llm = _RRv.get_client(_Rolev.CODER)
+            _logger.debug(
+                "P25-B4 verifier_llm: gen_prov=%s → verifier=%s",
+                _gen_prov, getattr(self._verifier_llm, 'provider_name', '?'),
+            )
+        except Exception as _exc:
+            _logger.debug("P25-B4 _get_verifier_llm fallback: %s", _exc)
+            self._verifier_llm = self.llm  # fallback: invariato
+        return self._verifier_llm
+
+    def _is_pure_explanation(self, goal: str) -> bool:
+        """True per una spiegazione concettuale completa che non richiede mutazioni.
+
+        I riferimenti nominali contestuali, per esempio ``dopo una modifica al
+        codice``, non trasformano una domanda esplicativa in un task operativo.
+        Una seconda azione imperativa resta invece un percorso operativo.
+        """
+        if len(goal) > 300:                                return False
+        text = goal[:200]
+        if not self._PURE_EXPLANATION_RE.search(text):      return False
+        if self._EXPL_FILE_REF_RE.search(text):             return False
+        if self._EXPL_REALTIME_RE.search(text):             return False
+        if self._EXPL_TUTORIAL_RE.search(text):             return True
+        contextual_spans = [
+            match.span()
+            for match in self._EXPL_CONTEXTUAL_ACTION_REF_RE.finditer(text)
+        ]
+        for action in self._EXPL_ACTION_RE.finditer(text):
+            if not any(
+                start <= action.start() < end
+                for start, end in contextual_spans
+            ):
+                return False
+        return True
+
+    # S371: _SKIP_SMOL_RE — skippa smolagents per query semplici (notizie, cerca) → direct tools
+    # S427: ampliato — più query bypassano smolagents → direct tools (più veloce).
+    _SKIP_SMOL_RE = re.compile(
+        r'\b(notizie|news|ultime notizie|cerca|ricerca|meteo|tempo|previsioni|'
+        r'cerca online|cerca su|trova online|guarda su|vai su|'
+        # S427: meteo/clima ampliato
+        r'weather|forecast|temperatura|clima|piove|nevica|temporale|umidità|vento|'
+        # S427: valute/crypto
+        r'valuta|cambio|tasso|euro|dollaro|bitcoin|ethereum|crypto|yen|sterlina|'
+        r'exchange rate|currency|'
+        # S427: knowledge lookup
+        r'wikipedia|enciclopedia|chi [eè]|chi era|storia di|'
+        # S427: calcoli diretti
+        r'calcola|quanto fa|quant[oei]\s+fa|risultato di|computa|'
+        # S427: data/ora
+        r'che ora|che giorno|data di oggi|ora attuale|orario|timezone|'
+        # S427: traduzione
+        r'traduci|traduzione|translate|translation|'
+        # EN-DIRECT: English patterns — bypass planner (save 5-15s latency) for simple EN queries
+        r'calculate|compute|how much is \d|what time is it|current time|today.s date|'
+        r'what.s the (?:time|date|day|weather)|who (?:is|was|are|were) |what is the (?:weather|capital|population)|'
+        r'stock price|crypto price|price of (?:bitcoin|ethereum|gold)|'
+        r'weather in|forecast for|temperature in|'
+        r'convert \d|how many \w+ in|exchange rate (?:of|for|from)|'
+        r'latest news (?:about|on)|search (?:for |on )?wikipedia|look up |'
+        # B7: unit conversion, timezone, date calc, IP — direct tools, skip planner
+        r'converti\s+\d+\s+\w+\s+(?:in|to)\s+\w+|'
+        r'quanti\s+giorni\s+(?:tra|fino|mancano)|'
+        r'che\s+ora\s+[e\xe8]\s+a\s+\w+|what\s+time\s+is\s+it\s+in\s+\w+|'
+        r'(?:mio\s+ip|my\s+ip|ip\s+address)\s*\??)\b',
+        re.IGNORECASE,
+    )
+
+    # ── S373: pattern per stima budget token output ────────────────────────
+    # S427: aggiunti più trigger per app/sistemi complessi + more token budget
+    _COMPLEX_APP_RE = re.compile(
+        r'\b(crea|scrivi|implementa|build|create|write|implement|'
+        r'sviluppa|costruisci|progetta|genera|scaffold|deploy|develop)\b.{0,80}'
+        r'\b(app|applicazione|application|progetto|project|website|sito|'
+        r'dashboard|api|backend|frontend|server|service|platform|piattaforma|'
+        r'sistema|e.?commerce|chatbot|bot|game|gioco|portfolio|blog|crm|cms|'
+        r'saas|marketplace|admin|panel|landing|cli|tool|library|sdk)\b',
+        re.IGNORECASE | re.DOTALL,
+    )
+    # S427: indicatori di complessità multi-feature ampliati
+    _MULTI_FEATURE_RE = re.compile(
+        r'\b(completo|completa|full.?stack|multi.?file|con\s+test|con\s+typescript|'
+        r'con\s+animazioni?|con\s+filtri?|con\s+localStorag|tipizzato|'
+        r'multiple\s+components?|più\s+component|separati|con\s+routing|'
+        r'con\s+auth(?:entication)?|con\s+login|con\s+database|con\s+deploy|'
+        r'con\s+pagament[io]|con\s+api|con\s+websocket|con\s+i18n|'
+        r'con\s+dark\s+mode|con\s+responsive|multi.?pagina|multi.?step|'
+        r'end.?to.?end|production.?ready|scalabile|enterprise|'
+        r'con\s+docker|con\s+ci.?cd|con\s+testing|con\s+validation)\b',
+        re.IGNORECASE,
+    )
+    # S427: tipi di artefatti codice ampliati per token budget
+    _CODE_TASK_RE = re.compile(
+        r'\b(codice|funzione|function|classe|class|componente|component|'
+        r'modulo|module|script|algoritmo|algorithm|hook|utility|helper|'
+        r'type|interface|enum|decorator|middleware|service|repository|'
+        r'controller|handler|resolver|store|reducer|action|mutation|'
+        r'schema|dto|validator|mapper|factory|builder|'
+        r'context|provider|consumer|wrapper|composable|mixin)\b',
+        re.IGNORECASE,
+    )
+
+    # B7: planner richiesto solo per task di progettazione/implementazione complessa
+    # S427: aggiunti verbi che richiedono pianificazione (patch/debug/ottimizza/ecc.)
+    _NEEDS_PLAN_RE = re.compile(
+        # F18: esteso con pattern IT mancanti — installa/nuovo/clona/avvia/esegui/testa
+        r'\b(crea|implementa|scrivi|refactor|progetta|costruisci|'
+        r'sistema|architettura|deploy|migra|sviluppa|build|create|'
+        r'implement|design|architect|'
+        r'patch|fix|debug|ottimizza|optimize|rinomina|rename|'
+        r'aggiungi|aggiorna|update|integra|integrate|'
+        r'scaffold|bootstrap|genera|generate|'
+        r'ristruttura|restructure|refactorizza|converti|convert|'
+        r'installa|clona|avvia|esegui|testa|verifica|configura|'
+        r'install|clone|run|test|verify|setup|configure)\b',
+        re.IGNORECASE,
+    )
+
+    @classmethod  # B13: era @staticmethod — usa class attrs già compilati invece di re.search inline
+    def _max_tokens_for_goal(cls, goal: str) -> int:
+        """S373: stima budget max_tokens in base alla complessità del goal.
+        Groq llama-3.3-70b supporta 32768 output token, Gemini 2.5-flash 8192.
+        Default 2048 solo per Q&A semplice; per codice si scala fino a 8192.
+        B13: usa class attrs _COMPLEX_APP_RE/_MULTI_FEATURE_RE/_CODE_TASK_RE già compilati.
+        """
+        # B6: fast-fix task → risposta atomica breve → 512 token max (-30-60% LLM time)
+        # Conseguenza: "aggiungi import X" non richiede 4096 tokens — 50-100 bastano.
+        if cls._FAST_FIX_RE.search(goal[:180]) and len(goal) < 180:
+            return 512
+
+        g = goal[:600]
+        is_app     = bool(cls._COMPLEX_APP_RE.search(g))
+        is_complex = bool(cls._MULTI_FEATURE_RE.search(g))
+        is_code    = bool(cls._CODE_TASK_RE.search(g))
+        if is_app and is_complex:
+            return 8192   # app multi-feature → output completo garantito
+        if is_app or is_complex:
+            return 6144   # app semplice o feature complessa
+        if is_code:
+            return 4096   # singola funzione/componente
+        return 2048        # Q&A, spiegazioni, risposte brevi
+
+
+    # ── Block B: Output sanitization + explanation regex attrs ────────────────
+
+    @staticmethod
+    def _sanitize_agent_output(text: str) -> str:
+        """S371: Rimuove monologue interno che può leakare da smolagents/LLM.
+        Patterns rimossi: GOAL:/DONE_WHEN:/OUT_OF_SCOPE: blocks, Proceed.We need to output...,
+        Thought:/Code:/Observation: lines, raw JSON tool call arrays.
+        S390: aggiunto stripping <think> blocks (Qwen3/DeepSeek-R1 reasoning leaks).
+        B12: fast-path — skip tutti i regex se nessun segnale di monologue (risparmia 50-200ms).
+        """
+        if not text:
+            return text
+        # S390: strip <think> sempre — Qwen3 e DeepSeek-R1 li iniettano indipendentemente dagli altri segnali
+        import re as _re  # BV-3: hoisted — stdlib, always in sys.modules
+        if '<think>' in text:
+            text = _re.sub(r'<think>[\s\S]*?</think>', '', text, flags=_re.IGNORECASE)  # blocco chiuso
+            text = _re.sub(r'<think>[\s\S]*', '', text, flags=_re.IGNORECASE)            # blocco aperto (troncato)
+            text = text.strip()
+            if not text:
+                return text
+        # B12: fast-path exit — ~95% delle risposte normali non contengono questi segnali
+        _MONOLOGUE_SIGNALS = ('GOAL:', 'DONE_WHEN:', 'OUT_OF_SCOPE:', 'Proceed.', 'Thought:', 'Code:', '[{"action"')
+        if not any(s in text for s in _MONOLOGUE_SIGNALS):
+            return text.strip()
+        # BV-3: _re already imported at function top
+        # Strip smolagents internal prompt blocks (GOAL/DONE_WHEN/OUT_OF_SCOPE)
+        text = _re.sub(
+            r'(?m)^(?:GOAL|DONE_WHEN|OUT_OF_SCOPE):\s*.*(?:\n(?!\n)[^\n]*)*',
+            '', text
+        )
+        # Strip "Proceed. We need to output the tool call now. [{"action":...}]"
+        text = _re.sub(
+            r'Proceed\.?\s*We\s+need\s+to\s+output\s+the\s+tool\s+call\s+now\.?\s*\[.*?\]',
+            '', text, flags=_re.DOTALL
+        )
+        # Strip raw JSON tool call arrays at line start
+        text = _re.sub(r'^\s*\[\s*\{["\']*action["\']*\s*:', '', text, flags=_re.MULTILINE)
+        # Strip smolagents Thought:/Code:/Observation: line prefixes (when not inside code blocks)
+        text = _re.sub(r'^(?:Thought|Code|Observation|Action Input):\s*', '', text, flags=_re.MULTILINE)
+        # Strip [STEP N/M] markers
+        text = _re.sub(r'\[STEP\s+\d+/\d+\]\s*', '', text)
+        return text.strip()
+
+    # S375: Format directive classifier — speculare al frontend formatClassifier.ts
+    # Iniettato in _build_messages() per garantire formattazione consistente
+    # anche sui task tool-heavy gestiti interamente dal backend.
+    _FORMAT_DIRECTIVE_CODE = (
+        "FORMATO RISPOSTA OBBLIGATORIO — CODICE:\n"
+        "• Usa SEMPRE blocchi markdown con linguaggio specificato (```python, ```typescript, ecc.)\n"
+        "• Per una richiesta di singolo snippet, emetti ESATTAMENTE un blocco nel linguaggio richiesto; "
+        "non sostituirlo con pseudocodice, analisi o un blocco generico.\n"
+        "• Il blocco deve contenere la soluzione completa, autonoma ed eseguibile senza modifiche; "
+        "mantieni gli export e la firma richiesti.\n"
+        "• Prima di rispondere applica il CONTROLLO FINALE: codice compilabile, nessun placeholder/TODO, "
+        "nessun simbolo non definito, tipi espliciti.\n"
+        "• Per codice async con handler indipendenti: includi `async`, `await` e `try/catch` oppure "
+        "`Promise.allSettled` per isolare ogni errore.\n"
+        "• Per correzioni React useEffect: preserva la struttura, usa AbortController o una guardia di annullamento "
+        "e restituisci sempre cleanup (`return () => ...`).\n"
+        "• Aggiungi commenti inline solo per la logica non ovvia. Se multi-file: mostra ogni file in un blocco separato "
+        "con il nome come titolo; formato titolo: ### src/nomefile.tsx."
+    )
+    _FORMAT_DIRECTIVE_MARKDOWN = (
+        "FORMATO RISPOSTA OBBLIGATORIO — STRUTTURATO:\n"
+        "• Usa titoli (##), liste puntate, grassetto per punti chiave\n"
+        "• Max 3 livelli di gerarchia — non annidare troppo\n"
+        "• Tabelle markdown per confronti (3+ elementi)\n"
+        "• Paragrafi brevi (2-3 righe) per leggibilità mobile\n"
+        "Su mobile, tabelle 3+ colonne: usa lista chiave-valore o ### + punti (scroll orizzontale non usabile su iPhone)"
+    )
+    _FORMAT_DIRECTIVE_CONVERSATIONAL = (
+        "FORMATO RISPOSTA OBBLIGATORIO — CONVERSAZIONALE:\n"
+        "• Tono diretto e naturale, senza formalismi eccessivi\n"
+        "• Niente strutture markdown pesanti per domande semplici\n"
+        "• Rispondi in 1-3 paragrafi se la domanda è semplice\n"
+        "• Usa grassetto solo per termini chiave critici"
+    )
+    _FORMAT_DIRECTIVE_MATH = (
+        "FORMATO RISPOSTA OBBLIGATORIO — MATEMATICA:\n"
+        "• Mostra SEMPRE i calcoli passo per passo numerati\n"
+        "• Usa notazione chiara: P(A|B), E[X], Σ, ecc.\n"
+        "• Risultato finale in riga separata con grassetto\n"
+        "• Usa il PUNTO come separatore decimale (non virgola)\n"
+        "• Esprimi probabilità sia come frazione che come percentuale"
+    )
+
+    # S-FMT-MOBILE: 4 nuove direttive specializzate iPhone (2026-06-12)
+    _FORMAT_DIRECTIVE_RESEARCH = (
+        "FORMATO RISPOSTA OBBLIGATORIO - RICERCA:\n"
+        "- Struttura ogni fonte: Fonte -> sintesi 1-2 righe -> punto chiave\n"
+        "- Max 4 fonti, priorita qualita su quantita\n"
+        "- Separazione netta fatti verificati vs interpretazioni\n"
+        "- Termina con sezione VERDETTO (1 paragrafo, risposta diretta)\n"
+        "- Nessuna fonte disponibile: dichiaralo esplicitamente"
+    )
+    _FORMAT_DIRECTIVE_DEBUG = (
+        "FORMATO RISPOSTA OBBLIGATORIO - DEBUG:\n"
+        "- Struttura FISSA 4 sezioni: Errore -> Causa -> Fix (codice) -> Prevenzione\n"
+        "- Sezione Fix: codice completo pronto da copiare, non frammenti\n"
+        "- Sezione Causa: spiega PERCHE accade, non solo cosa accade\n"
+        "- Sezione Prevenzione: max 2 punti concreti\n"
+        "- Bug multipli: numera ogni set Errore/Causa/Fix/Prevenzione"
+    )
+    _FORMAT_DIRECTIVE_MEDIA = (
+        "FORMATO RISPOSTA OBBLIGATORIO - MEDIA/IMMAGINE:\n"
+        "- URL immagine come link cliccabile: [Visualizza immagine](URL)\n"
+        "- URL in riga separata per copy-paste\n"
+        "- Breve descrizione di cosa raffigura l' immagine generata\n"
+        "- Se non disponibile: fornisci URL Pollinations come fallback esplicito"
+    )
+    _FORMAT_DIRECTIVE_MOBILE_COMPACT = (
+        "FORMATO RISPOSTA OBBLIGATORIO - MOBILE RAPIDO:\n"
+        "- Risposta MASSIMO 150 parole, vai dritto al punto\n"
+        "- Prima riga = verdetto/azione (no preamboli)\n"
+        "- Usa emoji come icone stato: OK fatto, WARN attenzione, ERR errore, TIP suggerimento\n"
+        "- Zero spiegazioni non richieste, solo l' essenziale\n"
+        "- Se servono dettagli: offri follow-up"
+    )
+
+    # GAP-A: narrazione pre-tool — spiega all'utente PERCHÉ l'agente usa quel tool.
+    # Usato nel _run_subtask (reason field) e come text_chunk prima del gather.
+    # Zero latency: nessuna chiamata LLM — solo lookup di dizionario.
+    _TOOL_NARRATION: dict[str, str] = {
+        "web_search":           "🔍 Cerco informazioni aggiornate sul web",
+        "read_page":            "🌐 Leggo la pagina web per estrarre i dati",
+        "write_file":           "✍️ Implemento il codice richiesto",
+        "read_file":            "📂 Leggo il file per analizzare la struttura attuale",
+        "apply_patch":          "🔧 Applico la patch mirata al file",
+        "run_python":           "⚙️ Eseguo il codice Python per verificare il risultato",
+        "execute_shell":        "🖥️ Eseguo il comando shell",
+        "execute_sql":          "🗄️ Eseguo la query SQL",
+        "database_query":       "🗄️ Eseguo la query sul database",
+        "git_push":             "🚀 Invio le modifiche al repository",
+        "git_commit":           "💾 Salvo le modifiche con un commit",
+        "git_status":           "📊 Verifico lo stato del repository",
+        "git_diff":             "🔎 Confronto le modifiche in staging",
+        "git_clone":            "📥 Clono il repository",
+        "npm_install":          "📦 Installo le dipendenze Node.js",
+        "npm_run":              "▶️ Avvio lo script npm",
+        "pip_install":          "📦 Installo i pacchetti Python",
+        "type_check":           "✅ Verifico i tipi TypeScript",
+        "lint_code":            "🔍 Analizzo la qualità del codice",
+        "get_weather":          "🌤️ Recupero le previsioni meteo",
+        "get_news":             "📰 Recupero le ultime notizie",
+        "recall":               "🧠 Consulto la memoria dell'agente",
+        "list_files":           "📁 Elenco i file del progetto",
+        "directory_tree":       "🗂️ Analizzo la struttura del progetto",
+        "file_search":          "🔎 Cerco nel codice del progetto",
+        "create_project":       "🏗️ Creo la struttura del progetto",
+        "scaffold_project":     "🏗️ Genero la struttura del progetto da template",
+        # Tool planner-only (non in TOOL_REGISTRY) — narrazione pre-gather
+        "code":                 "💻 Implemento la soluzione richiesta",
+        "send_email":           "📧 Invio l'email tramite Resend",
+        "create_pdf":           "📄 Genero il documento PDF",
+        "call_api":             "🔗 Chiamo l'API esterna",
+        "browser_navigate":     "🌐 Navigo verso la pagina",
+        "browser_session_open": "🌐 Apro una sessione browser",
+        "browser_session_act":  "🖱️ Interagisco con la pagina",
+        "get_image":            "🖼️ Recupero l'immagine",
+        "create_chart":         "📊 Creo il grafico",
+        "diff_text":            "🔎 Confronto i testi",
+        "validate_json":        "✅ Valido il JSON",
+        "calculate":            "🔢 Calcolo il risultato matematico",
+        "image":                "🎨 Genero un'immagine con AI",
+        "generate_image":       "🎨 Genero un'immagine con AI",
+        "delegate_task":        "🤝 Delego a un micro-agente specializzato",
+        "browser_session_open":  "🖱️ Apro una sessione browser autonoma",
+        "browser_session_act":   "🖱️ Interagisco con la pagina nel browser",
+        "web_research":         "🔍 Ricerca approfondita multi-fonte sul web",
+    }
+    _TOOL_NARRATION_DEFAULT = "⚙️ Eseguo l'operazione"
+
+    # GAP-B scaffold preview: albero file mostrato in real-time PRIMA che il tool scriva.
+    # Sincronizzato con i template in registry.py/_scaffold_project — aggiorna entrambi.
+    _SCAFFOLD_FILE_TREE: dict[str, list[str]] = {
+        "react":   ["package.json", "index.html", "vite.config.ts", "src/main.tsx", "src/App.tsx", "src/index.css"],
+        "nextjs":  ["package.json", "next.config.mjs", "app/layout.tsx", "app/page.tsx"],
+        "fastapi": ["main.py", "requirements.txt", "Dockerfile", ".gitignore"],
+        "flask":   ["app.py", "requirements.txt", ".gitignore"],
+        "django":  ["manage.py", "requirements.txt", "config/settings.py", "config/urls.py", "api/views.py", "api/urls.py"],
+        "express": ["package.json", "src/index.js", ".gitignore"],
+    }
+
+    # S427: ampliato con verbi IT/EN + tecnologie — stesso set di _CODE_RE
+    _CODE_GOAL_RE = re.compile(
+        r'\b(scrivi|crea|genera|implementa|refactor|codice|funzione|classe|componente|'
+        r'script|algoritmo|api|endpoint|hook|store|tipo|interface|migration|query|schema|'
+        r'write|create|generate|implement|code|function|class|component|backend|frontend|'
+        r'sistema|correggi|debugga|patch|rinomina|sostituisci|rimpiazza|ottimizza|'
+        r'rename|replace|remove|delete|fix|debug|optimize|deploy|scaffold|'
+        r'typescript|javascript|python|react|vue|svelte|angular|next\.?js|nuxt|'
+        r'fastapi|flask|django|express|nest\.?js|rails|laravel|'
+        r'service|repository|controller|middleware|utility|helper|'
+        r'css|scss|html|sql|graphql|dockerfile|prisma|drizzle)\b',
+        re.IGNORECASE,
+    )
+    # S427: ampliato con più concetti matematici IT/EN
+    _MATH_GOAL_RE = re.compile(
+        r'\b(calcola|calcolare|probabilit|bayes|integra|derivat|statistic|media|'
+        r'varianza|percentuale|equazione|formula|risolvi|calculate|probability|'
+        r'integral|derivative|statistic|mean|variance|equation|solve|'
+        r'somma|prodotto|divisione|divisore|multiplo|mcd|mcm|modulo|quoziente|'
+        r'logaritmo|radice|potenza|fattoriale|fibonacci|'
+        r'trigonometria|seno|coseno|tangente|algebra|geometria|aritmetica|'
+        r'matrice|determinante|vettore|'
+        r'sum|product|division|lcm|gcd|remainder|quotient|'
+        r'logarithm|sqrt|square\s*root|factorial|power|'
+        r'trigonometry|sine|cosine|tangent|matrix|determinant|vector|'
+        r'fraction|frazioni|decimali|decimal|percentag)\b',
+        re.IGNORECASE,
+    )
+    # S427: ampliato con più trigger per risposta strutturata markdown
+    _MARKDOWN_GOAL_RE = re.compile(
+        r'\b(elenca|confronta|spiega|differenz|vantaggi|svantaggi|guida|tutorial|'
+        r'passaggi|step|pros?|contro|list|compare|explain|differences?|advantages?|'
+        r'disadvantages?|guide|steps?|pros?|cons?|'
+        r'riassumi|riassunto|summarize|summary|overview|panoramica|'
+        r'tabella|table|sezioni|sections|categorizza|categorie|'
+        r'elencami|dammi una lista|i migliori|le migliori|i principali|le principali|'
+        r'tipi di|types\s+of|examples?\s+of|esempi\s+di|'
+        r'struttura|structure|breakdown|analisi|analysis)\b',
+        re.IGNORECASE,
+    )
+
+    # S-FMT-MOBILE: regex per direttive specializzate iPhone (2026-06-12)
+    _RESEARCH_GOAL_RE = re.compile(
+        r'\b(ricerca|research|trova\s+info|notizie|news|articoli|fonti|'
+        r'find\s+information|when\s+did|storia\s+di|'
+        r'ultima\s+notizia|latest\s+on|trending|fact.?check)\b',
+        re.IGNORECASE,
+    )
+    _DEBUG_GOAL_RE = re.compile(
+        r'\b(errore|error|traceback|exception|stacktrace|stack\s+trace|'
+        r'debug|debugga|crash|fallisce|non\s+funziona|si\s+rompe|'
+        r'undefined\s+is\s+not|cannot\s+read|type\s+error|runtime\s+error|'
+        r'fix\s+(?:the\s+)?(?:bug|error|crash|issue|problem))\b',
+        re.IGNORECASE,
+    )
+    _MEDIA_GOAL_RE = re.compile(
+        r'\b(genera\s+immagine|generate\s+image|crea\s+immagine|create\s+image|'
+        r'immagine\s+di|image\s+of|foto\s+di|picture\s+of|'
+        r'disegna|draw|illustra|illustrate|render|genera\s+foto|'
+        r'flux|dall.?e|midjourney|stable\s+diffusion|pollinations)\b',
+        re.IGNORECASE,
+    )
+    _MOBILE_COMPACT_RE = re.compile(
+        r'\b(quick|veloce|breve|dimmi\s+solo|solo\s+il\s+risultato|verdetto|'
+        r'in\s+breve|tl;?dr|sintesi\s+rapida|recap|riassumi\s+in\s+poche|'
+        r'risposta\s+breve|brief\s+answer|short\s+answer)\b',
+        re.IGNORECASE,
+    )
+    # GAP-ROUT: routing specializzato per benchmark (SQL, Reasoning, MMLU)
+    _SQL_GOAL_RE = re.compile(
+        r'\b(sql|postgresql|cte ricorsiva|recursive cte|with recursive|'
+        r'window functions?|over\(|partition by|rank\(|row_number\(|'
+        r'gerarchia|parent_id|manager_id|recursive)\b',
+        re.IGNORECASE,
+    )
+    _REASONING_GOAL_RE = re.compile(
+        r'\b(reasoning|gsm8k|math|matematica|logica|ragionamento|'
+        r'ted the t-rex|calcola|calcolare|probabilit|bayes|frazioni|percentuale)\b',
+        re.IGNORECASE,
+    )
+    _MMLU_GOAL_RE = re.compile(
+        r'\b(mmlu|computer science|informatica|architettura|os|networking|'
+        r'database|complessità|p vs np|modello osi|acid properties)\b',
+        re.IGNORECASE,
+    )
+    # S-FMT-ORCH: fast-fix detector per bypass ARCHITECT su singola operazione (<180 chars)
+    # B1: espansa con 10 operazioni atomiche — guardata da len(goal)<180 nel chiamante.
+    # Conseguenze: skip ARCHITECT (-15s) per operazioni single-step unambiguamente chiare.
+    # Zero cons: la guard len<180 esclude goal multi-step; il piano sintetico è sufficiente.
+    _FAST_FIX_RE = re.compile(
+        r'\b(typos?|rinomina\s+\w|rename\s+\w|'
+        r'cambia\s+.{1,40}\s+in\s+|change\s+.{1,40}\s+to\s+|'
+        r'sostituisci\s+.{1,40}\s+con\s+|replace\s+.{1,40}\s+with\s+|'
+        r'aggiungi\s+commento|add\s+comment|correggi\s+il\s+typo|fix\s+typo|'
+        r'rimuovi\s+riga|delete\s+line|bump\s+version|update\s+version\s+to|'
+        # Fix-4.2: import banali non hanno bisogno di 10-15s Architect
+        r'aggiungi\s+import|add\s+import|manca\s+import|import\s+missing|'
+        r'install\s+package|installa\s+pacchetto|aggiungi\s+dipendenza|'
+        # B1-a: parametri / campi / proprietà — operazioni single-step su firme
+        r'aggiungi\s+(?:un\s+)?(?:parametro|param|argomento|campo|field|propert\w+)\b|'
+        r'rimuovi\s+(?:il\s+|la\s+|questo\s+|questa\s+)?(?:parametro|param|campo|field|prop|propert\w+)\b|'
+        # B1-b: tipi / annotazioni — aggiunta tipo/interface senza logica
+        r'aggiungi\s+(?:il\s+|un\s+)?(?:tipo|type|annotation|return\s+type|tipo\s+di\s+ritorno)\b|'
+        r'(?:aggiorna|update)\s+(?:il\s+)?(?:tipo|type|interface|schema|signature)\b|'
+        # B1-c: export — aggiunta/rimozione senza logica
+        r'aggiungi\s+(?:il\s+|un\s+)?(?:export|export\s+default|default\s+export)\b|'
+        r'rimuovi\s+(?:il\s+)?(?:export|default\s+export)\b|'
+        # B1-d: log / debug — aggiungi o rimuovi singola istruzione
+        r'aggiungi\s+(?:un\s+)?(?:console\.log|print|log|debug)\b|'
+        r'(?:togli|elimina|cancella|rimuovi)\s+(?:il\s+|i\s+)?(?:console\.log|log\s+di\s+debug|debug\s+log|print)\b|'
+        # B1-e: formattazione / indentazione — nessuna logica, solo stile
+        r'correggi\s+(?:l[a\']?\s+)?(?:indentazione|indent|spaziatura|spacing|formatt\w+)\b|'
+        r'(?:formatta|format)\s+(?:il\s+)?(?:codice|file|questo)\b|'
+        # B1-f: conversioni semplici — async/arrow/const senza cambiare logica
+        r'(?:converti|convert)\s+.{1,50}\s+(?:in|to|a)\s+(?:async|arrow\s+function|const|let)\b)\b',
+        re.IGNORECASE,
+    )
+
+    # B5: pure-explanation bypass — nessun tool, LLM diretto (risparmio -20-30s).
+    # Fix storia: cos'?[eè] (char class ['è] era sbagliata: matchava 1 char, non seq 'è).
+    # Fail-open: 4 guard — len<300, pattern, no action verb, no file ref.
+    _PURE_EXPLANATION_RE = re.compile(
+        r"^\s*(?:"
+        r"(?:cos'?[e\xe8]\s+)"
+        r"|(?:che\s+cos'?[a\xe0]?\s*[e\xe8]\s+)"
+        r"|(?:spiega(?:mi)?\b)"
+        r"|(?:dimmi\s+(?:come|cosa|cos|perch[e\xe8]|qual[e\xe8])\b)"
+        r"|(?:qual[e\xe8]\s+|qual\s+[e\xe8]\s+)(?:la\s+)?(?:differenz[ae]|scopo|significato)"
+        r"|(?:come\s+funziona\s+(?!il\s+(?:mio|tuo|nostro|codice|progetto|login|sito|sistema|questo)\b))"
+        r"|(?:cosa\s+(?:fa|significa|vuol\s+dire|rappresenta)\s+)"
+        r"|(?:a\s+cosa\s+serve\s+)"
+        r"|(?:perch[e\xe8]\s+(?:si\s+usa|viene\s+usato|[e\xe8]\s+utile|esiste)\s+)"
+        r"|(?:what\s+(?:is|are|does|means?)\s+(?!my\b|the\s+output\b|this\s+code\b))"
+        r"|(?:how\s+does\s+(?!my\b|this\b|the\s+code\b|it\s+work\s+in\b))"
+        r"|(?:explain\s+(?:me\s+)?(?:briefly\s+)?(?:what|how|why|the)\s+)"
+        r")",
+        re.IGNORECASE | re.DOTALL,
+    )
+    _EXPL_REALTIME_RE = re.compile(
+        r"\b(oggi|adesso|ora|live|real.?time|notizie|news|ultime|recenti|"
+        r"aggiornamenti|previsioni|meteo|prezzo|quotazione|borsa|trend)\b",
+        re.IGNORECASE,
+    )
+    _EXPL_TUTORIAL_RE = re.compile(
+        r"^\s*spiega(?:mi)?\b.{0,80}?\b(?:e\s+)?poi\s+"
+        r"(?:indica|descrivi|elenca)\s+(?:i\s+)?(?:passaggi|step)\s+"
+        r"(?:per\s+)?(?:modificare|correggere|configurare|aggiornare)\b",
+        re.IGNORECASE | re.DOTALL,
+    )
+    _EXPL_CONTEXTUAL_ACTION_REF_RE = re.compile(
+        r"\b(?:dopo|prima|durante|in seguito a|a seguito di)\s+una\s+modifica\s+"
+        r"(?:al|del|nel)\s+(?:codice|file|progetto)\b",
+        re.IGNORECASE,
+    )
+    _EXPL_ACTION_RE = re.compile(
+        r"\b(crea|scrivi|genera|implementa|esegui|correggi|fix|run|create|write|"
+        r"generate|implement|execute|installa|deploy|avvia|configura|aggiorna|update|"
+        r"aggiungi|rimuovi|modifica|refactor|build|pubblica|manda|invia|upload|"
+        r"poi|then|e\s+poi|and\s+then|quindi|dopo|successivamente)\b",
+        re.IGNORECASE,
+    )
+    _EXPL_FILE_REF_RE = re.compile(
+        r"\b(nel\s+codice|in\s+questo\s+file|nel\s+file|nel\s+progetto|"
+        r"qui\s+sopra|il\s+codice\s+che|in\s+the\s+code|"
+        r"in\s+this\s+file|this\s+function|questa\s+funzione)\b",
+        re.IGNORECASE,
+    )
+

agents/unified_loop_tools.py

@@ -0,0 +1,779 @@
+"""unified_loop_tools.py — DirectToolsMixin: tool execution layer.
+Estratto da unified_loop.py per ridurre il file principale da 2541 a ~2000 righe.
+Contiene (nell'ordine originale del file):
+  - Regex class attrs: meteo, URL, ricerca, immagini, calcolo
+  - Helper: _extract_city / _extract_search_query / _extract_calc_expr
+  - _run_direct_tools: layer deterministico parallelo via TOOL_REGISTRY (S193/S419)
+  - _FALSE_CLAIM_RE / _REALTIME_GOAL_RE / _validate_claims: anti-hallucination (S428)
+  - _TOOL_NEEDED_RE / _needs_tools / _SIMPLE_CONV_RE / _is_simple_query: routing (S402)
+Invariante B1: nessun corpo duplicato con unified_loop.py.
+Python MRO garantisce che self.xxx funzioni per attr definite su UnifiedAgentLoop.
+"""
+from __future__ import annotations
+import asyncio
+import hashlib
+import os
+import re
+from typing import Any
+import logging
+try:
+    from api.state import record_timing as _rtc_global  # telemetria tool call
+except ImportError:
+    _rtc_global = None  # state module non ancora disponibile al boot
+
+_logger = logging.getLogger("agents.unified_loop_tools")
+# StepCallback centralizzato in unified_loop_types.py (P20-TD1 Fase 1)
+# S-FIX-IMPORT: aggiunto _maybe_await mancante che causava crash nel tool layer
+from agents.unified_loop_types import StepCallback, _maybe_await
+from agents.file_conversion import convert_csv_attachment_to_json, validate_csv_json_equivalence
+class DirectToolsMixin:
+    # ── Direct tool execution (S193) ─────────────────────────────────────────
+    # Chiama TOOL_REGISTRY direttamente, senza smolagents, senza LLM per routing.
+    # Deterministico, veloce, testabile. Restituisce i risultati come stringa
+    # pronta per essere iniettata nel prompt LLM.
+    _WEATHER_INTENT_RE = re.compile(
+        # S390-B-O: aggiunto 'temperature' (inglese) + 'forecast' come sinonimi weather
+        # S427: aggiunti fenomeni meteo, allerte, condizioni IT/EN
+        r"\b(meteo|temperatura|temperature|temp\s*a\b|clima|weather|previsioni|forecast|"
+        r"che\s+tempo\s+fa|quanto\s+fa\s+freddo|quanto\s+fa\s+caldo|gradi\s+a\b|"
+        r"piove|sta\s+piovendo|nevica|neve|pioggia|temporale|grandine|"
+        r"nebbia|umidità|vento|allerta\s+meteo|allerta\s+rossa|allerta\s+arancione|"
+        r"ondata\s+di\s+caldo|ondata\s+di\s+freddo|gelate|gelo|"
+        r"rain|raining|snow|snowing|fog|humid|wind|windy|storm|thunderstorm|hail|"
+        r"sunny|cloudy|overcast|uv\s+index|heat\s+wave|cold\s+snap|frost)\b",
+        re.IGNORECASE,
+    )
+    # S385: improved city extraction — catches bare patterns like "che tempo fa a Roma?"
+    # S390-B-O: aggiunti trigger 'temperature\s+in' e 'weather\s+(?:forecast\s+)?(?:in|at|for)'
+    _CITY_RE = re.compile(
+        r"(?:meteo|temperatura|temperature|temp(?:eratura)?\s+(?:a|in)|"
+        r"(?:che\s+)?tempo\s+(?:\w+\s+){0,2}(?:fa\s+)?(?:a|in)|"
+        r"com['\u2019]è\s+il\s+tempo\s+a|com['\u2019]è\s+il\s+meteo\s+a|"
+        r"clima\s+(?:a|in)|weather\s+(?:forecast\s+)?(?:in|at|for)|"
+        r"temperature\s+(?:in|at|for)|forecast\s+(?:for|in)|"
+        r"previsioni\s+(?:per|a|in)|gradi\s+(?:a|in))"
+        r"\s+(?:a\s+|in\s+|per\s+)?([A-Za-z\xc0-\xff][A-Za-z\xc0-\xff\s]{1,25}?)"
+        # S390-B-I: aggiunti terminatori inglesi (today/now/tomorrow/currently/right now)
+        r"(?:\?|$|\s*[,\.]|\s+adesso|\s+ora|\s+oggi|\s+domani|\s+attuale|\s+corrente"
+        r"|\s+today|\s+now|\s+tomorrow|\s+currently|\s+right\s+now)",
+        re.IGNORECASE,
+    )
+    _URL_RE = re.compile(r"https?://[^\s\)\}\]>]+", re.IGNORECASE)
+    _SEARCH_INTENT_RE = re.compile(
+        r"\b(cerca|search|trova|find|googla|google|duckduckgo|bing|research|investiga|indaga|"
+        r"fammi\s+sapere|dimmi\s+di\s+più\s+su|informazioni\s+su|info\s+su|news\s+su|notizie\s+su|"
+        r"chi\s+è|cos['\u2019]è|dove\s+si\s+trova|quando\s+è\s+successo|perché\s+il|storia\s+di|"
+        r"tell\s+me\s+about|who\s+is|what\s+is|where\s+is|when\s+did|why\s+is|history\s+of|"
+        r"latest\s+on|ultime\s+su|prezzo\s+di|valore\s+di|quotazione\s+di|stock\s+price\s+of|"
+        r"crypto|bitcoin|ethereum|market\s+cap|capitalizzazione)\b",
+        re.IGNORECASE,
+    )
+    # Un verbo generico come «crea» non autorizza un artefatto visivo: richiedi
+    # un output immagine esplicito, oppure un verbo artistico inequivoco. Questo
+    # evita che «Crea un piano…» diventi una generazione Pollinations/VFS.
+    _IMAGE_INTENT_RE = re.compile(
+        r"(?:\b(?:genera|crea|fai|mostra|visualizza|produce|generate|create|make)\b.{0,40}\b"
+        r"(?:immagine|foto|illustrazione|ritratto|paesaggio|logo|icona|disegno|grafica|"
+        r"image|photo|picture|illustration|portrait|landscape|drawing|graphic|art|artwork)\b)"
+        r"|(?:^\s*(?:disegna|illustra|dipingi|render|paint|sketch)\b"
+        r"(?!\s+(?:(?:un|una|il|lo|la|the|a|an)\s+)?(?:diagramma|grafico|chart|schema|ui|ux|figma)\b))",
+        re.IGNORECASE,
+    )
+    _CALC_INTENT_RE = re.compile(
+        r"\b(calcola|quanto\s+fa|risultato\s+di|compute|calculate|math|matematica|operazione|"
+        r"somma|sottrai|moltiplica|dividi|percentuale|radice|potenza|"
+        r"sum|add|subtract|multiply|divide|percentage|root|power)\b",
+        re.IGNORECASE,
+    )
+    def _extract_city(self, goal: str) -> str:
+        m = self._CITY_RE.search(goal)
+        if m:
+            candidate = m.group(1).strip()
+            if len(candidate) > 1 and candidate not in {"in", "nel", "un", "il"}:
+                return candidate
+        return "."
+    def _extract_search_query(self, goal: str) -> str:
+        q = re.sub(self._SEARCH_INTENT_RE, "", goal, flags=re.IGNORECASE).strip()
+        return q or goal
+    def _extract_calc_expr(self, goal: str) -> str:
+        m = re.search(r'[\d\s\+\-\*\/\^\(\)\.]+', goal)
+        return m.group(0).strip() if m else ""
+
+    def _extract_dir_path(self, goal: str) -> str:
+        """Extract a safe relative directory path, defaulting to the tool root."""
+        m = re.search(
+            r"(?:di|in|dentro|in\s+path|nel\s+path|directory|folder|cartella)\s+"
+            r"['\"]?([./\w\-]+/[./\w\-]*|[./\w\-]+)['\"]?",
+            goal, re.IGNORECASE,
+        )
+        if m:
+            candidate = m.group(1).strip().rstrip("/")
+            if candidate not in {"di", "in", "nel", "nella"}:
+                return candidate
+        return "."
+
+    def _extract_file_pattern(self, goal: str) -> str:
+        """Extract the search pattern without changing the registry's FS jail."""
+        m = re.search(
+            r"(?:grep\s+|cerca\s+(?:la\s+stringa\s+)?|trova\s+(?:la\s+stringa\s+)?|"
+            r"search\s+for\s+|find\s+in\s+files\s+)['\"]?([^\s'\"?,]{2,80})['\"]?",
+            goal, re.IGNORECASE,
+        )
+        return m.group(1).strip() if m else ""
+
+    def _extract_git_cwd(self, goal: str) -> str:
+        """Extract the requested git working directory, defaulting to root."""
+        m = re.search(
+            r"(?:in|nel\s+repo|nel\s+repository|in\s+path)\s+['\"]?([./\w\-]+)['\"]?",
+            goal, re.IGNORECASE,
+        )
+        if m:
+            candidate = m.group(1).strip()
+            if len(candidate) > 1 and candidate not in {"in", "nel", "un", "il"}:
+                return candidate
+        return "."
+    async def _run_direct_tools(
+        self,
+        goal: str,
+        on_step: StepCallback | None = None,
+        *,
+        local_csv_only: bool = False,
+    ) -> tuple[str, int, int, int]:
+        """
+        S193: Esegue tool direttamente via TOOL_REGISTRY senza smolagents o LLM per routing.
+        Returns: 4-tuple (results_str, n_called, n_success, n_errors).
+            results_str: stringa reale da iniettare nel prompt (join di tutti i tool output)
+            n_called:    numero totale di tool chiamati
+            n_success:   numero di tool completati con successo
+            n_errors:    numero di tool falliti
+        """
+        # FIX-TOOL-01: usare i package reali del backend; i moduli indicati dal
+        # precedente restore non esistono e interrompevano il direct-tools layer.
+        from tools.registry import TOOL_REGISTRY
+        from api.speculative import get_speculative_result as _speculative_result
+
+        results: list[str] = []
+        n_called = 0
+        n_success = 0
+        n_errors = 0
+        TOOL_TIMEOUT = 25
+
+        # Governor per singolo run: conserva budget adattivo e deduplicazione.
+        _gov_called: set[str] = set()
+        _gov_total = 0
+        _tok_budget_gov = self._max_tokens_for_goal(goal)
+        _gov_max_calls = 9 if _tok_budget_gov >= 6144 else 7 if _tok_budget_gov >= 4096 else 6
+
+        def _gov_check(tool_name: str, key_arg: str) -> bool:
+            nonlocal _gov_total
+            if _gov_total >= _gov_max_calls:
+                return False
+            signature = f"{tool_name}:{key_arg[:150]}"
+            if signature in _gov_called:
+                return False
+            _gov_called.add(signature)
+            _gov_total += 1
+            return True
+
+        def _spec_hit(tool_name: str, args: dict[str, Any]) -> str | None:
+            try:
+                return _speculative_result(goal, tool_name, args)
+            except Exception:
+                # Cache speculativa opzionale: mai bloccare l'esecuzione reale.
+                return None
+
+        # S419: esegui i tool eligible in parallelo con asyncio.gather
+        # Pre-check intent (sincrono) → costruisce lista coroutine → gather
+        url_m = self._URL_RE.search(goal)
+        async def _t_get_weather() -> str | None:
+            if not self._WEATHER_INTENT_RE.search(goal):
+                return None
+            city = self._extract_city(goal)
+            if not _gov_check("get_weather", city):
+                return None
+            try:
+                if on_step:
+                    await _maybe_await(on_step({"action": "tool_start", "status": "running",
+                        "title": "Meteo", "explanation": f"Recupero meteo per {city}…"}))
+                _sc = _spec_hit("get_weather", {"city": city})
+                if _sc is not None:
+                    return _sc
+                _t0 = asyncio.get_event_loop().time()
+                r = await asyncio.wait_for(TOOL_REGISTRY["get_weather"]["_fn"](city=city), timeout=TOOL_TIMEOUT)
+                try:
+                    from api.state import record_timing as _rtc; _rtc("tool_call", (asyncio.get_event_loop().time() - _t0) * 1000)
+                except Exception as _e: _logger.debug('[timing/record_timing] %s', _e)
+                if "temp_c" in r:
+                    _wdesc = {
+                        0: "cielo sereno", 1: "prevalentemente sereno", 2: "parzialmente nuvoloso", 3: "coperto",
+                        45: "nebbia", 48: "nebbia con brina", 51: "pioviggine leggera", 53: "pioviggine moderata",
+                        55: "pioviggine intensa", 61: "pioggia leggera", 63: "pioggia moderata", 65: "pioggia forte",
+                        71: "nevicata leggera", 73: "nevicata moderata", 75: "nevicata forte", 80: "rovesci leggeri",
+                        81: "rovesci moderati", 82: "rovesci violenti", 95: "temporale", 96: "temporale con grandine",
+                    }
+                    wcode = r.get("code"); temp_c = r.get("temp_c"); wind_kmh = r.get("wind_kmh")
+                    try:
+                        desc = _wdesc.get(int(wcode), f"codice {wcode}") if wcode is not None else "N/D"
+                    except (TypeError, ValueError):
+                        desc = "N/D"
+                    return (
+                        f"[METEO REALE — {r['city']}, {r.get('country', '')}]\n"
+                        f"Temperatura attuale: {f'{temp_c}°C' if temp_c is not None else 'N/D'}\n"
+                        f"Vento: {f'{wind_kmh} km/h' if wind_kmh is not None else 'N/D'}\n"
+                        f"Condizioni: {desc}"
+                    )
+                return f"[get_weather: errore — {r['error'][:300]}]"
+            except asyncio.TimeoutError:
+                return f"[get_weather: timeout {TOOL_TIMEOUT}s]"
+            except Exception as exc:
+                return f"[get_weather: errore — {str(exc)[:300]}]"
+        async def _t_read_page() -> str | None:
+            if not url_m:
+                return None
+            url = url_m.group(0)
+            if not _gov_check("read_page", url):
+                return None
+            try:
+                _sc = _spec_hit("read_page", {"url": url})
+                if _sc is not None:
+                    return _sc
+                if on_step:
+                    await _maybe_await(on_step({"action": "tool_start", "status": "running",
+                        "title": "Lettura pagina", "explanation": f"Leggo {url[:60]}…"}))
+                _t0 = asyncio.get_event_loop().time()
+                r = await asyncio.wait_for(TOOL_REGISTRY["read_page"]["_fn"](url=url), timeout=TOOL_TIMEOUT)
+                try:
+                    from api.state import record_timing as _rtc; _rtc("tool_call", (asyncio.get_event_loop().time() - _t0) * 1000)
+                except Exception as _e: _logger.debug('[timing/record_timing] %s', _e)
+                if r.get("content"):
+                    return (f"[PAGINA REALE: {url}]\n(status {r.get('status', '?')})\n{r['content'][:3000]}")
+                return f"[read_page: errore — {r.get('error', 'nessun contenuto')[:300]}]"
+            except asyncio.TimeoutError:
+                return f"[read_page: timeout {TOOL_TIMEOUT}s]"
+            except Exception as exc:
+                return f"[read_page: errore — {str(exc)[:300]}]"
+        async def _t_calculate() -> str | None:
+            if url_m or not self._CALC_INTENT_RE.search(goal):
+                return None
+            expr = self._extract_calc_expr(goal)
+            if not expr or not _gov_check("calculate", expr):
+                return None
+            try:
+                if on_step:
+                    await _maybe_await(on_step({"action": "tool_start", "status": "running",
+                        "title": "Calcolo", "explanation": f"Calcolo: {expr[:60]}"}))
+                _sc = _spec_hit("calculate", {"expression": expr})
+                if _sc is not None:
+                    return _sc
+                _t0 = asyncio.get_event_loop().time()
+                r = await asyncio.wait_for(TOOL_REGISTRY["calculate"]["_fn"](expression=expr), timeout=8)
+                try:
+                    from api.state import record_timing as _rtc; _rtc("tool_call", (asyncio.get_event_loop().time() - _t0) * 1000)
+                except Exception as _e: _logger.debug('[timing/record_timing] %s', _e)
+                if "result" in r:
+                    return f"[CALCOLO REALE]\n{r['expression']} = {r['result']}"
+                return f"[calculate: errore — {r.get('error', '?')[:300]}]"
+            except asyncio.TimeoutError:
+                return "[calculate: timeout]"
+            except Exception as exc:
+                return f"[calculate: errore — {str(exc)[:300]}]"
+        async def _t_web_search() -> str | None:
+            if not self._SEARCH_INTENT_RE.search(goal):
+                return None
+            query = self._extract_search_query(goal)
+            if not query or not _gov_check("web_search", query):
+                return None
+            try:
+                if on_step:
+                    await _maybe_await(on_step({"action": "tool_start", "status": "running",
+                        "title": "Ricerca web", "explanation": f"Cerco: {query[:60]}…"}))
+                _sc = _spec_hit("web_search", {"query": query})
+                if _sc is not None:
+                    return _sc
+                _t0 = asyncio.get_event_loop().time()
+                r = await asyncio.wait_for(TOOL_REGISTRY["web_search"]["_fn"](query=query, max_results=5), timeout=TOOL_TIMEOUT)
+                try:
+                    from api.state import record_timing as _rtc; _rtc("tool_call", (asyncio.get_event_loop().time() - _t0) * 1000)
+                except Exception as _e: _logger.debug('[timing/record_timing] %s', _e)
+                hits = r.get("results", [])
+                if hits:
+                    _out = [f"[RICERCA WEB REALE: {query}]"]
+                    for h in hits:
+                        _out.append(f"• {h['title']} ({h['url']}): {h['snippet']}")
+                    return "\n".join(_out)
+                return f"[web_search: nessun risultato per '{query}']"
+            except asyncio.TimeoutError:
+                return f"[web_search: timeout {TOOL_TIMEOUT}s]"
+            except Exception as exc:
+                return f"[web_search: errore — {str(exc)[:300]}]"
+        async def _t_convert_csv_attachment() -> str | None:
+            conversion = convert_csv_attachment_to_json(goal)
+            if conversion is None:
+                return None
+            if not _gov_check("convert_csv_to_json", conversion.target_name):
+                return None
+
+            # Il successo diretto è consentito solo dopo il confronto semantico
+            # record-per-record. Questo blocca cataloghi generici/allucinati prima
+            # che il loop possa dichiarare una conversione corretta.
+            is_valid, validation_error = validate_csv_json_equivalence(
+                conversion.source_content,
+                conversion.content,
+            )
+            if not is_valid:
+                return f"[convert_csv_to_json: validazione fallita — {validation_error}]"
+
+            async def _write(path: str, content: str) -> dict[str, Any]:
+                return await asyncio.wait_for(
+                    TOOL_REGISTRY["write_file"]["_fn"](path=path, content=content),
+                    timeout=TOOL_TIMEOUT,
+                )
+
+            try:
+                if on_step:
+                    await _maybe_await(on_step({"action": "tool_start", "status": "running",
+                        "title": "Conversione CSV in JSON",
+                        "explanation": f"Converto {conversion.source_name} in {conversion.target_name} con verifica record…"}))
+                _t0 = asyncio.get_event_loop().time()
+
+                # Per il CSV inline il goal richiede esplicitamente entrambi gli
+                # artefatti. Gli allegati conservano il comportamento esistente:
+                # viene scritto soltanto il JSON, poiché la fonte è già disponibile.
+                written_paths: list[str] = []
+                if conversion.source_is_inline:
+                    source_written = await _write(conversion.source_name, conversion.source_content)
+                    if not source_written.get("ok"):
+                        return f"[convert_csv_to_json: errore sorgente — {str(source_written.get('error', 'scrittura non riuscita'))[:300]}]"
+                    written_paths.append(conversion.source_name)
+                    if on_step:
+                        await _maybe_await(on_step({
+                            "action": "file_written", "status": "done",
+                            "path": conversion.source_name, "content": conversion.source_content,
+                            "title": "File CSV creato",
+                            "explanation": f"Creato {conversion.source_name} con i dati sorgente verificati.",
+                        }))
+
+                target_written = await _write(conversion.target_name, conversion.content)
+                if not target_written.get("ok"):
+                    return f"[convert_csv_to_json: errore JSON — {str(target_written.get('error', 'scrittura non riuscita'))[:300]}]"
+                written_paths.append(conversion.target_name)
+                if on_step:
+                    await _maybe_await(on_step({
+                        "action": "file_written", "status": "done",
+                        "path": conversion.target_name, "content": conversion.content,
+                        "title": "File JSON creato",
+                        "explanation": f"Creato {conversion.target_name} con {conversion.row_count} record verificati.",
+                    }))
+                try:
+                    from api.state import record_timing as _rtc
+                    _rtc("tool_call", (asyncio.get_event_loop().time() - _t0) * 1000)
+                except Exception as _e:
+                    _logger.debug('[timing/record_timing] %s', _e)
+                paths = ", ".join(f"`{path}`" for path in written_paths)
+                return (
+                    "[DIRECT_TERMINAL]\n"
+                    f"E2E_CONVERSION_OK: verificati {conversion.row_count} record tra `{conversion.source_name}` "
+                    f"e `{conversion.target_name}`.\n\n"
+                    f"File workspace salvati: {paths}."
+                )
+            except asyncio.TimeoutError:
+                return "[convert_csv_to_json: timeout]"
+            except Exception as exc:
+                return f"[convert_csv_to_json: errore — {str(exc)[:300]}]"
+
+        async def _t_generate_image() -> str | None:
+            if not self._IMAGE_INTENT_RE.search(goal):
+                return None
+            _img_prompt = re.sub(
+                r"^.*?(?:genera|crea|disegna|illustra|fai|mostra).*?(?:immagine|foto|illustrazione|di|un[a']?|del?la?|del?l[o']?)\s*",
+                "", goal, flags=re.IGNORECASE
+            ).strip() or goal
+            if not _gov_check("generate_image", _img_prompt):
+                return None
+            try:
+                if on_step:
+                    await _maybe_await(on_step({"action": "tool_start", "status": "running",
+                        "title": "Generazione immagine", "explanation": f"Genero: {_img_prompt[:60]}…"}))
+                _sc = _spec_hit("generate_image", {"prompt": _img_prompt[:600]})
+                if _sc is not None:
+                    return _sc
+                _img_prompt = _img_prompt[:600]
+                # Il provider autenticato rimane lato server. Il fallback storico
+                # resta solo per garantire la creazione gratuita se il secret non è
+                # ancora disponibile durante un riavvio del runtime.
+                try:
+                    from api.image_provider import generate_pollinations_image
+                    remote = await generate_pollinations_image(_img_prompt, width=512, height=512)
+                    img_url = remote.url
+                    img_mime = remote.mime_type
+                except Exception as provider_exc:
+                    _logger.info("image provider unavailable; using free URL fallback (%s)", type(provider_exc).__name__)
+                    from urllib.parse import quote
+                    _img_seed = sum(ord(char) for char in _img_prompt) % 9999 + 1
+                    img_url = (
+                        f"https://image.pollinations.ai/prompt/{quote(_img_prompt, safe='')}"
+                        f"?width=512&height=512&seed={_img_seed}&nologo=true&enhance=true"
+                    )
+                    img_mime = "image/jpeg"
+                _artifact_id = hashlib.sha256(_img_prompt.encode("utf-8")).hexdigest()[:12]
+                _artifact_path = f"generated-image-{_artifact_id}.jpg"
+                if on_step:
+                    await _maybe_await(on_step({
+                        "action": "file_written",
+                        "status": "done",
+                        "path": _artifact_path,
+                        "source_url": img_url,
+                        "mime_type": img_mime,
+                        "title": "Immagine salvata nel workspace",
+                        "explanation": f"Salvo {_artifact_path} nel VFS…",
+                    }))
+                return (
+                    "[DIRECT_TERMINAL]\n"
+                    f"![Immagine generata]({img_url})\n\n"
+                    "E2E_IMAGE_OK: immagine generata, visualizzata e salvata nel workspace. "
+                    f"[Apri o scarica l’immagine]({img_url}).\n\n"
+                    f"File VFS: `{_artifact_path}`\n"
+                    f"Prompt usato: {_img_prompt[:200]}\n"
+                    "Dimensioni: 512x512 px"
+                )
+            except asyncio.TimeoutError:
+                return "[generate_image: timeout — provider non raggiungibile]"
+            except Exception as exc:
+                return f"[generate_image: errore — {str(exc)[:300]}]"
+        async def _t_run_python() -> str | None:
+            _RUN_CODE_RE = re.compile(
+                r"\b(?:run\s+(?:python\s+)?code|esegui\s+(?:\w+\s+){0,2}codice|"
+                r"execute\s+(?:python\s+)?code|lancia\s+(?:il\s+)?codice|"
+                r"esegui\s+(?:questo\s+|il\s+)?(?:script|programma))\b",
+                re.IGNORECASE,
+            )
+            if not _RUN_CODE_RE.search(goal):
+                return None
+            _code_m = re.search(r"[:：]\s*(.+)$", goal, re.DOTALL)
+            _code = _code_m.group(1).strip() if _code_m else goal
+            _code = re.sub(r"^```(?:python)?\s*|\s*```$", "", _code.strip(), flags=re.DOTALL).strip()
+            if not _code or len(_code) <= 3 or not _gov_check("run_python", _code[:80]):
+                return None
+            try:
+                if on_step:
+                    await _maybe_await(on_step({"action": "tool_start", "status": "running",
+                        "title": "Esecuzione codice Python", "explanation": "Eseguo il codice in sandbox…"}))
+                _sc = _spec_hit("run_python", {"code": _code[:400]})
+                if _sc is not None:
+                    return _sc
+                _t0 = asyncio.get_event_loop().time()
+                r = await asyncio.wait_for(TOOL_REGISTRY["run_python"]["_fn"](code=_code), timeout=18)
+                try:
+                    from api.state import record_timing as _rtc; _rtc("tool_call", (asyncio.get_event_loop().time() - _t0) * 1000)
+                except Exception as _e: _logger.debug('[timing/record_timing] %s', _e)
+                if r.get("returncode", -1) == 0 and r.get("stdout"):
+                    _out = (
+                        "[CODICE PYTHON ESEGUITO]\n"
+                        f"```python\n{_code[:500]}\n```\n"
+                        f"Output:\n```\n{r['stdout'][:1500]}\n```"
+                    )
+                    return _out
+                return f"[run_python: errore — {r.get('stderr', 'ignoto')[:300]}]"
+            except asyncio.TimeoutError:
+                return "[run_python: timeout 18s]"
+            except Exception as exc:
+                return f"[run_python: errore — {str(exc)[:300]}]"
+        async def _t_web_research() -> str | None:
+            _RESEARCH_RE = re.compile(r"\b(ricerca\s+approfondita|deep\s+research|investigazione|analisi\s+dettagliata)\b", re.IGNORECASE)
+            if not _RESEARCH_RE.search(goal):
+                return None
+            query = self._extract_search_query(goal)
+            if not _gov_check("web_research", query):
+                return None
+            try:
+                if on_step:
+                    await _maybe_await(on_step({"action": "tool_start", "status": "running",
+                        "title": "Ricerca approfondita", "explanation": f"Analisi dettagliata su: {query[:60]}…"}))
+                _t0 = asyncio.get_event_loop().time()
+                r = await asyncio.wait_for(TOOL_REGISTRY["web_research"]["_fn"](query=query), timeout=45)
+                try:
+                    from api.state import record_timing as _rtc; _rtc("tool_call", (asyncio.get_event_loop().time() - _t0) * 1000)
+                except Exception as _e: _logger.debug('[timing/record_timing] %s', _e)
+                if r.get("report"):
+                    return f"[RICERCA APPROFONDITA REALE: {query}]\n\n{r['report'][:4000]}"
+                return f"[web_research: errore — {r.get('error', 'nessun report')[:300]}]"
+            except asyncio.TimeoutError:
+                return "[web_research: timeout 45s]"
+            except Exception as exc:
+                return f"[web_research: errore — {str(exc)[:300]}]"
+        async def _t_directory_tree() -> str | None:
+            _TREE_RE = re.compile(r"\b(albero|struttura|directory\s+tree|files?|cartell[ae])\b", re.IGNORECASE)
+            if not _TREE_RE.search(goal):
+                return None
+            _path = self._extract_dir_path(goal)
+            if not _gov_check("directory_tree", _path):
+                return None
+            try:
+                if on_step:
+                    await _maybe_await(on_step({"action": "tool_start", "status": "running",
+                        "title": "Struttura progetto", "explanation": f"Analisi directory: {_path}"}))
+                r = await asyncio.wait_for(
+                    TOOL_REGISTRY["directory_tree"]["_fn"](path=_path, max_depth=3), timeout=8
+                )
+                if r.get("ok") and r.get("tree"):
+                    return f"[STRUTTURA PROGETTO REALE: '{_path}']\n{r['tree'][:2000]}"
+                return f"[directory_tree: {r.get('error', 'nessun risultato')[:200]}]"
+            except Exception as exc:
+                return f"[directory_tree: errore — {str(exc)[:200]}]"
+        async def _t_file_search() -> str | None:
+            _SEARCH_RE = re.compile(r"\b(cerca\s+file|find\s+file|grep)\b", re.IGNORECASE)
+            if not _SEARCH_RE.search(goal):
+                return None
+            _pattern = self._extract_file_pattern(goal)
+            if not _pattern or not _gov_check("file_search", _pattern):
+                return None
+            _search_path = self._extract_dir_path(goal)
+            try:
+                if on_step:
+                    await _maybe_await(on_step({"action": "tool_start", "status": "running",
+                        "title": "Ricerca file", "explanation": f"Cerco '{_pattern}' nel codice…"}))
+                r = await asyncio.wait_for(
+                    TOOL_REGISTRY["file_search"]["_fn"](pattern=_pattern, path=_search_path), timeout=10
+                )
+                if r.get("ok"):
+                    _matches = r.get("matches", [])
+                    _out = [f"[FILE TROVATI: pattern='{_pattern}', {r.get('count', len(_matches))} occorrenze]"]
+                    for match in _matches[:20]:
+                        _out.append(f"{match.get('file', '?')}:{match.get('line', '?')}: {match.get('text', '')[:120]}")
+                    return "\n".join(_out)
+                return f"[file_search: {r.get('error', 'nessun risultato')[:200]}]"
+            except Exception as exc:
+                return f"[file_search: errore — {str(exc)[:200]}]"
+        async def _t_get_news() -> str | None:
+            _NEWS_RE = re.compile(r"\b(news|notizie|ultim[ae]\s+ora|breaking)\b", re.IGNORECASE)
+            if not _NEWS_RE.search(goal):
+                return None
+            query = self._extract_search_query(goal)
+            try:
+                if on_step:
+                    await _maybe_await(on_step({"action": "tool_start", "status": "running",
+                        "title": "Notizie", "explanation": f"Cerco notizie su: {query[:60]}…"}))
+                r = await asyncio.wait_for(TOOL_REGISTRY["get_news"]["_fn"](query=query), timeout=15)
+                if r.get("news"):
+                    _out = [f"[NOTIZIE REALI: {query}]"]
+                    for n in r["news"][:5]:
+                        _out.append(f"• {n['title']} ({n.get('source', '?')}): {n.get('description', '')[:150]}")
+                    return "\n".join(_out)
+                return "[get_news: nessuna notizia trovata]"
+            except Exception as exc:
+                return f"[get_news: errore — {str(exc)[:200]}]"
+        async def _t_git_status() -> str | None:
+            _GIT_RE = re.compile(r"\b(git|status|commit|branch|repo)\b", re.IGNORECASE)
+            if not _GIT_RE.search(goal):
+                return None
+            _cwd = self._extract_git_cwd(goal)
+            if not _gov_check("git_status", _cwd):
+                return None
+            try:
+                if on_step:
+                    await _maybe_await(on_step({"action": "tool_start", "status": "running",
+                        "title": "Stato Git", "explanation": f"Controllo la repo in {_cwd}…"}))
+                r = await asyncio.wait_for(
+                    TOOL_REGISTRY["git_status"]["_fn"](cwd=_cwd), timeout=8
+                )
+                if r.get("ok"):
+                    _out = [f"[STATO GIT REALE (branch: {r.get('branch', '?')})]"]
+                    if r.get("status"):
+                        _out.append(f"File modificati:\n{r['status'][:600]}")
+                    if r.get("log"):
+                        _out.append(f"Ultimi commit:\n{r['log'][:400]}")
+                    return "\n".join(_out)
+                return f"[git_status: {r.get('error', 'nessun risultato')[:200]}]"
+            except Exception as exc:
+                return f"[git_status: errore — {str(exc)[:200]}]"
+        async def _t_analyze_python() -> str | None:
+            # P30-B1: Analisi statica Python integrata nel tool layer
+            if not self._ANALYZE_PY_RE.search(goal):
+                return None
+            _code = ""
+            _m = self._PY_BLOCK_IN_GOAL_RE.search(goal)
+            if _m: _code = _m.group(1).strip()
+            if not _code: return None
+            try:
+                if on_step:
+                    await _maybe_await(on_step({"action": "tool_start", "status": "running",
+                        "title": "Analisi codice Python", "explanation": "Controllo sintassi e best practices…"}))
+                from scripts.gap_map import analyze_python_code as _apc
+                r = await asyncio.wait_for(_apc(_code), timeout=15)
+                _out = ["[ANALISI PYTHON REALE]"]
+                if r.get("errors"):
+                    _out.append("❌ Errori rilevati:")
+                    for _e in r["errors"]: _out.append(f"  - {_e}")
+                else:
+                    _out.append("✅ Nessun errore di sintassi rilevato.")
+                if r.get("suggestions"):
+                    _out.append("\n💡 Suggerimenti:")
+                    for _s in r["suggestions"]: _out.append(f"  - {_s}")
+                return "\n".join(_out)
+            except asyncio.TimeoutError:
+                return "[python_analyze: timeout]"
+            except Exception as _exc:
+                return f"[python_analyze: errore — {str(_exc)[:200]}]"
+        # Conversione e immagine sono artefatti terminali: eseguirli prima del
+        # fan-out evita risultati accessori e, soprattutto, una successiva chiamata LLM.
+        _terminal_conversion = await _t_convert_csv_attachment()
+        if _terminal_conversion is not None:
+            return (_terminal_conversion, 1,
+                    int(_terminal_conversion.startswith("[DIRECT_TERMINAL]")),
+                    int(": errore" in _terminal_conversion or ": timeout" in _terminal_conversion))
+        # Policy ristretta: dopo il riconoscimento HTTP del CSV locale non sono
+        # ammessi altri direct tool, né fallback impliciti a immagine/rete.
+        if local_csv_only:
+            return ("[convert_csv_to_json: conversione locale non riconosciuta]", 0, 0, 1)
+        _terminal_image = await _t_generate_image()
+        if _terminal_image is not None:
+            return (_terminal_image, 1,
+                    int(_terminal_image.startswith("[DIRECT_TERMINAL]")),
+                    int(": errore" in _terminal_image or ": timeout" in _terminal_image))
+
+        # Esecuzione parallela per i tool non terminali.
+        _sem = asyncio.Semaphore(3)
+        async def _sem_wrap(coro):
+            if coro is None: return None
+            async with _sem: return await coro
+        _parallel_results = await asyncio.gather(
+            _sem_wrap(_t_get_weather()),
+            _sem_wrap(_t_read_page()),
+            _sem_wrap(_t_calculate()),
+            _sem_wrap(_t_web_search()),
+            _sem_wrap(_t_run_python()),
+            _sem_wrap(_t_web_research()),
+            _sem_wrap(_t_directory_tree()),
+            _sem_wrap(_t_file_search()),
+            _sem_wrap(_t_get_news()),
+            _sem_wrap(_t_git_status()),
+            _sem_wrap(_t_analyze_python()),
+            return_exceptions=True,
+        )
+        for _pr in _parallel_results:
+            if isinstance(_pr, str):
+                results.append(_pr)
+        # S428 Sprint1-Fix1: Tool Success Contract
+        _REAL_DATA_PREFIXES = (
+            "[RICERCA WEB REALE", "[METEO REALE", "[PAGINA REALE", "[CALCOLO REALE",
+            "[IMMAGINE AI GENERATA", "[DIRECT_TERMINAL]", "[CODICE PYTHON ESEGUITO", "[RICERCA APPROFONDITA REALE",
+            "[STRUTTURA PROGETTO REALE", "[RICERCA FILE REALE", "[NOTIZIE REALI",
+            "[STATO GIT REALE", "[ANALISI PYTHON REALE"
+        )
+        for r_str in results:
+            n_called += 1
+            if any(r_str.startswith(p) for p in _REAL_DATA_PREFIXES):
+                n_success += 1
+            elif ": errore" in r_str or ": timeout" in r_str:
+                n_errors += 1
+        return ("\n\n".join(results), n_called, n_success, n_errors)
+    # ── Claim Validation (S428 Sprint1-Fix3) ─────────────────────────────────
+    # A failed live tool must never be represented as a successful live lookup.
+    _FALSE_CLAIM_RE = re.compile(
+        r"\b(ho\s+trovato(?:\s+che)?|ho\s+recuperato|ho\s+cercato\s+e\s+trovato|"
+        r"dai\s+risultati(?:\s+della\s+ricerca)?|stando\s+ai\s+risultati|"
+        r"i\s+risultati\s+(?:mostrano|indicano|confermano)|"
+        r"la\s+ricerca\s+ha\s+(?:trovato|restituito)|"
+        r"secondo\s+i\s+risultati|dalle\s+mie\s+ricerche|"
+        r"I\s+found|the\s+results?\s+show|based\s+on\s+(?:the\s+)?results?|"
+        r"according\s+to\s+(?:the\s+)?(?:search\s+)?results?)\b",
+        re.IGNORECASE,
+    )
+    _REALTIME_GOAL_RE = re.compile(
+        r"\b(notizie|news|ultime\s+notizie|cerca|ricerca\s+web|"
+        r"weather|meteo|previsioni|temperatura|"
+        r"bitcoin|ethereum|cambio\s+valuta|tasso|crypto|"
+        r"versione\s+(?:attuale|corrente|recente)|aggiornamenti\s+su|release)\b",
+        re.IGNORECASE,
+    )
+
+    @staticmethod
+    def _validate_claims(
+        response: str,
+        n_success: int,
+        n_errors: int,
+        goal: str,
+        false_claim_re: "re.Pattern[str]",
+        realtime_goal_re: "re.Pattern[str]",
+    ) -> str:
+        """Add transparency when failed live tools are presented as successful."""
+        if n_success > 0 or n_errors == 0:
+            return response
+        if not realtime_goal_re.search(goal):
+            return response
+        if not false_claim_re.search(response):
+            return response
+        disclaimer = (
+            "\n\n---\n"
+            "**Nota tecnica**: i servizi di ricerca in tempo reale non erano "
+            "raggiungibili durante questa risposta. Le informazioni sopra provengono "
+            "dal mio training e potrebbero non essere aggiornate. "
+            "Per dati live consulta una fonte ufficiale."
+        )
+        return response + disclaimer
+    _TOOL_NEEDED_RE = re.compile(
+        r"\b(meteo|temperatura|weather|forecast|cerca|search|trova|find|googla|google|"
+        r"immagine|foto|photo|image|disegna|draw|genera|create|calcola|calculate|math|"
+        r"news|notizie|prezzo|quotazione|stock|crypto|bitcoin|albero|struttura|directory|"
+        r"file|cartella|grep|python|esegui|run|execute|script|webhook|api|http|zapier|n8n)\b",
+        re.IGNORECASE,
+    )
+    def _needs_tools(self, goal: str) -> bool:
+        # S-BENCH-FIX: abbassata soglia a 50 per catturare task di benchmark complessi
+        if len(goal) > 50: return True
+        if bool(self._TOOL_NEEDED_RE.search(goal)): return True
+        # Aggiunto 'benchmark', 'test', 'codice' per forzare tool su task tecnici
+        tech_keywords = ['file', 'directory', 'folder', 'script', 'api', 'json', 'data', 'analisi', 'fix', 'bug', 'benchmark', 'test', 'codice']
+        if any(kw in goal.lower() for kw in tech_keywords): return True
+        # Se sembra un goal di codice, attiva i tool
+        if bool(self._CODE_GOAL_RE.search(goal)): return True
+        return False
+    _SIMPLE_CONV_RE = re.compile(
+        r"^(?:ciao|salve|hey\b|hi\b|hello\b|buongiorno|buonasera|buonanotte|"
+        r"grazie(?:\s+mille)?|prego|perfetto|ottimo|esatto|capito|ok\b|bene\b|"
+        r"come stai\??|come va\??|stai bene\??|chi sei\??|cosa sei\??|"
+        r"sei (?:un[ao']?\s+)?(?:ai|bot|intelligenza artificiale|assistente)\??|"
+        r"cosa (?:puoi fare|sai fare)\??|dimmi qualcosa di te|"
+        r"bravo|benissimo|magnifico|fantastico|geniale|ottima risposta|"
+        r"giusto|corretto|esattamente|d['\u2019]accordo|"
+        r"capisco|ho capito|inteso|compreso|ricevuto|"
+        r"s[iì] grazie|no grazie|va bene|va benissimo|"
+        r"thanks|thank you|ty|thx|great|nice|perfect|exactly|understood|"
+        r"got it|sure|right|agreed|makes sense|correct|good|"
+        r"good morning|good evening|good night"
+        r")\.?\s*[!?]?$",
+        re.IGNORECASE,
+    )
+    _SIMPLE_MATH_RE = re.compile(
+        r'^(?:(?:calcola|quanto\s+(?:fa|fanno|vale|valgono)|quant[oei]\s+(?:fa|fanno)|'
+        r'dimmi\s+(?:solo\s+)?(?:il\s+)?(?:risultato|valore)\s+di|'
+        r'compute|calculate|what(?:\'s|\s+is)\s+(?:the\s+(?:result\s+of\s+)?)?)\s*)?'
+        r'[\d\s\+\-\*\/\^\(\)\.]+\s*[=?]?$',
+        re.IGNORECASE,
+    )
+    _ANALYZE_PY_RE = re.compile(
+        r"(?:analizza\s+(?:questo\s+)?(?:codice|script|programma)(?:\s+python)?"
+        r"|analisi\s+(?:del\s+)?(?:codice|script)(?:\s+python)?"
+        r"|check\s+(?:my\s+)?(?:python\s+)?(?:code|syntax|script)"
+        r"|review\s+(?:my\s+)?(?:python\s+)?(?:code|script)"
+        r"|syntax\s+check(?:\s+python)?"
+        r"|verifica\s+(?:la\s+)?(?:sintassi|il\s+codice)(?:\s+python)?"
+        r"|controlla\s+(?:il\s+)?(?:codice|sintassi)(?:\s+python)?"
+        r"|esamina\s+(?:il\s+)?(?:codice|script)(?:\s+python)?)",
+        re.IGNORECASE,
+    )
+    _PY_BLOCK_IN_GOAL_RE = re.compile(
+        r"```(?:python|py)\s*\n([\s\S]+?)```",
+        re.IGNORECASE,
+    )
+    _CODE_GOAL_RE = re.compile(r"\b(codice|script|programma|funzione|classe|modulo|libreria|package|repository|repo|git|github|branch|commit|pull\s+request|pr|merge|conflitto|conflict|test|unit\s+test|benchmark|profiling|debug|fix|bug|issue|refactor|ottimizzazione|optimization|typescript|javascript|python|rust|go|java|c\+\+|html|css|react|vue|angular|svelte|nextjs|vite|webpack|babel|eslint|prettier|npm|pnpm|yarn|docker|kubernetes|k8s|aws|gcp|azure|vercel|netlify|railway|supabase|firebase|database|sql|nosql|mongodb|postgresql|mysql|redis|api|rest|graphql|grpc|websocket|oauth|jwt|auth|sicurezza|security|crittografia|encryption|ai|llm|agente|agent|transformer|pytorch|tensorflow|scikit-learn|pandas|numpy|matplotlib|seaborn|plotly|fastapi|flask|django|express|koa|nest|spring|laravel|rails|symfony|phoenix|elixir|erlang|clojure|haskell|scala|kotlin|swift|objective-c|dart|flutter|react-native|expo|electron|tauri|capacitor|cordova|ionic|wasm|webassembly)\b", re.IGNORECASE)
+    _CODE_RE = re.compile(r"```[\s\S]*?```")
+    def _is_simple_query(self, goal: str) -> bool:
+        g = goal.strip()
+        if self._CODE_GOAL_RE.search(g) or self._CODE_RE.search(g):
+            return False
+        if len(g) <= 100 and self._SIMPLE_MATH_RE.match(g):
+            return True
+        if len(g) > 70 or self._needs_tools(g):
+            return False
+        return bool(self._SIMPLE_CONV_RE.match(g))

agents/unified_loop_types.py

@@ -0,0 +1,217 @@
+"""unified_loop_types.py — Tipi condivisi e helper leggeri per UnifiedAgentLoop.
+
+Estratto da unified_loop.py (P20-TD1 Fase 1).
+
+Contiene:
+  - StepCallback: type alias condiviso (era duplicato in unified_loop_tools.py)
+  - _detect_user_lang(): rilevamento lingua (P27-B2), zero LLM, <1ms
+  - _LANG_INSTRUCTIONS: dizionario prompt per lingua
+  - _TASK_VERBS_RE: regex verbi azione (P28-B2)
+  - _is_goal_ambiguous(): gate ambiguità strutturale (P28-B2, wired P29-B1)
+  - UnifiedLoopState: dataclass stato del loop
+  - _maybe_await(): helper coroutine-safe
+
+Invariante: nessuna dipendenza da altri moduli agents/ — solo stdlib.
+Importato da: unified_loop.py, unified_loop_tools.py, unified_loop_prompts.py
+"""
+from __future__ import annotations
+
+import asyncio
+import re
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Awaitable, Callable
+
+StepCallback = Callable[[dict[str, Any]], Awaitable[None] | None]
+
+class AgentState(str, Enum):
+    """Lifecycle states for one UnifiedAgentLoop execution."""
+
+    IDLE = "IDLE"
+    CLASSIFYING = "CLASSIFYING"
+    TOOL_EXECUTING = "TOOL_EXECUTING"
+    THINKING = "THINKING"
+    FAILED = "FAILED"
+    COMPLETED = "COMPLETED"
+
+
+_AGENT_STATE_TRANSITIONS: dict[AgentState, frozenset[AgentState]] = {
+    AgentState.IDLE: frozenset({AgentState.CLASSIFYING, AgentState.FAILED}),
+    AgentState.CLASSIFYING: frozenset({
+        AgentState.TOOL_EXECUTING, AgentState.THINKING, AgentState.COMPLETED, AgentState.FAILED,
+    }),
+    AgentState.TOOL_EXECUTING: frozenset({
+        AgentState.THINKING, AgentState.COMPLETED, AgentState.FAILED,
+    }),
+    AgentState.THINKING: frozenset({AgentState.COMPLETED, AgentState.FAILED}),
+    AgentState.FAILED: frozenset({AgentState.IDLE}),
+    # Exceptional finalization errors must be able to surface as FAILED.
+    AgentState.COMPLETED: frozenset({AgentState.IDLE, AgentState.FAILED}),
+}
+
+
+class AgentLoopStateMachine:
+    """Deterministic lifecycle machine owned by one loop invocation."""
+
+    def __init__(self) -> None:
+        self.current: AgentState = AgentState.IDLE
+        self.history: list[AgentState] = [AgentState.IDLE]
+
+    def transition(self, next_state: AgentState) -> None:
+        if next_state == self.current:
+            return
+        if next_state not in _AGENT_STATE_TRANSITIONS[self.current]:
+            raise ValueError(
+                f"Invalid AgentLoop transition: {self.current.value} -> {next_state.value}"
+            )
+        self.current = next_state
+        self.history.append(next_state)
+
+    def snapshot(self) -> dict[str, Any]:
+        return {
+            "agent_state": self.current.value,
+            "state_history": [state.value for state in self.history],
+        }
+
+
+
+def _detect_user_lang(goal: str) -> str:
+    """P27-B2: rilevamento lingua leggero — zero I/O, zero LLM, <1ms.
+
+    Conta token ad alta frequenza per lingua sui primi 200 char del goal.
+    Se nessuna lingua raggiunge soglia minima (≥2 token) → 'auto'.
+
+    Lingue supportate: it, en, es, fr, de.
+    Usata per iniettare istruzione esplicita nel system prompt invece del
+    generico "Rispondi nella lingua dell'utente" che il modello può ignorare.
+    """
+    import re as _re
+    g = goal.lower()[:200]
+    _EN = len(_re.findall(
+        r'\b(the|is|are|was|were|can|please|make|create|how|what|write|get|set|add|'
+        r'fix|find|show|give|build|help|need|want|check|update|remove|delete|use|'
+        r'with|from|that|this|have|will|your|you|i|me|my|do|does|did)\b', g))
+    _IT = len(_re.findall(
+        r'\b(il|lo|la|le|gli|dei|del|della|delle|degli|nella|nel|crea|scrivi|fai|'
+        r'dammi|mostra|aggiungi|rimuovi|correggi|sistema|puoi|devo|voglio|come|'
+        r'cosa|quale|quando|perché|senza|con|una|uno|ho|hai|ha|sono|sei|è)\b', g))
+    _ES = len(_re.findall(
+        r'\b(el|la|los|las|del|como|qué|cómo|crear|hacer|dame|muestra|agrega|'
+        r'corrige|necesito|quiero|puedes|tengo|tienes|tiene|es|son|una|uno)\b', g))
+    _FR = len(_re.findall(
+        r'\b(le|la|les|des|du|une|comment|créer|faire|donne|montre|ajoute|'
+        r'corrige|besoin|veux|peux|je|tu|il|elle|nous|vous|est|sont|un)\b', g))
+    _DE = len(_re.findall(
+        r'\b(der|die|das|den|dem|wie|was|erstelle|schreibe|mache|zeige|füge|'
+        r'korrigiere|brauche|kann|bitte|ich|du|er|sie|wir|ihr|ist|sind|ein)\b', g))
+    scores = {'en': _EN, 'it': _IT, 'es': _ES, 'fr': _FR, 'de': _DE}
+    best = max(scores, key=scores.get)
+    return best if scores[best] >= 2 else 'auto'
+
+
+_LANG_INSTRUCTIONS: dict[str, str] = {
+    'en': 'Respond in English.',
+    'it': 'Rispondi in italiano.',
+    'es': 'Responde en español.',
+    'fr': 'Réponds en français.',
+    'de': 'Antworte auf Deutsch.',
+}
+
+_TASK_VERBS_RE = re.compile(
+    r'\b(fix|create|crea|analyze|analizza|write|scrivi|find|trova|show|mostra|'
+    r'check|controlla|help|aiuta|build|costruisci|make|fai|get|ottieni|set|imposta|'
+    r'add|aggiungi|remove|rimuovi|update|aggiorna|run|esegui|execute|test|'
+    r'generate|genera|explain|spiega|summarize|riassumi|translate|traduci|'
+    r'calculate|calcola|compare|confronta|search|cerca|fetch|scarica|deploy|'
+    r'install|installa|debug|refactor|optimize|ottimizza|review|list|elenco|'
+    r'arregla|haz|muestra|busca|dame|explica)\b',
+    re.IGNORECASE,
+)
+
+# MIN-LENGTH-GATE (Item 1/5): verbi analitici che richiedono risposta elaborata.
+# Sottoinsieme di _TASK_VERBS_RE — solo verbi non-coding orientati alla prosa.
+# Usato da: unified_loop.py (min-length gate + _fast_pass non-coding branch).
+_ANALYTICAL_VERBS_RE = re.compile(
+    r'\b(analizza|analyze|analysis|analisi|spiega|explain|descrivi|describe|'
+    r'confronta|compare|riassumi|summarize|valuta|evaluate|discuss|discuti|'
+    r'illustra|illustrate|approfondisci|elaborate|'
+    r'pros.*cons|vantaggi.*svantaggi|differenz|difference|'
+    r'cosa.*meglio|quale.*migliore)\b',
+    re.IGNORECASE,
+)
+
+
+
+def _is_goal_ambiguous(goal: str) -> bool:
+    """P28-B2: heuristic gate — rileva goal strutturalmente ambigui (zero LLM, <0.1ms).
+
+    Un goal e ambiguo se ha meno di 5 parole reali E nessun verbo task riconoscibile.
+    Complementare a S-BENCH-REC-AMB: cattura goal brevi come help, aiutami, fix it.
+    """
+    words = re.findall(r'\w+', goal)
+    if len(words) >= 5:
+        return False
+    return not bool(_TASK_VERBS_RE.search(goal))
+
+
+# ── P29-R1: borderline ambiguity patterns ────────────────────────────────────
+# Cattura goal che PASSANO _is_goal_ambiguous() (hanno un verbo) ma sono
+# semanticamente vaghi perché l'oggetto è solo un pronome ("it","this","quello").
+
+_BORDERLINE_FIX_RE = re.compile(
+    r"^(?:fix|debug|repair|check|sistemo?|aggiust[aao]|arregla|fixe|corrige|r[eé]pare)\s+"
+    r"(?:it|this|that|them|those|these|quello|questa|questo|esto|ça|lo|la|das)\s*[.!?]?\s*$",
+    re.IGNORECASE,
+)
+_BORDERLINE_HELP_RE = re.compile(
+    r"^(?:help(?:\s+me)?|aiutami|ayúdame|aide[z-]?\s*moi|hilf\s+mir)"
+    r"(?:\s+(?:with|con|avec|mit)\s+(?:it|this|that|questo|eso|cela|das))?\s*[.!?]?\s*$",
+    re.IGNORECASE,
+)
+_BORDERLINE_MAKE_RE = re.compile(
+    r"^(?:make|render|rendi|haz|fais|mach(?:e)?)\s+"
+    r"(?:it|this|that|quello|esto|ça|das)\s+"
+    r"(?:better|work|faster|good|bello|buono|mejor|bien|besser|gut)\s*[.!?]?\s*$",
+    re.IGNORECASE,
+)
+
+
+def _is_borderline_ambiguous(goal: str) -> tuple[bool, str]:
+    """P29-R1: rileva goal 'borderline' — verbo presente ma oggetto pronominale vago.
+
+    Ritorna (True, pattern_key) se borderline, (False, '') altrimenti.
+    Zero LLM, <0.1ms. Chiamata DOPO _is_goal_ambiguous() (che gestisce goal senza verbo).
+    Solo su goal 3-60 char — oltre sono abbastanza specifici da non richiedere chiarimento.
+
+    Pattern catturati:
+    - "fix it/this/that/quello" → 'fix_pronoun'
+    - "help me / help me with this" → 'help_vague'
+    - "make it better/work" → 'make_vague'
+    """
+    g = goal.strip()
+    if len(g) < 3 or len(g) > 60:
+        return False, ''
+    if _BORDERLINE_FIX_RE.match(g):
+        return True, 'fix_pronoun'
+    if _BORDERLINE_HELP_RE.match(g):
+        return True, 'help_vague'
+    if _BORDERLINE_MAKE_RE.match(g):
+        return True, 'make_vague'
+    return False, ''
+
+
+@dataclass
+class UnifiedLoopState:
+    goal: str
+    context: str = ""
+    max_steps: int = 8
+    steps: list[dict[str, Any]] = field(default_factory=list)
+    errors: list[str] = field(default_factory=list)
+    has_files: bool = False  # B10: flag separato — evita di inquinare il context string
+    session_id: str = ""  # P17-F2: blackboard session key per sync Upstash
+    state_machine: AgentLoopStateMachine = field(default_factory=AgentLoopStateMachine)
+
+
+async def _maybe_await(val: Any) -> None:
+    if asyncio.iscoroutine(val) or asyncio.isfuture(val):
+        await val

agents/workflow_engine.py

@@ -0,0 +1,112 @@
+import logging
+import time
+import uuid
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, Field
+
+_logger = logging.getLogger("agents.workflow_engine")
+
+
+class WorkflowStep(BaseModel):
+    step_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    tool_name: str
+    args: Dict[str, Any]
+    status: str = "pending"  # pending, running, completed, failed
+    result: Any = None
+    error: Optional[str] = None
+    started_at: Optional[float] = None
+    finished_at: Optional[float] = None
+
+
+class Workflow(BaseModel):
+    workflow_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    name: str
+    steps: List[WorkflowStep]
+    status: str = "pending"
+    created_at: float = Field(default_factory=time.time)
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+
+
+class WorkflowExecutor:
+    """
+    ARCH-I4.3: Workflow Engine.
+
+    Coordina workflow in-memory step-by-step tramite Kernel ed Executor. La
+    persistenza o il resume inter-processo non sono garantiti da questo motore;
+    i caller possono consultare lo stato del workflow corrente tramite
+    ``get_workflow``.
+    """
+
+    def __init__(self, kernel: Any, executor: Any):
+        self.kernel = kernel
+        self.executor = executor
+        self.active_workflows: Dict[str, Workflow] = {}
+
+    def get_workflow(self, workflow_id: str) -> Optional[Workflow]:
+        """Ritorna il workflow noto, inclusi gli stati terminali in memoria."""
+        return self.active_workflows.get(workflow_id)
+
+    async def execute_workflow(self, workflow: Workflow) -> Workflow:
+        """Esegue un workflow step-by-step, mantenendo il fallback locale."""
+        self.active_workflows[workflow.workflow_id] = workflow
+        workflow.status = "running"
+        _logger.info("Avvio workflow: %s (%s)", workflow.name, workflow.workflow_id)
+
+        for step in workflow.steps:
+            step.status = "running"
+            step.started_at = time.time()
+            _logger.info(
+                "Esecuzione step: %s in workflow %s",
+                step.tool_name,
+                workflow.workflow_id,
+            )
+            try:
+                # ARCH-I4.3: il Kernel risolve la capability senza esporre
+                # l'infrastruttura al workflow.
+                resolution = await self.kernel.resolve_capability(step.tool_name)
+                if resolution.get("status") == "resolved":
+                    worker = resolution["worker"]
+                    worker_id = worker.id if hasattr(worker, "id") else worker["id"]
+                    _logger.info(
+                        "Step %s risolto su worker: %s",
+                        step.tool_name,
+                        worker_id,
+                    )
+                    result = await self.executor.run_tool(
+                        tool_name=step.tool_name,
+                        inputs=step.args,
+                        worker_hint=worker_id,
+                    )
+                else:
+                    # Nessun worker registrato: il comportamento storico resta
+                    # l'esecuzione locale tramite lo stesso Executor.
+                    _logger.warning(
+                        "Nessun worker per %s, provo esecuzione locale",
+                        step.tool_name,
+                    )
+                    result = await self.executor.run_tool(
+                        tool_name=step.tool_name,
+                        inputs=step.args,
+                    )
+
+                step.result = result
+                if isinstance(result, dict) and result.get("success") is False:
+                    step.status = "failed"
+                    step.error = str(result.get("error", "Tool execution failed"))
+                    workflow.status = "failed"
+                    break
+                step.status = "completed"
+            except Exception as exc:
+                step.status = "failed"
+                step.error = str(exc)
+                workflow.status = "failed"
+                _logger.error("Step %s fallito: %s", step.tool_name, exc)
+                break
+            finally:
+                step.finished_at = time.time()
+
+        if workflow.status == "running":
+            workflow.status = "completed"
+        _logger.info("Workflow %s terminato con stato: %s", workflow.name, workflow.status)
+        return workflow

api/admin_state.py

@@ -0,0 +1,75 @@
+"""Stato operativo amministrativo protetto da JWT Supabase admin."""
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+from typing import Any
+
+from fastapi import APIRouter, Depends, Query
+
+from .auth_guard import require_admin_user
+from .private_state import _MAX_TASK_PAGE, _as_epoch_ms, _call, _json_object
+
+router = APIRouter(
+    prefix="/api/admin/state",
+    tags=["admin"],
+    dependencies=[Depends(require_admin_user)],
+)
+
+
+@router.get("/sessions")
+async def admin_sessions(
+    max_age_ms: int = Query(default=300_000, ge=10_000, le=3_600_000),
+    limit: int = Query(default=100, ge=1, le=200),
+) -> dict[str, object]:
+    cutoff = (datetime.now(timezone.utc) - timedelta(milliseconds=max_age_ms)).isoformat()
+
+    def operation(client: Any):
+        return client.table("agent_tasks").select("task_id,context,updated_at").eq("status", "__session__").gte("updated_at", cutoff).order("updated_at", desc=True).limit(limit).execute()
+
+    result = await _call(operation)
+    sessions = []
+    for row in result.data or []:
+        context = _json_object(row.get("context"))
+        session_id = str(context.get("sessionId") or row.get("task_id") or "").strip()
+        if not session_id:
+            continue
+        claimed = context.get("claimedFiles")
+        sessions.append({
+            "session_id": session_id,
+            "session_name": str(context.get("sessionName") or session_id)[:160],
+            "sprint": str(context["sprint"])[:120] if context.get("sprint") else None,
+            "claimed_files": [str(item)[:300] for item in claimed[:100]] if isinstance(claimed, list) else [],
+            "last_heartbeat": _as_epoch_ms(context.get("lastHeartbeat")) or _as_epoch_ms(row.get("updated_at")),
+            "current_task": str(context["currentTask"])[:500] if context.get("currentTask") else None,
+        })
+    return {"sessions": sessions}
+
+
+@router.get("/tasks")
+async def admin_tasks(
+    limit: int = Query(default=20, ge=1, le=_MAX_TASK_PAGE),
+    offset: int = Query(default=0, ge=0, le=10_000),
+    status: str | None = Query(default=None, max_length=64),
+) -> dict[str, object]:
+    normalized_status = status.strip().upper() if status else ""
+
+    def operation(client: Any):
+        query = client.table("agent_tasks").select("task_id,goal,status,updated_at").neq("status", "__session__").neq("status", "__config__")
+        if normalized_status:
+            query = query.eq("status", normalized_status)
+        page = query.order("updated_at", desc=True).range(offset, offset + limit - 1).execute()
+        all_statuses = client.table("agent_tasks").select("status").neq("status", "__session__").neq("status", "__config__").limit(2_000).execute()
+        return page, all_statuses
+
+    page, all_statuses = await _call(operation)
+    counts: dict[str, int] = {}
+    for row in all_statuses.data or []:
+        key = str(row.get("status") or "UNKNOWN").upper()
+        counts[key] = counts.get(key, 0) + 1
+    tasks = [{
+        "task_id": str(row.get("task_id") or ""),
+        "goal": str(row.get("goal") or "")[:1_000],
+        "status": str(row.get("status") or "UNKNOWN"),
+        "updated_at": _as_epoch_ms(row.get("updated_at")),
+    } for row in page.data or []]
+    return {"tasks": tasks, "counts": counts, "offset": offset, "limit": limit}

api/agent_checkpoint.py

@@ -0,0 +1,131 @@
+"""
+backend/api/agent_checkpoint.py — Simplified checkpoint endpoints (ARCH-K2.3)
+
+Aggiunge alias /api/agent/checkpoint (senza task_id nella path) per uso diretto dal frontend:
+  GET    /api/agent/checkpoint             — lista tutti i checkpoint attivi in memoria
+  POST   /api/agent/checkpoint             — salva checkpoint (taskId opzionale nel body)
+  GET    /api/agent/checkpoint/{task_id}   — recupera checkpoint specifico
+  DELETE /api/agent/checkpoint/{task_id}   — elimina checkpoint
+
+I checkpoint per-task esistono già su /api/agent/tasks/{id}/checkpoint (agent.py).
+Questi alias sono più comodi quando il frontend non ha un task_id esplicito
+(es. salvataggio periodico dello stato dell'agente, resume dopo refresh).
+
+ROUTING CF PAGES: /api/agent/* → HANDS (Space B) via HANDS_PATTERNS[0].
+Nessuna modifica a [[catchall]].ts necessaria.
+
+NOTA: Import da api.agent e api.persistence sono LAZY (dentro le funzioni)
+per evitare import circolari — agent.py importa già molti altri moduli.
+"""
+import time
+import asyncio
+import logging
+from typing import Optional
+
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+
+from .auth_guard import require_role, AuthRole
+
+_logger = logging.getLogger("api.agent_checkpoint")
+
+router = APIRouter(dependencies=[Depends(require_role(AuthRole.MACHINE))])
+
+
+class CheckpointBody(BaseModel):
+    taskId:     Optional[str]  = None   # se omesso → usa "default"
+    step:       int            = 0
+    goal:       str            = ""
+    plan:       list           = []
+    logs:       list[str]      = []
+    artifacts:  list[str]      = []
+    retryCount: int            = 0
+    extra:      dict           = {}
+
+
+# ── GET /api/agent/checkpoint ─────────────────────────────────────────────────
+@router.get("/api/agent/checkpoint")
+async def list_checkpoints_alias():
+    """
+    Lista tutti i checkpoint attivi in memoria.
+    Alias leggero per /api/agent/checkpoints (agent.py).
+    """
+    # Import lazy — evita circolarità
+    from api.agent import _task_checkpoints, _prune_checkpoints  # type: ignore[import]
+
+    _prune_checkpoints()
+    now = int(time.time() * 1000)
+    return {
+        "count": len(_task_checkpoints),
+        "checkpoints": [
+            {
+                "taskId": k,
+                "step":   v.get("step", 0),
+                "goal":   v.get("goal", "")[:300],
+                "age_ms": now - v.get("savedAt", now),
+            }
+            for k, v in _task_checkpoints.items()
+        ],
+    }
+
+
+# ── POST /api/agent/checkpoint ────────────────────────────────────────────────
+@router.post("/api/agent/checkpoint")
+async def save_checkpoint_alias(body: CheckpointBody):
+    """
+    Salva un checkpoint. taskId opzionale: se omesso usa 'default'.
+    Replica la logica di /api/agent/tasks/{id}/checkpoint con Supabase persist.
+    """
+    from api.agent import _task_checkpoints, _prune_checkpoints  # type: ignore[import]
+    from api.persistence import sb_save_checkpoint               # type: ignore[import]
+
+    _prune_checkpoints()
+    task_id = body.taskId or "default"
+
+    cp: dict = {
+        "taskId":     task_id,
+        "step":       body.step,
+        "goal":       body.goal,
+        "plan":       body.plan,
+        "logs":       body.logs[-50:],   # mantieni solo gli ultimi 50 log
+        "artifacts":  body.artifacts,
+        "retryCount": body.retryCount,
+        "extra":      body.extra,
+        "savedAt":    int(time.time() * 1000),
+    }
+    _task_checkpoints[task_id] = cp
+    # Persist su Supabase — fire-and-forget (stesso pattern di agent.py)
+    asyncio.create_task(sb_save_checkpoint(task_id, body.step, cp))
+    return {"saved": True, "taskId": task_id, "step": body.step}
+
+
+# ── GET /api/agent/checkpoint/{task_id} ──────────────────────────────────────
+@router.get("/api/agent/checkpoint/{task_id}")
+async def get_checkpoint_alias(task_id: str):
+    """
+    Recupera il checkpoint per un task specifico.
+    Cerca prima in memoria (_task_checkpoints), poi su Supabase via sb_get_checkpoint.
+    """
+    from api.agent import _task_checkpoints, _prune_checkpoints  # type: ignore[import]
+    from api.persistence import sb_get_checkpoint                # type: ignore[import]
+
+    _prune_checkpoints()
+    cp = _task_checkpoints.get(task_id)
+    if not cp:
+        cp = await sb_get_checkpoint(task_id)
+    if not cp:
+        raise HTTPException(
+            status_code=404,
+            detail={"error": "checkpoint_not_found", "taskId": task_id},
+        )
+    return cp
+
+
+# ── DELETE /api/agent/checkpoint/{task_id} ───────────────────────────────────
+@router.delete("/api/agent/checkpoint/{task_id}")
+async def delete_checkpoint_alias(task_id: str):
+    """Rimuove il checkpoint da memoria in-process (non elimina da Supabase)."""
+    from api.agent import _task_checkpoints  # type: ignore[import]
+
+    _task_checkpoints.pop(task_id, None)
+    return {"deleted": task_id}

api/agent_memory.py

@@ -0,0 +1,132 @@
+"""
+backend/api/agent_memory.py — Agent memory CRUD (S354).
+GAP-MEM-FIX: aggiunta riconciliazione _mem_fallback → Supabase.
+GAP-SENSITIVE-FIX: implementato masking per le chiavi definite in SENSITIVE.
+"""
+import time, asyncio
+from typing import Any
+from fastapi import APIRouter, Depends
+from .auth_guard import require_role, AuthRole
+from pydantic import BaseModel
+from .state import _sb, _mem_fallback, SENSITIVE
+import logging
+
+_logger = logging.getLogger("api.agent_memory")
+
+# Router protetto a livello MACHINE — richiede X-Internal-Token
+router = APIRouter(dependencies=[Depends(require_role(AuthRole.MACHINE))])
+
+class MemoryEntry(BaseModel):
+    key: str
+    value: str
+    category: str = 'general'
+    createdAt: int = 0
+    updatedAt: int = 0
+
+def _mask_value(key: str, value: Any) -> Any:
+    """Maschera il valore se la chiave è presente nel set SENSITIVE."""
+    if key in SENSITIVE and value:
+        return "[REDACTED]"
+    return value
+
+async def _reconcile_fallback() -> int:
+    """GAP-MEM-FIX: sincronizza voci _mem_fallback → Supabase."""
+    if not _sb or not _mem_fallback:
+        return 0
+    synced = 0
+    for key, entry in list(_mem_fallback.items()):
+        try:
+            _sb.table('agent_memory').upsert({
+                'key':        entry['key'],
+                'value':      entry['value'],
+                'category':   entry.get('category', 'general'),
+                'created_at': entry.get('createdAt', 0),
+                'updated_at': entry.get('updatedAt', 0),
+            }, on_conflict='key').execute()
+            synced += 1
+        except Exception as _e:
+            _logger.debug("[memory] reconcile stopped at key=%s: %s", key, _e)
+            break
+    if synced:
+        _logger.info("[memory] GAP-MEM-FIX: reconciled %d fallback entries to Supabase", synced)
+    return synced
+
+@router.get('/api/memory/agent')
+async def list_agent_memory():
+    """Lista le voci di memoria, mascherando i segreti."""
+    if _sb:
+        try:
+            data = _sb.table('agent_memory').select('*').order('updated_at', desc=True).limit(500).execute()
+            entries = [
+                {
+                    'key': r['key'], 
+                    'value': _mask_value(r['key'], r['value']), 
+                    'category': r.get('category', 'general'),
+                    'createdAt': r.get('created_at', 0), 
+                    'updatedAt': r.get('updated_at', 0)
+                }
+                for r in (data.data or [])
+            ]
+            return {'entries': entries}
+        except Exception as e:
+            _logger.warning('[memory] Supabase list error: %s', e)
+    
+    entries = [
+        {
+            'key': v['key'], 
+            'value': _mask_value(v['key'], v['value']), 
+            'category': v.get('category', 'general'),
+            'createdAt': v.get('createdAt', 0), 
+            'updatedAt': v.get('updatedAt', 0)
+        }
+        for v in _mem_fallback.values()
+    ]
+    return {'entries': entries}
+
+@router.get('/api/memory/agent/{key}')
+async def get_agent_memory(key: str):
+    """Recupera una singola voce di memoria, mascherando se sensibile."""
+    val = None
+    if _sb:
+        try:
+            data = _sb.table('agent_memory').select('*').eq('key', key).limit(1).execute()
+            if data.data:
+                val = data.data[0]['value']
+        except Exception as e:
+            _logger.warning('[memory] Supabase get error: %s', e)
+    
+    if val is None:
+        entry = _mem_fallback.get(key)
+        val = entry['value'] if entry else None
+        
+    return {'value': _mask_value(key, val)}
+
+@router.post('/api/memory/agent')
+async def set_agent_memory(entry: MemoryEntry):
+    now = int(time.time() * 1000)
+    record = {
+        'key': entry.key, 'value': entry.value, 'category': entry.category,
+        'createdAt': entry.createdAt or now, 'updatedAt': entry.updatedAt or now,
+    }
+    _mem_fallback[entry.key] = record
+    if _sb:
+        try:
+            _sb.table('agent_memory').upsert({
+                'key': entry.key, 'value': entry.value, 'category': entry.category,
+                'created_at': entry.createdAt or now, 'updated_at': entry.updatedAt or now,
+            }, on_conflict='key').execute()
+            if len(_mem_fallback) > 1:
+                asyncio.create_task(_reconcile_fallback())
+        except Exception as _e:
+            _logger.warning('[memory] Supabase write error (fallback attivo): %s', _e)
+    return {'ok': True, 'key': entry.key}
+
+@router.delete('/api/memory/agent/{key}')
+async def delete_agent_memory(key: str):
+    if _sb:
+        try:
+            _sb.table('agent_memory').delete().eq('key', key).execute()
+        except Exception as _exc:
+            _logger.debug("[agent_memory] silenced %s", type(_exc).__name__)
+    _mem_fallback.pop(key, None)
+    return {'deleted': key}

api/agent_telemetry.py

@@ -0,0 +1,230 @@
+"""
+backend/api/agent_telemetry.py — Sync verdetti agentTelemetry.ts cross-session/device.
+
+Gap N4: agentTelemetry.ts usava solo localStorage → dati di calibrazione persi su
+altri device o dopo clear della cache. Questo endpoint li persiste su /data/ del
+volume HF Space (stesso usato dalla memoria episodica — mai si perde tra restart).
+
+Endpoints:
+  POST /api/agent-telemetry/sync  — riceve TelemetryStore dal client, merge server,
+                                    persiste, ritorna il merged aggiornato.
+  GET  /api/agent-telemetry/sync  — ritorna store server-side (load al boot del client).
+  DELETE /api/agent-telemetry/sync — reset admin/debug.
+
+Auth: nessuna (dati aggregati, zero PII — stesso pattern di /api/telemetry esistente).
+Rate limit: middleware globale 120 req/min/IP già applicato da main.py.
+Merge: additive — per ogni (system, verdict) prende max(count) e max(lastSeenMs).
+       I contatori non diminuiscono mai (protezione da client con dati parziali).
+"""
+import os, json, logging, time, asyncio
+from pathlib import Path
+from fastapi import APIRouter, Depends
+from .auth_guard import require_role, AuthRole
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+
+router = APIRouter( dependencies=[Depends(require_role(AuthRole.MACHINE))])  # GAP-1-fix: router-level auth
+_logger = logging.getLogger("agente_ai")
+
+# ─── Storage ──────────────────────────────────────────────────────────────────
+_DATA_DIR = Path(os.getenv("DATA_DIR", "/data"))
+_TEL_FILE = _DATA_DIR / "agent_telemetry.json"
+_MAX_STORE  = 500  # max entry totali prima del pruning
+# Serializza write concorrenti: due POST simultanei da device diversi leggerebbero
+# lo stesso store e si sovrascriverebbero. asyncio.Lock() è safe a livello di modulo
+# in Python 3.10+ (non richiede event loop attivo all'init del modulo).
+_store_lock = asyncio.Lock()
+_RUNTIME_PHASES = ('auth', 'queue', 'provider', 'tool', 'persistence')
+_RUNTIME_MAX_SAMPLES = 200
+_runtime_lock = asyncio.Lock()
+_runtime_store: dict[str, dict] = {
+    phase: {'samples_ms': [], 'ok': 0, 'errors': {}}
+    for phase in _RUNTIME_PHASES
+}
+
+
+async def record_runtime_phase(phase: str, duration_ms: float = 0.0,
+                               outcome: str = 'ok', error_class: str | None = None) -> None:
+    if phase not in _runtime_store:
+        return
+    async with _runtime_lock:
+        bucket = _runtime_store[phase]
+        samples = bucket['samples_ms']
+        samples.append(max(0.0, round(float(duration_ms), 2)))
+        if len(samples) > _RUNTIME_MAX_SAMPLES:
+            del samples[:-_RUNTIME_MAX_SAMPLES]
+        if outcome == 'ok':
+            bucket['ok'] += 1
+        else:
+            key = error_class or outcome or 'unknown'
+            bucket['errors'][key] = bucket['errors'].get(key, 0) + 1
+
+
+def _percentile(samples: list[float], percentile: float) -> float:
+    if not samples:
+        return 0.0
+    ordered = sorted(samples)
+    index = min(len(ordered) - 1, int(round((percentile / 100) * (len(ordered) - 1))))
+    return ordered[index]
+
+
+async def runtime_snapshot() -> dict[str, dict]:
+    async with _runtime_lock:
+        return {
+            phase: {
+                'count': len(bucket['samples_ms']),
+                'ok': bucket['ok'],
+                'errors': dict(bucket['errors']),
+                'p50_ms': _percentile(bucket['samples_ms'], 50),
+                'p95_ms': _percentile(bucket['samples_ms'], 95),
+            }
+            for phase, bucket in _runtime_store.items()
+        }
+
+# ─── Store helpers ────────────────────────────────────────────────────────────
+
+def _load_store() -> dict:
+    """Carica /data/agent_telemetry.json. Ritorna {} in caso di errore."""
+    try:
+        if _TEL_FILE.exists():
+            return json.loads(_TEL_FILE.read_text("utf-8"))
+    except Exception as exc:
+        _logger.warning("agent_telemetry: load error — %s", exc)
+    return {}
+
+
+def _save_store(store: dict) -> None:
+    """Persiste store su disco. Fail-open."""
+    try:
+        _DATA_DIR.mkdir(parents=True, exist_ok=True)
+        _TEL_FILE.write_text(json.dumps(store, separators=(",", ":")), "utf-8")
+    except Exception as exc:
+        _logger.warning("agent_telemetry: save error — %s", exc)
+
+
+def _merge(server: dict, client: dict) -> dict:
+    """
+    Merge additive cross-device.
+    Regola: per ogni (system, verdict) prende max(count) e max(lastSeenMs).
+    Un client con dati parziali non può mai ridurre i contatori server.
+    """
+    merged: dict = {k: dict(v) for k, v in server.items()}
+    for sys_name, verdicts in client.items():
+        if not isinstance(verdicts, dict):
+            continue
+        if sys_name not in merged:
+            merged[sys_name] = {}
+        srv_sys = merged[sys_name]
+        for verdict, stats in verdicts.items():
+            if not isinstance(stats, dict):
+                continue
+            c_count = int(stats.get("count", 0))
+            c_ts    = int(stats.get("lastSeenMs", 0))
+            prev    = srv_sys.get(verdict, {"count": 0, "lastSeenMs": 0})
+            srv_sys[verdict] = {
+                "count":      max(int(prev.get("count", 0)), c_count),
+                "lastSeenMs": max(int(prev.get("lastSeenMs", 0)), c_ts),
+            }
+    return merged
+
+
+def _prune(store: dict) -> dict:
+    """Se totale entry > _MAX_STORE, sacrifica i sistemi meno usati."""
+    total = sum(len(v) for v in store.values())
+    if total <= _MAX_STORE:
+        return store
+    sorted_sys = sorted(
+        store.items(),
+        key=lambda kv: sum(s.get("count", 0) for s in kv[1].values()),
+        reverse=True,
+    )
+    pruned: dict = {}
+    kept = 0
+    for sys_name, verdicts in sorted_sys:
+        n = len(verdicts)
+        if kept + n > _MAX_STORE:
+            break
+        pruned[sys_name] = verdicts
+        kept += n
+    return pruned
+
+
+# ─── Pydantic models ──────────────────────────────────────────────────────────
+
+class TelemetrySyncBody(BaseModel):
+    """
+    Payload POST dal client — struttura identica a TelemetryStore di agentTelemetry.ts:
+    { "crossCritic": { "pass": {"count": 5, "lastSeenMs": 1718000000000} }, ... }
+    """
+    data: dict
+
+
+# ─── Endpoints ────────────────────────────────────────────────────────────────
+
+@router.get("/api/agent-telemetry/runtime")
+async def get_runtime_telemetry() -> JSONResponse:
+    return JSONResponse({'ok': True, 'phases': await runtime_snapshot(), 'server_ts': int(time.time() * 1000)})
+
+
+@router.post("/api/agent-telemetry/sync")
+async def post_agent_telemetry(body: TelemetrySyncBody) -> JSONResponse:
+    """
+    POST /api/agent-telemetry/sync
+
+    Riceve il TelemetryStore locale del client (agentTelemetry.ts localStorage).
+    Lo merge con lo store server-side (additive — max count), lo persiste su
+    /data/agent_telemetry.json, e ritorna il merged.
+
+    Il client sostituisce il suo localStorage con il merged ricevuto:
+    i dati da altri device sono ora disponibili localmente.
+    """
+    try:
+        async with _store_lock:
+            server  = _load_store()
+            merged  = _prune(_merge(server, body.data))
+            _save_store(merged)
+        return JSONResponse({
+            "ok":        True,
+            "merged":    merged,
+            "server_ts": int(time.time() * 1000),
+        })
+    except Exception as exc:
+        _logger.error("agent_telemetry POST error: %s", exc)
+        return JSONResponse({"ok": False, "error": str(exc)[:120]}, status_code=500)
+
+
+@router.get("/api/agent-telemetry/sync")
+async def get_agent_telemetry() -> JSONResponse:
+    """
+    GET /api/agent-telemetry/sync
+
+    Ritorna lo store server-side. Il client lo carica all'avvio e lo mergia
+    con il localStorage locale (additive — max count) prima di iniziare
+    a registrare nuovi eventi.
+    """
+    try:
+        store = _load_store()
+        return JSONResponse({
+            "ok":        True,
+            "data":      store,
+            "server_ts": int(time.time() * 1000),
+        })
+    except Exception as exc:
+        _logger.error("agent_telemetry GET error: %s", exc)
+        return JSONResponse({"ok": False, "error": str(exc)[:120]}, status_code=500)
+
+
+@router.delete("/api/agent-telemetry/sync")
+async def delete_agent_telemetry() -> JSONResponse:
+    """
+    DELETE /api/agent-telemetry/sync — solo per admin/debug.
+    Cancella lo store server-side. Non tocca il localStorage dei client.
+    """
+    try:
+        async with _store_lock:
+            if _TEL_FILE.exists():
+                _TEL_FILE.unlink()
+        return JSONResponse({"ok": True, "deleted": True})
+    except Exception as exc:
+        _logger.error("agent_telemetry DELETE error: %s", exc)
+        return JSONResponse({"ok": False, "error": str(exc)[:120]}, status_code=500)

api/auth_guard.py

@@ -0,0 +1,401 @@
+"""backend/api/auth_guard.py — GAP-A6: Authorization model granulare.
+
+Definisce ruoli gerarchici + dependency FastAPI per proteggere gli endpoint.
+
+Ruoli (IntEnum, gerarchici):
+  USER     — nessuna auth (endpoint pubblici, chiamate frontend)
+  MACHINE  — X-Internal-Token header = INTERNAL_TOKEN env var (backend↔backend)
+  OPERATOR — X-Operator-Token header = OPERATOR_TOKEN env var (monitoring, trigger)
+  ADMIN    — X-Admin-Token header = ADMIN_TOKEN env var (operazioni distruttive)
+
+Utilizzo:
+  from api.auth_guard import require_role, AuthRole
+
+  @router.delete("/tasks/{id}")
+  async def delete_task(role: AuthRole = Depends(require_role(AuthRole.OPERATOR))):
+      ...
+
+  @router.post("/incidents/purge")
+  async def purge(role: AuthRole = Depends(require_role(AuthRole.ADMIN))):
+      ...
+
+Token env vars (Railway):
+  INTERNAL_TOKEN  — già usato in main.py (generato al boot se assente)
+  OPERATOR_TOKEN  — opzionale; se assente, endpoint OPERATOR bloccati
+  ADMIN_TOKEN     — opzionale; se assente, endpoint ADMIN bloccati
+
+NOTA: endpoint USER non richiedono alcun header.
+      Se OPERATOR_TOKEN non è impostato, gli endpoint OPERATOR ritornano 503
+      invece di 403 (distinzione "non configurato" vs "token errato").
+"""
+from __future__ import annotations
+
+import logging
+import os
+from enum import IntEnum
+from typing import Optional, Any
+
+from fastapi import Depends, Header, HTTPException, Request
+
+logger = logging.getLogger("agente_ai.auth_guard")
+
+
+# ── Rate limiter sliding window (RATE-LIMIT-FIX + GAP-AUTH-FIX) ──────────────
+# In-memory, per token hash (sicuro: non salva il token in chiaro).
+# Limiti per ruolo: USER=10/min, MACHINE=30/min, OPERATOR=60/min, ADMIN=illimitato.
+# Thread-safe in asyncio (GIL + nessun await interno).
+#
+# GAP-AUTH-FIX: per USER (role=0) la chiave usa client_ip invece di 'anonymous'.
+# Prima del fix: tutti gli utenti pubblici condividevano sha256("0:anonymous") →
+# un singolo client poteva svuotare il bucket per tutti gli utenti al mondo.
+# Fix: sha256("0:{client_ip}") — bucket separato per IP.
+# Fallback: 'unknown' se IP non rilevabile (raro su Railway/HF con proxy).
+
+import collections as _col
+# ── Redis-backed rate store (Upstash) — DoS-FIX: persiste cross-restart ────
+# Fallback automatico a in-memory se UPSTASH_REDIS_URL non configurato.
+_upstash_url  = os.getenv('UPSTASH_REDIS_URL', '')
+_upstash_token = os.getenv('UPSTASH_REDIS_TOKEN', '')
+_use_redis = bool(_upstash_url and _upstash_token)
+
+def _redis_rate_check(key: str, limit: int, window_s: int) -> tuple[bool, int]:
+    """Rate check via Upstash Redis REST API (zero dipendenze extra)."""
+    import urllib.request as _ur, json as _js, time as _rt
+    now_s = int(_rt.time())
+    window_key = f'{key}:{now_s // window_s}'
+    try:
+        req = _ur.Request(
+            f'{_upstash_url}/pipeline',
+            data=_js.dumps([
+                ['INCR', window_key],
+                ['EXPIRE', window_key, window_s * 2],
+            ]).encode(),
+            headers={'Authorization': f'Bearer {_upstash_token}', 'Content-Type': 'application/json'},
+            method='POST',
+        )
+        with _ur.urlopen(req, timeout=1) as r:
+            results = _js.loads(r.read())
+        count = results[0]['result'] if isinstance(results[0], dict) else results[0]
+        if count > limit:
+            return False, window_s
+        return True, 0
+    except Exception as _exc:  # SEC2-5: Redis irraggiungibile → fallback in-memory, non fail-open puro
+        logger.warning('[auth_guard] Redis rate check fallito (%s), fallback in-memory', _exc)
+        return _inmem_rate_check(key, limit, window_s)
+
+
+import time as _rl_time
+import hashlib as _rl_hash
+
+_RATE_LIMITS: dict[int, int] = {
+    0: 10,   # USER
+    1: 30,   # MACHINE
+    2: 60,   # OPERATOR
+    3: -1,   # ADMIN — illimitato
+}
+_RATE_WINDOW_S = 60  # finestra sliding 60s
+_rate_store: dict[str, _col.deque] = {}  # token_hash → deque di timestamps
+
+# Lo store è usato anche quando Redis non è disponibile. Un client una tantum
+# lasciava una deque vuota nel dict per l'intera vita del processo. Eseguiamo uno
+# sweep ammortizzato: il lavoro resta O(1) per la quasi totalità delle richieste
+# e il numero di chiavi inattive rimane limitato al traffico tra due sweep.
+_RATE_STORE_SWEEP_EVERY = 128
+_rate_store_checks = 0
+
+
+def _prune_expired_rate_keys(now: float, window_s: float) -> None:
+    """Rimuove bucket in-memory senza timestamp ancora nella finestra corrente."""
+    global _rate_store_checks
+    _rate_store_checks += 1
+    if _rate_store_checks % _RATE_STORE_SWEEP_EVERY:
+        return
+
+    window_start = now - window_s
+    stale_keys = [
+        stored_key
+        for stored_key, timestamps in _rate_store.items()
+        if not timestamps or timestamps[-1] < window_start
+    ]
+    for stored_key in stale_keys:
+        _rate_store.pop(stored_key, None)
+
+
+def _rate_key(role: int, token_header: str | None, client_ip: str | None = None) -> str:
+    """Chiave rate limiter: hash(role + discriminante) — non espone token né IP in chiaro.
+
+    USER usa sempre l'IP come discriminante. MACHINE usa l'IP quando il proxy
+    fidato lo inoltra: Cloudflare usa un unico token interno per tutti i browser,
+    quindi il solo token renderebbe globale il limite di 30 richieste/minuto.
+    In assenza di IP attestato, MACHINE conserva il fallback per-token. OPERATOR
+    e ADMIN mantengono il bucket per-token.
+    """
+    if role == 0:
+        # USER: bucket per IP, mai globale condiviso.
+        raw = f"0:{client_ip or 'unknown'}"
+    elif role == 1 and client_ip:
+        # MACHINE via proxy fidato: separa gli utenti dietro INTERNAL_TOKEN.
+        raw = f"1:{client_ip}"
+    else:
+        # Chiamate server-to-server e ruoli elevati: bucket per token.
+        raw = f"{role}:{token_header or 'anonymous'}"
+    return _rl_hash.sha256(raw.encode()).hexdigest()[:16]
+
+
+
+def _inmem_rate_check(key: str, limit: int, window_s: float) -> tuple[bool, int]:
+    """Rate check in-memory sliding window.
+
+    SEC2-5: usata sia quando Redis non è configurato, sia come fallback quando
+    Redis è temporaneamente irraggiungibile (prima era fail-open puro).
+    Thread-safe in asyncio (GIL, nessun await interno).
+    """
+    now = _rl_time.monotonic()
+    window_start = now - window_s
+    _prune_expired_rate_keys(now, window_s)
+
+    if key not in _rate_store:
+        _rate_store[key] = _col.deque()
+    dq = _rate_store[key]
+
+    while dq and dq[0] < window_start:
+        dq.popleft()
+
+    if len(dq) >= limit:
+        retry_after = int(window_s - (now - dq[0])) + 1
+        return False, max(retry_after, 1)
+
+    dq.append(now)
+    return True, 0
+
+def _check_rate_limit(
+    role: int,
+    token_header: str | None,
+    client_ip: str | None = None,
+) -> tuple[bool, int]:
+    """Controlla il rate limit per ruolo.
+
+    Ritorna (ok, retry_after_seconds).
+    ok=True → richiesta consentita.
+    ok=False → limite superato, retry_after = secondi alla prossima finestra.
+    ADMIN (role=3) è sempre ok.
+    """
+    limit = _RATE_LIMITS.get(role, 10)
+    if limit < 0:
+        return True, 0  # ADMIN — illimitato
+
+    key = _rate_key(role, token_header, client_ip)
+    # DoS-FIX: usa Redis se disponibile (persiste cross-restart HF Space)
+    # SEC2-5: se Redis fallisce, _redis_rate_check fa fallback su _inmem_rate_check
+    if _use_redis:
+        return _redis_rate_check(key, limit, int(_RATE_WINDOW_S))
+    return _inmem_rate_check(key, limit, int(_RATE_WINDOW_S))
+
+
+async def require_supabase_user(request: Request) -> dict[str, Any]:
+    """Valida il Bearer JWT tramite Supabase Auth e restituisce il profilo minimo.
+
+    La chiave Supabase resta server-side; il JWT arriva esclusivamente nell'header
+    Authorization del chiamante e non viene scritto nei log.
+    """
+    import httpx
+
+    authorization = request.headers.get("Authorization", "")
+    if not authorization.lower().startswith("bearer "):
+        raise HTTPException(status_code=401, detail="Bearer token richiesto")
+    jwt = authorization[7:].strip()
+    if not jwt:
+        raise HTTPException(status_code=401, detail="Bearer token non valido")
+
+    supabase_url = os.getenv("SUPABASE_URL", "").rstrip("/")
+    api_key = os.getenv("SUPABASE_SERVICE_ROLE_KEY") or os.getenv("SUPABASE_KEY", "")
+    if not supabase_url or not api_key:
+        raise HTTPException(status_code=503, detail="Autenticazione Supabase non configurata")
+
+    try:
+        async with httpx.AsyncClient(timeout=5) as client:
+            response = await client.get(
+                f"{supabase_url}/auth/v1/user",
+                headers={
+                    "apikey": api_key,
+                    "Authorization": f"Bearer {jwt}",
+                    "Accept": "application/json",
+                },
+            )
+    except httpx.HTTPError as exc:
+        logger.warning("supabase user validation unavailable: %s", type(exc).__name__)
+        raise HTTPException(status_code=503, detail="Autenticazione temporaneamente non disponibile") from exc
+
+    if response.status_code != 200:
+        raise HTTPException(status_code=401, detail="Sessione Supabase non valida o scaduta")
+    try:
+        user = response.json()
+    except ValueError as exc:
+        raise HTTPException(status_code=401, detail="Risposta autenticazione non valida") from exc
+    if not isinstance(user, dict) or not user.get("id"):
+        raise HTTPException(status_code=401, detail="Utente Supabase non valido")
+    return user
+
+
+async def require_admin_user(request: Request) -> dict[str, Any]:
+    """Richiede un JWT Supabase con app_metadata.role=admin.
+
+    app_metadata è server-controlled; user_metadata non viene mai considerato
+    per autorizzare l’area amministrativa.
+    """
+    user = await require_supabase_user(request)
+    app_metadata = user.get("app_metadata") or {}
+    roles = app_metadata.get("roles") or []
+    is_admin = app_metadata.get("role") == "admin" or "admin" in roles
+    if not is_admin:
+        raise HTTPException(status_code=403, detail="Membership amministrativa richiesta")
+    return user
+
+
+class AuthRole(IntEnum):
+    """Gerarchia ruoli: USER < MACHINE < OPERATOR < ADMIN."""
+    USER     = 0
+    MACHINE  = 1
+    OPERATOR = 2
+    ADMIN    = 3
+
+
+def _get_token(env_var: str) -> str:
+    return os.getenv(env_var, "").strip()
+
+
+async def _resolve_role(
+    x_internal_token: Optional[str] = Header(None, alias="X-Internal-Token"),
+    x_machine_token:   Optional[str] = Header(None, alias="X-Machine-Token"),
+    x_operator_token:  Optional[str] = Header(None, alias="X-Operator-Token"),
+    x_admin_token:     Optional[str] = Header(None, alias="X-Admin-Token"),
+) -> AuthRole:
+    """Risolve il ruolo del chiamante in base agli header presenti."""
+    import secrets as _sec_comp
+    # ADMIN (massima priorità)
+    admin_tok = _get_token("ADMIN_TOKEN")
+    if admin_tok and x_admin_token and _sec_comp.compare_digest(x_admin_token, admin_tok):
+        logger.debug("auth: ADMIN role granted")
+        return AuthRole.ADMIN
+
+    # OPERATOR
+    op_tok = _get_token("OPERATOR_TOKEN")
+    if op_tok and x_operator_token and _sec_comp.compare_digest(x_operator_token, op_tok):
+        logger.debug("auth: OPERATOR role granted")
+        return AuthRole.OPERATOR
+
+    # MACHINE: supporta entrambi gli header per compatibilità tra runner e backend.
+    # Il valore resta confrontato esclusivamente con il secret server-side.
+    int_tok = _get_token("INTERNAL_TOKEN") or _get_token("MACHINE_TOKEN")
+    machine_header = x_internal_token or x_machine_token
+    if int_tok and machine_header and _sec_comp.compare_digest(machine_header, int_tok):
+        logger.debug("auth: MACHINE role granted")
+        return AuthRole.MACHINE
+
+    # Nessun token valido → ruolo USER (minimo)
+    return AuthRole.USER
+
+
+async def require_private_state_machine(
+    request: 'Request',
+    x_internal_token: Optional[str] = Header(None, alias="X-Internal-Token"),
+) -> AuthRole:
+    """Autorizza esclusivamente il proxy Pages dello stato privato.
+
+    Usa un token dedicato per non ruotare o esporre ``INTERNAL_TOKEN``, da cui
+    dipendono le integrazioni legacy del master B. Il token non conferisce un
+    ruolo più ampio del canale MACHINE e resta soggetto allo stesso rate limit.
+    """
+    import secrets as _sec_comp
+    private_token = _get_token("PRIVATE_STATE_INTERNAL_TOKEN")
+    if not private_token:
+        raise HTTPException(status_code=503, detail="Canale stato privato non configurato")
+    if not x_internal_token or not _sec_comp.compare_digest(x_internal_token, private_token):
+        raise HTTPException(status_code=403, detail="Permessi insufficienti per lo stato privato")
+
+    client_ip = (
+        request.headers.get('X-Forwarded-For', '').split(',')[0].strip()
+        or request.headers.get('X-Real-IP', '')
+        or (request.client.host if request.client else None)
+    ) or None
+    allowed, retry_after = _check_rate_limit(int(AuthRole.MACHINE), x_internal_token, client_ip)
+    if not allowed:
+        raise HTTPException(
+            status_code=429,
+            detail="Rate limit stato privato superato",
+            headers={'Retry-After': str(retry_after)},
+        )
+    return AuthRole.MACHINE
+
+
+def require_role(min_role: AuthRole):
+    """
+    FastAPI Depends factory per autorizzazione granulare.
+
+    Esempio:
+      @router.post("/trigger")
+      async def trigger(role: AuthRole = Depends(require_role(AuthRole.OPERATOR))):
+          ...
+
+    Se il ruolo risolto < min_role → 403 Forbidden.
+    Se il token richiesto non è configurato (env var assente) → 503 Service Unavailable.
+    """
+    async def _check(
+        request: 'Request',
+        resolved: AuthRole = Depends(_resolve_role),
+    ) -> AuthRole:
+        # RATE-LIMIT-FIX + GAP-AUTH-FIX: estrai IP cliente per bucket USER per-IP
+        _token_hdr = (
+            request.headers.get('X-Admin-Token') or
+            request.headers.get('X-Operator-Token') or
+            request.headers.get('X-Internal-Token') or
+            request.headers.get('X-Machine-Token')
+        )
+        # GAP-AUTH-FIX: estrai IP reale (Railway/HF dietro proxy → X-Forwarded-For)
+        _client_ip: str | None = (
+            request.headers.get('X-Forwarded-For', '').split(',')[0].strip()
+            or request.headers.get('X-Real-IP', '')
+            or (request.client.host if request.client else None)
+        ) or None
+        _ok, _retry = _check_rate_limit(int(resolved), _token_hdr, _client_ip)
+        if not _ok:
+            raise HTTPException(
+                status_code=429,
+                detail={
+                    'error': 'Rate limit superato',
+                    'role': resolved.name,
+                    'limit': f'{_RATE_LIMITS.get(int(resolved), 10)}/min',
+                    'retry_after_seconds': _retry,
+                },
+                headers={'Retry-After': str(_retry)},
+            )
+        if resolved < min_role:
+            # Distingue "token non configurato" (503) da "token errato" (403)
+            if min_role == AuthRole.OPERATOR and not _get_token("OPERATOR_TOKEN"):
+                raise HTTPException(503, {
+                    "error": "Endpoint non disponibile",
+                    "reason": "OPERATOR_TOKEN non configurato su Railway",
+                    "required": "AuthRole.OPERATOR",
+                })
+            if min_role == AuthRole.ADMIN and not _get_token("ADMIN_TOKEN"):
+                raise HTTPException(503, {
+                    "error": "Endpoint non disponibile",
+                    "reason": "ADMIN_TOKEN non configurato su Railway",
+                    "required": "AuthRole.ADMIN",
+                })
+            raise HTTPException(403, {
+                "error": "Permessi insufficienti",
+                "required_role": min_role.name,
+                "your_role":     resolved.name,
+                "hint": f"Fornire header X-{min_role.name.capitalize()}-Token con il token corretto",
+            })
+        return resolved
+    return _check
+
+
+# ── Convenienza: dependency per endpoint pubblici (nessun controllo) ─────────
+
+async def any_role(resolved: AuthRole = Depends(_resolve_role)) -> AuthRole:
+    """Dependency che accetta qualsiasi ruolo (incluso USER senza token).
+    Usare per endpoint pubblici che vogliono loggare il ruolo del chiamante."""
+    return resolved

api/auth_managed.py

@@ -0,0 +1,545 @@
+"""backend/api/auth_managed.py — OAuth "One-Click" connectors (P38).
+
+Rotte:
+  GET  /api/auth/connect/{provider}   → redirect URL OAuth del provider
+  GET  /api/auth/callback/{provider}  → scambia code → token, salva su Supabase cifrato
+  GET  /api/auth/providers            → stato connessione tutti i provider per l'utente
+  DELETE /api/auth/disconnect/{provider} → revoca e cancella token da Supabase
+
+Provider supportati: github, google, instagram.
+I CLIENT_ID/SECRET vanno nei secret HF Spaces (mai nel codice).
+
+Cifratura token: Fernet(PBKDF2HMAC-SHA256, 260k iter, salt fisso) — richiede cryptography>=42.
+"""
+import os, time, secrets, json, logging, asyncio, hashlib
+from typing import Optional
+from fastapi import APIRouter, Depends, Request, HTTPException
+from .auth_guard import require_role, AuthRole
+from fastapi.responses import RedirectResponse, JSONResponse
+import httpx
+
+_logger = logging.getLogger('api.auth_managed')
+router  = APIRouter()
+
+_DIAGNOSTIC_SECRET_NAMES = (
+    'ADMIN_DIAGNOSTICS_TOKEN', 'INTERNAL_TOKEN', 'PUBLIC_API_TOKEN',
+    'PRIVATE_STATE_INTERNAL_TOKEN', 'SUPABASE_SERVICE_ROLE_KEY',
+    'SUPABASE_SERVICE_ROLE_KEY_B', 'GROQ_API_KEY', 'HF_TOKEN',
+    'GEMINI_API_KEY', 'CEREBRAS_API_KEY', 'SAMBANOVA_API_KEY',
+    'OPENROUTER_API_KEY', 'OPENROUTER_API_KEY_B', 'OPENROUTER_API_KEY_C',
+    'OPENROUTER_PROFILES_JSON', 'NVIDIA_API_KEY', 'NVIDIA_API_KEY_B',
+)
+
+
+def _secret_fingerprint(name: str) -> dict[str, object]:
+    value = os.getenv(name, '').strip()
+    return {
+        'configured': bool(value),
+        'length': len(value),
+        'sha256': hashlib.sha256(value.encode('utf-8')).hexdigest()[:16] if value else None,
+    }
+
+
+@router.get('/api/admin/secret-fingerprint')
+async def secret_fingerprint(role: AuthRole = Depends(require_role(AuthRole.MACHINE))):
+    return {'secrets': {name: _secret_fingerprint(name) for name in _DIAGNOSTIC_SECRET_NAMES}}
+
+# ── Fernet encryption setup ──────────────────────────────────────────────────
+# Salt statico pubblico: accettabile per chiave macchina (non password utente).
+# Il VAULT_KEY è il segreto; il salt previene rainbow-table cross-application.
+# ⚠️  ATTENZIONE MIGRAZIONE: cambiare questo salt o la derivazione invalida
+#     tutti i token OAuth cifrati esistenti → gli utenti dovranno riconnettere
+#     i provider. Questo è intenzionale quando si corregge una derivazione debole.
+_FERNET_SALT = b'agente-ai-vault-v1-pbkdf2'
+
+def _get_fernet():
+    """Lazy-init Fernet cipher da VAULT_KEY via PBKDF2HMAC-SHA256 (260k iter).
+
+    Fix P19-SEC2-4: SHA-256 raw (veloce, GPU-bruteforce in ore su chiavi brevi)
+    sostituito con PBKDF2HMAC 260_000 iter — conforme NIST SP 800-132 (2023).
+    ⚠️  Cambio di derivazione: i token cifrati con SHA-256 non sono più decifrabili.
+        _decrypt() ritorna '' su InvalidToken — gli utenti devono riconnettersi.
+    """
+    from cryptography.fernet import Fernet
+    from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+    from cryptography.hazmat.primitives import hashes as _hashes
+    import base64
+    vault_key = os.getenv('VAULT_KEY', '')
+    if not vault_key:
+        raise RuntimeError('VAULT_KEY non configurata — impossibile cifrare/decifrare i token OAuth')
+    kdf = PBKDF2HMAC(
+        algorithm=_hashes.SHA256(),
+        length=32,
+        salt=_FERNET_SALT,
+        iterations=260_000,  # NIST SP 800-132 (2023): ≥ 210_000 per PBKDF2-SHA256
+    )
+    fernet_key = base64.urlsafe_b64encode(kdf.derive(vault_key.encode('utf-8')))
+    return Fernet(fernet_key)
+
+def _encrypt(text: str) -> str:
+    if not text:
+        return text
+    f = _get_fernet()  # P19-SEC2-4: propaga eccezione — niente più plaintext fallback
+    return f.encrypt(text.encode()).decode()
+
+def _decrypt(token: str) -> str:
+    if not token:
+        return token
+    f = _get_fernet()
+    try:
+        return f.decrypt(token.encode()).decode()
+    except Exception:
+        _logger.error('[auth_managed] decrypt fallito — token corrotto o VAULT_KEY cambiata')
+        return ''  # corrotto o key cambiata
+
+# ── OAuth state store (CSRF) — P19-SEC2-5 ────────────────────────────────────
+# Era in-memory dict: rotto con >1 worker/replica (state creato su worker A,
+# consumato su worker B → 404/invalid_state) e perso a ogni restart.
+# Ora persistito su Supabase tabella `oauth_states` (vedi sec01_rls_agent_tasks.sql).
+_STATE_TTL = 600  # 10 minuti
+
+# Fallback in-memory SOLO per sviluppo locale senza Supabase configurato.
+_oauth_states_fallback: dict[str, dict] = {}
+
+async def _make_state(provider: str, user_id: str) -> str:
+    from api.state import _sb
+    state = secrets.token_urlsafe(32)
+    now = time.time()
+    if _sb:
+        try:
+            await asyncio.to_thread(
+                lambda: _sb.table('oauth_states').insert({
+                    'state':    state,
+                    'provider': provider,
+                    'user_id':  user_id,
+                    # created_at: lasciato al DEFAULT NOW() della tabella (TIMESTAMPTZ)
+                }).execute()
+            )
+            return state
+        except Exception as e:
+            _logger.warning('[auth_managed] oauth_states insert fallito, fallback memoria: %s', e)
+            # SEC2-7: in produzione (Railway/HF Spaces) il fallback in-memory è pericoloso
+            # su multi-replica: state creato su replica A, consumato su replica B → CSRF bypass.
+            # In dev locale (_sb assente o Supabase non configurato) il fallback rimane attivo.
+            if os.getenv('RAILWAY_ENVIRONMENT') or os.getenv('SPACE_ID'):
+                raise HTTPException(503, detail={
+                    'error':  'oauth_state_store_unavailable',
+                    'detail': 'Il database OAuth (Supabase) non è raggiungibile. Riprova tra qualche secondo.',
+                })
+    _purge_states_fallback()
+    _oauth_states_fallback[state] = {'provider': provider, 'user_id': user_id, 'created_at': now}
+    return state
+
+async def _consume_state(state: str) -> Optional[dict]:
+    from api.state import _sb
+    if _sb:
+        try:
+            res = await asyncio.to_thread(
+                lambda: _sb.table('oauth_states').select('*').eq('state', state).limit(1).execute()
+            )
+            if res.data:
+                row = res.data[0]
+                await asyncio.to_thread(
+                    lambda: _sb.table('oauth_states').delete().eq('state', state).execute()
+                )
+                # created_at è TIMESTAMPTZ (stringa ISO8601) — parse per calcolare l'età
+                try:
+                    from datetime import datetime, timezone
+                    created_raw = row.get('created_at', '')
+                    created_dt = datetime.fromisoformat(created_raw.replace('Z', '+00:00'))
+                    age_s = (datetime.now(timezone.utc) - created_dt).total_seconds()
+                except Exception:
+                    age_s = 0  # se il parsing fallisce, non blocchiamo il flow OAuth per questo
+                if age_s > _STATE_TTL:
+                    return None
+                return {'provider': row['provider'], 'user_id': row['user_id']}
+            return None
+        except Exception as e:
+            _logger.warning('[auth_managed] oauth_states select fallito, fallback memoria: %s', e)
+            # SEC2-7: in produzione, se Supabase è irraggiungibile rifiutiamo il state
+            # (sicuro: l'utente deve ripetere il flow OAuth). Meglio un 400 che un bypass CSRF.
+            if os.getenv('RAILWAY_ENVIRONMENT') or os.getenv('SPACE_ID'):
+                return None
+    _purge_states_fallback()
+    entry = _oauth_states_fallback.pop(state, None)
+    if not entry:
+        return None
+    if time.time() - entry['created_at'] > _STATE_TTL:
+        return None
+    return entry
+
+def _purge_states_fallback():
+    now = time.time()
+    expired = [k for k, v in _oauth_states_fallback.items() if now - v['created_at'] > _STATE_TTL]
+    for k in expired:
+        _oauth_states_fallback.pop(k, None)
+
+# ── Provider configs ──────────────────────────────────────────────────────────
+_BACKEND_URL = os.getenv('BACKEND_URL', '').rstrip('/')
+
+def _get_callback_url(provider: str) -> str:
+    return f"{_BACKEND_URL}/api/auth/callback/{provider}"
+
+def _get_frontend_url() -> str:
+    """URL frontend da redirigere dopo il callback OAuth."""
+    return os.getenv('FRONTEND_URL', 'https://agente-ai.pages.dev')
+
+_PROVIDER_CONFIGS = {
+    'github': {
+        'authorize_url': 'https://github.com/login/oauth/authorize',
+        'token_url':     'https://github.com/login/oauth/access_token',
+        'userinfo_url':  'https://api.github.com/user',
+        'scope':         'read:user,repo',
+        'client_id_env':     'GITHUB_OAUTH_CLIENT_ID',
+        'client_secret_env': 'GITHUB_OAUTH_CLIENT_SECRET',
+    },
+    'google': {
+        'authorize_url': 'https://accounts.google.com/o/oauth2/v2/auth',
+        'token_url':     'https://oauth2.googleapis.com/token',
+        'userinfo_url':  'https://www.googleapis.com/oauth2/v2/userinfo',
+        # P19-SEC2-6: rimosso scope 'calendar' (accesso full R/W al calendario) —
+        # non richiesto da nessuna feature attuale, violava il principio del minimo privilegio.
+        'scope':         'openid email profile',
+        'client_id_env':     'GOOGLE_OAUTH_CLIENT_ID',
+        'client_secret_env': 'GOOGLE_OAUTH_CLIENT_SECRET',
+    },
+    'instagram': {
+        'authorize_url': 'https://api.instagram.com/oauth/authorize',
+        'token_url':     'https://api.instagram.com/oauth/access_token',
+        'userinfo_url':  'https://graph.instagram.com/me?fields=id,username',
+        'scope':         'user_profile,user_media',
+        'client_id_env':     'INSTAGRAM_CLIENT_ID',
+        'client_secret_env': 'INSTAGRAM_CLIENT_SECRET',
+    },
+}
+
+# ── Supabase helpers ──────────────────────────────────────────────────────────
+
+async def _sb_upsert_token(user_id: str, provider: str, access_token: str,
+                             refresh_token: str, expires_at: int, scope: str, meta: dict) -> None:
+    from api.state import _sb
+    if not _sb:
+        return
+    now = int(time.time() * 1000)
+    payload = {
+        'user_id':       user_id,
+        'provider':      provider,
+        'access_token':  _encrypt(access_token),
+        'refresh_token': _encrypt(refresh_token) if refresh_token else '',
+        'expires_at':    expires_at,
+        'scope':         scope,
+        'raw_meta':      json.dumps(meta)[:4000],
+        'created_at':    now,
+        'updated_at':    now,
+    }
+    try:
+        await asyncio.to_thread(
+            lambda: _sb.table('managed_tokens')
+                .upsert(payload, on_conflict='user_id,provider')
+                .execute()
+        )
+    except Exception as e:
+        _logger.warning('[auth_managed] upsert token %s/%s: %s', user_id, provider, e)
+
+
+async def _sb_get_token(user_id: str, provider: str) -> Optional[dict]:
+    from api.state import _sb
+    if not _sb:
+        return None
+    try:
+        res = await asyncio.to_thread(
+            lambda: _sb.table('managed_tokens')
+                .select('provider,scope,expires_at,updated_at,raw_meta,access_token,refresh_token')
+                .eq('user_id', user_id)
+                .eq('provider', provider)
+                .limit(1)
+                .execute()
+        )
+        return res.data[0] if res.data else None
+    except Exception as e:
+        _logger.debug('[auth_managed] get_token %s/%s: %s', user_id, provider, e)
+        return None
+
+
+async def _sb_list_tokens(user_id: str) -> list[dict]:
+    from api.state import _sb
+    if not _sb:
+        return []
+    try:
+        res = await asyncio.to_thread(
+            lambda: _sb.table('managed_tokens')
+                .select('provider,scope,expires_at,updated_at,raw_meta')
+                .eq('user_id', user_id)
+                .execute()
+        )
+        return res.data or []
+    except Exception as e:
+        _logger.debug('[auth_managed] list_tokens %s: %s', user_id, e)
+        return []
+
+
+async def _sb_delete_token(user_id: str, provider: str) -> None:
+    from api.state import _sb
+    if not _sb:
+        return
+    try:
+        await asyncio.to_thread(
+            lambda: _sb.table('managed_tokens')
+                .delete()
+                .eq('user_id', user_id)
+                .eq('provider', provider)
+                .execute()
+        )
+    except Exception as e:
+        _logger.warning('[auth_managed] delete_token %s/%s: %s', user_id, provider, e)
+
+
+# Public helper: altri moduli chiamano questa per ottenere un token decifrato
+async def get_managed_token(user_id: str, provider: str) -> Optional[str]:
+    """Restituisce il token d'accesso decifrato per (user_id, provider). None se non connesso.
+
+    P19-SEC2-8: prima ritornava sempre il token salvato, anche se scaduto da
+    tempo (provider come Google li invalidano dopo ~1h) → chiamate a valle
+    fallivano silenziosamente con 401. Ora, se scaduto e c'è un refresh_token,
+    tenta il refresh presso il provider prima di restituire.
+    """
+    row = await _sb_get_token(user_id, provider)
+    if not row:
+        return None
+
+    exp = row.get('expires_at', 0)
+    now_ms = int(time.time() * 1000)
+    if exp and exp > now_ms + 60_000:  # ancora valido per >60s
+        return _decrypt(row['access_token'])
+
+    encrypted_refresh = row.get('refresh_token', '')
+    if not encrypted_refresh:
+        # Niente refresh_token: ritorna quello che c'è (potrebbe essere già scaduto)
+        return _decrypt(row['access_token'])
+
+    cfg = _PROVIDER_CONFIGS.get(provider)
+    if not cfg:
+        return _decrypt(row['access_token'])
+
+    refresh_token = _decrypt(encrypted_refresh)
+    if not refresh_token:
+        return _decrypt(row['access_token'])
+
+    client_id     = os.getenv(cfg['client_id_env'], '')
+    client_secret = os.getenv(cfg['client_secret_env'], '')
+    try:
+        async with httpx.AsyncClient(timeout=15) as http:
+            resp = await http.post(
+                cfg['token_url'],
+                data={
+                    'grant_type':    'refresh_token',
+                    'refresh_token': refresh_token,
+                    'client_id':     client_id,
+                    'client_secret': client_secret,
+                },
+                headers={'Accept': 'application/json'},
+            )
+        if resp.status_code != 200:
+            _logger.warning('[auth_managed] refresh token fallito %s/%s: %s', user_id, provider, resp.text[:200])
+            return _decrypt(row['access_token'])
+
+        tok_json = resp.json()
+        new_access  = tok_json.get('access_token', '')
+        new_refresh = tok_json.get('refresh_token', refresh_token)  # alcuni provider non lo riemettono
+        expires_in  = tok_json.get('expires_in', 0)
+        new_expires_at = int((time.time() + expires_in) * 1000) if expires_in else 0
+        if not new_access:
+            return _decrypt(row['access_token'])
+
+        await _sb_upsert_token(user_id, provider, new_access, new_refresh,
+                                new_expires_at, row.get('scope', cfg['scope']),
+                                json.loads(row.get('raw_meta') or '{}') if isinstance(row.get('raw_meta'), str) else {})
+        _logger.info('[auth_managed] token refreshed %s/%s (expires_at=%d)', user_id, provider, new_expires_at)
+        return new_access
+    except Exception as e:
+        _logger.error('[auth_managed] refresh exception %s/%s: %s', user_id, provider, e)
+        return _decrypt(row['access_token'])
+
+
+# ── Routes ────────────────────────────────────────────────────────────────────
+
+def _user_id(request: Request) -> str:
+    # P19-SEC2-7: NON fidarsi di X-User-ID lato client — permetteva a chiunque di
+    # impersonare/leggere i token OAuth di un altro utente semplicemente inviando
+    # un header diverso. L'app è single-tenant (un solo utente reale), quindi si
+    # usa sempre 'default'. Se in futuro serve multi-tenant, l'identità va
+    # derivata da una sessione autenticata server-side (JWT/cookie firmato),
+    # mai da un header controllato dal client.
+    return 'default'
+
+
+@router.get('/api/auth/connect/{provider}')
+async def connect_provider(provider: str, request: Request):
+    """Genera l'URL OAuth e redirige il browser dell'utente."""
+    cfg = _PROVIDER_CONFIGS.get(provider)
+    if not cfg:
+        raise HTTPException(400, detail={'error': 'unknown_provider', 'provider': provider})
+
+    client_id = os.getenv(cfg['client_id_env'], '')
+    if not client_id:
+        raise HTTPException(503, detail={
+            'error': 'provider_not_configured',
+            'provider': provider,
+            'hint': f"Set {cfg['client_id_env']} in HuggingFace Spaces secrets.",
+        })
+
+    user_id  = _user_id(request)
+    state    = await _make_state(provider, user_id)
+    callback = _get_callback_url(provider)
+
+    params = {
+        'client_id':    client_id,
+        'redirect_uri': callback,
+        'scope':        cfg['scope'],
+        'state':        state,
+        'response_type': 'code',
+    }
+    # Google richiede access_type=offline per il refresh_token
+    if provider == 'google':
+        params['access_type'] = 'offline'
+        params['prompt']      = 'consent'
+
+    from urllib.parse import urlencode
+    auth_url = cfg['authorize_url'] + '?' + urlencode(params)
+    _logger.info('[auth_managed] connect %s → redirect %s', provider, auth_url[:80])
+    return RedirectResponse(url=auth_url, status_code=302)
+
+
+@router.get('/api/auth/callback/{provider}')
+async def oauth_callback(provider: str, request: Request):
+    """Riceve il code dal provider, scambia con token, salva su Supabase."""
+    cfg = _PROVIDER_CONFIGS.get(provider)
+    if not cfg:
+        raise HTTPException(400, detail={'error': 'unknown_provider'})
+
+    code  = request.query_params.get('code', '')
+    state = request.query_params.get('state', '')
+    error = request.query_params.get('error', '')
+
+    frontend = _get_frontend_url()
+
+    if error:
+        _logger.warning('[auth_managed] callback %s error=%s', provider, error)
+        return RedirectResponse(url=f"{frontend}?oauth_error={error}&provider={provider}")
+
+    state_data = await _consume_state(state)
+    if not state_data:
+        _logger.warning('[auth_managed] invalid/expired state %s', state[:20])
+        return RedirectResponse(url=f"{frontend}?oauth_error=invalid_state&provider={provider}")
+
+    user_id = state_data['user_id']
+
+    client_id     = os.getenv(cfg['client_id_env'], '')
+    client_secret = os.getenv(cfg['client_secret_env'], '')
+    callback_url  = _get_callback_url(provider)
+
+    # Scambia code → token
+    try:
+        async with httpx.AsyncClient(timeout=15) as http:
+            token_resp = await http.post(
+                cfg['token_url'],
+                data={
+                    'code':          code,
+                    'client_id':     client_id,
+                    'client_secret': client_secret,
+                    'redirect_uri':  callback_url,
+                    'grant_type':    'authorization_code',
+                },
+                headers={'Accept': 'application/json'},
+            )
+        if token_resp.status_code != 200:
+            _logger.error('[auth_managed] token exchange %s: %s', provider, token_resp.text[:200])
+            return RedirectResponse(url=f"{frontend}?oauth_error=token_exchange&provider={provider}")
+
+        tok_json = token_resp.json()
+        access_token  = tok_json.get('access_token', '')
+        refresh_token = tok_json.get('refresh_token', '')
+        scope         = tok_json.get('scope', cfg['scope'])
+        expires_in    = tok_json.get('expires_in', 0)
+        expires_at    = int((time.time() + expires_in) * 1000) if expires_in else 0
+
+        if not access_token:
+            _logger.error('[auth_managed] no access_token from %s: %s', provider, tok_json)
+            return RedirectResponse(url=f"{frontend}?oauth_error=no_token&provider={provider}")
+
+        # Recupera metadata utente (opzionale, soft fail)
+        meta: dict = {}
+        try:
+            async with httpx.AsyncClient(timeout=8) as http:
+                me_resp = await http.get(
+                    cfg['userinfo_url'],
+                    headers={'Authorization': f'Bearer {access_token}', 'Accept': 'application/json'},
+                )
+                if me_resp.status_code == 200:
+                    meta = me_resp.json()
+        except Exception:
+            pass
+
+        await _sb_upsert_token(user_id, provider, access_token, refresh_token,
+                                expires_at, str(scope), meta)
+        _logger.info('[auth_managed] token saved %s/%s (expires_at=%d)', user_id, provider, expires_at)
+
+    except Exception as e:
+        _logger.error('[auth_managed] callback exception %s: %s', provider, e)
+        return RedirectResponse(url=f"{frontend}?oauth_error=server_error&provider={provider}")
+
+    # Redirect frontend con successo
+    return RedirectResponse(url=f"{frontend}?oauth_success=1&provider={provider}", status_code=302)
+
+
+@router.get('/api/auth/providers')
+async def list_providers(request: Request, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix: info-disclosure
+    """Restituisce stato connessione di tutti i provider per l'utente corrente."""
+    user_id = _user_id(request)
+    rows    = await _sb_list_tokens(user_id)
+    connected = {r['provider']: r for r in rows}
+
+    now_ms = int(time.time() * 1000)
+    result = []
+    for pname, cfg in _PROVIDER_CONFIGS.items():
+        row = connected.get(pname)
+        is_configured = bool(os.getenv(cfg['client_id_env'], ''))
+        if row:
+            exp = row.get('expires_at', 0)
+            meta_raw = row.get('raw_meta', '{}')
+            try:
+                meta = json.loads(meta_raw) if isinstance(meta_raw, str) else meta_raw
+            except Exception:
+                meta = {}
+            result.append({
+                'provider':      pname,
+                'connected':     True,
+                'configured':    is_configured,
+                'expired':       bool(exp and exp < now_ms),
+                'scope':         row.get('scope', ''),
+                'updated_at':    row.get('updated_at', 0),
+                'username':      meta.get('login') or meta.get('email') or meta.get('username', ''),
+            })
+        else:
+            result.append({
+                'provider':   pname,
+                'connected':  False,
+                'configured': is_configured,
+                'expired':    False,
+                'scope':      '',
+                'updated_at': 0,
+                'username':   '',
+            })
+
+    return JSONResponse({'providers': result, 'user_id': user_id})
+
+
+@router.delete('/api/auth/disconnect/{provider}')
+async def disconnect_provider(provider: str, request: Request, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
+    """Rimuove il token salvato per il provider specificato."""
+    if provider not in _PROVIDER_CONFIGS:
+        raise HTTPException(400, detail={'error': 'unknown_provider'})
+    user_id = _user_id(request)
+    await _sb_delete_token(user_id, provider)
+    _logger.info('[auth_managed] disconnected %s/%s', user_id, provider)
+    return JSONResponse({'ok': True, 'provider': provider})

api/background_tasks.py

@@ -0,0 +1,53 @@
+"""Supervision utilities for long-lived background asyncio tasks."""
+from __future__ import annotations
+
+import asyncio
+import logging
+from collections.abc import Awaitable
+from typing import Any
+
+_logger = logging.getLogger("agente_ai.background_tasks")
+_tasks: dict[str, asyncio.Task[Any]] = {}
+
+
+def spawn_background_task(coro: Awaitable[Any], *, name: str) -> asyncio.Task[Any]:
+    """Start one named background task and retain it for lifecycle shutdown.
+
+    A live task with the same name is reused. The passed coroutine is closed in
+    that case so duplicate startup calls do not leak an un-awaited coroutine.
+    """
+    current = _tasks.get(name)
+    if current is not None and not current.done():
+        close = getattr(coro, "close", None)
+        if close is not None:
+            close()
+        return current
+
+    task = asyncio.create_task(coro, name=name)
+    _tasks[name] = task
+
+    def _report(task_result: asyncio.Task[Any]) -> None:
+        if task_result.cancelled():
+            return
+        try:
+            error = task_result.exception()
+        except asyncio.CancelledError:
+            return
+        if error is not None:
+            _logger.error("background task %s failed: %s", name, error, exc_info=error)
+
+    task.add_done_callback(_report)
+    return task
+
+
+async def shutdown_background_tasks() -> None:
+    """Cancel and await all supervised background tasks."""
+    tasks = [task for task in _tasks.values() if not task.done()]
+    for task in tasks:
+        task.cancel()
+    if tasks:
+        await asyncio.gather(*tasks, return_exceptions=True)
+    _tasks.clear()
+
+
+__all__ = ["spawn_background_task", "shutdown_background_tasks"]

api/benchmark.py

@@ -0,0 +1,763 @@
+"""backend/api/benchmark.py — Self-test endpoint server-side (S-BENCH).
+
+Endpoint: GET /api/debug/benchmark?token=<daily_hmac>
+
+Auth: HMAC-SHA256(seed=_BENCH_SEED, msg=YYYY-MM-DD) — calcolabile da Replit
+senza dover conoscere INTERNAL_TOKEN. Token cambia ogni giorno (replay protection).
+Zero config aggiuntivo su HF Spaces.
+
+Il benchmark esegue ~20 test interni e restituisce JSON con:
+  { ok, score, pass, fail, warn, duration_ms, tests: [...], gaps: [...] }
+
+Uso da Replit:
+  python3 -c "
+  import hmac, hashlib, datetime
+  seed = 'agente-ai-bench-2026'
+  day  = datetime.date.today().isoformat()
+  tok  = hmac.new(seed.encode(), day.encode(), hashlib.sha256).hexdigest()
+  print(tok)
+  "
+  curl '<hf-space-a-url>/api/debug/benchmark?token=<tok>'
+"""
+import os, sys, asyncio, time, hmac, hashlib, datetime, importlib, tempfile, subprocess, re, uuid
+from fastapi import APIRouter, Depends, BackgroundTasks, HTTPException, Query, Request
+from .auth_guard import require_role, AuthRole
+from fastapi.responses import JSONResponse
+
+router = APIRouter( dependencies=[Depends(require_role(AuthRole.MACHINE))])  # GAP-1-fix: router-level auth
+
+# ── Seed per HMAC daily token — NON è un secret, è solo anti-scraping ─────────
+_BENCH_SEED = "agente-ai-bench-2026"
+
+
+def _daily_token() -> str:
+    day = datetime.date.today().isoformat()
+    return hmac.new(_BENCH_SEED.encode(), day.encode(), hashlib.sha256).hexdigest()
+
+
+# ── Result helpers ──────────────────────────────────────────────────────────────
+def _ok(id: str, desc: str, note: str = "") -> dict:
+    return {"id": id, "desc": desc, "ok": True, "warn": False, "note": note}
+
+def _ko(id: str, desc: str, note: str = "") -> dict:
+    return {"id": id, "desc": desc, "ok": False, "warn": False, "note": note}
+
+def _wn(id: str, desc: str, note: str = "") -> dict:
+    return {"id": id, "desc": desc, "ok": False, "warn": True, "note": note}
+
+
+async def _run_tests() -> list[dict]:
+    results: list[dict] = []
+    t_global = time.monotonic()
+
+    # ── T01: Sprint / version ─────────────────────────────────────────────────
+    try:
+        from api.providers import api_version
+        ver = await api_version() if asyncio.iscoroutinefunction(api_version) else api_version()
+        sprint = ver.get("sprint", "?") if isinstance(ver, dict) else getattr(ver, "sprint", "?")
+        body   = ver if isinstance(ver, dict) else ver.__dict__
+        results.append(_ok("T01", f"Sprint: {sprint} — {body.get('version','?')}", f"build={body.get('build_date','?')}"))
+    except Exception as e:
+        results.append(_ko("T01", "Sprint/version import fallito", str(e)))
+
+    # ── T02: INTERNAL_TOKEN configurato ──────────────────────────────────────
+    itok = os.getenv("INTERNAL_TOKEN", "")
+    if itok and len(itok) >= 16:
+        results.append(_ok("T02", "INTERNAL_TOKEN configurato in env", f"len={len(itok)}"))
+    elif itok:
+        results.append(_wn("T02", "INTERNAL_TOKEN troppo corto (< 16 chars)", f"len={len(itok)}"))
+    else:
+        results.append(_wn("T02", "INTERNAL_TOKEN non configurato — token effimero generato a ogni boot"))
+
+    # ── T03: UnifiedAgentLoop import ─────────────────────────────────────────
+    t = time.monotonic()
+    try:
+        from agents.unified_loop import UnifiedAgentLoop
+        ms = int((time.monotonic() - t) * 1000)
+        results.append(_ok("T03", f"UnifiedAgentLoop import OK ({ms}ms)"))
+    except Exception as e:
+        ms = int((time.monotonic() - t) * 1000)
+        results.append(_ko("T03", "UnifiedAgentLoop import FALLITO", str(e)[:120]))
+
+    # ── T04: RoleRouter + Role.FAST ──────────────────────────────────────────
+    t = time.monotonic()
+    try:
+        from models.role_router import RoleRouter, Role
+        fast_role = Role.FAST
+        client = RoleRouter.get_client(Role.FAST)
+        ms = int((time.monotonic() - t) * 1000)
+        provider = getattr(client, "provider_name", type(client).__name__)
+        results.append(_ok("T04", f"Role.FAST client OK ({ms}ms) — provider={provider}"))
+    except Exception as e:
+        ms = int((time.monotonic() - t) * 1000)
+        results.append(_ko("T04", f"Role.FAST client FALLITO ({ms}ms)", str(e)[:120]))
+
+    # ── T05: Python exec via asyncio subprocess ───────────────────────────────
+    t = time.monotonic()
+    try:
+        proc = await asyncio.wait_for(
+            asyncio.create_subprocess_exec(
+                sys.executable, "-c",
+                "import sys; print(f'py{sys.version_info.major}.{sys.version_info.minor} ok')",
+                stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE,
+            ),
+            timeout=10.0,
+        )
+        stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=10.0)
+        ms = int((time.monotonic() - t) * 1000)
+        out = stdout.decode().strip()
+        if "ok" in out:
+            results.append(_ok("T05", f"Python exec subprocess OK ({ms}ms)", out))
+        else:
+            results.append(_ko("T05", f"Python exec output inatteso ({ms}ms)", out[:80]))
+    except Exception as e:
+        ms = int((time.monotonic() - t) * 1000)
+        results.append(_ko("T05", f"Python exec FALLITO ({ms}ms)", str(e)[:120]))
+
+    # ── T06: Shell echo + date ────────────────────────────────────────────────
+    t = time.monotonic()
+    try:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            proc = await asyncio.wait_for(
+                asyncio.create_subprocess_shell(
+                    "echo bench_ok && date +%s",
+                    stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE,
+                    cwd=tmpdir,
+                ),
+                timeout=8.0,
+            )
+            stdout, _ = await asyncio.wait_for(proc.communicate(), timeout=8.0)
+        ms = int((time.monotonic() - t) * 1000)
+        out = stdout.decode().strip()
+        if "bench_ok" in out:
+            results.append(_ok("T06", f"Shell execute OK ({ms}ms)", out[:60]))
+        else:
+            results.append(_ko("T06", f"Shell output inatteso ({ms}ms)", out[:60]))
+    except Exception as e:
+        ms = int((time.monotonic() - t) * 1000)
+        results.append(_ko("T06", f"Shell execute FALLITO ({ms}ms)", str(e)[:120]))
+
+    # ── T07: Shell denylist — BLOCKED_CMDS + _EXEC_BLOCKED_RE ──────────────────
+    # exec.py ha due meccanismi: BLOCKED_CMDS (pattern esatti per /api/execute-shell)
+    # e _EXEC_BLOCKED_RE (regex per /api/exec sandbox Python).
+    # Test: verifica che almeno uno dei due meccanismi esista e funzioni.
+    try:
+        from api.exec import BLOCKED_CMDS
+        # BLOCKED_CMDS deve contenere pattern per i comandi più pericolosi
+        # Realtà: {'rm -rf /', 'mkfs', ':(){:|:&};:', 'dd if=/dev/zero'}
+        must_have = ["rm -rf /", "mkfs", "dd if=/dev/zero"]
+        present = [p for p in must_have if any(p in b or b in p for b in BLOCKED_CMDS)]
+        if len(present) >= 2:
+            results.append(_ok("T07", f"Shell denylist OK — BLOCKED_CMDS: {len(BLOCKED_CMDS)} pattern",
+                               f"include: {list(BLOCKED_CMDS)[:3]}"))
+        else:
+            results.append(_wn("T07", f"Shell denylist parziale — {len(present)}/{len(must_have)} pattern critici",
+                               f"BLOCKED_CMDS={list(BLOCKED_CMDS)}"))
+    except ImportError:
+        try:
+            from api.exec import _EXEC_BLOCKED_RE
+            results.append(_ok("T07", "Shell denylist OK — _EXEC_BLOCKED_RE presente"))
+        except ImportError:
+            results.append(_wn("T07", "denylist non importabile da api.exec (modulo assente)"))
+
+    # ── T08: asyncio.Semaphore S734 ──────────────────────────────────────────
+    try:
+        from agents.unified_loop_tools import DirectToolsMixin
+        src_path = importlib.util.find_spec("agents.unified_loop_tools")
+        if src_path:
+            import inspect
+            src = inspect.getsource(DirectToolsMixin)
+            if "asyncio.Semaphore(4)" in src or "Semaphore" in src:
+                results.append(_ok("T08", "asyncio.Semaphore S734 presente in DirectToolsMixin"))
+            else:
+                results.append(_wn("T08", "asyncio.Semaphore non trovato in DirectToolsMixin"))
+        else:
+            results.append(_wn("T08", "unified_loop_tools non trovato"))
+    except Exception as e:
+        results.append(_wn("T08", "S734 check non eseguibile", str(e)[:80]))
+
+    # ── T09: Provider env keys — tutti i provider supportati ─────────────────
+    # Aggiornato 2026-06-14: aggiunto SAMBANOVA_API_KEY (DeepSeek-V3.1 100% bench)
+    providers_conf = {
+        "GROQ_API_KEY":       "Groq",
+        "OPENROUTER_API_KEY": "OpenRouter",
+        "GEMINI_API_KEY":     "Gemini",
+        "HF_TOKEN":           "HuggingFace",
+        "CEREBRAS_API_KEY":   "Cerebras",
+        "SAMBANOVA_API_KEY":  "SambaNova",
+    }
+    configured = [name for key, name in providers_conf.items() if os.getenv(key)]
+    missing    = [name for key, name in providers_conf.items() if not os.getenv(key)]
+    if len(configured) >= 2:
+        results.append(_ok("T09", f"Provider keys: {len(configured)}/{len(providers_conf)} configurati", ", ".join(configured)))
+    elif len(configured) == 1:
+        results.append(_wn("T09", f"Provider keys: solo 1/{len(providers_conf)} ({configured[0]}) — fallback chain ridotta", f"mancanti: {', '.join(missing)}"))
+    else:
+        results.append(_ko("T09", "Nessuna provider API key configurata!", f"mancanti: {', '.join(missing)}"))
+
+    # ── T10: SQLite DB write/read ─────────────────────────────────────────────
+    t = time.monotonic()
+    try:
+        import sqlite3
+        with tempfile.NamedTemporaryFile(suffix=".db", delete=True) as f:
+            db_path = f.name
+        conn = sqlite3.connect(db_path)
+        conn.execute("CREATE TABLE bench (k TEXT, v TEXT)")
+        conn.execute("INSERT INTO bench VALUES ('test', 'bench_ok')")
+        conn.commit()
+        row = conn.execute("SELECT v FROM bench WHERE k='test'").fetchone()
+        conn.close()
+        os.unlink(db_path)
+        ms = int((time.monotonic() - t) * 1000)
+        if row and row[0] == "bench_ok":
+            results.append(_ok("T10", f"SQLite write/read OK ({ms}ms)"))
+        else:
+            results.append(_ko("T10", f"SQLite round-trip fallito ({ms}ms)", str(row)))
+    except Exception as e:
+        ms = int((time.monotonic() - t) * 1000)
+        results.append(_ko("T10", f"SQLite FALLITO ({ms}ms)", str(e)[:120]))
+
+    # ── T11: /tmp write + read ────────────────────────────────────────────────
+    t = time.monotonic()
+    try:
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".bench", delete=False) as f:
+            f.write("bench_filesystem_ok")
+            fname = f.name
+        with open(fname) as _bf: content = _bf.read()
+        os.unlink(fname)
+        ms = int((time.monotonic() - t) * 1000)
+        if content == "bench_filesystem_ok":
+            results.append(_ok("T11", f"/tmp filesystem write/read OK ({ms}ms)"))
+        else:
+            results.append(_ko("T11", f"/tmp read mismatch ({ms}ms)", content[:40]))
+    except Exception as e:
+        ms = int((time.monotonic() - t) * 1000)
+        results.append(_ko("T11", f"/tmp filesystem FALLITO ({ms}ms)", str(e)[:120]))
+
+    # ── T12: asyncio concurrency — 5 task paralleli ───────────────────────────
+    t = time.monotonic()
+    try:
+        async def _noop(i: int) -> int:
+            await asyncio.sleep(0.01)
+            return i * 2
+        outcomes = await asyncio.gather(*[_noop(i) for i in range(5)])
+        ms = int((time.monotonic() - t) * 1000)
+        if outcomes == [0, 2, 4, 6, 8]:
+            results.append(_ok("T12", f"asyncio concurrency 5x tasks OK ({ms}ms)"))
+        else:
+            results.append(_ko("T12", f"asyncio concurrency output inatteso ({ms}ms)", str(outcomes)))
+    except Exception as e:
+        ms = int((time.monotonic() - t) * 1000)
+        results.append(_ko("T12", f"asyncio concurrency FALLITA ({ms}ms)", str(e)[:120]))
+
+    # ── T13: Memory manager import ────────────────────────────────────────────
+    t = time.monotonic()
+    try:
+        from memory.manager import MemoryManager
+        ms = int((time.monotonic() - t) * 1000)
+        results.append(_ok("T13", f"MemoryManager import OK ({ms}ms)"))
+    except Exception as e:
+        ms = int((time.monotonic() - t) * 1000)
+        results.append(_wn("T13", f"MemoryManager import WARN ({ms}ms)", str(e)[:80]))
+
+    # ── T14: Role.FAST _run_fast_path — verifica wiring nel codice sorgente ──
+    try:
+        import inspect
+        from agents.unified_loop import UnifiedAgentLoop
+        src = inspect.getsource(UnifiedAgentLoop)
+        has_fast_llm    = "_fast_llm" in src
+        has_get_fast    = "_get_fast_llm" in src
+        has_fast_client = "_fast_client" in src
+        if has_fast_llm and has_get_fast and has_fast_client:
+            results.append(_ok("T14", "Role.FAST wiring completo in UnifiedAgentLoop",
+                               "_fast_llm + _get_fast_llm() + _fast_client.chat()"))
+        else:
+            missing = [k for k, v in [("_fast_llm", has_fast_llm), ("_get_fast_llm", has_get_fast), ("_fast_client", has_fast_client)] if not v]
+            results.append(_ko("T14", "Role.FAST wiring incompleto", f"mancanti: {missing}"))
+    except Exception as e:
+        results.append(_ko("T14", "Role.FAST wiring check FALLITO", str(e)[:120]))
+
+    # ── T15: Python deps critici importabili ──────────────────────────────────
+    critical_deps = ["fastapi", "pydantic", "httpx", "aiohttp", "groq", "google.generativeai"]
+    dep_ok, dep_ko = [], []
+    for dep in critical_deps:
+        try:
+            importlib.import_module(dep)
+            dep_ok.append(dep)
+        except ImportError:
+            dep_ko.append(dep)
+    if not dep_ko:
+        results.append(_ok("T15", f"Deps critici: tutti {len(dep_ok)} importabili", ", ".join(dep_ok)))
+    elif len(dep_ko) <= 2:
+        results.append(_wn("T15", f"Deps critici: {len(dep_ko)} mancanti", f"ko={dep_ko}"))
+    else:
+        results.append(_ko("T15", f"Deps critici: {len(dep_ko)}/{len(critical_deps)} mancanti", f"ko={dep_ko}"))
+
+    # ── T16: Groq FAST path — latenza client init ────────────────────────────
+    t = time.monotonic()
+    groq_key = os.getenv("GROQ_API_KEY", "")
+    if groq_key:
+        try:
+            from models.role_router import RoleRouter, Role
+            client = RoleRouter.get_client(Role.FAST)
+            ms = int((time.monotonic() - t) * 1000)
+            results.append(_ok("T16", f"Groq FAST client init ({ms}ms)",
+                               getattr(client, "provider_name", type(client).__name__)))
+        except Exception as e:
+            ms = int((time.monotonic() - t) * 1000)
+            results.append(_ko("T16", f"Groq FAST client FALLITO ({ms}ms)", str(e)[:120]))
+    else:
+        results.append(_wn("T16", "GROQ_API_KEY non configurata — Role.FAST userà self.llm come fallback"))
+
+    # ── T17: Latenza totale benchmark ─────────────────────────────────────────
+    total_ms = int((time.monotonic() - t_global) * 1000)
+    results.append(_ok("T17", f"Benchmark completato in {total_ms}ms",
+                        f"{'OK' if total_ms < 5000 else 'SLOW'} (target <5s)"))
+
+    return results
+
+
+@router.get("/api/debug/benchmark")
+async def run_benchmark(
+    token: str = Query(..., description="Daily HMAC token — vedi docstring modulo"),
+    pretty: bool = Query(False, description="Output human-readable invece di JSON compatto"),
+):
+    """S-BENCH: Self-test server-side completo — zero dipendenza da Replit.
+
+    Auth: HMAC-SHA256 daily token (seed fisso in codice, non è un secret).
+    Calcola il token del giorno con:
+        python3 -c "import hmac,hashlib,datetime; print(hmac.new(b'agente-ai-bench-2026', datetime.date.today().isoformat().encode(), hashlib.sha256).hexdigest())"
+    """
+    expected = _daily_token()
+    if not hmac.compare_digest(token, expected):
+        raise HTTPException(
+            status_code=401,
+            detail={
+                "error": "Token non valido o scaduto (cambia ogni giorno).",
+                "hint": "python3 -c \"import hmac,hashlib,datetime; "
+                        "print(hmac.new(b'agente-ai-bench-2026', datetime.date.today().isoformat().encode(), hashlib.sha256).hexdigest())\"",
+            },
+        )
+
+    t0 = time.monotonic()
+    results = await _run_tests()
+    elapsed_ms = int((time.monotonic() - t0) * 1000)
+
+    pass_n  = sum(1 for r in results if r["ok"])
+    fail_n  = sum(1 for r in results if not r["ok"] and not r["warn"])
+    warn_n  = sum(1 for r in results if r["warn"])
+    total_n = len(results)
+    score   = round(pass_n / max(1, pass_n + fail_n) * 100)
+
+    gaps = [r for r in results if not r["ok"] and not r["warn"]]
+
+    payload = {
+        "ok":          fail_n == 0,
+        "score":       score,
+        "pass":        pass_n,
+        "fail":        fail_n,
+        "warn":        warn_n,
+        "total":       total_n,
+        "duration_ms": elapsed_ms,
+        "timestamp":   datetime.datetime.utcnow().isoformat() + "Z",
+        "tests":       results,
+        "gaps":        [{"id": r["id"], "desc": r["desc"], "note": r.get("note", "")} for r in gaps],
+    }
+    return JSONResponse(content=payload, status_code=200 if fail_n == 0 else 207)
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# QUALITY BENCHMARK — misura miglioramenti LLM per sprint (S-BENCH-Q)
+# POST /api/benchmark/quality/run          → avvia background task, ritorna task_id
+# GET  /api/benchmark/quality/status/{id}  → polling risultati
+#
+# Per ogni categoria agente (DA / ORCH / MC / REC):
+#   1. Inietta la context rule via UnifiedLoopPrompts._pick_context_rules()
+#   2. Chiama il LLM (ARCHITECT = openai/gpt-oss-120b) a temperatura 0.3
+#   3. Valuta la risposta con checker regex (stessa logica di benchmark-extended.mjs)
+#   4. Produce score 0-100 per categoria + media totale
+#
+# Auth: stesso token HMAC daily del /api/debug/benchmark.
+# ═══════════════════════════════════════════════════════════════════════════════
+
+_QUALITY_RUNS: dict[str, dict] = {}   # task_id → {status, results, …}
+
+# ── Definizione task benchmark qualità ─────────────────────────────────────────
+_QUALITY_TASKS = [
+    {
+        "id": "DA",
+        "category": "data_analysis",
+        "label": "Analisi Dati",
+        "goal_for_rules": "analisi dati vendite statistiche media picco anomalia trend",
+        "user_prompt": (
+            "Analizza questi dati di vendite mensili:\n"
+            "Gen=100, Feb=120, Mar=80, Apr=150, Mag=90, Giu=200.\n\n"
+            "Fornisci un'analisi strutturata con Media, Picco, Anomalia e Trend."
+        ),
+        "criteria": [
+            {"id": "media",    "label": "**Media: N**",       "weight": 25},
+            {"id": "picco",    "label": "**Picco: MESE**",    "weight": 25},
+            {"id": "anomalia", "label": "**Anomalia: MESE**", "weight": 25},
+            {"id": "trend",    "label": "**Trend: ...**",     "weight": 25},
+        ],
+    },
+    {
+        "id": "ORCH",
+        "category": "orchestration",
+        "label": "Orchestrazione",
+        "goal_for_rules": "implementa sistema backend typescript asincrono dipendenze sql async",
+        "user_prompt": (
+            "Implementa un sistema di notifiche email per e-commerce con:\n"
+            "- Invio email alla conferma ordine\n"
+            "- Retry automatico su failure (3 tentativi)\n"
+            "- Tracking stato consegna\n\n"
+            "TypeScript + Node.js. Mostra: piano → implementazione → dipendenze."
+        ),
+        "criteria": [
+            {"id": "hasPlan",  "label": "Piano / sezione strutturata", "weight": 25},
+            {"id": "hasCode",  "label": "Codice TypeScript",           "weight": 25},
+            {"id": "hasAsync", "label": "async/await o Promise",       "weight": 25},
+            {"id": "hasDeps",  "label": "Dipendenze elencate",         "weight": 25},
+        ],
+    },
+    {
+        "id": "MC",
+        "category": "memory_context",
+        "label": "Memory Context",
+        "goal_for_rules": "interface typescript endpoint apiresponse stack architettura libreria",
+        "user_prompt": (
+            "Implementa la route Express per GET /api/users/:id.\n"
+            "Usa il pattern ApiResponse<T> con i campi: success, data, error, requestId.\n"
+            "Rispetta le convenzioni dello stack del progetto (Drizzle, Zod, Express)."
+        ),
+        "criteria": [
+            {"id": "hasApiResponse", "label": "ApiResponse<T> usato",        "weight": 35},
+            {"id": "hasRequestId",   "label": "requestId nel response",       "weight": 35},
+            {"id": "hasStack",       "label": "Stack reale (Drizzle/Zod/..)", "weight": 30},
+        ],
+    },
+    {
+        "id": "REC",
+        "category": "recovery",
+        "label": "Recovery",
+        "goal_for_rules": "task ambiguo input mancante cosa fare rollback vincoli",
+        "user_prompt": (
+            "L'utente scrive solo: 'Fammi un'analisi'.\n"
+            "Non specifica cosa analizzare, non ha fornito dati.\n\n"
+            "Cosa fai? (non inventare dati, non procedere silenziosamente)"
+        ),
+        "criteria": [
+            {"id": "asksDetails",     "label": "Chiede chiarimenti",               "weight": 40},
+            {"id": "listAssumptions", "label": "Lista assunzioni / ipotesi",        "weight": 30},
+            {"id": "noHallucinate",   "label": "Non inventa dati (anti-hallucination)", "weight": 30},
+        ],
+    },
+    {
+        "id": "ROB",
+        "category": "robustness",
+        "label": "Robustness",
+        "goal_for_rules": "istruzioni diventano progressivamente meno specifiche gestisci l ambiguità rendila ancora più efficiente ordinamento typescript",
+        "user_prompt": (
+            "Implementa una funzione di ordinamento TypeScript efficiente.\n"
+            "Poi rendila ancora più efficiente.\n"
+            "Ottimizzala per il caso d'uso tipico.\n"
+            "Assicurati che funzioni.\n\n"
+            "Nota: le istruzioni diventano progressivamente meno specifiche. "
+            "Gestisci l'ambiguità in modo esplicito."
+        ),
+        "criteria": [
+            {"id": "hasCode",          "label": "Codice TypeScript (sort)",       "weight": 25},
+            {"id": "handlesAmbiguity", "label": "Dichiara assunzioni esplicite",  "weight": 25},
+            {"id": "hasSort",          "label": "Usa sort/algorithm",             "weight": 25},
+            {"id": "hasRationale",     "label": "Motivazione / perché",           "weight": 25},
+        ],
+    },
+]
+
+
+def _score_quality_task(task: dict, response: str) -> dict:
+    """Valuta risposta LLM su ogni criterio — ritorna score 0-100."""
+    r   = response
+    tid = task["id"]
+
+    if tid == "DA":
+        checks = {
+            "media":    bool(re.search(r'\*\*Media',   r, re.IGNORECASE)),
+            "picco":    bool(re.search(r'\*\*Picco',   r, re.IGNORECASE)),
+            "anomalia": bool(re.search(r'\*\*Anomali', r, re.IGNORECASE)),
+            "trend":    bool(re.search(r'\*\*(Trend|Andamento|Tendenz)',   r, re.IGNORECASE)),
+        }
+    elif tid == "ORCH":
+        checks = {
+            "hasPlan":  bool(re.search(r'(piano|step\s*\d|fase\s*\d|\d+\.\s+[A-Z])', r, re.IGNORECASE)),
+            "hasCode":  bool(re.search(r'```(ts|typescript|javascript|js)', r, re.IGNORECASE)),
+            "hasAsync": bool(re.search(r'(async|await|Promise\.all)', r)),
+            "hasDeps":  bool(re.search(r'(npm|pnpm|yarn|install|dependen|dipendenz|package\.json)', r, re.IGNORECASE)),
+        }
+    elif tid == "MC":
+        checks = {
+            "hasApiResponse": bool(re.search(r'ApiResponse', r)),
+            "hasRequestId":   bool(re.search(r'requestId', r)),
+            "hasStack":       bool(re.search(r'(Drizzle|Zod|Express|Prisma|knex)', r, re.IGNORECASE)),
+        }
+    elif tid == "REC":
+        checks = {
+            "asksDetails":     bool(re.search(
+                r'(\?|qual[ei]|cosa intendi|chiar|specificar|dettagl|di\s+pi)', r, re.IGNORECASE)),
+            "listAssumptions": bool(re.search(
+                r'(assumo|ipotesi|assunzion|potrebbe essere|se intendi|per esempio|ad esempio'
+                r'|se si tratta|che tipo|quale tipo|se vuole|potrei fare|opzione [ab]'
+                r'|se intende|potrebbe trattarsi|quale delle|in base a cosa)', r, re.IGNORECASE)),
+            # pass se NON inventa dati concreti senza chiedere
+            "noHallucinate":   not bool(re.search(
+                r'(ecco l.analisi|ecco i dati|i dati mostrano|risultati:|media:\s*\d)', r, re.IGNORECASE)),
+        }
+    elif tid == "ROB":
+        import re as _re
+        code_blocks = _re.findall(r"```(?:typescript|ts)[\s\S]*?```", r, _re.IGNORECASE)
+        code_txt = " ".join(code_blocks)
+        checks = {
+            "hasCode":          bool(code_blocks) and len(code_txt) > 50,
+            "handlesAmbiguity": bool(_re.search(r"assumo|ipotizzo|ambiguo|caso tipico|interpretto", r, _re.IGNORECASE)),
+            "hasSort":          bool(_re.search(r"sort|quicksort|mergesort|compareFn|algorithm", r, _re.IGNORECASE)),
+            "hasRationale":     bool(_re.search(r"perché|motivazione|scelta|rationale|perche", r, _re.IGNORECASE)),
+        }
+    else:
+        checks = {}
+
+    scored = [{**c, "pass": checks.get(c["id"], False)} for c in task["criteria"]]
+    score  = sum(c["weight"] for c in scored if c["pass"])
+    return {
+        "id":               task["id"],
+        "category":         task["category"],
+        "label":            task["label"],
+        "score":            score,
+        "criteria":         scored,
+        "response_preview": r[:400] + ("\u2026" if len(r) > 400 else ""),
+    }
+
+
+async def _run_quality_benchmark(task_id: str) -> None:
+    """Background task: 4 chiamate LLM in parallelo → scorecard qualità."""
+    _QUALITY_RUNS[task_id]["status"] = "running"
+    results: list[dict] = []
+    errors:  list[dict] = []
+
+    try:
+        from models.role_router import RoleRouter, Role            # noqa: PLC0415
+        from agents.unified_loop_prompts import PromptBuilderMixin  # noqa: PLC0415
+
+        # System prompt leggero per benchmark: NO tool definitions (evita tool-call da FAST)
+        # Le context rules iniettano le istruzioni specifiche per categoria
+        prompts_obj = PromptBuilderMixin()
+        _BENCH_SYS = (
+            "Sei un assistente AI specializzato in sviluppo software e analisi dati. "
+            "Rispondi in italiano usando markdown. "
+            "Usa blocchi di codice ```typescript``` / ```javascript``` per il codice. "
+            "NON usare tool calls o function calls — rispondi sempre con testo e codice."
+        )
+
+        # Provider chain: ARCHITECT prima (qualità), poi fallback per 402/depleted
+        _PROVIDER_CHAIN = ["ARCHITECT", "REASONER", "CODER", "FAST"]
+
+        async def _run_one_task(msgs: list[dict]) -> str:
+            """Retry indipendente per task — ARCHITECT first, FAST come ultimo resort."""
+            last_exc: Exception | None = None
+            for _rname in _PROVIDER_CHAIN:
+                _r = getattr(Role, _rname, None)
+                if _r is None:
+                    continue
+                try:
+                    _c = RoleRouter.get_client(_r)
+                    result = await asyncio.wait_for(
+                        _c.chat(msgs, temperature=0.3, max_tokens=1200),
+                        timeout=35.0,
+                    )
+                    return str(result)
+                except Exception as _exc:
+                    last_exc = _exc
+                    _exc_s = str(_exc).lower()
+                    # 402 / depleted / rate-limit → prova il prossimo provider
+                    if any(k in _exc_s for k in ["402", "depleted", "rate limit", "too many", "429"]):
+                        continue
+                    raise  # errore non-recuperabile → propaga subito
+            raise last_exc or Exception("Nessun provider disponibile")
+
+        # Esecuzione sequenziale — evita rate-limit da 5 richieste simultanee allo stesso provider
+        # Latenza: ~30-50s (5 × ~7-10s) vs 402 su tutto con parallelo
+        results_map: list[str | Exception] = []
+        for task in _QUALITY_TASKS:
+            ctx_rules = prompts_obj._pick_context_rules(task["goal_for_rules"])
+            system    = _BENCH_SYS + (("\n\n" + ctx_rules) if ctx_rules else "")
+            msgs = [
+                {"role": "system", "content": system},
+                {"role": "user",   "content": task["user_prompt"]},
+            ]
+            try:
+                resp = await _run_one_task(msgs)
+                results_map.append(resp)
+            except Exception as _exc:
+                results_map.append(_exc)
+
+        responses = results_map
+
+        for task, response in zip(_QUALITY_TASKS, responses):
+            if isinstance(response, Exception):
+                err_msg = str(response)[:150]
+                errors.append({"id": task["id"], "error": err_msg})
+                results.append({
+                    "id": task["id"], "category": task["category"],
+                    "label": task["label"], "score": 0, "criteria": [], "error": err_msg,
+                })
+            else:
+                results.append(_score_quality_task(task, str(response)))
+
+    except Exception as exc:
+        errors.append({"global": str(exc)[:250]})
+
+    passed    = [r for r in results if not r.get("error")]
+    avg_score = round(sum(r["score"] for r in passed) / max(1, len(passed)))
+
+    _QUALITY_RUNS[task_id].update({
+        "status":         "done",
+        "results":        results,
+        "errors":         errors,
+        "total_score":    avg_score,
+        "categories_run": len(results),
+        "finished_at":    datetime.datetime.utcnow().isoformat() + "Z",
+    })
+
+
+@router.post("/api/benchmark/quality/run")
+async def start_quality_benchmark(
+    background_tasks: BackgroundTasks,
+    token: str = Query(..., description="Daily HMAC token — stesso del /api/debug/benchmark"),
+):
+    """Avvia il benchmark qualità LLM in background (S-BENCH-Q).
+
+    Testa 4 categorie agentiche iniettando le context rules del sprint corrente,
+    chiama il LLM e valuta la risposta con checker regex.
+
+    Ritorna task_id per polling: GET /api/benchmark/quality/status/{task_id}
+
+    Calcola il token del giorno con:
+        python3 -c "import hmac,hashlib,datetime; \\
+            print(hmac.new(b'agente-ai-bench-2026', \\
+            datetime.date.today().isoformat().encode(), \\
+            hashlib.sha256).hexdigest())"
+    """
+    expected = _daily_token()
+    if not hmac.compare_digest(token, expected):
+        raise HTTPException(
+            status_code=401,
+            detail={
+                "error": "Token non valido o scaduto (cambia ogni giorno).",
+                "hint":  ("python3 -c \"import hmac,hashlib,datetime; "
+                          "print(hmac.new(b'agente-ai-bench-2026',"
+                          "datetime.date.today().isoformat().encode(),"
+                          "hashlib.sha256).hexdigest())\""),
+            },
+        )
+
+    task_id = uuid.uuid4().hex[:12]
+    now_iso = datetime.datetime.utcnow().isoformat() + "Z"
+    _QUALITY_RUNS[task_id] = {
+        "status":         "queued",
+        "started_at":     now_iso,
+        "results":        [],
+        "errors":         [],
+        "total_score":    None,
+        "categories_run": 0,
+    }
+    background_tasks.add_task(_run_quality_benchmark, task_id)
+
+    return JSONResponse({
+        "task_id":    task_id,
+        "status":     "queued",
+        "poll_url":   f"/api/benchmark/quality/status/{task_id}",
+        "categories": [f"{t['id']} ({t['label']})" for t in _QUALITY_TASKS],
+        "started_at": now_iso,
+    }, status_code=202)
+
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# RUN-SELF — il bot esegue il proprio benchmark in autonomia (S-BENCH-SELF)
+# POST /api/benchmark/run-self  →  auth: X-Internal-Token header
+#
+# Esegue il quality benchmark su tutte le categorie + ROB e ritorna i risultati
+# direttamente (sincrono, ~20-30s). Il bot può chiamare questo endpoint
+# autonomamente senza Replit, senza token HMAC, senza configurazione esterna.
+# ═══════════════════════════════════════════════════════════════════════════════
+
+@router.post("/api/benchmark/run-self")
+async def run_self_benchmark(request: "Request"):
+    """Self-benchmark: il bot misura le proprie performance in autonomia.
+
+    Auth: X-Internal-Token header (stesso usato per /api/agent/run-stream).
+    Nessun token HMAC, nessuna dipendenza da Replit.
+
+    Esegue il quality benchmark su tutte le categorie (DA, ORCH, MC, REC, ROB)
+    e ritorna lo scorecard completo.
+
+    Esempio:
+        curl -X POST <hf-space-a-url>/api/benchmark/run-self \
+             -H "X-Internal-Token: <token>"
+    """
+    import os as _os
+    from fastapi import Request as _Req
+    itok_conf = _os.getenv("INTERNAL_TOKEN", "")
+    itok_recv = request.headers.get("X-Internal-Token", "")
+    if not itok_conf or not itok_recv or itok_recv != itok_conf:
+        from fastapi import HTTPException as _HTTP
+        raise _HTTP(status_code=401, detail="X-Internal-Token non valido o mancante.")
+
+    t0 = __import__("time").monotonic()
+    task_id = __import__("uuid").uuid4().hex[:12]
+    _QUALITY_RUNS[task_id] = {
+        "status": "running", "started_at": datetime.datetime.utcnow().isoformat() + "Z",
+        "results": [], "errors": [], "total_score": None, "categories_run": 0,
+    }
+    await _run_quality_benchmark(task_id)
+    elapsed_ms = int((__import__("time").monotonic() - t0) * 1000)
+
+    run = _QUALITY_RUNS[task_id]
+    results = run.get("results", [])
+    passed  = [r for r in results if not r.get("error")]
+    avg     = round(sum(r["score"] for r in passed) / max(1, len(passed)))
+
+    return JSONResponse({
+        "ok":          len(run.get("errors", [])) == 0,
+        "total_score": avg,
+        "categories_run": len(results),
+        "duration_ms": elapsed_ms,
+        "timestamp":   datetime.datetime.utcnow().isoformat() + "Z",
+        "results":     results,
+        "errors":      run.get("errors", []),
+        "gaps": [
+            {"id": r["id"], "label": r["label"], "score": r["score"],
+             "failed_criteria": [c["label"] for c in r.get("criteria", []) if not c.get("pass")]}
+            for r in results if r["score"] < 75
+        ],
+    })
+
+@router.get("/api/benchmark/quality/status/{task_id}")
+async def quality_benchmark_status(task_id: str):
+    """Polling sullo stato del benchmark qualità.
+
+    Lifecycle: queued → running → done
+
+    Response fields:
+      status:         queued | running | done
+      total_score:    0-100 (media delle categorie senza errori)
+      results:        per-task score + criteri + preview risposta
+      errors:         errori LLM per task (score=0 se presente)
+      categories_run: quante categorie hanno prodotto un risultato
+    """
+    run = _QUALITY_RUNS.get(task_id)
+    if run is None:
+        raise HTTPException(
+            status_code=404,
+            detail=f"Task '{task_id}' non trovato. Avvia prima POST /api/benchmark/quality/run",
+        )
+    return JSONResponse(run)

api/benchmark_handler.py

@@ -0,0 +1,331 @@
+"""backend/api/benchmark_handler.py — Gestore benchmark via Telegram.
+
+Versione v7 (GAP-BENCH-2): usa benchmark-extended.mjs (comprehensive, 2319 righe)
+con flag --json. Mantiene compatibilità backward con report v6.2-stress per /riepilogo.
+
+Sprint history:
+  v6.2 — benchmark-ultra-v6.2-stress.mjs (208 righe, stress+Groq judge)
+  v7   — benchmark-extended.mjs (2319 righe, 10+ categorie, HF datasets,
+          ref vs Replit/Cursor/Devin/Manus)
+
+Fix invarianti portati da v6.2:
+  - FIX-1: process.kill() + wait() su TimeoutError — nessun zombie su Railway.
+  - FIX-2: _load_gap_map() usa importlib isolato — nessuna sys.path pollution.
+  - FIX-3: I/O su file in asyncio.to_thread — non blocca l'event loop.
+"""
+from __future__ import annotations
+import asyncio, importlib, importlib.util, json, logging, os
+from typing import Any
+
+logger = logging.getLogger("agente_ai.benchmark_handler")
+
+# ── Percorsi server Railway ────────────────────────────────────────────────────
+# Lo Space HF esegue il backend in /app; Railway può impostare REPO_ROOT.
+_REPO_ROOT     = os.getenv("REPO_ROOT", "/app")
+
+# Extended v5: 20 categorie. Gli Space possono montare il repository in
+# /home/user/app anche quando il Dockerfile dichiara WORKDIR=/app.
+_BENCH_SCRIPT_CANDIDATES = (
+    os.getenv("BENCHMARK_RUNNER_PATH", "").strip(),
+    os.path.join(_REPO_ROOT, "benchmark-extended.mjs"),
+    "/home/user/app/benchmark-extended.mjs",
+    "/app/benchmark-extended.mjs",
+)
+_BENCH_SCRIPT = next(
+    (candidate for candidate in _BENCH_SCRIPT_CANDIDATES if candidate and os.path.isfile(candidate)),
+    os.path.join(_REPO_ROOT, "benchmark-extended.mjs"),
+)
+_REPORT_V7     = "/tmp/agente-ai/benchmark-v5-latest.json"
+_REPORT_V7_WEAK = "/tmp/agente-ai/benchmark-v5-weak-latest.json"
+_WEAK_CATEGORIES = (
+    "sql", "context_window", "reasoning", "data_analysis", "research_synthesis",
+    "mmlu", "technical_writing", "code_correct", "feature", "security",
+)
+# 20 task seriali possono richiedere più di 12 minuti con provider gratuiti.
+_BENCH_TIMEOUT = float(os.getenv("BENCH_TIMEOUT_SECS", "3600"))
+
+# v6.2 — usato come fallback in get_smart_summary per compatibilità
+_REPORT_V6     = os.path.join(_REPO_ROOT, "benchmark-stress-report.json")
+
+
+async def run_benchmark_task(chat_id: int, send_reply_fn, mode: str = "full") -> None:
+    """Esegue il benchmark Extended v5 su tutte le 20 categorie via API task moderna."""
+    if not await asyncio.to_thread(os.path.isfile, _BENCH_SCRIPT):
+        await send_reply_fn(chat_id, "❌ <b>Runner benchmark esteso non disponibile.</b>\n"
+                            "Il deployment non ha incluso <code>benchmark-extended.mjs</code>.")
+        return
+
+    is_weak_run = mode == "weak"
+    if is_weak_run:
+        report_path = _REPORT_V7_WEAK
+        flags = [
+            f"--categories={','.join(_WEAK_CATEGORIES)}", "--json",
+            f"--output={report_path}", "--gap-analysis",
+        ]
+        await send_reply_fn(
+            chat_id,
+            "🎯 <b>Benchmark Extended v5 mirato avviato</b>\n"
+            "<i>10 categorie più deboli della baseline 39,1 · seed 1337 · task API moderna.</i>",
+        )
+    else:
+        report_path = _REPORT_V7
+        flags = ["--full", "--json", f"--output={report_path}", "--gap-analysis"]
+        await send_reply_fn(
+            chat_id,
+            "🚀 <b>Benchmark Extended v5 avviato</b>\n"
+            "<i>20/20 categorie · seed 1337 · task API moderna · durata variabile fino a ~60 min.</i>",
+        )
+    env = {
+        **os.environ,
+        "INTERNAL_TOKEN": os.getenv("INTERNAL_TOKEN", ""),
+        "BENCHMARK_BASE_URL": os.getenv("BENCHMARK_BASE_URL", "http://127.0.0.1:7860"),
+    }
+    process: asyncio.subprocess.Process | None = None
+    try:
+        process = await asyncio.create_subprocess_exec(
+            "node", _BENCH_SCRIPT, *flags,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            env=env,
+        )
+        _stdout, stderr = await asyncio.wait_for(process.communicate(), timeout=_BENCH_TIMEOUT)
+        if process.returncode != 0:
+            err = stderr.decode(errors="replace")[:400]
+            logger.error("Extended benchmark failed rc=%d: %s", process.returncode, err)
+            await send_reply_fn(chat_id, f"❌ <b>Errore benchmark Extended:</b>\n<code>{err}</code>")
+            return
+    except asyncio.TimeoutError:
+        if process is not None:
+            try:
+                process.kill()
+                await process.wait()
+            except Exception:
+                pass
+        logger.warning("Extended benchmark timeout (>%.0fs) — process killed", _BENCH_TIMEOUT)
+        await send_reply_fn(chat_id, f"⏱ <b>Timeout benchmark Extended</b> (>{int(_BENCH_TIMEOUT // 60)} min) — processo terminato.")
+        return
+    except Exception as exc:
+        if process is not None:
+            try:
+                process.kill()
+                await process.wait()
+            except Exception:
+                pass
+        logger.exception("run_benchmark_task extended error")
+        await send_reply_fn(chat_id, f"💥 <b>Errore critico benchmark:</b> <code>{exc}</code>")
+        return
+
+    report_exists = await asyncio.to_thread(os.path.exists, report_path)
+    if not report_exists:
+        await send_reply_fn(chat_id, "⚠️ <b>Benchmark Extended terminato ma report non trovato.</b>")
+        return
+    try:
+        report: dict[str, Any] = await asyncio.to_thread(_read_json, report_path)
+    except Exception as exc:
+        await send_reply_fn(chat_id, f"⚠️ <b>Report Extended non leggibile:</b> <code>{exc}</code>")
+        return
+
+    categories = {str(task.get("cat", "")) for task in report.get("tasks", []) if task.get("cat")}
+    expected_categories = len(_WEAK_CATEGORIES) if is_weak_run else 20
+    if len(categories) != expected_categories:
+        await send_reply_fn(chat_id, f"⚠️ <b>Run incompleta:</b> <code>{len(categories)}/{expected_categories}</code> categorie nel report."
+                            " Nessun risultato incompleto viene presentato come benchmark completo.")
+        return
+    await send_reply_fn(chat_id, _format_v7_report(report, expected_categories=expected_categories, run_label="mirato · categorie deboli" if is_weak_run else None))
+
+
+def _format_v7_report(report: dict[str, Any], *, expected_categories: int = 20, run_label: str | None = None) -> str:
+    """Formatta il report v7 per Telegram HTML."""
+    s   = report.get("summary", {})
+    ts  = (report.get("timestamp") or "")[:16].replace("T", " ")
+    ver = report.get("version", "extended-v7")
+
+    avg   = s.get("avgScore",  "N/A")
+    repl  = s.get("avgReplit", "N/A")
+    curs  = s.get("avgCursor", "N/A")
+    devi  = s.get("avgDevin",  "N/A")
+    manu  = s.get("avgManus",  "N/A")
+    gaps  = s.get("gapCount",  0)
+    verd  = s.get("verdict",   "")
+    canary = s.get("canaryLeaks", 0)
+
+    lines: list[str] = [
+        f"🏆 <b>Benchmark {ver} completato!</b>\n\n"
+        f"📊 <b>Score agente:</b> <code>{avg}/100</code>\n"
+        f"📅 <b>Run:</b> <code>{ts}</code>\n"
+        + (f"🎯 <b>Modalità:</b> <code>{run_label}</code>\n" if run_label else "") + "\n"
+        "📈 <b>Confronto vs riferimenti:</b>\n"
+        f"  • Replit:  <code>{repl}/100</code>\n"
+        f"  • Cursor:  <code>{curs}/100</code>\n"
+        f"  • Devin:   <code>{devi}/100</code>\n"
+        f"  • Manus:   <code>{manu}/100</code>\n"
+    ]
+
+    if verd:
+        lines.append(f"\n📝 <b>Verdetto:</b> {verd}\n")
+    if canary:
+        lines.append(f"⚠️ <b>Canary leak:</b> {canary} task\n")
+
+    # Score per categoria. Una categoria in timeout resta tentata ma non entra
+    # nella media: non va trasformata silenziosamente in uno score pari a zero.
+    tasks = report.get("tasks", [])
+    if tasks:
+        attempted_categories = {str(t.get("cat")) for t in tasks if t.get("cat")}
+        by_cat: dict[str, list[float]] = {}
+        for t in tasks:
+            cat = t.get("cat", "?")
+            sc  = t.get("score")
+            if isinstance(sc, (int, float)):
+                by_cat.setdefault(cat, []).append(float(sc))
+        attempted = s.get("attemptedTaskCount", len(tasks))
+        scored = s.get("scoredTaskCount", sum(len(v) for v in by_cat.values()))
+        skipped = s.get("skippedTaskCount", max(0, attempted - scored))
+        lines.append(
+            f"🧪 <b>Copertura:</b> <code>{len(attempted_categories)}/{expected_categories} categorie tentate · "
+            f"{scored} valutabili · {skipped} non valutabili</code>\n"
+        )
+        if by_cat:
+            lines.append("\n📂 <b>Per categoria:</b>\n")
+            for cat, scores in sorted(by_cat.items()):
+                avg_cat = sum(scores) / len(scores)
+                icon = "🟢" if avg_cat >= 70 else "🟡" if avg_cat >= 50 else "🔴"
+                lines.append(f"  {icon} <code>{avg_cat:5.1f}</code>  {cat}\n")
+
+    failures = report.get("taskFailures", [])
+    if failures:
+        lines.append("\n⚠️ <b>Categorie non valutabili:</b>\n")
+        for failure in failures[:3]:
+            cat = failure.get("cat", "?")
+            reason = str(failure.get("reason", "errore non specificato"))[:100]
+            lines.append(f"  • <code>{cat}</code> — {reason}\n")
+        if len(failures) > 3:
+            lines.append(f"  <i>...e altre {len(failures) - 3}.</i>\n")
+
+    # Gap cards (prime 3)
+    gap_cards = report.get("gapCards", [])
+    if gap_cards:
+        lines.append(f"\n💡 <b>Gap ({gaps} totali):</b>\n")
+        for gc in gap_cards[:3]:
+            gid   = gc.get("id",  "?")
+            gtit  = gc.get("title", gc.get("name", ""))
+            gsev  = gc.get("severity", "")
+            lines.append(f"  • <code>{gid}</code> {gtit}" + (f" [{gsev}]" if gsev else "") + "\n")
+        if gaps > 3:
+            lines.append(f"  <i>...e altri {gaps - 3} gap.</i>\n")
+
+    lines.append("\n🔍 <i>Usa /riepilogo per analisi approfondita.</i>")
+    return "".join(lines)
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+def _read_json(path: str) -> dict[str, Any]:
+    """Lettura JSON sincrona — da eseguire sempre in asyncio.to_thread."""
+    with open(path, encoding="utf-8") as f:
+        return json.load(f)
+
+
+def _load_gap_map() -> tuple[list, list]:
+    """Importa GAPS e CATS da scripts/gap_map.py senza inquinare sys.path.
+
+    FIX-2: usa importlib.util.spec_from_file_location per un import isolato.
+    """
+    gap_map_path = os.path.join(_REPO_ROOT, "scripts", "gap_map.py")
+    if not os.path.exists(gap_map_path):
+        logger.debug("gap_map.py not found at %s", gap_map_path)
+        return [], []
+    try:
+        spec = importlib.util.spec_from_file_location("_gap_map_isolated", gap_map_path)
+        if spec is None or spec.loader is None:
+            return [], []
+        mod = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(mod)  # type: ignore[union-attr]
+        return getattr(mod, "GAPS", []), getattr(mod, "CATS", [])
+    except Exception as exc:
+        logger.warning("_load_gap_map failed: %s", exc)
+        return [], []
+
+
+async def get_smart_summary(chat_id: int) -> str:
+    """Genera riepilogo strutturato: stato sistema + ultimo score + gap priority.
+
+    GAP-BENCH-2: prova prima report v7, fallback a v6.2 per compatibilità.
+    """
+    GAPS, _ = await asyncio.to_thread(_load_gap_map)
+    lines: list[str] = ["📋 <b>Briefing Assistente Proattivo</b>\n\n"]
+    lines.append("🟢 <b>Stato Sistema:</b> Railway operativo\n")
+
+    # Prova v7 per prima
+    v7_exists = await asyncio.to_thread(os.path.exists, _REPORT_V7)
+    v6_exists = await asyncio.to_thread(os.path.exists, _REPORT_V6)
+
+    if v7_exists:
+        try:
+            report: dict[str, Any] = await asyncio.to_thread(_read_json, _REPORT_V7)
+            s   = report.get("summary", {})
+            avg = s.get("avgScore", "N/A")
+            ts  = (report.get("timestamp") or "")[:16].replace("T", " ")
+            ver = report.get("version", "v7")
+            lines.append(f"📊 <b>Ultimo Score ({ver}):</b> <code>{avg}/100</code>\n")
+            lines.append(f"📅 <b>Run:</b> <code>{ts}</code>\n\n")
+
+            # Categorie con score < 50 → alimenta gap priority
+            failed_cats: set[str] = set()
+            for t in report.get("tasks", []):
+                sc = t.get("score")
+                if isinstance(sc, (int, float)) and sc < 50:
+                    failed_cats.add(t.get("cat", "").lower())
+
+            if failed_cats and GAPS:
+                lines.append("💡 <b>Aree prioritarie:</b>\n")
+                for gap in GAPS:
+                    if any(c in failed_cats for c in gap.get("categories", [])):
+                        slug = (
+                            f"feature/{gap['id'].lower()}"
+                            f"-{gap['name'].lower().replace(' ', '-')}"
+                        )
+                        lines.append(f"  • <code>{gap['name']}</code> → <code>{slug}</code>\n")
+            else:
+                lines.append("✨ <b>Nessun gap critico nell'ultimo run.</b>\n")
+        except Exception as exc:
+            logger.warning("get_smart_summary v7 error: %s", exc)
+            lines.append("⚠️ Errore lettura report v7 — esegui /bench per aggiornare.\n")
+
+    elif v6_exists:
+        # Fallback v6.2 — compatibilità
+        try:
+            report = await asyncio.to_thread(_read_json, _REPORT_V6)
+            score = report.get("finalScore", "N/A")
+            ts    = (report.get("timestamp") or "")[:16].replace("T", " ")
+            judge = report.get("judge", "heuristic")
+            lines.append(f"📊 <b>Ultimo Score (v6.2):</b> <code>{score}/100</code> [{judge}]\n")
+            lines.append(f"📅 <b>Run:</b> <code>{ts}</code>\n\n")
+            failed_cats: set[str] = set()
+            for res in report.get("results", []):
+                if res.get("score", {}).get("total", 100) < 50:
+                    rid = res.get("id", "")
+                    if rid.startswith("STRESS_AMB"): failed_cats.add("recovery")
+                    if rid.startswith("STRESS_REC"): failed_cats.add("recovery")
+                    if rid.startswith("STRESS_MEM"): failed_cats.add("memory_context")
+                    if rid.startswith("WEB"):        failed_cats.add("orchestration")
+                    if rid.startswith("CODE"):       failed_cats.add("bug_fix")
+                    if rid.startswith("REASON"):     failed_cats.add("reasoning")
+            if failed_cats and GAPS:
+                lines.append("💡 <b>Aree prioritarie:</b>\n")
+                for gap in GAPS:
+                    if any(c in failed_cats for c in gap.get("categories", [])):
+                        slug = (
+                            f"feature/{gap['id'].lower()}"
+                            f"-{gap['name'].lower().replace(' ', '-')}"
+                        )
+                        lines.append(f"  • <code>{gap['name']}</code> → <code>{slug}</code>\n")
+            else:
+                lines.append("✨ <b>Nessun gap critico nell'ultimo run.</b>\n")
+        except Exception as exc:
+            logger.warning("get_smart_summary v6 error: %s", exc)
+            lines.append("⚠️ Errore lettura report v6.2 — esegui /bench per aggiornare.\n")
+    else:
+        lines.append("📊 <b>Nessun report</b> — esegui <code>/bench</code> per generare dati.\n")
+
+    lines.append("\n🚀 <b>Task in corso:</b> controlla /status per stato live.")
+    return "".join(lines)

api/blackboard.py

@@ -0,0 +1,131 @@
+"""
+backend/api/blackboard.py — S-BB: Blackboard condiviso cross-sessione via Upstash Redis REST.
+
+Riusa UPSTASH_REDIS_REST_URL e UPSTASH_REDIS_REST_TOKEN già configurati
+in backend/api/llm_cache.py — zero setup aggiuntivo.
+
+TTL: 600s (10 minuti) — session-scoped.
+Endpoint:
+  POST /api/blackboard/{session_id}/write  — scrive una entry
+  GET  /api/blackboard/{session_id}/read   — legge tutte le entry
+  DEL  /api/blackboard/{session_id}        — pulisce il blackboard
+
+Pattern: i sub-agenti scrivono via frontend in-memory (agentBlackboard.ts);
+il backend persiste su Upstash per cross-tab/cross-reload continuity.
+"""
+import os
+import json
+import httpx
+import asyncio
+from fastapi import APIRouter, Depends
+from .auth_guard import require_role, AuthRole
+from pydantic import BaseModel
+
+router = APIRouter(prefix="/api/blackboard", tags=["blackboard"], dependencies=[Depends(require_role(AuthRole.MACHINE))])  # GAP-1-fix: router-level auth
+
+_URL   = os.getenv("UPSTASH_REDIS_REST_URL", "")
+_TOKEN = os.getenv("UPSTASH_REDIS_REST_TOKEN", "")
+_TTL   = 600  # 10 minuti
+
+
+class BBEntry(BaseModel):
+    agentId:  str
+    key:      str
+    value:    str
+    severity: str = "info"
+    ts:       float = 0.0
+
+
+async def _redis_post(command: list) -> dict | None:
+    """Esegue un comando Redis via Upstash REST API."""
+    if not _URL or not _TOKEN:
+        return None
+    try:
+        async with httpx.AsyncClient(timeout=2.0) as c:
+            r = await c.post(
+                _URL,
+                json=command,
+                headers={
+                    "Authorization": f"Bearer {_TOKEN}",
+                    "Content-Type": "application/json",
+                },
+            )
+            return r.json() if r.is_success else None
+    except Exception:
+        return None
+
+
+async def _redis_scan(pattern: str) -> list[str]:
+    """Scansiona le chiavi Redis con SCAN paginato via POST (Upstash REST API).
+
+    P40-H: la versione precedente usava cursor fisso "0" → solo il primo batch
+    di 100 chiavi veniva letto. Con >100 entry Redis per sessione le chiavi
+    extra venivano omesse silenziosamente. Fix: loop cursor finché cursor == "0".
+
+    FIX G3: la versione GET usava URL-encoding del pattern (: → %3A, * → %2A).
+    Upstash router path-decodifica %3A → ':' ma il pattern risultante veniva
+    spezzato alla prima '/' → SCAN trovava 0 chiavi su pattern con ':'.
+    La versione POST invia il pattern come stringa JSON → nessun encoding → corretto.
+    """
+    all_keys: list[str] = []
+    cursor = "0"
+    while True:
+        result = await _redis_post(["SCAN", cursor, "MATCH", pattern, "COUNT", "100"])
+        if not result or "result" not in result:
+            break
+        scan_result = result["result"]
+        # Upstash SCAN ritorna [next_cursor, [keys]] o [[next_cursor, [keys]]] (pipeline)
+        if not isinstance(scan_result, list) or len(scan_result) < 2:
+            break
+        cursor = str(scan_result[0])
+        keys = scan_result[1]
+        if isinstance(keys, list):
+            all_keys.extend(keys)
+        # cursor "0" segnala fine iterazione
+        if cursor == "0":
+            break
+    return all_keys
+
+
+@router.post("/{session_id}/write")
+async def bb_write(session_id: str, entry: BBEntry):
+    """Scrive una entry nel blackboard Upstash. Fail-safe: ritorna ok=True anche se Upstash non disponibile."""
+    rkey    = f"bb:{session_id}:{entry.agentId}:{entry.key}"
+    payload = json.dumps({
+        "agentId":  entry.agentId,
+        "key":      entry.key,
+        "value":    entry.value,
+        "severity": entry.severity,
+        "ts":       entry.ts,
+    })
+    # SET key value EX ttl
+    await _redis_post(["SET", rkey, payload, "EX", _TTL])
+    return {"ok": True}
+
+
+@router.get("/{session_id}/read")
+async def bb_read(session_id: str):
+    """Legge tutte le entries del blackboard per la sessione."""
+    keys = await _redis_scan(f"bb:{session_id}:*")
+    if not keys:
+        return {"entries": [], "session_id": session_id}
+
+    mget = await _redis_post(["MGET"] + keys)
+    entries = []
+    if mget and "result" in mget:
+        for v in mget["result"]:
+            if v:
+                try:
+                    entries.append(json.loads(v))
+                except Exception:
+                    pass
+    return {"entries": entries, "session_id": session_id}
+
+
+@router.delete("/{session_id}")
+async def bb_clear(session_id: str):
+    """Pulisce il blackboard al termine della sessione."""
+    keys = await _redis_scan(f"bb:{session_id}:*")
+    if keys:
+        await _redis_post(["DEL"] + keys)
+    return {"ok": True, "deleted": len(keys)}

api/browser.py

@@ -0,0 +1,1037 @@
+"""
+browser.py — Playwright browser automation.
+
+S65  — /screenshot + /navigate stateless (mantenuti per retrocompat)
+S_NEW — /open + /act + /close con sessioni persistenti + DOM Intelligence
+S174 — GET /screenshot/{session_id} snapshot sessione attiva senza azioni
+
+W-NAV aggiornamenti:
+  - MAX_TEXT 3000→6000: più contesto per l'LLM senza rischiare OOM
+  - _goto_with_networkidle(): networkidle per SPA/React/Vue, fallback domcontentloaded
+  - _dismiss_cookie_banner(): auto-dismiss CSS+JS prima dell'estrazione DOM (W-NAV2)
+  - _extract_text_trafilatura(): estrazione mainbody Readability-quality (W-NAV)
+  - /navigate: usa trafilatura per text_content (da 2000→5000 chars utili)
+  - /open: aggiunto text_content via trafilatura nella risposta
+
+Vincoli HF free tier:
+  - Max SESSION_LIMIT sessioni vive (OOM guard: Chromium ~300 MB/sessione)
+  - Timeout sessione: SESSION_TTL_S secondi di inattività
+  - Un solo _browser_lock per aprire nuove sessioni (evita race condition)
+
+Problematiche W-NAV anticipate:
+  - networkidle timeout: pagine con polling infinito (ads/analytics/WebSocket)
+    non raggiungono mai networkidle → timeout catturato, flusso continua
+    (domcontentloaded è già avvenuto come prerequisito → DOM accessibile)
+  - Cookie banner loop: _dismiss_cookie_banner() è idempotente e silenziosa —
+    se fallisce il flusso continua normalmente (banner nella DOM, LLM lo vede
+    e può istruire browser_act per gestirlo manualmente)
+  - trafilatura su pagine non-article (login, dashboard, SPA vuota): restituisce
+    None → fallback a DOM innerText evaluation (pre-esistente, sempre funziona)
+  - get_by_text Playwright API: usiamo page.evaluate() JS per text-matching invece
+    di Locator API (più stabile tra versioni playwright, zero versioning issues)
+"""
+import os
+import asyncio, base64, hashlib, os, time, uuid, logging
+from typing import Optional, Any
+from fastapi import APIRouter, Depends, HTTPException, Request
+from pydantic import BaseModel
+from .auth_guard import require_role, AuthRole
+
+router  = APIRouter(prefix="/api/browser", tags=["browser"])
+_logger = logging.getLogger("browser")
+
+# ─── Costanti ─────────────────────────────────────────────────────────────────
+SESSION_LIMIT  = 2          # max sessioni vive (OOM guard HF free)
+SESSION_TTL_S  = 300        # QF-4: 2→5 min inattività — supporta navigazione multi-step più lunga
+GOTO_TIMEOUT   = 25_000     # QF-4: 15→25s goto — SPA pesanti (React/Next.js) servono più tempo
+ACTION_TIMEOUT = 5_000      # ms per singola azione
+MAX_LINKS      = 25
+MAX_INPUTS     = 20
+MAX_TEXT       = 6000       # W-NAV: alzato da 3000→6000 (più contesto per LLM)
+
+# ─── Lock + registry sessioni ─────────────────────────────────────────────────
+_browser_lock = asyncio.Lock()
+_sessions: dict[str, dict[str, Any]] = {}
+
+# ─── Launch args ottimizzati HF Spaces free ───────────────────────────────────
+_LAUNCH_ARGS = [
+    "--no-sandbox",
+    "--disable-setuid-sandbox",
+    "--disable-dev-shm-usage",
+    "--disable-gpu",
+    "--single-process",
+    "--no-zygote",
+    "--disable-extensions",
+    "--disable-background-networking",
+    "--disable-default-apps",
+    "--mute-audio",
+    # S274-SEC5: rimosso --disable-web-security — disabilita Same-Origin Policy → SSRF via siti visitati
+    # "--disable-web-security",  # RIMOSSO per sicurezza
+    # ARCH-3: ulteriori flag riduzione memoria (HF free tier ~1GB RAM)
+    "--disable-accelerated-2d-canvas",    # disabilita canvas GPU (non usato in headless)
+    "--disable-renderer-backgrounding",   # previene throttling renderer in background
+    "--renderer-process-limit=1",         # max 1 renderer process (headless, no tabs visibili)
+    "--js-flags=--max-old-space-size=200",# limita heap V8 a 200MB per renderer
+]
+
+_UA_MOBILE  = "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15"
+_UA_DESKTOP = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 Chrome/124.0.0.0"
+
+_BLOCKED = [
+    "localhost", "127.0.0.1", "0.0.0.0",
+    "192.168.", "10.0.", "172.16.", "172.17.", "172.18.",
+    "metadata.google", "169.254",
+]
+
+# ─── W-NAV2: Cookie dismiss — selettori CSS prioritizzati ────────────────────
+# Ordine: vendor-specifici (più precisi) → pattern generici (più ampi)
+# Problematica: selettori troppo generici (es. "button") catturano azioni non-cookie
+# → usiamo pattern specifici per namespace (id/class con "cookie/consent/gdpr")
+_COOKIE_DISMISS_SELECTORS = [
+    "#onetrust-accept-btn-handler",                          # OneTrust (ubiquo)
+    "#CybotCookiebotDialogBodyButtonAccept",                 # Cookiebot
+    "#CybotCookiebotDialogBodyLevelButtonLevelOptinAllowAll",
+    "[data-cookiebanner='accept_button']",
+    ".cc-btn.cc-allow",                                      # CookieConsent.js
+    ".cc-accept-all",
+    "#cookie_action_close_header",
+    "#accept-cookies",
+    "#acceptAllCookies",
+    "#acceptCookies",
+    ".cookie-accept-all",
+    ".cookie__btn--accept",
+    "#gdpr-cookie-accept",
+    ".gdpr-accept-all",
+    ".gdpr__btn",
+    "[aria-label='Accept all cookies']",
+    "[aria-label='Accetta tutti i cookie']",
+    "[aria-label='Consenti tutti i cookie']",
+    "[aria-label='Allow all cookies']",
+    "button[id*='cookie'][id*='accept']",
+    "button[id*='accept'][id*='cookie']",
+    "button[class*='cookie'][class*='accept']",
+    ".cookie-consent__accept",
+    ".cookie-notice__accept",
+    ".cookie-banner__accept",
+    "#cookie-accept",
+    ".js-accept-cookies",
+]
+
+# JS fallback: testo-matching su pulsanti visibili
+# Problematica: .innerText può essere "" su elementi visibili ma con solo icone
+# → usiamo .textContent come fallback per innerText
+# Problematica: false positive su "OK" generico (es. dialog di conferma)
+#   → "ok" solo se il genitore contiene "cookie/consent/gdpr" nel className/id
+_COOKIE_DISMISS_JS = """() => {
+    const EXACT = [
+        'accetta tutto', 'accetta tutti', 'accetta tutti i cookie',
+        'accept all', 'accept all cookies', 'allow all', 'allow all cookies',
+        'tout accepter', 'alle akzeptieren', 'aceitar tudo', 'aceptar todo',
+        'i accept all', 'i agree to all',
+    ];
+    const PARTIAL = [
+        'accetta', 'accept cookies', 'allow cookies',
+        'consenti tutto', 'ho capito', 'i accept', 'i agree',
+    ];
+    const isCookieCtx = (el) => {
+        const ctx = (el.id + ' ' + el.className + ' ' +
+                     (el.closest('[class*=cookie],[class*=consent],[class*=gdpr],[id*=cookie],[id*=consent],[id*=gdpr]')?.className || '')
+                    ).toLowerCase();
+        return ctx.includes('cookie') || ctx.includes('consent') || ctx.includes('gdpr') || ctx.includes('privacy');
+    };
+    const btns = Array.from(document.querySelectorAll(
+        'button,a,[role=button],[class*=cookie] *,[class*=consent] *,[id*=cookie] *,[id*=gdpr] *'
+    ));
+    for (const el of btns) {
+        const txt = (el.innerText || el.textContent || '').trim().toLowerCase().replace(/\\s+/g, ' ');
+        if (!txt || txt.length > 60) continue;
+        const s = window.getComputedStyle(el);
+        if (s.display === 'none' || s.visibility === 'hidden' || s.opacity === '0') continue;
+        if (EXACT.includes(txt) || (PARTIAL.some(p => txt.includes(p)) && isCookieCtx(el))) {
+            el.click();
+            return txt.slice(0, 40);
+        }
+    }
+    return null;
+}"""
+
+# ─── DOM Intelligence script ─────────────────────────────────────────────────
+_DOM_SCRIPT = """() => {
+    const links = [...document.querySelectorAll('a[href]')]
+        .filter(a => a.href.startsWith('http') && a.innerText.trim())
+        .slice(0, %d)
+        .map(a => ({
+            text: a.innerText.trim().replace(/\\s+/g, ' ').slice(0, 80),
+            href: a.href,
+            selector: a.id ? '#' + a.id : (a.getAttribute('aria-label')
+                ? '[aria-label="' + a.getAttribute('aria-label') + '"]'
+                : (a.className ? '.' + a.className.split(' ').filter(c=>c&&!c.match(/^[a-z]{1,2}$/)).slice(0,2).join('.') : 'a'))
+        }));
+
+    const inputs = [...document.querySelectorAll(
+        'input:not([type=hidden]),textarea,select,button,[role=button],[role=checkbox],[role=radio],[role=switch],[role=combobox]'
+    )]
+        .filter(el => {
+            const s = window.getComputedStyle(el);
+            return s.display !== 'none' && s.visibility !== 'hidden' && s.opacity !== '0';
+        })
+        .slice(0, %d)
+        .map(el => {
+            let selector = null;
+            const role = el.getAttribute('role') || el.tagName.toLowerCase();
+            if (el.id) selector = '#' + el.id;
+            else if (el.getAttribute('name')) selector = '[name="' + el.getAttribute('name') + '"]';
+            else if (el.getAttribute('aria-label')) selector = '[aria-label="' + el.getAttribute('aria-label') + '"]';
+            else if (el.placeholder) selector = '[placeholder="' + el.placeholder + '"]';
+            else if (el.getAttribute('data-testid')) selector = '[data-testid="' + el.getAttribute('data-testid') + '"]';
+            const tag = el.tagName.toLowerCase();
+            const isChecked = el.checked !== undefined ? el.checked : null;
+            const currentVal = (tag === 'input' || tag === 'textarea') ? (el.value || '') : null;
+            const isDisabled = el.disabled || el.getAttribute('aria-disabled') === 'true';
+            let label = el.getAttribute('aria-label') || el.placeholder || el.getAttribute('name') || el.id;
+            if (!label) {
+                const lbl = el.id ? document.querySelector('label[for="'+el.id+'"]') : el.closest('label');
+                if (lbl) label = lbl.innerText.trim().slice(0, 40);
+            }
+            if (!label) label = el.innerText?.trim().slice(0, 40) || null;
+            return { tag, role, type: el.type || null, label, selector,
+                     value: currentVal, checked: isChecked, disabled: isDisabled || false };
+        })
+        .filter(el => el.label || el.selector);
+
+    const headings = [...document.querySelectorAll('h1,h2,h3')]
+        .slice(0, 8)
+        .map(h => ({ level: h.tagName.toLowerCase(), text: h.innerText.trim().slice(0, 80) }));
+
+    const modals = [...document.querySelectorAll(
+        '[role=dialog],[role=alertdialog],[role=modal],.modal,.dialog,[aria-modal=true]'
+    )]
+        .filter(el => {
+            const s = window.getComputedStyle(el);
+            return s.display !== 'none' && s.visibility !== 'hidden';
+        })
+        .slice(0, 3)
+        .map(el => ({
+            role: el.getAttribute('role') || 'modal',
+            title: el.querySelector('h1,h2,h3,[role=heading]')?.innerText.trim().slice(0,60) || null,
+            selector: el.id ? '#' + el.id : (el.getAttribute('aria-label') ? '[aria-label="'+el.getAttribute('aria-label')+'"]' : '[role="'+(el.getAttribute('role')||'dialog')+'"]'),
+        }));
+
+    const title  = document.title;
+    const desc   = document.querySelector('meta[name=description]')?.content?.slice(0, 200) || null;
+    const mainEl = document.querySelector('main,[role=main],article,.content,#content') || document.body;
+    const text   = mainEl.innerText.replace(/\\s+/g, ' ').trim().slice(0, %d);
+
+    return { title, desc, text, links, inputs, headings, modals };
+}"""
+
+# ─── Helpers ──────────────────────────────────────────────────────────────────
+
+async def _get_ax_tree(page: Any, max_depth: int = 5) -> Optional[dict]:
+    """GAP-AX: Playwright Accessibility Tree — 'screenshot testuale' MCP-style.
+
+    Restituisce una struttura ad albero ARIA che descrive la pagina in modo
+    semantico: ruoli, nomi, stati, relazioni. Usato dall'LLM per interazioni
+    precise senza ambiguità visiva (stile Manus / browser-use).
+
+    Limitazioni sicure:
+    - max_depth=5: alberi profondi generano payload enormi. 5 livelli coprono
+      il 95% delle pagine senza superare ~8KB di JSON.
+    - Timeout 3s: mai blocca il flusso principale (snapshot è sincrono ma può
+      bloccarsi su pagine con ARIA dinamici in aggiornamento continuo).
+    - Ritorna None su qualsiasi errore: campo opzionale, zero impatto.
+    """
+    try:
+        # interesting=True: esclude nodi ARIA nascosti (display:none, aria-hidden)
+        snapshot = await asyncio.wait_for(
+            page.accessibility.snapshot(interesting_only=True),
+            timeout=3.0,
+        )
+        if not snapshot:
+            return None
+        return _trim_ax_tree(snapshot, max_depth)
+    except Exception:
+        return None
+
+
+def _trim_ax_tree(node: dict, depth: int) -> dict:
+    """Riduce ricorsivamente l'albero AX a max_depth livelli.
+
+    Mantiene: role, name, description, value, checked, expanded, required.
+    Scarta: proprietà interne Playwright (nodeId, backendDOMNodeId, ignoredReasons).
+    """
+    KEEP = frozenset({"role", "name", "description", "value", "checked",
+                      "expanded", "required", "haspopup", "level", "pressed",
+                      "selected", "multiselectable", "orientation"})
+    result: dict = {k: v for k, v in node.items() if k in KEEP and v not in (None, False, )}
+    if depth > 0 and node.get("children"):
+        trimmed = [_trim_ax_tree(c, depth - 1) for c in node["children"]]
+        # Filtra nodi completamente vuoti (solo role senza nome né figli)
+        trimmed = [c for c in trimmed if len(c) > 1 or c.get("children")]
+        if trimmed:
+            result["children"] = trimmed
+    return result
+
+
+def _safe_url(url: str) -> bool:
+    low = url.lower()
+    return url.startswith(("http://", "https://")) and not any(b in low for b in _BLOCKED)
+
+
+async def _goto_with_networkidle(page: Any, url: str, timeout: int = GOTO_TIMEOUT) -> None:
+    """
+    Naviga all'URL con wait_until='networkidle' per SPA/React/Vue/Next.js.
+    W-NAV3: never use only domcontentloaded for SPAs — may miss JS-rendered content.
+
+    Comportamento:
+      - networkidle: aspetta 500ms senza richieste HTTP attive (standard per SPA)
+      - Timeout: se la pagina ha polling infinito (ads, analytics, WebSocket keepalive),
+        il timeout scatta DOPO che domcontentloaded è già avvenuto → DOM accessibile.
+        Catturiamo silenziosamente e continuiamo.
+      - wait_for_load_state fallback: su timeout, forza attesa domcontentloaded
+        (già avvenuto, ritorna subito — è solo un safety net)
+
+    Nota: timeout di goto con networkidle NON significa pagina non caricata.
+    Significa che ci sono richieste background attive dopo il caricamento visibile.
+    """
+    try:
+        await page.goto(url, wait_until="networkidle", timeout=timeout)
+    except Exception:
+        # Timeout o navigazione interrotta — il DOM è comunque disponibile
+        try:
+            await page.wait_for_load_state("domcontentloaded", timeout=3000)
+        except Exception:
+            pass  # Anche domcontentloaded fallisce? Procediamo — page.content() funziona comunque
+
+
+async def _dismiss_cookie_banner(page: Any) -> bool:
+    """
+    Auto-dismiss banner cookie prima dell'estrazione DOM.
+    W-NAV2: eseguita dopo ogni _goto_with_networkidle in /open, /navigate, /screenshot.
+
+    Strategia a 2 fasi:
+      Fase 1: CSS selectors vendor-specifici (precisi, zero false positive)
+      Fase 2: JS text-matching su pulsanti visibili (copre CMP custom e traduzioni)
+
+    Silenziosa: non lancia mai, timeout brevi (1.5s per selettore) per non
+    bloccare il flusso. Se fallisce, il banner rimane nel DOM e l'LLM lo vede
+    nei dom.modals → può istruire browser_act per gestirlo manualmente.
+    """
+    # Fase 1: CSS selectors diretti
+    for sel in _COOKIE_DISMISS_SELECTORS:
+        try:
+            el = await page.query_selector(sel)
+            if el:
+                visible = await el.is_visible()
+                if visible:
+                    await el.click(timeout=1500)
+                    await page.wait_for_timeout(300)
+                    _logger.debug("Cookie banner dismissed via CSS: %s", sel)
+                    return True
+        except Exception:
+            continue
+
+    # Fase 2: JS text-matching (CMP custom, traduzioni non standard)
+    try:
+        clicked = await page.evaluate(_COOKIE_DISMISS_JS)
+        if clicked:
+            await page.wait_for_timeout(300)
+            _logger.debug("Cookie banner dismissed via JS text-match: '%s'", clicked)
+            return True
+    except Exception as _exc:
+        _logger.debug("[browser] silenced %s", type(_exc).__name__)  # noqa: BLE001
+
+    return False
+
+
+async def _extract_text_trafilatura(page: Any, url: str = "", max_chars: int = MAX_TEXT) -> str:
+    """
+    Estrae il testo mainbody via trafilatura (Readability-quality).
+    Fallback: DOM innerText evaluation se trafilatura non disponibile o restituisce poco.
+
+    Problematiche:
+      - trafilatura su SPA: l'HTML di page.content() include il DOM post-JS →
+        trafilatura può estrarre più testo rispetto all'HTML statico iniziale
+      - trafilatura su pagine non-article (login, 404): restituisce None →
+        fallback a DOM innerText (sempre disponibile)
+      - max_chars applicato sia a trafilatura che al fallback
+    """
+    try:
+        import trafilatura  # type: ignore[import-untyped]
+        html = await page.content()
+        extracted = trafilatura.extract(
+            html,
+            url=url or None,
+            include_comments=False,
+            include_tables=True,
+            include_images=False,
+            deduplicate=True,
+            favor_recall=True,
+        )
+        if extracted and len(extracted.strip()) > 200:
+            return extracted[:max_chars]
+    except Exception as _exc:
+        _logger.debug("[browser] silenced %s", type(_exc).__name__)  # noqa: BLE001
+
+    # Fallback: DOM evaluation (pre-esistente, sempre funziona)
+    try:
+        text = await page.evaluate(
+            "() => (document.querySelector('main,[role=main],article,.content,#content') || document.body)"
+            f".innerText.replace(/\\s+/g,' ').trim().slice(0,{max_chars})"
+        )
+        return str(text)
+    except Exception:
+        return ""
+
+
+async def _try_persist_screenshot(url: str, png_b64: str, title: str) -> None:
+    try:
+        sb_url = os.getenv("SUPABASE_URL", "")
+        sb_key = os.getenv("SUPABASE_ANON_KEY") or os.getenv("SUPABASE_KEY", "")
+        if not (sb_url and sb_key):
+            return
+        from supabase import create_client
+        sb  = create_client(sb_url, sb_key)
+        fid = hashlib.sha256(url.encode()).hexdigest()[:32]
+        now = int(time.time() * 1000)
+        sb.table("vfs_files").upsert({
+            "id": fid, "path": f"/browser-screenshots/{fid}.png",
+            "language": "image", "content": png_b64, "conversation_id": None,
+            "created_at": now, "updated_at": now,
+            "metadata": {"source_url": url, "title": title},
+        }).execute()
+    except Exception as _e:
+        _logger.warning("_try_persist_screenshot: Supabase upsert failed: %s", _e)
+
+
+async def _make_context(browser: Any, width: int, height: int, mobile: bool) -> Any:
+    return await browser.new_context(
+        viewport={"width": 390 if mobile else width, "height": height},
+        is_mobile=mobile,
+        user_agent=_UA_MOBILE if mobile else _UA_DESKTOP,
+    )
+
+
+async def _execute_actions(page: Any, actions: list) -> None:
+    for action in actions:
+        sel = action.selector or ""
+        try:
+            if action.type == "click" and sel:
+                await page.click(sel, timeout=ACTION_TIMEOUT)
+                await page.wait_for_load_state("domcontentloaded", timeout=5000)
+            elif action.type == "click" and action.x is not None and action.y is not None:
+                # GAP-CLICK: fallback coordinate per elementi senza selector DOM
+                await page.mouse.click(action.x, action.y)
+                await page.wait_for_load_state("domcontentloaded", timeout=5000)
+            elif action.type == "fill" and sel:
+                await page.fill(sel, action.value or "", timeout=ACTION_TIMEOUT)
+            elif action.type == "select" and sel:
+                await page.select_option(sel, action.value or "", timeout=ACTION_TIMEOUT)
+            elif action.type == "press" and sel:
+                await page.press(sel, action.key or "Enter", timeout=ACTION_TIMEOUT)
+            elif action.type == "hover" and sel:
+                await page.hover(sel, timeout=ACTION_TIMEOUT)
+            elif action.type == "wait_for" and sel:
+                await page.wait_for_selector(sel, timeout=ACTION_TIMEOUT)
+            elif action.type == "wait":
+                await page.wait_for_timeout(min(action.ms or 500, 5000))
+            elif action.type == "scroll":
+                pct = float(action.value or "50")
+                await page.evaluate(f"window.scrollTo(0, document.body.scrollHeight * {pct / 100})")
+        except Exception as e:
+            _logger.debug("Action %s on '%s' failed: %s", action.type, sel, e)
+
+
+# ─── ARCH-7: Browserless.io CDP fallback ─────────────────────────────────────
+# Se BROWSERLESS_TOKEN è impostato su Railway, usa CDP remoto (zero RAM locale).
+# Fallback automatico a Chromium locale se token assente o connessione fallisce.
+_BROWSERLESS_WS = "wss://chrome.browserless.io"
+
+async def _get_browser_instance():
+    """
+    Ritorna (pw, browser, is_remote).
+    is_remote=True  → CDP remoto: non chiamare browser.close() né pw.stop().
+    is_remote=False → Chromium locale: cleanup normale.
+    """
+    from playwright.async_api import async_playwright
+    pw    = await async_playwright().start()
+    token = os.getenv("BROWSERLESS_TOKEN", "").strip()
+    if token:
+        try:
+            ws      = f"{_BROWSERLESS_WS}?token={token}"
+            browser = await pw.chromium.connect_over_cdp(ws, timeout=10_000)
+            _logger.info("Browser: Browserless.io CDP ✓ (zero RAM locale)")
+            return pw, browser, True
+        except Exception as _e:
+            _logger.warning("Browser: CDP non disponibile (%s) — fallback locale", _e)
+    browser = await pw.chromium.launch(headless=True, args=_LAUNCH_ARGS)
+    return pw, browser, False
+
+
+async def _close_session(sid: str, reason: str = "explicit") -> None:
+    sess = _sessions.pop(sid, None)
+    if not sess:
+        return
+    is_remote = sess.get("is_remote", False)
+    try:
+        await sess["context"].close()
+        if not is_remote:
+            await sess["browser"].close()
+        # pw.stop() sempre: chiude la connessione playwright (locale: termina processo; CDP: disconnette)
+        await sess["pw"].stop()
+        _logger.info("Session %s closed (%s, remote=%s)", sid, reason, is_remote)
+    except Exception as e:
+        _logger.warning("Session %s close error: %s", sid, e)
+
+
+async def _session_cleanup_loop() -> None:
+    while True:
+        await asyncio.sleep(30)  # ARCH-3: check più frequente (era 60s)
+        now     = time.time()
+        expired = [sid for sid, s in list(_sessions.items())
+                   if now - s["last_used"] > SESSION_TTL_S]
+        for sid in expired:
+            await _close_session(sid, "TTL expired")
+
+
+def _log_browser_bg_exc(t):  # BUGFIX: log eccezioni da create_task fire-and-forget
+    if not t.cancelled() and t.exception():
+        _logger.warning("[browser] bg task raised: %s", t.exception())
+
+
+def _start_cleanup() -> None:
+    try:
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            asyncio.create_task(_session_cleanup_loop()).add_done_callback(_log_browser_bg_exc)  # BUGFIX
+    except Exception as _e:
+        _logger.warning("_start_cleanup: create_task failed — cleanup loop not running: %s", _e)
+
+
+# ─── Models ───────────────────────────────────────────────────────────────────
+
+class BrowserAction(BaseModel):
+    type: str
+    selector: Optional[str] = None
+    value:    Optional[str] = None
+    key:      Optional[str] = None
+    ms:       Optional[int] = None
+    x:        Optional[float] = None   # GAP-CLICK: coordinata X per click-by-position
+    y:        Optional[float] = None   # GAP-CLICK: coordinata Y per click-by-position
+
+class ScreenshotRequest(BaseModel):
+    url:     str
+    width:   int  = 1280
+    height:  int  = 800
+    mobile:  bool = False
+    wait_ms: int  = 2000
+
+class NavigateRequest(BaseModel):
+    url:     str
+    actions: list[BrowserAction] = []
+    width:   int  = 1280
+    height:  int  = 800
+    mobile:  bool = False
+    wait_ms: int  = 2000
+
+class BrowserOpenRequest(BaseModel):
+    url:     str
+    actions: list[BrowserAction] = []
+    mobile:  bool = False
+    width:   int  = 1280
+    wait_ms: int  = 1500
+
+class BrowserActRequest(BaseModel):
+    session_id:      str
+    actions:         list[BrowserAction]
+    wait_ms:         int  = 1000
+    take_screenshot: bool = True
+
+class BrowserCloseRequest(BaseModel):
+    session_id: str
+
+class DomSnapshot(BaseModel):
+    title:    Optional[str]  = None
+    desc:     Optional[str]  = None
+    text:     Optional[str]  = None
+    links:    list[dict]     = []
+    inputs:   list[dict]     = []
+    headings: list[dict]     = []
+    modals:   list[dict]     = []
+
+class BrowserResult(BaseModel):
+    ok:             bool
+    session_id:     Optional[str] = None
+    screenshot_b64: Optional[str] = None
+    title:          Optional[str] = None
+    url:            Optional[str] = None
+    text_content:   Optional[str] = None
+    dom:            Optional[DomSnapshot] = None
+    ax_tree:        Optional[dict] = None  # GAP-AX: Playwright Accessibility Tree (MCP-style)
+    error:          Optional[str] = None
+    warnings:       list[str]     = []
+
+
+# ─── verify_goal_browser ──────────────────────────────────────────────────────
+# Sprint 3b ITEM 8
+async def verify_goal_browser(
+    goal: str,
+    url: str,
+    requirements: "list | None" = None,
+    timeout_s: float = 30.0,
+) -> dict:
+    if not _safe_url(url):
+        return {"ok": False, "overall": "UNKNOWN", "per_criterion": {}, "error": "URL non consentita"}
+
+    # S701: se requirements=None, fallback a basic DOM check (era UNKNOWN immediato)
+    # Prima: 90%+ dei casi usciva subito senza verificare nulla.
+    # Ora: check DOM non-empty + zero white screen + JS error interception.
+    if not requirements:
+        try:
+            import playwright  # noqa: F401
+        except ImportError:
+            return {"ok": True, "overall": "UNKNOWN", "per_criterion": {}, "error": "playwright non installato"}
+        try:
+            from playwright.async_api import async_playwright
+            _js_errs: list[str] = []
+            async with async_playwright() as _pw2:
+                _b2 = await asyncio.wait_for(
+                    _pw2.chromium.launch(headless=True, args=_LAUNCH_ARGS), timeout=10.0)
+                _ctx2 = await _b2.new_context(viewport={"width": 1280, "height": 800}, user_agent=_UA_DESKTOP)
+                _pg2 = await _ctx2.new_page()
+                _pg2.on("pageerror", lambda e: _js_errs.append(str(e)))
+                try:
+                    await asyncio.wait_for(
+                        _goto_with_networkidle(_pg2, url, GOTO_TIMEOUT),
+                        timeout=min(timeout_s, 15.0),
+                    )
+                    await _pg2.wait_for_timeout(600)
+                    _body_txt = await _pg2.evaluate("document.body ? document.body.innerText.trim() : ''")
+                    _body_html = await _pg2.evaluate("document.body ? document.body.innerHTML.trim() : ''")
+                    _title2 = await _pg2.title()
+                finally:
+                    await _ctx2.close()
+                    await _b2.close()
+            _is_white = len(_body_txt) < 5 and len(_body_html) < 30
+            _has_js_err = bool(_js_errs)
+            if _is_white:
+                _overall2 = "FAIL"
+                _crit2 = {"dom_not_empty": "FAIL", "js_errors": "PASS" if not _has_js_err else "FAIL"}
+            elif _has_js_err:
+                _overall2 = "FAIL"
+                _crit2 = {"dom_not_empty": "PASS", "js_errors": "FAIL"}
+            else:
+                _overall2 = "PASS"
+                _crit2 = {"dom_not_empty": "PASS", "js_errors": "PASS"}
+            # S701 R5: telemetria DOM check
+            try:
+                from api.state import increment_stat as _inc_dom
+                _inc_dom("browser_dom_check_pass" if _overall2 == "PASS" else "browser_dom_check_fail")
+            except Exception as _exc:
+                _logger.debug("[browser] silenced %s", type(_exc).__name__)  # noqa: BLE001
+            return {"ok": True, "overall": _overall2, "per_criterion": _crit2,
+                    "error": None, "title": _title2, "js_errors": _js_errs[:3]}
+        except asyncio.TimeoutError:
+            return {"ok": True, "overall": "UNKNOWN", "per_criterion": {}, "error": "timeout"}
+        except Exception as _be:
+            return {"ok": True, "overall": "UNKNOWN", "per_criterion": {}, "error": str(_be)[:200]}
+    try:
+        import playwright  # noqa: F401
+    except ImportError:
+        return {
+            "ok": True, "overall": "UNKNOWN", "per_criterion": {},
+            "error": "playwright non installato — browser verify disabilitato",
+        }
+
+    per_criterion: dict[str, str] = {}
+
+    try:
+        from playwright.async_api import async_playwright
+        async with async_playwright() as _pw:
+            _browser = await _pw.chromium.launch(headless=True, args=_LAUNCH_ARGS)
+            _ctx = await _browser.new_context(
+                viewport={"width": 1280, "height": 800},
+                user_agent=_UA_DESKTOP,
+            )
+            _page = await _ctx.new_page()
+            try:
+                # W-NAV3: usa networkidle anche per verify_goal_browser
+                await asyncio.wait_for(
+                    _goto_with_networkidle(_page, url, GOTO_TIMEOUT),
+                    timeout=min(timeout_s, GOTO_TIMEOUT / 1000),
+                )
+                await _page.wait_for_timeout(1000)
+
+                _criteria: list[str] = []
+                for _req in (requirements or [])[:5]:
+                    _ac = getattr(_req, "acceptance_criteria", None) or []
+                    _criteria.extend(str(c) for c in _ac[:2])
+                _criteria = _criteria[:5]
+
+                for _crit in _criteria:
+                    _low = _crit.lower()
+                    _verdict = "UNKNOWN"
+                    try:
+                        if any(k in _low for k in ["login", "autenti", "sessione", "http 200", "200 ok"]):
+                            _el = await _page.query_selector("form, input[type=password], input[type=email]")
+                            _verdict = "PASS" if _el else "FAIL"
+                        elif any(k in _low for k in ["crud", "lista", "record", "endpoint", "array", "json"]):
+                            _body = await _page.evaluate("() => document.body.innerText.slice(0, 3000)")
+                            _verdict = "PASS" if len(str(_body)) > 100 else "FAIL"
+                        elif any(k in _low for k in ["dashboard", "dati", "metriche", "renderizza", "mostra"]):
+                            _el = await _page.query_selector("main, [role=main], .dashboard, #app, #root, table, chart")
+                            _verdict = "PASS" if _el else "FAIL"
+                        elif any(k in _low for k in ["form", "validaz", "campo", "submit", "bottone"]):
+                            _el = await _page.query_selector("form, input, textarea, button[type=submit]")
+                            _verdict = "PASS" if _el else "FAIL"
+                        elif any(k in _low for k in ["errore", "error", "400", "401", "403", "fallisce"]):
+                            _verdict = "UNKNOWN"
+                        else:
+                            _title = await _page.title()
+                            _verdict = "PASS" if _title else "FAIL"
+                    except Exception:
+                        _verdict = "UNKNOWN"
+                    per_criterion[_crit[:80]] = _verdict
+            finally:
+                await _ctx.close()
+                await _browser.close()
+
+        _pass_n = sum(1 for v in per_criterion.values() if v == "PASS")
+        _total  = len(per_criterion)
+        if _total == 0:
+            _overall = "UNKNOWN"
+        elif _pass_n / _total >= 0.5:
+            _overall = "PASS"
+        else:
+            _overall = "FAIL"
+
+        return {"ok": True, "overall": _overall, "per_criterion": per_criterion, "error": None}
+
+    except ImportError:
+        return {"ok": False, "overall": "UNKNOWN", "per_criterion": {}, "error": "Playwright non installato"}
+    except Exception as _e:
+        return {"ok": False, "overall": "UNKNOWN", "per_criterion": per_criterion, "error": str(_e)[:300]}  # S588
+
+
+# ─── _take_screenshot (internal helper) ──────────────────────────────────────
+
+async def _take_screenshot(
+    url: str,
+    mobile: bool = False,
+    width: int = 1280,
+    height: int = 800,
+    wait_ms: int = 1500,
+) -> dict:
+    """
+    Wrapper interno per screenshot Playwright headless. (GAP-6-fix)
+    Usato da gemini_vision.py senza passare per la route HTTP.
+    Ritorna: {"ok": bool, "screenshot_b64": str, "title": str, "url": str}
+    """
+    if not _safe_url(url):
+        return {"ok": False, "error": "URL non consentita", "screenshot_b64": "", "title": url, "url": url}
+    async with _browser_lock:
+        try:
+            from playwright.async_api import async_playwright
+            async with async_playwright() as pw:
+                browser = await pw.chromium.launch(headless=True, args=_LAUNCH_ARGS)
+                ctx = await _make_context(browser, width, height, mobile)
+                page = await ctx.new_page()
+                try:
+                    await _goto_with_networkidle(page, url, GOTO_TIMEOUT)
+                    await _dismiss_cookie_banner(page)
+                    await page.wait_for_timeout(wait_ms)
+                    png     = await page.screenshot(type="png", full_page=False)
+                    title   = await page.title()
+                    png_b64 = base64.b64encode(png).decode()
+                    asyncio.create_task(_try_persist_screenshot(url, png_b64, title))
+                    return {"ok": True, "screenshot_b64": png_b64, "title": title, "url": page.url}
+                except Exception as _e:
+                    return {"ok": False, "error": str(_e)[:500], "screenshot_b64": "", "title": url, "url": url}
+                finally:
+                    await ctx.close()
+                    await browser.close()
+        except Exception as _e:
+            return {"ok": False, "error": str(_e)[:500], "screenshot_b64": "", "title": url, "url": url}
+
+
+# ─── /screenshot ─────────────────────────────────────────────────────────────
+
+@router.post("/screenshot", response_model=BrowserResult)
+async def browser_screenshot(req: ScreenshotRequest, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
+    """Screenshot headless di una pagina web (stateless)."""
+    if not _safe_url(req.url):
+        raise HTTPException(400, "URL non consentita")
+    async with _browser_lock:
+        try:
+            from playwright.async_api import async_playwright
+            async with async_playwright() as pw:
+                browser = await pw.chromium.launch(headless=True, args=_LAUNCH_ARGS)
+                ctx     = await _make_context(browser, req.width, req.height, req.mobile)
+                page    = await ctx.new_page()
+                try:
+                    # W-NAV3: networkidle per SPA
+                    await _goto_with_networkidle(page, req.url, GOTO_TIMEOUT)
+                    # W-NAV2: dismiss cookie banner prima dello screenshot
+                    await _dismiss_cookie_banner(page)
+                    await page.wait_for_timeout(req.wait_ms)
+                    png     = await page.screenshot(type="png", full_page=False)
+                    title   = await page.title()
+                    png_b64 = base64.b64encode(png).decode()
+                    asyncio.create_task(_try_persist_screenshot(req.url, png_b64, title)).add_done_callback(_log_browser_bg_exc)  # BUGFIX
+                    return BrowserResult(ok=True, screenshot_b64=png_b64, title=title, url=page.url)
+                except Exception as e:
+                    return BrowserResult(ok=False, error=str(e)[:500])  # S599: 300→500
+                finally:
+                    await ctx.close()
+                    await browser.close()
+        except Exception as e:
+            return BrowserResult(ok=False, error=str(e)[:500])
+
+
+# ─── /navigate ────────────────────────────────────────────────────────────────
+
+@router.post("/navigate", response_model=BrowserResult)
+async def browser_navigate(req: NavigateRequest, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
+    """
+    Naviga, esegui azioni, restituisce screenshot + testo (stateless).
+    W-NAV: text_content ora estratto via trafilatura (da 2000→5000 chars utili).
+    """
+    if not _safe_url(req.url):
+        raise HTTPException(400, "URL non consentita")
+    async with _browser_lock:
+        try:
+            from playwright.async_api import async_playwright
+            async with async_playwright() as pw:
+                browser = await pw.chromium.launch(headless=True, args=_LAUNCH_ARGS)
+                ctx     = await _make_context(browser, req.width, req.height, req.mobile)
+                page    = await ctx.new_page()
+                try:
+                    # W-NAV3: networkidle per SPA
+                    await _goto_with_networkidle(page, req.url, GOTO_TIMEOUT)
+                    # W-NAV2: dismiss cookie prima delle azioni
+                    await _dismiss_cookie_banner(page)
+                    await page.wait_for_timeout(500)
+                    await _execute_actions(page, req.actions)
+                    await page.wait_for_timeout(req.wait_ms)
+
+                    png   = await page.screenshot(type="png", full_page=False)
+                    title = await page.title()
+                    # W-NAV: trafilatura estrae mainbody, molto più testo utile
+                    text  = await _extract_text_trafilatura(page, req.url, max_chars=5000)
+
+                    png_b64 = base64.b64encode(png).decode()
+                    asyncio.create_task(_try_persist_screenshot(page.url, png_b64, title)).add_done_callback(_log_browser_bg_exc)  # BUGFIX
+                    ax_tree = await _get_ax_tree(page)  # GAP-AX
+                    return BrowserResult(
+                        ok=True, screenshot_b64=png_b64, title=title,
+                        url=page.url, text_content=text[:5000] if text else None,
+                        ax_tree=ax_tree,
+                    )
+                except Exception as e:
+                    return BrowserResult(ok=False, error=str(e)[:500])
+                finally:
+                    await ctx.close()
+                    await browser.close()
+        except Exception as e:
+            return BrowserResult(ok=False, error=str(e)[:500])
+
+
+# ─── /open ────────────────────────────────────────────────────────────────────
+
+@router.post("/open", response_model=BrowserResult)
+async def browser_open(
+    req: BrowserOpenRequest, request: Request,
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),  # P19-SEC2-1: era fail-open
+):
+    """
+    Apre una sessione Playwright persistente, naviga all'URL, restituisce
+    session_id + screenshot + mappa DOM + text_content (trafilatura).
+    """
+    if not _safe_url(req.url):
+        raise HTTPException(400, "URL non consentita")
+
+    if len(_sessions) >= SESSION_LIMIT:
+        oldest = min(_sessions, key=lambda sid: _sessions[sid]["last_used"])
+        await _close_session(oldest, "OOM guard")
+
+    async with _browser_lock:
+        try:
+            # ARCH-7: CDP remoto (Browserless) se BROWSERLESS_TOKEN, else locale
+            pw, browser, _is_remote = await _get_browser_instance()
+            ctx     = await _make_context(browser, req.width, 800, req.mobile)
+            page    = await ctx.new_page()
+
+            # W-NAV3: networkidle per SPA
+            await _goto_with_networkidle(page, req.url, GOTO_TIMEOUT)
+            # W-NAV2: dismiss cookie prima dell'estrazione DOM
+            await _dismiss_cookie_banner(page)
+            await page.wait_for_timeout(500)
+            await _execute_actions(page, req.actions)
+            await page.wait_for_timeout(req.wait_ms)
+
+            png     = await page.screenshot(type="png", full_page=False)
+            title   = await page.title()
+            png_b64 = base64.b64encode(png).decode()
+            dom_raw = await page.evaluate(_DOM_SCRIPT % (MAX_LINKS, MAX_INPUTS, MAX_TEXT))
+            # W-NAV: text_content via trafilatura (aggiunto — prima non era nella risposta /open)
+            text    = await _extract_text_trafilatura(page, req.url, max_chars=MAX_TEXT)
+
+            sid = uuid.uuid4().hex[:16]
+            _sessions[sid] = {
+                "pw": pw, "browser": browser, "context": ctx, "page": page,
+                "created_at": time.time(), "last_used": time.time(), "url": page.url,
+                "click_history": [],
+                "visited_urls":  [page.url],
+                "action_log":    [],
+                "is_remote":     _is_remote,  # ARCH-7: True=CDP, False=locale
+            }
+            asyncio.create_task(_try_persist_screenshot(page.url, png_b64, title)).add_done_callback(_log_browser_bg_exc)  # BUGFIX
+
+            dom = DomSnapshot(**dom_raw) if isinstance(dom_raw, dict) else None
+            ax_tree = await _get_ax_tree(page)  # GAP-AX: Accessibility Tree MCP-style
+            return BrowserResult(
+                ok=True, session_id=sid,
+                screenshot_b64=png_b64, title=title, url=page.url,
+                dom=dom,
+                text_content=text[:MAX_TEXT] if text else None,
+                ax_tree=ax_tree,
+            )
+        except Exception as e:
+            return BrowserResult(ok=False, error=str(e)[:500])  # S603: 400→500
+
+
+# ─── /act ─────────────────────────────────────────────────────────────────────
+
+@router.post("/act", response_model=BrowserResult)
+async def browser_act(
+    req: BrowserActRequest, request: Request,
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),  # P19-SEC2-1: era fail-open
+):
+    """
+    Esegue azioni su una sessione aperta.
+    Restituisce screenshot + mappa DOM + warnings anti-loop.
+    """
+    sess = _sessions.get(req.session_id)
+    if not sess:
+        raise HTTPException(404, f"Sessione {req.session_id} non trovata o scaduta")
+
+    sess["last_used"] = time.time()
+    page = sess["page"]
+    warnings: list[str] = []
+
+    CLICK_HISTORY_MAX = 20
+    LOOP_THRESHOLD    = 3
+    for action in req.actions:
+        if action.type == "click" and action.selector:
+            history: list[str] = sess.get("click_history", [])
+            repeat_count = history.count(action.selector)
+            if repeat_count >= LOOP_THRESHOLD:
+                warnings.append(
+                    f"⚠️ ANTI-LOOP: selettore '{action.selector}' già cliccato "
+                    f"{repeat_count}x — cambia strategia (prova altro selettore, scroll, modal, ecc.)"
+                )
+            history.append(action.selector)
+            sess["click_history"] = history[-CLICK_HISTORY_MAX:]
+
+    try:
+        url_before = page.url
+        await _execute_actions(page, req.actions)
+        await page.wait_for_timeout(req.wait_ms)
+
+        url_after = page.url
+        sess["url"] = url_after
+
+        visited: list[str] = sess.get("visited_urls", [])
+        if url_after not in visited:
+            visited.append(url_after)
+            sess["visited_urls"] = visited[-30:]
+
+        action_log: list[dict] = sess.get("action_log", [])
+        for a in req.actions:
+            action_log.append({
+                "type": a.type, "selector": a.selector,
+                "value": a.value, "url_after": url_after,
+            })
+        sess["action_log"] = action_log[-50:]
+
+        title   = await page.title()
+        dom_raw = await page.evaluate(_DOM_SCRIPT % (MAX_LINKS, MAX_INPUTS, MAX_TEXT))
+        dom     = DomSnapshot(**dom_raw) if isinstance(dom_raw, dict) else None
+
+        if dom and dom.modals:
+            modal_titles = [m.get("title") or m.get("role", "modal") for m in dom.modals]
+            warnings.append(
+                f"🔔 MODAL RILEVATO: {', '.join(str(t) for t in modal_titles)} "
+                "— potrebbe bloccare le azioni. Chiudilo prima di continuare."
+            )
+
+        ax_tree = await _get_ax_tree(page) if req.take_screenshot else None  # GAP-AX
+        result = BrowserResult(
+            ok=True, session_id=req.session_id,
+            url=page.url, title=title, dom=dom, warnings=warnings,
+            ax_tree=ax_tree,
+        )
+
+        if req.take_screenshot:
+            png             = await page.screenshot(type="png", full_page=False)
+            png_b64         = base64.b64encode(png).decode()
+            result.screenshot_b64 = png_b64
+            asyncio.create_task(_try_persist_screenshot(page.url, png_b64, title)).add_done_callback(_log_browser_bg_exc)  # BUGFIX
+
+        return result
+    except Exception as e:
+        return BrowserResult(ok=False, session_id=req.session_id, error=str(e)[:500], warnings=warnings)  # S603
+
+
+# ─── /close ───────────────────────────────────────────────────────────────────
+
+@router.post("/close", response_model=BrowserResult)
+async def browser_close(req: BrowserCloseRequest, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
+    """Chiude esplicitamente una sessione persistente e libera risorse."""
+    if req.session_id not in _sessions:
+        return BrowserResult(ok=True, session_id=req.session_id)
+    await _close_session(req.session_id, "explicit")
+    return BrowserResult(ok=True, session_id=req.session_id)
+
+
+# ─── GET /screenshot/{session_id} ─────────────────────────────────────────────
+
+@router.get("/screenshot/{session_id}", response_model=BrowserResult)
+async def browser_session_screenshot(session_id: str, full_page: bool = False, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
+    """Snapshot della pagina corrente senza azioni. Aggiorna last_used."""
+    sess = _sessions.get(session_id)
+    if not sess:
+        raise HTTPException(404, f"Sessione {session_id} non trovata o scaduta")
+
+    sess["last_used"] = time.time()
+    page = sess["page"]
+
+    try:
+        png     = await page.screenshot(type="png", full_page=full_page)
+        title   = await page.title()
+        png_b64 = base64.b64encode(png).decode()
+        asyncio.create_task(_try_persist_screenshot(page.url, png_b64, title)).add_done_callback(_log_browser_bg_exc)  # BUGFIX
+        return BrowserResult(
+            ok=True, session_id=session_id,
+            screenshot_b64=png_b64, title=title, url=page.url,
+        )
+    except Exception as e:
+        return BrowserResult(ok=False, session_id=session_id, error=str(e)[:500])  # S603
+
+
+# ─── /sessions ────────────────────────────────────────────────────────────────
+
+@router.get("/sessions")
+async def list_sessions(role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
+    now = time.time()
+    return {
+        sid: {
+            "url":    s["url"],
+            "idle_s": int(now - s["last_used"]),
+            "age_s":  int(now - s["created_at"]),
+        }
+        for sid, s in _sessions.items()
+    }
+
+
+_start_cleanup()

api/coding.py

@@ -0,0 +1,220 @@
+"""api/coding.py — Code analysis endpoint (S437→P37-PA)
+
+S437: CodeAgent Ollama rimosso. Sostituito con python_analyze reale.
+      Analisi statica Python via ast (zero deps) + complessità ciclomatica + metriche.
+      Opzionale: esecuzione in sandbox isolata via exec_sandbox.
+
+Endpoints:
+  POST /code/analyze   — analisi statica Python (+ opzionale esecuzione sandbox)
+  POST /code/session   — stub 501 (rimosso Ollama S437 — usa /api/agent/run)
+
+Sprint P37-PA — 2026-06-21
+"""
+from __future__ import annotations
+
+import ast
+import logging
+import textwrap
+import time
+from typing import Optional, List
+
+from fastapi import APIRouter, Depends
+from .auth_guard import require_role, AuthRole
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel, field_validator
+
+_logger = logging.getLogger("api.coding")
+
+router = APIRouter(prefix="/code", tags=["coding"])
+
+# ── Constants ─────────────────────────────────────────────────────────────────
+_MAX_CODE_LEN   = 50_000   # byte max per /code/analyze
+_MAX_RUN_LINES  = 200      # righe max per esecuzione sandbox
+
+
+# ── Request / Response schemas ────────────────────────────────────────────────
+class AnalyzeReq(BaseModel):
+    filepath: str = "code.py"
+    content:  str
+    goal:     str = ""
+    run_code: bool = False   # se True → esegue in sandbox dopo analisi
+
+    @field_validator("content")
+    @classmethod
+    def _check_len(cls, v: str) -> str:
+        if len(v) > _MAX_CODE_LEN:
+            raise ValueError(f"content troppo grande ({len(v)} byte, max {_MAX_CODE_LEN})")
+        return v
+
+
+class SessionReq(BaseModel):
+    goal:  str
+    files: List[dict]
+    model: Optional[str] = None
+
+
+# ── AST helpers ───────────────────────────────────────────────────────────────
+
+def _lint_python(code: str) -> dict:
+    """Analisi sintattica via ast.parse — zero dipendenze aggiuntive."""
+    try:
+        ast.parse(code, mode="exec")
+        return {"ok": True, "errors": []}
+    except SyntaxError as e:
+        return {"ok": False, "errors": [f"SyntaxError riga {e.lineno}: {e.msg} ('{e.text or ''}')".strip()]}
+    except Exception as e:
+        return {"ok": False, "errors": [str(e)[:300]]}
+
+
+def _complexity(tree: ast.AST) -> dict:
+    """
+    Complessità ciclomatica approssimata:
+    CC = 1 + somma rami decisionali (if/elif, while, for, except, with, assert, and/or booleani).
+    Per funzione e per modulo.
+    """
+    def _cc_node(node: ast.AST) -> int:
+        """Conta branch points in un sotto-albero."""
+        count = 0
+        for n in ast.walk(node):
+            if isinstance(n, (ast.If, ast.While, ast.For, ast.ExceptHandler,
+                               ast.With, ast.AsyncFor, ast.AsyncWith)):
+                count += 1
+            elif isinstance(n, ast.BoolOp) and isinstance(n.op, (ast.And, ast.Or)):
+                count += len(n.values) - 1
+            elif isinstance(n, ast.Assert):
+                count += 1
+        return count
+
+    funcs: list[dict] = []
+    for node in ast.walk(tree):
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            cc = 1 + _cc_node(node)
+            funcs.append({
+                "name":        node.name,
+                "line":        node.lineno,
+                "cc":          cc,
+                "risk":        "HIGH" if cc > 10 else "MEDIUM" if cc > 5 else "LOW",
+            })
+
+    total_cc = 1 + _cc_node(tree)
+    return {
+        "module_cc":   total_cc,
+        "functions":   sorted(funcs, key=lambda f: -f["cc"])[:20],  # top 20 per cc
+        "avg_func_cc": round(sum(f["cc"] for f in funcs) / len(funcs), 1) if funcs else 0,
+    }
+
+
+def _imports(tree: ast.AST) -> list[str]:
+    """Lista moduli importati."""
+    mods: list[str] = []
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            mods.extend(a.name for a in node.names)
+        elif isinstance(node, ast.ImportFrom) and node.module:
+            mods.append(node.module)
+    return sorted(set(mods))
+
+
+def _suggestions(lint: dict, cc: dict, code_lines: int) -> list[str]:
+    """Genera suggerimenti leggibili in base all'analisi."""
+    hints: list[str] = []
+    if not lint["ok"]:
+        hints.append("🔴 Correggere errori di sintassi prima di procedere.")
+    for f in cc["functions"]:
+        if f["risk"] == "HIGH":
+            hints.append(f"⚠️ Funzione '{f['name']}' (riga {f['line']}): CC={f['cc']} — considera di spezzarla.")
+        elif f["risk"] == "MEDIUM":
+            hints.append(f"📌 Funzione '{f['name']}' (riga {f['line']}): CC={f['cc']} — complessità moderata.")
+    if code_lines > 300:
+        hints.append(f"📏 File lungo ({code_lines} righe) — considera di suddividere in moduli.")
+    if cc["module_cc"] > 20:
+        hints.append(f"🔺 Complessità ciclomatica modulo alta (CC={cc['module_cc']}) — molti rami.")
+    return hints[:8]  # max 8 suggerimenti
+
+
+# ── Routes ────────────────────────────────────────────────────────────────────
+
+@router.post("/analyze")
+async def analyze(req: AnalyzeReq, role: AuthRole = Depends(require_role(AuthRole.MACHINE))) -> JSONResponse:  # GAP-1-fix: run_code=True esegue Python
+    """
+    Analisi statica Python: sintassi, complessità ciclomatica, imports, suggerimenti.
+    Se run_code=True: esegue in sandbox isolata via exec_sandbox (max _MAX_RUN_LINES righe).
+
+    Response JSON:
+      syntax_ok, syntax_errors, complexity, imports, suggestions, metrics,
+      execution (solo se run_code=True e sintassi ok)
+    """
+    t0 = time.monotonic()
+    code = req.content.strip()
+    code_lines = code.count("\n") + 1
+
+    # 1. Analisi sintattica
+    lint = _lint_python(code)
+
+    # 2. AST analysis (solo se sintassi ok)
+    cc_result: dict = {"module_cc": 0, "functions": [], "avg_func_cc": 0}
+    imp_list:  list = []
+    if lint["ok"]:
+        try:
+            tree = ast.parse(code, mode="exec")
+            cc_result  = _complexity(tree)
+            imp_list   = _imports(tree)
+        except Exception as e:
+            _logger.warning("AST analysis error: %s", e)
+
+    suggestions = _suggestions(lint, cc_result, code_lines)
+
+    result: dict = {
+        "syntax_ok":     lint["ok"],
+        "syntax_errors": lint["errors"],
+        "complexity":    cc_result,
+        "imports":       imp_list,
+        "suggestions":   suggestions,
+        "metrics": {
+            "lines":          code_lines,
+            "chars":          len(code),
+            "functions":      len(cc_result["functions"]),
+        },
+        "elapsed_ms":    round((time.monotonic() - t0) * 1000, 1),
+    }
+
+    # 3. Esecuzione sandbox opzionale
+    if req.run_code and lint["ok"]:
+        if code_lines > _MAX_RUN_LINES:
+            result["execution"] = {
+                "ok": False,
+                "error": f"Codice troppo lungo per esecuzione sandbox ({code_lines} righe, max {_MAX_RUN_LINES}).",
+            }
+        else:
+            try:
+                from api.exec_sandbox import run_in_sandbox_async
+                exec_result = await run_in_sandbox_async(
+                    code=code,
+                    language="python",
+                    timeout_s=10,
+                )
+                result["execution"] = exec_result
+            except ImportError:
+                result["execution"] = {"ok": False, "error": "exec_sandbox non disponibile in questo ambiente."}
+            except Exception as e:
+                result["execution"] = {"ok": False, "error": str(e)[:300]}
+
+    _logger.info("analyze %s: syntax=%s cc=%s t=%.0fms",
+                 req.filepath, lint["ok"], cc_result["module_cc"], result["elapsed_ms"])
+    return JSONResponse(content=result)
+
+
+_STUB_MSG = (
+    "Endpoint sessione rimosso (S437) — usa /api/agent/run con AIClient multi-provider."
+)
+
+
+class _SR(BaseModel):
+    goal: str
+    files: list
+    model: str | None = None
+
+
+@router.post("/session")
+async def session(_req: _SR, role: AuthRole = Depends(require_role(AuthRole.MACHINE))) -> JSONResponse:  # GAP-1-fix: stub 501 ma consistent
+    return JSONResponse(status_code=501, content={"error": _STUB_MSG})

api/conversations.py

@@ -0,0 +1,111 @@
+"""backend/api/conversations.py — Conversations + Messages CRUD (S354)."""
+import json, logging
+from .state import safe_json_dumps
+from typing import Optional, Any
+from fastapi import APIRouter, Depends, Body, HTTPException
+from .auth_guard import require_role, AuthRole
+from pydantic import BaseModel
+from .state import sb
+
+router = APIRouter( dependencies=[Depends(require_role(AuthRole.MACHINE))])  # GAP-1-fix: router-level auth
+_logger = logging.getLogger("conversations")
+
+
+class ConversationIn(BaseModel):
+    id: str
+    title: str = 'Nuova conversazione'
+    created_at: int
+    updated_at: int
+
+
+class MessageIn(BaseModel):
+    id: str
+    conversation_id: str
+    role: str
+    content: str
+    created_at: int
+    error: Optional[bool] = False
+    steps: Optional[Any] = None
+    agent_status: Optional[str] = None
+
+
+# ── Conversations ──────────────────────────────────────────────────────────────
+
+@router.get('/api/conversations')
+async def list_conversations():
+    try:
+        data = sb().table('conversations').select('*').order('updated_at', desc=True).limit(200).execute()  # BUGFIX: LIMIT 200 — senza limit OOM garantito su account con molte conversazioni
+        return {'conversations': data.data}
+    except Exception as exc:
+        _logger.warning("list_conversations: %s", exc)
+        # S750-GAP-I: Supabase non configurato o irraggiungibile → lista vuota invece di 500
+        return {'conversations': [], '_error': str(exc)[:120]}
+
+
+@router.post('/api/conversations')
+async def upsert_conversation(conv: ConversationIn):
+    try:
+        data = sb().table('conversations').upsert(conv.model_dump()).execute()
+        return {'conversation': data.data[0] if data.data else conv.model_dump()}
+    except Exception as exc:
+        _logger.warning("upsert_conversation %s: %s", conv.id, exc)
+        return {'conversation': conv.model_dump(), '_error': str(exc)[:120]}
+
+
+@router.put('/api/conversations/{conv_id}')
+async def update_conversation(conv_id: str, body: dict = Body(...)):
+    body['id'] = conv_id
+    try:
+        data = sb().table('conversations').upsert(body).execute()
+        return {'conversation': data.data[0] if data.data else body}
+    except Exception as exc:
+        _logger.warning("update_conversation %s: %s", conv_id, exc)
+        return {'conversation': body, '_error': str(exc)[:120]}
+
+
+@router.delete('/api/conversations/{conv_id}')
+async def delete_conversation(conv_id: str):
+    try:
+        sb().table('messages').delete().eq('conversation_id', conv_id).execute()
+        sb().table('conversations').delete().eq('id', conv_id).execute()
+    except Exception as exc:
+        _logger.warning("delete_conversation %s: %s", conv_id, exc)
+    return {'deleted': conv_id}
+
+
+# ── Messages ───────────────────────────────────────────────────────────────────
+
+@router.get('/api/conversations/{conv_id}/messages')
+async def list_messages(conv_id: str):
+    try:
+        data = sb().table('messages').select('*').eq('conversation_id', conv_id).order('created_at').limit(500).execute()  # BUGFIX: LIMIT 500 — senza limit OOM garantito su conversazioni lunghe
+        return {'messages': data.data}
+    except Exception as exc:
+        _logger.warning("list_messages %s: %s", conv_id, exc)
+        return {'messages': [], '_error': str(exc)[:120]}
+
+
+@router.post('/api/conversations/{conv_id}/messages')
+async def upsert_messages(conv_id: str, body: dict = Body(...)):
+    msgs = body.get('messages', [])
+    if not msgs:
+        return {'upserted': 0}
+    for m in msgs:
+        m['conversation_id'] = conv_id
+        if 'steps' in m and m['steps'] is not None:
+            m['steps'] = safe_json_dumps(m['steps']) if not isinstance(m['steps'], str) else m['steps']
+    try:
+        data = sb().table('messages').upsert(msgs).execute()
+        return {'upserted': len(data.data)}
+    except Exception as exc:
+        _logger.warning("upsert_messages %s: %s", conv_id, exc)
+        return {'upserted': 0, '_error': str(exc)[:120]}
+
+
+@router.delete('/api/conversations/{conv_id}/messages')
+async def clear_messages(conv_id: str):
+    try:
+        sb().table('messages').delete().eq('conversation_id', conv_id).execute()
+    except Exception as exc:
+        _logger.warning("clear_messages %s: %s", conv_id, exc)
+    return {'cleared': conv_id}

api/daemon_status.py

@@ -0,0 +1,149 @@
+"""backend/api/daemon_status.py — Live status of the Telegram session daemon.
+
+Espone lo stato del session-daemon (scripts/session-daemon.mjs) leggendo
+le sessioni attive da Supabase agent_tasks (status = "__session__").
+
+Endpoint:
+  GET /api/daemon/status  — sessioni attive, ultimo heartbeat, uptime, task corrente
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import time
+from typing import Any
+
+from fastapi import APIRouter, Depends
+from .auth_guard import require_role, AuthRole
+
+_logger = logging.getLogger("api.daemon_status")
+
+router = APIRouter(prefix="/api/daemon", tags=["daemon-status"], dependencies=[Depends(require_role(AuthRole.MACHINE))])  # GAP-1-fix: router-level auth
+
+# ACTIVE_TTL: allineato a session-daemon.mjs (5 * 60_000 ms)
+_ACTIVE_TTL_MS = 5 * 60 * 1000  # 5 minuti
+
+
+def _parse_context(raw: Any) -> dict:
+    """Decodifica il campo context (può essere str JSON o dict)."""
+    if isinstance(raw, dict):
+        return raw
+    if isinstance(raw, str):
+        try:
+            return json.loads(raw)
+        except Exception:
+            return {}
+    return {}
+
+
+def _fmt_uptime(started_at_ms: int | None) -> str:
+    if not started_at_ms:
+        return "unknown"
+    elapsed_s = int((time.time() * 1000 - started_at_ms) / 1000)
+    h, rem = divmod(elapsed_s, 3600)
+    m, s = divmod(rem, 60)
+    if h:
+        return f"{h}h {m}m"
+    if m:
+        return f"{m}m {s}s"
+    return f"{s}s"
+
+
+@router.get("/status")
+async def daemon_status() -> dict:
+    """
+    Ritorna lo stato live del session-daemon leggendo Supabase agent_tasks.
+
+    Una sessione è ATTIVA se updated_at < 5 minuti fa (ACTIVE_TTL del daemon).
+    Il daemon fa heartbeat ogni 30s — se non si vede da >5min è stale/crashato.
+
+    Response:
+      ok              — False se Supabase non raggiungibile
+      supabase_ok     — True se query OK
+      active_sessions — conteggio sessioni con heartbeat < 5min
+      sessions[]      — lista sessioni con: session_name, active, last_heartbeat,
+                        uptime, current_task, pid, head_sha, claimed_files
+      checked_at      — timestamp UTC della verifica
+    """
+    from .state import _sb
+
+    checked_at = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+    now_ms = int(time.time() * 1000)
+
+    if not _sb:
+        return {
+            "ok": False,
+            "supabase_ok": False,
+            "error": "Supabase non configurato (SUPABASE_URL / SUPABASE_KEY mancanti)",
+            "sessions": [],
+            "active_sessions": 0,
+            "checked_at": checked_at,
+        }
+
+    try:
+        result = await asyncio.to_thread(
+            lambda: _sb.table("agent_tasks")
+            .select("task_id, goal, context, updated_at, created_at")
+            .eq("status", "__session__")
+            .order("updated_at", desc=True)
+            .limit(10)
+            .execute()
+        )
+        rows = result.data or []
+    except Exception as exc:
+        _logger.warning("daemon_status: Supabase query failed: %s", exc)
+        return {
+            "ok": False,
+            "supabase_ok": False,
+            "error": str(exc),
+            "sessions": [],
+            "active_sessions": 0,
+            "checked_at": checked_at,
+        }
+
+    sessions = []
+    for row in rows:
+        ctx = _parse_context(row.get("context"))
+        updated_ms: int = row.get("updated_at") or 0
+        age_ms = now_ms - updated_ms
+        # CLOCK-SKEW-FIX: Railway clock può essere leggermente avanti di HF Space.
+        # age_ms negativo = heartbeat *appena* avvenuto → trattare come attivo.
+        # Tolleriamo fino a 60s di skew (ben oltre il tipico 1-2s osservato).
+        is_active = -60_000 < age_ms < _ACTIVE_TTL_MS
+
+        ago_s = int(age_ms / 1000)
+        if ago_s < 0:
+            last_seen = "appena ora"
+        elif ago_s < 60:
+            last_seen = f"{ago_s}s fa"
+        elif ago_s < 3600:
+            last_seen = f"{ago_s // 60}m {ago_s % 60}s fa"
+        else:
+            last_seen = f"{ago_s // 3600}h {(ago_s % 3600) // 60}m fa"
+
+        head = (ctx.get("headSha") or "")
+        sessions.append({
+            "session_id":    row.get("task_id", ""),
+            "session_name":  row.get("goal") or ctx.get("sessionName", ""),
+            "active":        is_active,
+            "last_heartbeat": last_seen,
+            "uptime":        _fmt_uptime(ctx.get("startedAt")),
+            "current_task":  ctx.get("sprint") or "idle",
+            "pid":           ctx.get("pid"),
+            "head_sha":      head[:10] if head else None,
+            "claimed_files": ctx.get("claimedFiles", []),
+            "updated_at_ms": updated_ms,
+        })
+
+    active_count = sum(1 for s in sessions if s["active"])
+
+    return {
+        "ok": True,
+        "supabase_ok": True,
+        "active_sessions": active_count,
+        "total_sessions":  len(sessions),
+        "sessions":        sessions,
+        "active_ttl_s":    _ACTIVE_TTL_MS // 1000,
+        "checked_at":      checked_at,
+    }