sync: 171 file da Baida98/AI@9b697a97 (2026-07-05 14:21 UTC)

.env.example

@@ -1,226 +1,65 @@
+# 🧠 Agente AI — Template .env Pulito (A-E)
 # ============================================================
-# .env.example — Template variabili d'ambiente Agente AI
-# Copiare in .env per uso locale. NON committare .env con valori reali.
-# Per deploy su HF Spaces: aggiungere come Secrets/Variables nelle impostazioni.
+# Copiare in .env per uso locale. NON committare valori reali.
+# Struttura ottimizzata per Quadranti A, B, C, D, E.
 # ============================================================
 
-# ── Runtime ──────────────────────────────────────────────────
+# ── 1. Core Runtime ──────────────────────────────────────────
 PORT=7860
-FRONTEND_DIST=/app/backend/static
-APP_PROFILE=hf_spaces_free_remote_kernel
-VITE_BACKEND_URL=
-VITE_API_BASE_URL=
-VITE_ENABLE_BROWSER_SANDBOX=false
-VITE_ENABLE_BROWSER_LLM=false
-VITE_ENABLE_LOCAL_ONLY_MODE=false
-
-# ── URLs (obbligatori) ────────────────────────────────────────
-# URL pubblico del tuo HF Space
-BACKEND_URL=https://arjanit98-terminal.hf.space  # HF Space A (collab A) — usato come BACKEND_URL su Railway
-FRONTEND_URL=https://agente-ai.pages.dev
-HF_SPACE_URL=https://arjanit98-terminal.hf.space  # HF Space A. Per collab B: https://baida00-ai-backend-collab.hf.space
-HF_SPACE_ID=Arjanit98/Terminal  # HF Space A (collab A). Per collab B: Baida00/ai-backend-collab
-
-# ── Vault / Sicurezza (obbligatori) ──────────────────────────
-# Genera con: python3 -c "import secrets; print(secrets.token_hex(32))"
-VAULT_KEY=
-VAULT_ADMIN_TOKEN=
-INTERNAL_TOKEN=
-NOTIFY_TOKEN=
-
-# ═══════════════════════════════════════════════════════════════════════════════════════
-# ── CLUSTER SUPABASE — Separazione Workload Ottimale ──────────────────────────────────
-# ═══════════════════════════════════════════════════════════════════════════════════════
-# Architettura:
-#   A: Analytics/Cache/Read-Heavy (reporting, dashboard, cache distribuito)
-#   B: Sync/State/Transazioni (stato globale, sincronizzazione cluster — PRIMARY)
-#   C: Memory/RAG/Embeddings (backend memoria, vector search, skill index)
-#   D: Audit/Logging/Compliance (event log, audit trail, compliance records)
-#
-# SUPABASE_URL (primario) → punta a B (Sync/State)
-# SUPABASE_KEY (primario) → punta a B
-# ═══════════════════════════════════════════════════════════════════════════════════════
-
-# ── Nodo B: PRIMARY — Stato Globale e Sincronizzazione ──────────────────────────────────
-# Workload: transazioni critiche, stato cluster, sincronizzazione, write-heavy
-SUPABASE_URL=https://sluvxtpbtxevrcooaqou.supabase.co
-SUPABASE_KEY=sb_secret_OHtVs6Vw4b5UTbm_QUnh4A_zqx9dadY
-SUPABASE_SERVICE_ROLE_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InNsdXZ4dHBidHhldnJjb29hcW91Iiwicm9sZSI6InNlcnZpY2Vfcm9sZSIsImlhdCI6MTc4MjA3Mjk5MiwiZXhwIjoyMDk3NjQ4OTkyfQ.WS4cpsvtO-FGkXukCqpFF6qXfQb38VUs5rtiLwa0khk
-SUPABASE_ANON_KEY=sb_secret_OHtVs6Vw4b5UTbm_QUnh4A_zqx9dadY
-DATABASE_URL=postgresql://postgres:[password]@db.sluvxtpbtxevrcooaqou.supabase.co:5432/postgres
-
-# ── Nodo A: Analytics/Cache — Read Replica e Cache Distribuito ──────────────────────────
-# Workload: reporting, dashboard, cache, read-heavy queries (non-critical)
-# Nota: Configurare con URL reale se disponibile; altrimenti fallback a B
-SUPABASE_URL_A=https://xxxx.supabase.co
-SUPABASE_KEY_A=
-SUPABASE_SERVICE_ROLE_KEY_A=
-# Enable cache layer su A (riduce carico su B)
-SUPABASE_CACHE_ENABLED=true
-SUPABASE_CACHE_TTL=3600
+APP_PROFILE=production_kernel
+INTERNAL_TOKEN=      # Bridge HF ↔ CF
+VAULT_KEY=           # AES-256 Hex
+NOTIFY_TOKEN=        # Notifiche Interne
 
-# ── HuggingFace ───────────────────────────────────────────────
-# huggingface.co → Settings → Access Tokens
-HF_TOKEN=
-HUGGINGFACE_API_KEY=
-HUGGINGFACE_TOKEN=
-HF_OPENAI_BASE_URL=https://router.huggingface.co/v1
-HF_MODEL=Qwen/Qwen2.5-Coder-32B-Instruct
-
-# ── GitHub ────────────────────────────────────────────────────
-# github.com → Settings → Developer settings → Personal access tokens
+# ── 2. Quadrante A (BRAIN - Primary) ─────────────────────────
+BACKEND_URL=https://arjanit98-terminal.hf.space
+RAILWAY_TOKEN=
+RAILWAY_PROJECT_ID=a9ce05f8-aeca-46c1-837b-8c2ca7a11081
+SUPABASE_URL=
+SUPABASE_SERVICE_ROLE_KEY=
 GITHUB_TOKEN=
-GH_TOKEN=
-GITHUB_REPOSITORY=Baida98/AI
-GITHUB_REPO=Baida98/AI
-GH_OWNER=Baida98
-GH_REPO=AI
-GITHUB_BRANCH=main
-AGENT_KERNEL_REF=main
-AGENT_KERNEL_MAX_TOKENS=3000
-AGENT_KERNEL_TIMEOUT=90
-AGENT_CONTEXT_FILES=120
-
-# ── OpenAI ────────────────────────────────────────────────────
-# platform.openai.com/api-keys
-OPENAI_API_KEY=
-OPENAI_API_BASE=https://api.openai.com/v1
-OPENAI_MODEL=gpt-4o-mini
+HF_TOKEN=
 
-# ── OpenRouter ────────────────────────────────────────────────
-# openrouter.ai/keys
+# ── 3. Quadrante B (HANDS - Collab/Failover) ─────────────────
+RAILWAY_TOKEN_B=
+RAILWAY_PROJECT_ID_B=51c7f764-a8ca-4dff-b3cd-d91116e09d8a
+SUPABASE_URL_B=
+SUPABASE_SERVICE_ROLE_KEY_B=
+GITHUB_TOKEN_B=
+
+# ── 4. Quadrante C (DAEMON - Telegram) ───────────────────────
+RAILWAY_TOKEN_C=
+RAILWAY_PROJECT_ID_C=d8843346-7c6a-48f1-adb3-0fd4a650b3e5
+SUPABASE_URL_C=
+SUPABASE_SERVICE_ROLE_KEY_C=
+
+# ── 5. Quadrante D (AUDIT - Compliance) ──────────────────────
+RAILWAY_TOKEN_D=
+RAILWAY_PROJECT_ID_D=898b1c3e-6e64-4c5a-9609-afdd0dce84f8
+SUPABASE_URL_D=
+SUPABASE_SERVICE_ROLE_KEY_D=
+
+# ── 6. Quadrante E (BOT-TG - Dedicated) ──────────────────────
+RAILWAY_TOKEN_E=
+RAILWAY_PROJECT_ID_E=0834551e-51c8-4eff-aa4f-65c0b04ea933
+
+# ── 7. LLM Unified Providers (A-E) ───────────────────────────
+# Configurare nei Secrets del provider hosting (HF/Railway)
+GROQ_API_KEY=
 OPENROUTER_API_KEY=
-OPENROUTER_MODEL=openai/gpt-oss-20b:free
-
-# ── Gemini ────────────────────────────────────────────────────
-# aistudio.google.com/app/apikey
 GEMINI_API_KEY=
-GEMINI_MODEL=gemini-2.5-flash-lite
-
-# ── Groq ─────────────────────────────────────────────────────
-# console.groq.com/keys
-GROQ_API_KEY=
-GROQ_API_KEY_B=
-GROQ_MODEL=llama-3.3-70b-versatile
-
-# ── Cerebras ──────────────────────────────────────────────────
-# cloud.cerebras.ai
-CEREBRAS_API_KEY=
-CEREBRAS_MODEL=gpt-oss-120b
-
-# ── SambaNova ─────────────────────────────────────────────────
-# cloud.sambanova.ai
-SAMBANOVA_API_KEY=
-SAMBANOVA_MODEL=DeepSeek-V3.1
-
-# ── NVIDIA NIM ─────────────────────────────────────────────────
-# build.nvidia.com → Get API Key (gratuito, no carta di credito)
-# Stessa chiave funziona su integrate.api.nvidia.com/v1 (OpenAI-compatible)
 NVIDIA_API_KEY=
-NVIDIA_MODEL=nvidia/nemotron-3-super-120b-a12b
-# Key B — secondo account NIM, raddoppia il rate-limit (30→60 RPM)
-NVIDIA_API_KEY_B=
-NVIDIA_B_MODEL=meta/llama-3.3-70b-instruct
-# DISABLE_NVIDIA_B=1
-
-# ── LLM Routing ───────────────────────────────────────────────
-LLM_MODEL=deepseek/deepseek-r1:free
-SMOLAGENTS_MODEL=deepseek/deepseek-r1:free
-UNIFIED_LOOP_MAX_STEPS=8
-
-# ── Telegram ─────────────────────────────────────────────────
-# @BotFather su Telegram per i token bot
-# @userinfobot per il tuo chat ID
-TELEGRAM_BOT_TOKEN=
-TELEGRAM_CHAT_ID=
-
-# ── Cloudflare ────────────────────────────────────────────────
-# dash.cloudflare.com → Profile → API Tokens
-CF_API_TOKEN=
-CLOUDFLARE_API_TOKEN=
-CF_ACCOUNT_ID=
-
-# ── Railway ───────────────────────────────────────────────────
-# railway.app → Account Settings → Tokens
-RAILWAY_TOKEN=
-RAILWAY_URL=https://railway.app
+OPENAI_API_KEY=
 
-# ── E2B (Code Execution Sandbox) ──────���──────────────────────
-# e2b.dev/dashboard
+# ── 8. Sandboxes & Tools ─────────────────────────────────────
 E2B_API_KEY=
-
-# ── Notion ────────────────────────────────────────────────────
-# notion.so/my-integrations
 NOTION_TOKEN=
-
-# ── Storage locale ────────────────────────────────────────────
-CHROMA_DB_DIR=/app/backend/.data/chroma
-SQLITE_DB_PATH=/app/backend/.data/agent.sqlite
-
-# ═══════════════════════════════════════════════════════════════════════════════════════
-# ── Nodo E: Oracle Cloud (OCI) — Compute/AI Workload ──────────────────────────────────
-# ═══════════════════════════════════════════════════════════════════════════════════════
-# Workload: Carichi di calcolo intensivi, esecuzione script Python complessi, task di background a lunga durata, hosting modelli AI locali.
-ORACLE_NODE_E_ENABLED=true
-ORACLE_NODE_E_IP=80.225.89.217
-ORACLE_NODE_E_USER=opc
-ORACLE_NODE_E_SSH_KEY_PATH=/app/secrets/oracle_private_key.pem  # Path alla chiave privata SSH (gestita come segreto)
-ORACLE_NODE_E_ROLE="Compute/AI Workload"
-ORACLE_NODE_E_REGION="Italy Northwest (Milan)"
-ORACLE_NODE_E_OCPUS=4
-ORACLE_NODE_E_RAM_GB=24
-
-# ── Opzionali ─────────────────────────────────────────────────
-# Qdrant (vector DB cloud)
-QDRANT_URL=
-QDRANT_API_KEY=
-# Jina AI (web reader avanzato — jina.ai/api-key)
-JINA_API_KEY=
-# Tavily (web search — tavily.com)
-TAVILY_API_KEY=
-# Brave Search
-BRAVE_SEARCH_API_KEY=
-# Resend (email — resend.com)
-RESEND_API_KEY=
-RESEND_FROM_EMAIL=
-# Upstash Redis
+TELEGRAM_BOT_TOKEN=
+TELEGRAM_CHAT_ID=
 UPSTASH_REDIS_REST_URL=
 UPSTASH_REDIS_REST_TOKEN=
-# Pexels / Pixabay (immagini)
-PEXELS_API_KEY=
-PIXABAY_API_KEY=
-
-# ═══════════════════════════════════════════════════
-# ── HF Spaces e Railway — Configurazione Infra ─────
-# ═══════════════════════════════════════════════════
-VITE_BACKEND_URL_2=https://baida00-ai-backend-collab.hf.space  # HF Space B — backend collab B (chat/AI)
-VITE_EXEC_BACKEND_URL_2=  # Railway B URL (exec/PTY) — formato: https://xxx.up.railway.app — DA CONFIGURARE
-E2B_API_KEY_2=2f548a79-9210-4037-87fa-4490a6a6b8fe               # e2b.dev — account B (100h/mese)
 
-# Groq account B (14.400 req/giorno) — load balancing con A
-GROQ_API_KEY_3=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
-VITE_GROQ_API_KEY_3=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
-
-# ═══════════════════════════════════════════════════════════════════════════════════════
-# ── Nodo C: Memory/RAG/Embeddings — Backend Memoria e Vector Search ──────────────────────
-# ═══════════════════════════════════════════════════════════════════════════════════════
-# Workload: embeddings, vector search, RAG index, skill memory, conversazioni
-SUPABASE_URL_C=https://rsiphwzlokhsxnkcvzos.supabase.co
-SUPABASE_ANON_KEY_C=sb_secret_11jeLuJnZBA1IKCAm1ZjiA_QxIyU5u6
-SUPABASE_SERVICE_ROLE_KEY_C=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InJzaXBod3psb2toc3hua2N2em9zIiwicm9sZSI6InNlcnZpY2Vfcm9sZSIsImlhdCI6MTc4MjI1OTEyOSwiZXhwIjoyMDk3ODM1MTI5fQ.LxO8ltt-t8SpHf-ZIi1ogcEtcQcPvW1Vyu2W14i1zzM
-E2B_API_KEY_C=2f548a79-9210-4037-87fa-4490a6a6b8fe
-# RAG/Vector DB — Qdrant per embeddings (opzionale, altrimenti usa Supabase C)
-QDRANT_URL_C=
-QDRANT_API_KEY_C=
-
-# ═══════════════════════════════════════════════════════════════════════════════════════
-# ── Nodo D: Audit/Logging/Compliance — Event Log e Compliance Records ─────────��────────
-# ═══════════════════════════════════════════════════════════════════════════════════════
-# Workload: audit trail, event logging, compliance records, immutable logs
-SUPABASE_URL_D=https://cyotadpvgaxfdwaovstv.supabase.co
-SUPABASE_ANON_KEY_D=sb_secret_aZGjt7d8KWsvIm5-JP4qrg_XrNPBAZE
-SUPABASE_SERVICE_ROLE_KEY_D=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImN5b3RhZHB2Z2F4ZmR3YW92c3R2Iiwicm9sZSI6InNlcnZpY2Vfcm9sZSIsImlhdCI6MTc4MjY1NjQ1OSwiZXhwIjoyMDk4MjMyNDU5fQ.FuLweX2H6RKJmC7PbXdctmgzVIcqspq9FSxwFzFwB9o
-E2B_API_KEY_D=e2b_9d242366288d5e9e0bb267f31cccc5d49298348c
-# Audit log — immutable append-only (opzionale)
-AUDIT_LOG_ENABLED=true
-AUDIT_LOG_RETENTION_DAYS=90
+# ── 9. Feature Flags ─────────────────────────────────────────
+VITE_ENABLE_BROWSER_SANDBOX=false
+UNIFIED_LOOP_MAX_STEPS=8
+LLM_MODEL=deepseek/deepseek-r1:free

REBUILD_TRIGGER

@@ -1 +1,2 @@
-rebuild
+Rebuild trigger — 2026-07-03T13:39:25.801Z
+Fix: rootDirectory corretto da /backend a backend (Railway backend service)

api/_agent_helpers.py

@@ -45,11 +45,8 @@ except Exception:
 
 router = APIRouter()
 
-@router.post('/run_loop', deprecated=True)
-async def run_loop():
-    """Deprecated — use /agent/task instead."""
-    from fastapi.responses import JSONResponse
-    return JSONResponse(status_code=410, content={"detail": {"error": "Gone", "migration": "/api/agent/tasks"}})
+# DEP-11: /run_loop route rimossa (era stub 410 che attraversava CORS+rate-limiter+auth inutilmente).
+# Migrazione client → /api/agent/tasks ; CF Worker redirect se necessario.
 
 
 # ─── P17-F5: Persona helpers ──────────────────────────────────────────────────

api/ads_manager.py

@@ -0,0 +1,50 @@
+import os
+import sqlite3
+import logging
+from fastapi import APIRouter, HTTPException
+from typing import List, Dict, Any
+
+_logger = logging.getLogger("ads_manager")
+router = APIRouter(prefix="/api/ads", tags=["ads"])
+
+DB_PATH = os.getenv("ADS_DB_PATH", "/app/data/ads/ads-client.db")
+
+def get_db_connection():
+    if not os.path.exists(DB_PATH):
+        _logger.warning(f"Database Ads non trovato in {DB_PATH}")
+        return None
+    try:
+        conn = sqlite3.connect(DB_PATH)
+        conn.row_factory = sqlite3.Row
+        return conn
+    except Exception as e:
+        _logger.error(f"Errore connessione DB Ads: {e}")
+        return None
+
+@router.get("/health")
+async def ads_health():
+    conn = get_db_connection()
+    if not conn:
+        return {"status": "error", "message": "Database non disponibile"}
+    try:
+        cursor = conn.cursor()
+        cursor.execute("SELECT count(*) FROM http_cache")
+        count = cursor.fetchone()[0]
+        conn.close()
+        return {"status": "ok", "record_count": count}
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
+
+@router.get("/cache")
+async def get_ads_cache(limit: int = 10):
+    conn = get_db_connection()
+    if not conn:
+        raise HTTPException(status_code=503, detail="Database Ads non disponibile")
+    try:
+        cursor = conn.cursor()
+        cursor.execute("SELECT * FROM http_cache LIMIT ?", (limit,))
+        rows = [dict(row) for row in cursor.fetchall()]
+        conn.close()
+        return {"ok": True, "data": rows}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

api/agent_loop_routes.py

@@ -43,6 +43,7 @@ from ._agent_helpers import (
     _PERSONA_KEYWORD_MAP, _PERSONA_CLIENT_CACHE,
     _build_persona_kw_map, _classify_persona_server, _get_persona_llm_client,
 )
+@router.post('/run_loop')
 async def run_loop_removed():
     """S352: endpoint rimosso. Usare POST /api/agent/tasks + GET /api/agent/tasks/{id}/stream."""
     raise HTTPException(

api/browser.py

@@ -33,7 +33,8 @@ Problematiche W-NAV anticipate:
 import os
 import asyncio, base64, hashlib, os, time, uuid, logging
 from typing import Optional, Any
-from fastapi import APIRouter, HTTPException, Request
+from fastapi import APIRouter, HTTPException, Request, Depends
+from .auth_guard import require_role, AuthRole
 from pydantic import BaseModel
 
 router  = APIRouter(prefix="/api/browser", tags=["browser"])
@@ -792,14 +793,14 @@ async def browser_navigate(req: NavigateRequest):
 # ─── /open ────────────────────────────────────────────────────────────────────
 
 @router.post("/open", response_model=BrowserResult)
-async def browser_open(req: BrowserOpenRequest, request: Request):
+async def browser_open(
+    req: BrowserOpenRequest,
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+):
     """
     Apre una sessione Playwright persistente, naviga all'URL, restituisce
     session_id + screenshot + mappa DOM + text_content (trafilatura).
     """
-    _internal_token = os.getenv('INTERNAL_TOKEN', '')
-    if _internal_token and request.headers.get('X-Internal-Token') != _internal_token:
-        raise HTTPException(401, 'Unauthorized')
     if not _safe_url(req.url):
         raise HTTPException(400, "URL non consentita")
 
@@ -856,14 +857,14 @@ async def browser_open(req: BrowserOpenRequest, request: Request):
 # ─── /act ─────────────────────────────────────────────────────────────────────
 
 @router.post("/act", response_model=BrowserResult)
-async def browser_act(req: BrowserActRequest, request: Request):
+async def browser_act(
+    req: BrowserActRequest,
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+):
     """
     Esegue azioni su una sessione aperta.
     Restituisce screenshot + mappa DOM + warnings anti-loop.
     """
-    _internal_token = os.getenv('INTERNAL_TOKEN', '')
-    if _internal_token and request.headers.get('X-Internal-Token') != _internal_token:
-        raise HTTPException(401, 'Unauthorized')
     sess = _sessions.get(req.session_id)
     if not sess:
         raise HTTPException(404, f"Sessione {req.session_id} non trovata o scaduta")

api/database_router.py

@@ -21,7 +21,8 @@ import logging
 import re as _re
 from typing import Optional, Literal
 from enum import Enum
-from fastapi import APIRouter, HTTPException, Request
+from fastapi import APIRouter, HTTPException, Request, Depends
+from .auth_guard import require_role, AuthRole
 from pydantic import BaseModel
 
 router = APIRouter(prefix="/api/database", tags=["database"])
@@ -174,7 +175,10 @@ def _choose_node(
 
 # ─── Endpoint Principale ──────────────────────────────────────────────────
 @router.post("/query", response_model=QueryResponse)
-async def database_query(req: QueryRequest, request: Request):
+async def database_query(
+    req: QueryRequest,
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+):
     """
     Endpoint query con routing intelligente tra nodi Supabase A/B/C/D.
     
@@ -192,10 +196,6 @@ async def database_query(req: QueryRequest, request: Request):
       - truncated: se risultato è stato troncato
       - node_used: nodo Supabase utilizzato
     """
-    # Verifica token interno
-    _internal_token = os.getenv("INTERNAL_TOKEN", "")
-    if _internal_token and request.headers.get("X-Internal-Token") != _internal_token:
-        raise HTTPException(401, "Unauthorized")
     
     # Rileva tipo query e contesto
     query_type = _detect_query_type(req.sql)
@@ -223,8 +223,18 @@ async def database_query(req: QueryRequest, request: Request):
             node_used=chosen_node.value,
         )
     
+    # ── GAP-DB-QUERY-PUBLIC fix: forziamo read_only basandoci sul contenuto ──
+    # Non ci fidiamo di req.read_only dal client per la sicurezza.
+    _sql_upper = req.sql.upper()
+    _is_write = any(kw in _sql_upper for kw in ["INSERT", "UPDATE", "DELETE", "DROP", "ALTER", "CREATE", "TRUNCATE"])
+    
+    # Se la query contiene keyword di scrittura, richiediamo esplicitamente permessi OPERATOR o superiore
+    # In questo endpoint MACHINE (default) permettiamo solo SELECT.
+    if _is_write and role < AuthRole.OPERATOR:
+        raise HTTPException(403, "Permessi insufficienti per query di scrittura (richiesto OPERATOR)")
+        
     # Verifica read-only
-    if req.read_only:
+    if req.read_only or not _is_write:
         kw = _is_dangerous(req.sql)
         if kw:
             return QueryResponse(

api/email.py

@@ -22,7 +22,8 @@ Error handling:
 from __future__ import annotations
 
 import os, logging, httpx
-from fastapi import APIRouter, Request
+from fastapi import APIRouter, Request, Depends, HTTPException
+from .auth_guard import require_role, AuthRole
 from pydantic import BaseModel, EmailStr, field_validator
 from typing import Optional, List
 
@@ -60,14 +61,14 @@ class SendEmailResponse(BaseModel):
 # ── Endpoint ─────────────────────────────────────────────────────────────────
 
 @router.post("/send", response_model=SendEmailResponse)
-async def send_email(req: SendEmailRequest, request: Request) -> SendEmailResponse:
+async def send_email(
+    req: SendEmailRequest,
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+) -> SendEmailResponse:
     """
     Invia email via Resend API.
     Richiede RESEND_API_KEY nell'ambiente del backend HF Space.
     """
-    _internal_token = os.getenv('INTERNAL_TOKEN', '')
-    if _internal_token and request.headers.get('X-Internal-Token') != _internal_token:
-        raise HTTPException(401, 'Unauthorized')
     api_key = os.getenv("RESEND_API_KEY", "")
     if not api_key:
         _logger.warning("RESEND_API_KEY non configurata")
@@ -83,8 +84,20 @@ async def send_email(req: SendEmailRequest, request: Request) -> SendEmailRespon
             ),
         )
 
-    # Costruisci mittente
+    # ── GAP-EMAIL-OPENRELAY fix: allowlist domini mittente e validazione ──
+    import re as _re_email
+    _EMAIL_RE = _re_email.compile(r'^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$')
+    if not _EMAIL_RE.match(req.to):
+        raise HTTPException(400, "Destinatario non valido")
+
+    _allowed_domains = {os.getenv("RESEND_DOMAIN", "resend.dev"), "agente-ai.pages.dev"}
     from_email = req.from_email or os.getenv("RESEND_FROM_EMAIL", "noreply@resend.dev")
+    _from_domain = from_email.split("@")[-1] if "@" in from_email else ""
+    if _from_domain not in _allowed_domains and not from_email.endswith(".resend.dev"):
+        # Se il dominio non è in allowlist, forza il mittente di sistema
+        from_email = os.getenv("RESEND_FROM_EMAIL", "noreply@resend.dev")
+
+    # Costruisci mittente
     from_field = f"{req.from_name} <{from_email}>" if req.from_name else from_email
 
     # Payload Resend

api/exec.py

@@ -268,23 +268,30 @@ def _ast_sandbox_check(code: str) -> tuple[bool, str]:
 # ── Routes ────────────────────────────────────────────────────────────────────
 
 @router.post('/api/exec')
-async def exec_code(req: ExecRequest, request: Request):
-    _internal_token = os.getenv('INTERNAL_TOKEN', '')
-    if _internal_token and request.headers.get('X-Internal-Token') != _internal_token:
-        raise HTTPException(401, 'Unauthorized')
+async def exec_code(
+    req: ExecRequest,
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+):
     code = req.code.strip()
     lang = req.lang.lower()
     if not code:
         return {'stdout': '', 'stderr': 'No code', 'exit_code': 1, 'durationMs': 0}
 
+    # ── GAP-NODE-NOSANDBOX fix: filtri per JS/TS ───────────────────────────
+    _normalized = _re_exec.sub(r'\s+', ' ', code)
     if lang == 'python':
-        _normalized = _re_exec.sub(r'\s+', ' ', code)
         _blocked_match = _EXEC_BLOCKED_RE.search(_normalized)
         if _blocked_match:
             return {'stdout': '', 'stderr': f'Blocked: pattern "{_blocked_match.group()}"', 'exit_code': 1, 'durationMs': 0}
         _ast_safe, _ast_reason = _ast_sandbox_check(code)
         if not _ast_safe:
             return {'stdout': '', 'stderr': f'Blocked (AST): {_ast_reason}', 'exit_code': 1, 'durationMs': 0}
+    elif lang in ('javascript', 'js', 'typescript', 'ts'):
+        # Blocca accesso a shell, fs, env e rete in Node.js
+        _JS_BLOCKED = _re_exec.compile(r'child_process|process\.env|require\s*\(|import\s+.*from|fs\.|net\.|http')
+        _js_match = _JS_BLOCKED.search(_normalized)
+        if _js_match:
+            return {'stdout': '', 'stderr': f'Blocked (JS/TS): pattern "{_js_match.group()}"', 'exit_code': 1, 'durationMs': 0}
 
     t0 = int(time.time() * 1000)
     try:
@@ -347,14 +354,23 @@ async def exec_code(req: ExecRequest, request: Request):
 
 
 @router.post('/api/execute-shell')
-async def execute_shell(cmd: ShellCmd, request: Request):
-    _internal_token = os.getenv('INTERNAL_TOKEN', '')
-    if _internal_token and request.headers.get('X-Internal-Token') != _internal_token:
-        raise HTTPException(401, 'Unauthorized')
+async def execute_shell(
+    cmd: ShellCmd,
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+):
     raw = cmd.command.strip()
-    for bad in BLOCKED_CMDS:
-        if bad in raw:
-            raise HTTPException(400, 'Command blocked for safety')
+    # ── GAP-SHELL-NOFILTER fix: Allowlist invece di blocklist minima ─────────
+    _SAFE_SHELL = _re_exec.compile(r'^(ls|pwd|date|echo|cat|grep|find|du|df|uptime|ps|top|free|git status|git log|pnpm|npm|pip|python3|node|ts-node)( .*)?$')
+    if not _SAFE_SHELL.match(raw):
+        # Fallback blocklist per comandi composti o non in lista
+        for bad in BLOCKED_CMDS:
+            if bad in raw:
+                raise HTTPException(400, 'Command blocked for safety')
+        # Se non è in allowlist, limitiamo a sola lettura/info
+        _DANGEROUS = {'rm ', 'mv ', 'cp ', 'chmod ', 'chown ', 'wget ', 'curl ', '>', '>>', '|'}
+        for d in _DANGEROUS:
+            if d in raw:
+                raise HTTPException(400, f'Command "{d.strip()}" not allowed in this shell')
     timeout = min(max(cmd.timeout, 1), 60)
     try:
         async with _realtime_job(timeout_s=90.0):
@@ -366,7 +382,11 @@ async def execute_shell(cmd: ShellCmd, request: Request):
                         stderr=asyncio.subprocess.PIPE,
                         cwd=tmpdir,
                         preexec_fn=_child_resource_limits,  # GAP-EXEC-FIX: RLIMIT_AS/CPU/NOFILE/NPROC
-                        env={**os.environ, 'HOME': tmpdir, 'TMPDIR': tmpdir},
+                        env={
+                            'HOME': tmpdir, 'TMPDIR': tmpdir,
+                            'PATH': os.environ.get('PATH', '/usr/local/bin:/usr/bin:/bin'),
+                            'PYTHONPATH': os.environ.get('PYTHONPATH', ''),
+                        },
                     )
                     stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=timeout)
                     return {
@@ -559,11 +579,11 @@ class ToolDispatchRequest(BaseModel):
 
 
 @router.post('/api/exec/tool')
-async def exec_tool_dispatch(req: ToolDispatchRequest, request: Request):
+async def exec_tool_dispatch(
+    req: ToolDispatchRequest,
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+):
     """GAP-2: dispatcher generico — risolve tool nel TOOL_REGISTRY e chiama _fn."""
-    _internal_token = os.getenv('INTERNAL_TOKEN', '')
-    if _internal_token and request.headers.get('X-Internal-Token') != _internal_token:
-        raise HTTPException(401, 'Unauthorized')
     try:
         from tools.registry import TOOL_REGISTRY  # import locale — evita circular import
     except ImportError as _ie:

api/job_queue.py

@@ -10,7 +10,8 @@ try:
 except ImportError:
     _HAS_RESOURCE = False
 from typing import Optional, List, Dict, Any
-from fastapi import APIRouter, HTTPException, Request
+from fastapi import APIRouter, HTTPException, Request, Depends
+from .auth_guard import require_role, AuthRole
 from pydantic import BaseModel
 from .load_balancer import balancer  # S951
 import httpx
@@ -258,7 +259,9 @@ async def start_job_queue_consumer() -> None:
 
 # ── FastAPI endpoints ──────────────────────────────────────────────────────────
 @router.get("/status")
-async def jq_status():
+async def jq_status(
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+):
     return {
         "space_role":       _SPACE_ROLE,
         "jq_enabled":       _JQ_ENABLED,
@@ -268,7 +271,10 @@ async def jq_status():
     }
 
 @router.get("/load/{role}")
-async def jq_load(role: str):
+async def jq_load(
+    role: str,
+    auth_role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+):
     if role not in ("brain", "hands", "memory", "audit"):
         raise HTTPException(400, "role non valido")
     res = await _rcmd(["GET", _K_LOAD(role)])
@@ -280,10 +286,11 @@ async def jq_load(role: str):
         raise HTTPException(500, f"Metriche Redis corrotte per {role}: {_je}")
 
 @router.post("/submit")
-async def jq_submit(job: JobPayload, request: Request):
+async def jq_submit(
+    job: JobPayload,
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+):
     """S42 — Grid Orchestrator: sottomissione job reale su Redis."""
-    if _INTERNAL_TOKEN and request.headers.get("X-Internal-Token") != _INTERNAL_TOKEN:
-        raise HTTPException(401, "Unauthorized")
     if not _redis_ok():
         raise HTTPException(503, "Job queue non disponibile: Redis non configurato")
 
@@ -317,10 +324,11 @@ async def jq_submit(job: JobPayload, request: Request):
     }
 
 @router.get("/result/{task_id}")
-async def jq_result(task_id: str, request: Request):
+async def jq_result(
+    task_id: str,
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+):
     """S429 — Tool Success Contract: recupero risultato job per taskId."""
-    if _INTERNAL_TOKEN and request.headers.get("X-Internal-Token") != _INTERNAL_TOKEN:
-        raise HTTPException(401, "Unauthorized")
     if not _redis_ok():
         raise HTTPException(503, "Job queue non disponibile: Redis non configurato")
 

api/research.py

@@ -20,7 +20,8 @@ Budget (iPhone free tier):
 """
 import asyncio, os, re, logging, time
 import httpx
-from fastapi import APIRouter, HTTPException, Request
+from fastapi import APIRouter, HTTPException, Request, Depends
+from .auth_guard import require_role, AuthRole
 from pydantic import BaseModel
 
 router  = APIRouter(prefix="/api/web", tags=["web-research"])
@@ -277,11 +278,11 @@ async def _synthesize(topic: str, sources: list[dict]) -> str:
 # ─── Main endpoint ────────────────────────────────────────────────────────────
 
 @router.post("/research")
-async def web_research(req: ResearchRequest, request: Request):
+async def web_research(
+    req: ResearchRequest,
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+):
     # S-GAP23: X-Internal-Token guard — protegge consumi Groq API da abusi esterni.
-    _internal_token = os.getenv('INTERNAL_TOKEN', '')
-    if _internal_token and request.headers.get('X-Internal-Token') != _internal_token:
-        raise HTTPException(401, 'Unauthorized')
 
     n = min(max(int(req.depth), 1), _MAX_URLS_PER_ROUND)
 
@@ -605,11 +606,11 @@ async def _synthesize(topic: str, sources: list[dict]) -> str:
 # ─── Main endpoint ────────────────────────────────────────────────────────────
 
 @router.post("/research")
-async def web_research(req: ResearchRequest, request: Request):
+async def web_research(
+    req: ResearchRequest,
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+):
     # S-GAP23: X-Internal-Token guard — protegge consumi Groq API da abusi esterni.
-    _internal_token = os.getenv('INTERNAL_TOKEN', '')
-    if _internal_token and request.headers.get('X-Internal-Token') != _internal_token:
-        raise HTTPException(401, 'Unauthorized')
 
     n = min(max(int(req.depth), 1), _MAX_URLS_PER_ROUND)
 

api/scheduler.py

@@ -34,9 +34,10 @@ import uuid
 from pathlib import Path
 from typing import Any, AsyncGenerator, Optional
 
-from fastapi import APIRouter, HTTPException, Request
+from fastapi import APIRouter, HTTPException, Request, Depends
 from fastapi.responses import StreamingResponse
 from pydantic import BaseModel
+from .auth_guard import require_role, AuthRole
 import logging
 _logger = logging.getLogger("agente_ai")  # S-BUGFIX
 
@@ -281,13 +282,14 @@ def _is_due(task: dict, now_ms: int) -> bool:
     if tt == "daily":      return now_ms >= t.get("nextRun", 0)
     if tt == "on_open":    return True          # boot-time task
     if tt == "issue_poll": return now_ms >= t.get("nextRun", 0)
+    if tt == "tiered_scan":  return now_ms >= t.get("nextRun", 0)  # MX-SCHED-TIERED
     return False
 
 
 def _advance_trigger(trigger: dict, now_ms: int) -> dict:
     t  = dict(trigger)
     tt = t.get("type")
-    if tt in ("interval", "issue_poll"):
+    if tt in ("interval", "issue_poll", "tiered_scan"):  # MX-SCHED-TIERED
         t["nextRun"] = now_ms + t.get("intervalMs", 3_600_000)
     elif tt == "daily":
         hour   = t.get("hour",   9)
@@ -582,14 +584,19 @@ class TaskPatch(BaseModel):
 # ─── REST Endpoints ───────────────────────────────────────────────────────────
 
 @router.get("/tasks")
-async def list_tasks() -> list[dict]:
+async def list_tasks(
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+) -> list[dict]:
     """Polling dal frontend (fallback se SSE non disponibile) — fonte di verità server-side."""
     async with _lock:
         return list(_tasks.values())
 
 
 @router.post("/tasks", status_code=201)
-async def create_task(body: TaskCreate) -> dict:
+async def create_task(
+    body: TaskCreate,
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+) -> dict:
     """Crea task sul backend. Il frontend chiama questo DOPO il salvataggio Dexie."""
     tid = body.id or f"sched_{int(time.time()*1000):x}_{uuid.uuid4().hex[:4]}"
     task: dict[str, Any] = {
@@ -616,7 +623,11 @@ async def create_task(body: TaskCreate) -> dict:
 
 
 @router.patch("/tasks/{task_id}")
-async def patch_task(task_id: str, body: TaskPatch) -> dict:
+async def patch_task(
+    task_id: str,
+    body: TaskPatch,
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+) -> dict:
     """Pausa, riprendi, o aggiorna label/trigger di un task."""
     async with _lock:
         task = _tasks.get(task_id)
@@ -631,7 +642,10 @@ async def patch_task(task_id: str, body: TaskPatch) -> dict:
 
 
 @router.delete("/tasks/{task_id}", status_code=204)
-async def delete_task(task_id: str) -> None:
+async def delete_task(
+    task_id: str,
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+) -> None:
     """Cancella task dal backend + Supabase (MX11-SCHED)."""
     async with _lock:
         if task_id not in _tasks:
@@ -644,7 +658,10 @@ async def delete_task(task_id: str) -> None:
 
 
 @router.post("/sync")
-async def sync_tasks(body: list[dict]) -> dict:
+async def sync_tasks(
+    body: list[dict],
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+) -> dict:
     """
     Bulk upsert da Dexie → backend.
     Idempotente: inserisce solo i task assenti. Non sovrascrive quelli esistenti.
@@ -675,7 +692,10 @@ async def sync_tasks(body: list[dict]) -> dict:
 
 
 @router.post("/trigger/{task_id}")
-async def trigger_task_now(task_id: str) -> dict:
+async def trigger_task_now(
+    task_id: str,
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+) -> dict:
     """Esecuzione immediata ignorando il trigger temporale (debug / run manuale)."""
     async with _lock:
         task = _tasks.get(task_id)
@@ -686,7 +706,10 @@ async def trigger_task_now(task_id: str) -> dict:
 
 
 @router.post("/tick")
-async def external_tick(request: Request) -> dict:
+async def external_tick(
+    request: Request,
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+) -> dict:
     """
     Pacemaker esterno — MX11-SCHED.
 
@@ -698,24 +721,12 @@ async def external_tick(request: Request) -> dict:
       - Esegue _tick() immediatamente (no attesa del ciclo 60s)
       - Auto-riavvia il loop asyncio se è morto (self-healing)
       - Idempotente: sicuro da più sorgenti concorrenti
-      - Non richiede auth se INTERNAL_TOKEN non configurato
+      - Richiede AuthRole.MACHINE (X-Internal-Token)
 
     Response: { ok, source, loopRevived, loopRunning, tasks, pending, running, ts }
     """
     global _loop_task
-
-    source    = request.query_params.get("source", "external")
-
-    # Token check opzionale — solo se INTERNAL_TOKEN è configurato
-    _int_tok  = os.getenv("INTERNAL_TOKEN", "")
-    # Fail-close: INTERNAL_TOKEN deve essere configurato e valido
-    if not _int_tok:
-        raise HTTPException(503, "Service unavailable — INTERNAL_TOKEN non configurato.")
-    
-    if _int_tok:
-        req_tok = request.headers.get("X-Internal-Token", "")
-        if req_tok != _int_tok:
-            raise HTTPException(403, "Unauthorized — X-Internal-Token richiesto")
+    source = request.query_params.get("source", "external")
 
     # Self-heal: riavvia il loop se morto
     loop_was_dead = _loop_task is None or _loop_task.done()
@@ -756,7 +767,9 @@ async def external_tick(request: Request) -> dict:
 
 
 @router.get("/status")
-async def scheduler_status() -> dict:
+async def scheduler_status(
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+) -> dict:
     """Stato del loop asyncio — usato dal frontend per il badge ☁️/📱."""
     loop_ok = _loop_task is not None and not _loop_task.done()
     async with _lock:
@@ -774,7 +787,10 @@ async def scheduler_status() -> dict:
 
 
 @router.get("/delta")
-async def scheduler_delta(since_ms: int = 0) -> dict:
+async def scheduler_delta(
+    since_ms: int = 0,
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+) -> dict:
     """GAP-A7: Delta-only view — solo task aggiornati dopo since_ms (epoch ms).
 
     Permette polling incrementale efficiente dal frontend:

api/search.py

@@ -8,8 +8,9 @@ import os, asyncio, html, json
 import re as _re
 import urllib.request, urllib.parse
 from typing import Optional
-from fastapi import APIRouter, HTTPException, Request
+from fastapi import APIRouter, HTTPException, Request, Depends
 from pydantic import BaseModel
+from .auth_guard import require_role, AuthRole
 
 import logging
 _logger = logging.getLogger("api.search")
@@ -237,8 +238,12 @@ async def _ddg_instant_search(q: str, limit: int) -> list[dict]:
 
 # ── Search ─────────────────────────────────────────────────────────────────────
 
-@router.post('/api/search')
-async def proxy_search(req: SearchRequest):
+@router.post('/search')
+async def proxy_search(
+    req: SearchRequest,
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+):
+    # ── GAP-FAILOPEN fix: l'endpoint ora richiede AuthRole.MACHINE ───────────
     q = req.query.strip()[:200]
     if not q:
         return {'results': []}
@@ -337,8 +342,12 @@ async def proxy_search(req: SearchRequest):
 
 # ── Fetch page ─────────────────────────────────────────────────────────────────
 
-@router.post('/api/fetch-page')
-async def proxy_fetch_page(req: FetchPageRequest):
+@router.post('/fetch-page')
+async def proxy_fetch_page(
+    req: FetchPageRequest,
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+):
+    # ── GAP-FAILOPEN fix: protezione endpoint fetch-page ─────────────────────
     url = req.url.strip()
     if not url.startswith(('http://', 'https://')):
         raise HTTPException(400, detail={'error': 'url_invalido'})
@@ -364,16 +373,16 @@ async def proxy_fetch_page(req: FetchPageRequest):
 
 # ── Analyze image ──────────────────────────────────────────────────────────────
 
-@router.post('/api/analyze-image')
-async def analyze_image(body: AnalyzeImageRequest, request: Request):
+@router.post('/analyze-image')
+async def analyze_image(
+    body: AnalyzeImageRequest,
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+):
     """
     Vision AI — OpenRouter free VL models → Gemini fallback.
     [S191] rimossi modelli deprecated.
     [S-GAP23] X-Internal-Token guard — protegge consumi LLM da abusi esterni.
     """
-    _internal_token = os.getenv('INTERNAL_TOKEN', '')
-    if _internal_token and request.headers.get('X-Internal-Token') != _internal_token:
-        raise HTTPException(401, 'Unauthorized')
     import re as _re2, json as _json
     from openai import OpenAI as _OAI
 

api/telegram_callbacks.py

@@ -5,23 +5,25 @@ Handler:
   _handle_callback — callback_data dei bottoni inline
 """
 from __future__ import annotations
-import asyncio, html, logging, os, time
+import asyncio, html, httpx, logging, os, time
 
 from .telegram_tg_client import (
     _get_bot_token, _tg_reply, _tg_send, _tg_edit,
     _tg_typing, _tg_answer_callback, _fmt_elapsed,
-    _log_tg_exc, _BACK_KB,
+    _log_tg_exc, _BACK_KB, _WEBAPP_KB,
 )
 from .telegram_keyboards import (
     _MAIN_KB, _QUICK_PICK_KB, _after_task_kb, _BENCH_CACHE, _LAST_GOAL,
+    _TASK_MENU_KB, _STATUS_MENU_KB, _PERF_MENU_KB, _DEV_MENU_KB, _HEALTH_MENU_KB,
 )
 from .telegram_cmd_ai import (
     _cmd_do, _cmd_autofix, _cmd_score, _cmd_bench, _cmd_improve,
     _cmd_scan_now, _cmd_telemetry, _cmd_coord, _cmd_git,
+    _cmd_deploy, _cmd_restart_node, _cmd_riepilogo,
 )
 from .telegram_cmd_monitoring import (
     _cmd_help, _cmd_status, _cmd_tasks, _cmd_check,
-    _cmd_logs,
+    _cmd_logs, _cmd_nodes, _cmd_commit_summary, _cmd_free_text,
 )
 
 _logger = logging.getLogger("api.telegram_webhook")
@@ -170,6 +172,34 @@ async def _handle_callback(callback_query: dict, token: str) -> None:
     elif data == "tgw_bench_run":
         # Rilancia bench
         asyncio.create_task(_cmd_bench(chat_id)).add_done_callback(_log_tg_exc)
+    # ── Dispatch: infra + monitoraggio ──────────────────────────────────────
+    elif data == "tgw_nodes":
+        asyncio.create_task(_cmd_nodes(chat_id)).add_done_callback(_log_tg_exc)
+    elif data == "tgw_commits":
+        asyncio.create_task(_cmd_commit_summary(chat_id)).add_done_callback(_log_tg_exc)
+    elif data == "tgw_deploy":
+        asyncio.create_task(_cmd_deploy(chat_id)).add_done_callback(_log_tg_exc)
+    elif data in ("tgw_restart_A","tgw_restart_B","tgw_restart_C","tgw_restart_D"):
+        node = data.split("_")[-1]  # "A","B","C","D"
+        asyncio.create_task(_cmd_restart_node(chat_id, node)).add_done_callback(_log_tg_exc)
+    elif data == "tgw_restart_all":
+        # "all" mostra conferma prima di agire (azione distruttiva)
+        asyncio.create_task(_cmd_restart_node(chat_id, "all")).add_done_callback(_log_tg_exc)
+    elif data == "tgw_confirm_restart_all":
+        # Conferma ottenuta → esegue davvero il restart di tutti i nodi
+        from .telegram_cmd_ai import _cmd_restart_node as _crn
+        asyncio.create_task(_crn(chat_id, "_CONFIRMED_ALL")).add_done_callback(_log_tg_exc)
+    # ── Confirm/cancel task da testo libero ───────────────────────────────────
+    elif data == "tgw_confirm_task":
+        from .telegram_keyboards import _LAST_GOAL
+        goal = _LAST_GOAL.get(chat_id, "")
+        if goal:
+            from .telegram_cmd_ai import _cmd_do
+            asyncio.create_task(_cmd_do(chat_id, goal)).add_done_callback(_log_tg_exc)
+        else:
+            asyncio.create_task(_cmd_help(chat_id)).add_done_callback(_log_tg_exc)
+    elif data == "tgw_cancel":
+        asyncio.create_task(_cmd_help(chat_id)).add_done_callback(_log_tg_exc)
     elif data == "tgw_score":
         asyncio.create_task(_cmd_score(chat_id)).add_done_callback(_log_tg_exc)
     elif data == "tgw_telemetry":

api/telegram_cmd_ai.py

@@ -371,7 +371,7 @@ async def _cmd_autofix(chat_id: int, hint: str = "") -> None:
             f"<b>Commit:</b> <code>{c_sha[:10]}</code>\n"
             f"<b>Branch:</b> <code>{gh_branch}</code>\n"
             f"<b>File patchati:</b>\n{files_list}\n\n"
-            "U0001f680 <b>Railway deploy:</b> avviato automaticamente\n"
+            "🚀 <b>Railway deploy:</b> avviato automaticamente\n"
             f"U0001f517 <a href=\"https://github.com/{gh_repo}/commit/{c_sha}\">Vedi commit</a>",
             final=True,
         )
@@ -1152,3 +1152,153 @@ async def _cmd_improve(chat_id: int) -> None:
             keyboard=_BACK_KB)
 
 
+
+
+# ── Nuovi comandi infrastruttura (aggiunti da refactor bot) ───────────────────
+
+async def _cmd_deploy(chat_id: int) -> None:
+    """☁️ /deploy — Trigger deploy Cloudflare Pages via hook o backend."""
+    import httpx as _hx
+    await _tg_typing(chat_id)
+
+    deploy_hook = os.getenv("CF_DEPLOY_HOOK", "").strip()
+    railway_url = os.getenv("RAILWAY_URL", "https://ai-production-4c06.up.railway.app").rstrip("/")
+
+    msg_id = await _tg_send(chat_id,
+        "☁️ <b>Deploy Cloudflare Pages</b>\n⏳ <i>Triggering build…</i>")
+
+    async def _edit_final(text: str) -> None:
+        if msg_id:
+            await _tg_edit(chat_id, msg_id, text, keyboard=_MAIN_KB)
+
+    # Prova prima il CF deploy hook diretto
+    if deploy_hook:
+        try:
+            async with _hx.AsyncClient(timeout=15.0) as c:
+                r = await c.post(deploy_hook)
+            if r.status_code in (200, 201):
+                await _edit_final(
+                    "☁️ <b>Deploy avviato!</b>\n"
+                    "⏳ <i>Build Cloudflare in corso (2-3 min)…</i>\n"
+                    "🔗 <a href='https://agente-ai.pages.dev'>Verifica live</a>"
+                )
+            else:
+                await _edit_final(f"⚠️ Hook risposta HTTP {r.status_code} — controlla CF dashboard")
+        except Exception as exc:
+            await _edit_final(f"❌ Deploy hook fallito: <code>{html.escape(str(exc)[:200])}</code>")
+        return
+
+    # Fallback: chiedi al backend Railway di triggerare il deploy
+    try:
+        async with _hx.AsyncClient(timeout=20.0) as c:
+            r = await c.post(f"{railway_url}/api/deploy",
+                             json={"target": "cloudflare", "source": "telegram"})
+        if r.status_code == 200:
+            data = r.json()
+            await _edit_final(
+                "☁️ <b>Deploy avviato via backend</b>\n"
+                f"<code>{html.escape(str(data.get('message',''))[:200])}</code>\n"
+                "🔗 <a href='https://agente-ai.pages.dev'>Verifica live</a>"
+            )
+        else:
+            await _edit_final(
+                f"⚠️ Backend risposta HTTP {r.status_code}\n"
+                "<i>Configura CF_DEPLOY_HOOK nel .env per deploy diretto.</i>"
+            )
+    except Exception as exc:
+        await _edit_final(
+            f"❌ Deploy fallito: <code>{html.escape(str(exc)[:200])}</code>\n"
+            "<i>Controlla CF_DEPLOY_HOOK nelle variabili Railway.</i>"
+        )
+
+
+async def _cmd_restart_node(chat_id: int, node: str = "") -> None:
+    """🔄 /restart A|B|C|D|all — Riavvia un nodo HF Space via HF API."""
+    import httpx as _hx
+
+    node = node.strip().upper()
+    # "_CONFIRMED_ALL" arriva dal callback tgw_confirm_restart_all (bypass conferma)
+    if node == "_CONFIRMED_ALL":
+        node = "_ALL_CONFIRMED"  # marcatore interno — salta la schermata di conferma
+    _HF_SPACES = {
+        "A": ("arjanit98", "Terminal"),
+        "B": ("baida07",   "ai-backend-collab"),
+        "C": ("baida07",   "ai-memory-backend"),
+        "D": ("arypulka98","AUDIT"),
+    }
+
+    if node not in _HF_SPACES and node not in ("ALL", "_ALL_CONFIRMED"):
+        from .telegram_keyboards import _CLUSTER_RESTART_KB
+        await _tg_reply(chat_id,
+            "⚠️ <b>Quale nodo vuoi riavviare?</b>\n\n"
+            "  A = BRAIN   (Arjanit98/Terminal)\n"
+            "  B = HANDS   (baida07/ai-backend-collab)\n"
+            "  C = MEMORY  (baida07/ai-memory-backend)\n"
+            "  D = AUDIT   (arypulka98/AUDIT)\n\n"
+            "Usa: <code>/restart A</code> oppure <code>/restart all</code>\n"
+            "<i>Ogni nodo impiega 1-2 min per ripartire dopo il restart.</i>",
+            keyboard=_CLUSTER_RESTART_KB)
+        return
+
+    # Conferma obbligatoria per restart di TUTTI i nodi (azione distruttiva)
+    if node == "ALL":
+        from .telegram_keyboards import _restart_confirm_kb
+        await _tg_reply(chat_id,
+            "⚠️ <b>Sei sicuro?</b>\n\n"
+            "Stai per riavviare <b>tutti e 4 i nodi HF Space</b>:\n"
+            "  A BRAIN · B HANDS · C MEMORY · D AUDIT\n\n"
+            "<i>L'infrastruttura sarà offline per 2-3 minuti durante il riavvio.</i>",
+            keyboard=_restart_confirm_kb("all"))
+        return
+
+    hf_token = os.getenv("HF_TOKEN", "").strip()
+    if not hf_token:
+        await _tg_reply(chat_id, "❌ HF_TOKEN non trovato nelle variabili Railway.", keyboard=_BACK_KB)
+        return
+
+    is_all = node in ("ALL", "_ALL_CONFIRMED")
+    nodes_to_restart = (
+        list(_HF_SPACES.items()) if is_all
+        else [(node, _HF_SPACES[node])]
+    )
+
+    label = "tutti i nodi" if is_all else f"nodo {node}"
+    await _tg_typing(chat_id)
+    msg_id = await _tg_send(chat_id,
+        f"🔄 <b>Restart {label}</b>\n⏳ <i>Chiamata HF API…</i>")
+
+    async def _restart_one(nid: str, owner: str, repo: str) -> tuple:
+        try:
+            async with _hx.AsyncClient(timeout=15.0) as c:
+                r = await c.post(
+                    f"https://huggingface.co/api/spaces/{owner}/{repo}/restart",
+                    headers={"Authorization": f"Bearer {hf_token}"},
+                )
+            ok = r.status_code in (200, 201, 204)
+            return nid, r.status_code, ok
+        except Exception as exc:
+            return nid, -1, False
+
+    results = await asyncio.gather(
+        *[_restart_one(nid, owner, repo) for nid, (owner, repo) in nodes_to_restart]
+    )
+
+    lines = []
+    all_ok = True
+    for nid, code, ok in results:
+        icon   = "✅" if ok else "❌"
+        status = "riavviato" if ok else f"errore HTTP {code}"
+        lines.append(f"  {icon} Nodo <b>{nid}</b>: {status}")
+        if not ok:
+            all_ok = False
+
+    summary = "Restart completato" if all_ok else "Restart parziale — verifica i nodi in errore"
+    final = (
+        f"🔄 <b>{summary}</b>\n\n" +
+        "\n".join(lines) +
+        "\n\n<i>I nodi impiegano 1-2 min per ripartire.\nUsa /nodes per verificare lo stato.</i>"
+    )
+    if msg_id:
+        await _tg_edit(chat_id, msg_id, final, keyboard=_MAIN_KB)
+    else:
+        await _tg_reply(chat_id, final, keyboard=_MAIN_KB)

api/telegram_cmd_monitoring.py

@@ -1,12 +1,14 @@
 """backend/api/telegram_cmd_monitoring.py — Comandi Telegram di monitoraggio e stato.
 
 Comandi:
-  _cmd_help, _cmd_logs, _cmd_status, _cmd_commit_summary,
-  _cmd_check, _cmd_tasks, _cmd_git, _cmd_coord,
+  _cmd_help, _cmd_logs, _cmd_status, _cmd_nodes, _cmd_free_text,
+  _cmd_commit_summary, _cmd_check, _cmd_tasks, _cmd_git, _cmd_coord,
   _cmd_scan_now, _cmd_telemetry
 """
 from __future__ import annotations
 import asyncio, html, logging, os, re, time
+import httpx  # FIX: mancava a livello modulo — usato in _cmd_commit_summary e _cmd_check
+              # (bug silenzioso: NameError catturato da 'except Exception', mai visibile all'utente)
 
 from .telegram_tg_client import (
     _get_bot_token, _tg_reply, _tg_send, _tg_edit,
@@ -15,31 +17,33 @@ from .telegram_tg_client import (
 )
 from .telegram_keyboards import (
     _MAIN_KB, _QUICK_PICK_KB, _after_task_kb, _BENCH_CACHE, _LAST_GOAL,
+    _CLUSTER_RESTART_KB, _status_action_kb, _nodes_action_kb, _task_confirm_kb,
 )
 
 _logger = logging.getLogger("api.telegram_webhook")
 
+# ── Token GitHub per commit summary e infra check ────────────────────────────
+_gh_token: str = os.getenv("GH_TOKEN") or os.getenv("GITHUB_TOKEN", "")
+
 # ── Command handlers ──────────────────────────────────────────────────────────
 
 async def _cmd_help(chat_id: int) -> None:
-    """Menu principale: un messaggio pulito + inline keyboard essenziale."""
+    """Benvenuto / menu principale."""
     await _tg_typing(chat_id)
-    welcome = (
-        "🤖 <b>Agente AI</b>\n"
-        "<i>Assistente autonomo per lo sviluppo software</i>\n\n"
-        "📝 <b>Come usarmi:</b>\n"
-        "Scrivi qualsiasi obiettivo — lo eseguo autonomamente:\n"
-        "  • <code>analizza i bug in providers.py</code>\n"
-        "  • <code>ottimizza le query Supabase più lente</code>\n"
-        "  • <code>fai autofix degli errori nel log</code>\n\n"
-        "📌 <b>Comandi rapidi:</b>\n"
-        "  /avvia — lancia un task AI\n"
-        "  /stato — vedi cosa sta facendo\n"
-        "  /salute — controllo sistema\n"
-        "  /chiedi — domanda veloce all\'AI\n\n"
-        "⬇️ <b>O scegli dal menu:</b>"
-    )
-    await _tg_reply(chat_id, welcome, keyboard=_MAIN_KB)
+    msg = (
+    "👋 <b>Agente AI</b> — controllo infrastruttura dal telefono\n\n"
+    "💬 <b>Scrivi qualsiasi cosa</b> e la gestisco io\n"
+    "   oppure usa i pulsanti qui sotto\n\n"
+    "⚡ <b>Comandi rapidi</b>\n"
+    "  /status  — cluster + deploy in un colpo\n"
+    "  /nodes   — ping live dei 4 nodi (ms)\n"
+    "  /do &lt;task&gt; — lancia un task AI\n"
+    "  /autofix — corregge errori automaticamente\n"
+    "  /logs    — ultimi warning/errori\n"
+    "  /commits — commit GitHub recenti\n\n"
+    "💡 <i>Non serve conoscere i comandi — scrivi in italiano naturale</i>"
+      )
+    await _tg_reply(chat_id, msg, keyboard=_MAIN_KB)
 
 
 async def _cmd_logs(chat_id: int, level: str = "WARNING") -> None:
@@ -77,198 +81,133 @@ async def _cmd_logs(chat_id: int, level: str = "WARNING") -> None:
     await _tg_reply(chat_id, "\n".join(lines), keyboard=_BACK_KB)
 
 
+
+
+
+
 async def _cmd_status(chat_id: int) -> None:
+    """Dashboard unificata: cluster 4 nodi HF + Railway + CF Pages + task.
+    I pulsanti cambiano in base ai nodi down (UX contestuale).
+    """
+    import httpx as _hx, datetime as _dt, time as _time
+    from .telegram_keyboards import _status_action_kb
     await _tg_typing(chat_id)
-    try:
-        from api.state import _agent_tasks, _loop_registry  # noqa: F401
-        total   = len(_agent_tasks)
-        running = sum(1 for t in _agent_tasks.values() if t.get("status") == "RUNNING")
-        success = sum(1 for t in _agent_tasks.values() if t.get("status") == "SUCCESS")
-        error   = sum(1 for t in _agent_tasks.values() if t.get("status") == "ERROR")
-        queued  = sum(1 for t in _agent_tasks.values() if t.get("status") == "QUEUED")
-
-        # Supabase fallback: se in-memory è vuoto (restart backend) legge dal DB
-        sb_line = ""
-        if total == 0:
-            try:
-                from api.state import _sb
-                if _sb:
-                    res = await asyncio.to_thread(
-                        lambda: _sb.table("agent_tasks")
-                        .select("status")
-                        .order("created_at", desc=True)
-                        .limit(50)
-                        .execute()
-                    )
-                    rows = res.data or []
-                    if rows:
-                        db_run  = sum(1 for r in rows if r.get("status") == "RUNNING")
-                        db_done = sum(1 for r in rows if r.get("status") == "SUCCESS")
-                        db_err  = sum(1 for r in rows if r.get("status") == "ERROR")
-                        sb_line = (
-                            "\n📦 <b>Supabase (ultimi 50):</b> "
-                            + str(db_run) + " in corso / "
-                            + str(db_done) + " ok / "
-                            + str(db_err) + " err"
-                            + " <i>(backend riavviato)</i>"
-                        )
-            except Exception as _exc:
-                _logger.debug("[telegram_webhook] silenced %s", type(_exc).__name__)  # noqa: BLE001
 
-        from api.scheduler import _tasks as sched_tasks, _loop_task
-        sched_ok = _loop_task is not None and not _loop_task.done()
-        sched_pending = sum(1 for t in sched_tasks.values() if t.get("status") == "pending")
-        sched_label = "✅ attivo" if sched_ok else "❌ fermo"
+    _RAILWAY = os.getenv("RAILWAY_URL", "https://ai-production-4c06.up.railway.app").rstrip("/")
+    _HF_NODES = [
+        ("A", "BRAIN",  "https://arjanit98-terminal.hf.space"),
+        ("B", "HANDS",  "https://baida07-ai-backend-collab.hf.space"),
+        ("C", "MEMORY", "https://baida07-ai-memory-backend.hf.space"),
+        ("D", "AUDIT",  "https://arypulka98-audit.hf.space"),
+    ]
 
-        ts_now = time.strftime("%Y-%m-%d %H:%M:%S")
-        railway_url = os.getenv("RAILWAY_URL","https://ai-production-4c06.up.railway.app")
-        ry_line = ""
+    async def _ping(url: str, path: str = "/", timeout: float = 7.0) -> tuple:
+        t0 = _time.monotonic()
         try:
-            import httpx as _hx
-            async with _hx.AsyncClient(timeout=4.0) as c:
-                rv = await c.get(f"{railway_url}/api/info")
-                if rv.status_code == 200:
-                    rj = rv.json()
-                    ry_line = ("\n🚂 <b>Railway:</b> v" + rj.get("version","?")
-                               + " — " + rj.get("sprint",""))
+            async with _hx.AsyncClient(timeout=timeout, follow_redirects=True) as c:
+                r = await c.get(url + path)
+            ms = round((_time.monotonic() - t0) * 1000)
+            return r.status_code, ms
         except Exception:
-            pass
+            return -1, round((_time.monotonic() - t0) * 1000)
 
-        # ── NEW-1: HEAD git + ultimo commit ──────────────────────────────────
-        # Chiama GitHub API con GITHUB_TOKEN (Railway env) — timeout 4s, silent fail.
-        # Mostra: sha corto + prima riga commit message + età ("3h fa").
-        git_line = ""
-        try:
-            import httpx as _hx_g, datetime as _dt
-            _gh_token = os.getenv("GITHUB_TOKEN", "").strip()
-            _gh_repo  = os.getenv("GITHUB_REPO", "Baida98/AI").strip()
-            if _gh_token and _gh_repo:
-                async with _hx_g.AsyncClient(timeout=4.0) as _gc:
-                    _gr = await _gc.get(
-                        f"https://api.github.com/repos/{_gh_repo}/commits/main",
-                        headers={"Authorization": f"Bearer {_gh_token}", "User-Agent": "agente-ai"},
-                        params={"per_page": 1},
-                    )
-                if _gr.status_code == 200:
-                    _cj   = _gr.json()
-                    _sha  = (_cj.get("sha") or "")[:7]
-                    _cmsg = ((_cj.get("commit") or {}).get("message") or "").split("\n")[0][:45]
-                    _date = ((_cj.get("commit") or {}).get("committer") or {}).get("date", "")
-                    _age  = ""
-                    if _date:
-                        _ts   = _dt.datetime.fromisoformat(_date.replace("Z", "+00:00"))
-                        _secs = int((_dt.datetime.now(_dt.timezone.utc) - _ts).total_seconds())
-                        if _secs < 3600:   _age = f"{_secs // 60}m fa"
-                        elif _secs < 86400: _age = f"{_secs // 3600}h fa"
-                        else:               _age = f"{_secs // 86400}g fa"
-                    git_line = (
-                        f"\n🔀 <b>HEAD:</b> <code>{html.escape(_sha)}</code>"
-                        f" {html.escape(_cmsg)} <i>({_age})</i>"
-                    )
-        except Exception:
-            pass
+    pings = await asyncio.gather(
+        *[_ping(url) for _, _, url in _HF_NODES],
+        _ping(_RAILWAY, "/health"),
+        _ping("https://agente-ai.pages.dev"),
+        return_exceptions=True,
+    )
 
-        # ── NEW-2: task live — goal + step corrente dal loop_registry ────────
-        # Per il primo task RUNNING: mostra goal + azione corrente (dal buffer SSE)
-        # + tempo trascorso. Zero overhead se non c'è task in corso.
-        live_line = ""
-        try:
-            _running_list = [t for t in _agent_tasks.values() if t.get("status") == "RUNNING"]
-            if _running_list:
-                import json as _lj
-                _rt   = _running_list[0]
-                _tid  = _rt.get("id") or _rt.get("task_id") or ""
-                _goal_s = html.escape((_rt.get("goal") or "")[:38])
-                _elapsed = ""
-                _ca = _rt.get("created_at", 0)
-                if isinstance(_ca, int) and _ca > 0:
-                    _es = int(time.time() * 1000 - _ca) // 1000
-                    _elapsed = f" · {_es // 60}m{_es % 60:02d}s" if _es >= 60 else f" · {_es}s"
-                # Legge ultimo evento SSE dal buffer (action/type corrente)
-                _act = ""
-                _ebuf = (_loop_registry.get(_tid) or {}).get("event_buffer", [])
-                for _ev in reversed(_ebuf[-30:]):
-                    try:
-                        _raw = _ev[6:] if _ev.startswith("data: ") else _ev
-                        _ed  = _lj.loads(_raw)
-                        _a   = _ed.get("action") or _ed.get("type") or ""
-                        if _a and _a not in ("ping", "connected", "keepalive"):
-                            _act = f" → <code>{html.escape(str(_a)[:20])}</code>"
-                            break
-                    except Exception:
-                        pass
-                live_line = f"\n⚙️ <b>Live:</b> {_goal_s}{_act}{_elapsed}"
-        except Exception:
-            pass
+    try:
+        from api.state import _agent_tasks
+        running  = sum(1 for t in _agent_tasks.values() if t.get("status") == "RUNNING")
+        done_tot = sum(1 for t in _agent_tasks.values() if t.get("status") == "SUCCESS")
+    except Exception:
+        running = done_tot = 0
+
+    now = _dt.datetime.now(_dt.timezone.utc).strftime("%d/%m %H:%M UTC")
+
+    def _icon_lat(r) -> tuple[str, str]:
+        if isinstance(r, Exception) or r[0] == -1:
+            return "🔴", "no risposta"
+        code, ms = r
+        if code in (200, 201, 204, 302):
+            return "✅", f"{ms}ms"
+        if code == 503:
+            return "🟠", "in avvio"
+        return "🟡", f"HTTP {code}"
+
+    down_nodes: list[str] = []
+    cluster_lines: list[str] = []
+    for i, (nid, role, _) in enumerate(_HF_NODES):
+        icon, lat = _icon_lat(pings[i])
+        if icon == "🔴":
+            down_nodes.append(nid)
+        cluster_lines.append(f"  {icon} <b>{nid}</b> {role:<7} — {lat}")
+
+    rw_icon, rw_lat = _icon_lat(pings[4])
+    cf_icon, cf_lat = _icon_lat(pings[5])
+
+    if running:
+        task_line = f"⚙️ {running} in esecuzione"
+    elif done_tot:
+        task_line = f"✅ {done_tot} completati, nessuno in corso"
+    else:
+        task_line = "— nessun task recente"
+
+    issues = ""
+    if down_nodes:
+        issues = f"\n⚠️ <b>Nodi non raggiungibili:</b> {', '.join(down_nodes)} — usa i pulsanti per riavviare"
+
+    msg = (
+        f"📊 <b>Dashboard</b> — {now}\n"
+        f"\n🖥 <b>Cluster HF</b>\n" + "\n".join(cluster_lines) +
+        f"\n\n⚙️ <b>Backend Railway</b> — {rw_icon} {rw_lat}" +
+        f"\n☁️ <b>CF Pages</b>        — {cf_icon} {cf_lat}" +
+        f"\n\n{task_line}" +
+        issues
+    )
+
+    await _tg_reply(chat_id, msg, keyboard=_status_action_kb(down_nodes))
 
-        # ── NEW-3: coord mini — sessioni agent-coord attive ──────────────────
-        # 1 riga: chi sta lavorando, su quale sprint, su quali file.
-        # Timeout aggressivo 3s — /status deve essere veloce.
-        coord_line = ""
-        try:
-            import httpx as _hx_c2, json as _jc2, time as _tc2
-            _SB_URL2 = os.getenv("SUPABASE_URL", "").rstrip("/")
-            _SB_KEY2 = os.getenv("SUPABASE_KEY", "")
-            if _SB_KEY2:
-                async with _hx_c2.AsyncClient(timeout=3.0) as _cc:
-                    _cr = await _cc.get(
-                        f"{_SB_URL2}/rest/v1/agent_tasks",
-                        params={"goal": "ilike.*__session__*", "select": "context"},
-                        headers={"apikey": _SB_KEY2, "Authorization": f"Bearer {_SB_KEY2}"},
-                    )
-                if _cr.is_success:
-                    _now_ms = int(_tc2.time() * 1000)
-                    _active = []
-                    for _row in (_cr.json() or []):
-                        try:
-                            _ctx = _jc2.loads(_row.get("context") or "{}")
-                            if _now_ms - int(_ctx.get("lastHeartbeat", 0)) < 300_000:
-                                _active.append(_ctx)
-                        except Exception:
-                            pass
-                    if _active:
-                        _s     = _active[0]
-                        _files = [f.split("/")[-1] for f in _s.get("claimedFiles", [])]
-                        _fstr  = ", ".join(_files[:3]) or "—"
-                        _extra = f" (+{len(_active)-1})" if len(_active) > 1 else ""
-                        coord_line = (
-                            f"\n🔗 <b>Coord:</b> {html.escape(_s.get('sessionName','?'))}"
-                            f" [{html.escape(_s.get('sprint','—'))}]"
-                            f" · <code>{html.escape(_fstr)}</code>{_extra}"
-                        )
-                    else:
-                        coord_line = "\n🔗 <b>Coord:</b> <i>nessuna sessione attiva</i>"
-        except Exception:
-            pass
-
-        # ── Icona salute sistema ──────────────────────────────────────────────
-        if running > 0:
-            _sys_icon, _sys_label = "⚙️", f"{running} task in esecuzione"
-        elif error > 0 and success == 0 and total > 0:
-            _sys_icon, _sys_label = "🔴", "ultimi task terminati con errore"
-        elif total == 0:
-            _sys_icon, _sys_label = "💤", "nessun task recente"
-        else:
-            _sys_icon, _sys_label = "✅", "tutto operativo"
-
-        parts = [f"📊 <b>Sistema</b> {_sys_icon} — <i>{_sys_label}</i>", ""]
-        if running or queued:
-            parts.append(f"⚙️ <b>In esecuzione:</b> {running}  ·  <b>In coda:</b> {queued}")
-        if success or error or total:
-            parts.append(f"✅ Completati: {success}  ·  ❌ Errori: {error}  ·  Totale: {total}")
-        for _extra_line in [sb_line, ry_line, git_line, live_line, coord_line]:
-            if _extra_line:
-                parts.append(_extra_line)
-        parts += [
-            "",
-            f"🗓 <b>Scheduler:</b> {sched_label}" + (f" · {sched_pending} in coda" if sched_pending else ""),
-            "",
-            f"<i>🕐 {ts_now} UTC</i>",
-        ]
-        await _tg_reply(chat_id, "\n".join(p for p in parts if p is not None),
-                        keyboard=_MAIN_KB)
-    except Exception as exc:
-        await _tg_reply(chat_id, "⚠️ Errore lettura stato: " + html.escape(str(exc)[:200]))
+
+
+
+async def _cmd_free_text(chat_id: int, text: str) -> None:
+    """Gestisce testo libero senza /comando in modo intelligente.
+
+    Logica:
+    - Testo breve (≤ 70 chars) o domanda → esegue direttamente come query AI
+    - Testo lungo → mostra card di conferma prima di eseguire il task
+    Salva sempre il testo come _LAST_GOAL per il retry.
+    """
+    from .telegram_keyboards import _task_confirm_kb
+    text = text.strip()
+    if not text:
+        await _tg_reply(chat_id, "Scrivi un obiettivo o usa /help per il menu.", keyboard=_MAIN_KB)
+        return
+
+    _LAST_GOAL[chat_id] = text  # sempre, per retry
+
+    # Domanda breve o query semplice → esegui direttamente (nessuna frizione)
+    is_short  = len(text) <= 70
+    is_question = text.endswith("?") or any(
+        text.lower().startswith(w) for w in ("cos'è", "cosa è", "come", "perché", "quando", "dove", "che", "chi", "qual")
+    )
+    if is_short or is_question:
+        from .telegram_cmd_ai import _cmd_do
+        await _cmd_do(chat_id, text)
+        return
+
+    # Goal lungo → chiedi conferma (evita task accidentali)
+    preview = html.escape(text[:150]) + ("…" if len(text) > 150 else "")
+    await _tg_reply(
+        chat_id,
+        f"🎯 <b>Eseguo questo task?</b>\n\n"
+        f"<blockquote>{preview}</blockquote>\n\n"
+        "<i>✅ Conferma per avviare, oppure ❌ per tornare al menu.</i>",
+        keyboard=_task_confirm_kb(),
+    )
 
 
 async def _cmd_commit_summary(chat_id: int) -> None:
@@ -392,6 +331,80 @@ async def _cmd_check(chat_id: int) -> None:
     await _tg_reply(chat_id, "\n".join(lines_out), keyboard=_BACK_KB)
 
 
+
+
+async def _cmd_nodes(chat_id: int) -> None:
+    """Ping live dettagliato di tutti i nodi: HF A/B/C/D + Railway + CF Pages.
+
+    FIX: era duplicata (due `_cmd_nodes` nello stesso modulo — la seconda
+    sovrascriveva silenziosamente la prima). Unificata qui in un'unica
+    versione che mantiene il rilevamento dettagliato (503 sleeping, redirect)
+    e i pulsanti di restart CONTESTUALI (solo per i nodi HF realmente giù),
+    invece della tastiera statica precedente che offriva sempre tutti i restart.
+    """
+    import httpx as _hx, datetime as _dt, time as _time
+    await _tg_typing(chat_id)
+
+    _RAILWAY = os.getenv("RAILWAY_URL", "https://ai-production-4c06.up.railway.app").rstrip("/")
+    _HF_NODES = [
+        ("A", "BRAIN",  "https://arjanit98-terminal.hf.space",       "arjanit98/Terminal"),
+        ("B", "HANDS",  "https://baida07-ai-backend-collab.hf.space", "baida07/ai-backend-collab"),
+        ("C", "MEMORY", "https://baida07-ai-memory-backend.hf.space", "baida07/ai-memory-backend"),
+        ("D", "AUDIT",  "https://arypulka98-audit.hf.space",          "arypulka98/AUDIT"),
+    ]
+
+    async def _ping_full(label: str, url: str, path: str = "/", timeout: float = 8.0) -> tuple[str, bool]:
+        import time as _t
+        t0 = _t.monotonic()
+        try:
+            async with _hx.AsyncClient(timeout=timeout, follow_redirects=True) as c:
+                r = await c.get(url + path)
+            ms = round((_t.monotonic() - t0) * 1000)
+            if r.status_code in (200, 201, 204):
+                icon, status, ok = "✅", f"OK {ms}ms", True
+            elif r.status_code == 302:
+                icon, status, ok = "✅", f"redirect {ms}ms", True
+            elif r.status_code == 503:
+                icon, status, ok = "🔴", "503 sleeping", False
+            else:
+                icon, status, ok = "🟡", f"HTTP {r.status_code} {ms}ms", True
+        except _hx.TimeoutException:
+            ms = round((_t.monotonic() - t0) * 1000)
+            icon, status, ok = "🔴", f"timeout ({ms}ms)", False
+        except Exception as exc:
+            icon, status, ok = "🔴", str(exc)[:40], False
+        return f"{icon} <b>{label}</b> — {status}", ok
+
+    now = _dt.datetime.now(_dt.timezone.utc).strftime("%d/%m %H:%M UTC")
+    await _tg_reply(chat_id, f"🖥 <b>Ping cluster</b> — {now}\n⏳ <i>Pinging 6 endpoint…</i>")
+
+    results = await asyncio.gather(
+        *[_ping_full(f"HF {nid} {role}", url) for nid, role, url, _ in _HF_NODES],
+        _ping_full("Railway backend", _RAILWAY, "/health"),
+        _ping_full("CF Pages",        "https://agente-ai.pages.dev"),
+        return_exceptions=True,
+    )
+
+    down_nodes: list[str] = []
+    lines = [f"🖥 <b>Cluster live</b> — {now}\n"]
+    for i, r in enumerate(results):
+        if isinstance(r, Exception):
+            lines.append("  ❌ Errore imprevisto")
+            continue
+        text, ok = r
+        lines.append(text)
+        if not ok and i < len(_HF_NODES):
+            down_nodes.append(_HF_NODES[i][0])  # "A", "B", "C", "D"
+
+    lines.append(
+        "\n<i>🔴 timeout/error | 🟡 risponde ma non 200 | ✅ ok</i>"
+        "\n<i>/restart A|B|C|D|all — riavvia nodo</i>"
+    )
+
+    await _tg_reply(chat_id, "\n".join(lines),
+                     keyboard=_nodes_action_kb(down_nodes) if down_nodes else _CLUSTER_RESTART_KB)
+
+
 async def _cmd_tasks(chat_id: int) -> None:
     await _tg_typing(chat_id)
     STATUS_EMOJI = {

api/telegram_keyboards.py

@@ -1,122 +1,176 @@
-"""backend/api/telegram_keyboards.py — Inline keyboards, menu e costanti UI Telegram.
-
-Costanti:
-  _QUICK_PICK_KB  — quick-pick task templates
-  _MAIN_KB        — tastiera principale (reply keyboard)
-  _LAST_GOAL      — dict chat_id → ultimo goal (per retry)
-  _BENCH_CACHE    — cache benchmark
-
-Funzioni:
-  _after_task_kb(chat_id) — keyboard post-task con retry
-"""
+"""backend/api/telegram_keyboards.py — Inline keyboards, menu e costanti UI Telegram."""
 from __future__ import annotations
-# ── Quick-pick task templates (MX-QUICKPICK) ──────────────────────────────────
-_QUICK_PICK_KB = {
-    "inline_keyboard": [
-        [{"text": "🔍 Analizza bug",    "callback_data": "qp_bug"},
-         {"text": "⚡ Ottimizza DB",    "callback_data": "qp_db"}],
-        [{"text": "🔧 AutoFix log",     "callback_data": "qp_autofix"},
-         {"text": "🔀 Riassumi commit", "callback_data": "qp_commits"}],
-        [{"text": "📝 Genera docs",     "callback_data": "qp_docs"},
-         {"text": "🧪 Genera test",     "callback_data": "qp_tests"}],
-        [{"text": "✍️ Scrivi obiettivo...", "callback_data": "qp_custom"}],
-        [{"text": "🏠 Menu",            "callback_data": "tgw_help"}],
-    ]
-}
+import html as _html
+
+# ── Stato condiviso tra moduli ────────────────────────────────────────────────
+_LAST_GOAL: dict[int, str] = {}   # ultimo goal per chat_id (retry)
+_BENCH_CACHE: dict[int, dict] = {}  # cache benchmark per chat_id
 
-# ── After-task keyboard (retry + navigazione) ─────────────────────────────────
-# Ultimo goal per chat_id — usato da 🔁 Rifai
-_LAST_GOAL: dict[int, str] = {}
+# ── Main keyboard ─────────────────────────────────────────────────────────────
+_MAIN_KB = {
+      "inline_keyboard": [
+          [{"text": "💬 Chiedi all’AI",  "callback_data": "agent"},
+           {"text": "⚡ Task rapidi",          "callback_data": "quick_pick"}],
+          [{"text": "📊 Dashboard",            "callback_data": "tgw_status"},
+           {"text": "🖥 Nodi",                 "callback_data": "tgw_nodes"}],
+          [{"text": "📋 Task attivi",          "callback_data": "tgw_tasks"},
+           {"text": "🔧 AutoFix",              "callback_data": "tgw_autofix"}],
+          [{"text": "📝 Commit",               "callback_data": "tgw_commits"},
+           {"text": "📋 Log",                  "callback_data": "tgw_logs"}],
+          [{"text": "🌐 Apri Dashboard →",     "url": "https://agente-ai.pages.dev"}],
+      ]
+    }
 
+    # ── After-task keyboard ───────────────────────────────────────────────────────
 def _after_task_kb(chat_id: int) -> dict:
-    """Keyboard mostrata dopo ogni task completato."""
+    """Keyboard post-task con retry e navigazione."""
+    return {
+        "inline_keyboard": [
+            [{"text": "🔁 Rifai stesso task", "callback_data": "tgw_retry"},
+             {"text": "🚀 Nuovo task",        "callback_data": "agent"}],
+            [{"text": "🔧 AutoFix risultato", "callback_data": "tgw_autofix"},
+             {"text": "📊 Dashboard",         "callback_data": "tgw_status"}],
+        ]
+    }
+
+# ── Conferma task da testo libero ─────────────────────────────────────────────
+def _task_confirm_kb() -> dict:
+    """Keyboard di conferma prima di eseguire un task da testo libero."""
     return {
         "inline_keyboard": [
-            [{"text": "🔁 Rifai",       "callback_data": "tgw_retry"},
-             {"text": "📋 Attività",    "callback_data": "tgw_tasks"}],
-            [{"text": "🚀 Nuovo Task",  "callback_data": "agent"},
-             {"text": "🏠 Menu",        "callback_data": "tgw_help"}],
+            [{"text": "✅ Sì, esegui",      "callback_data": "tgw_confirm_task"},
+             {"text": "🔧 AutoFix invece",  "callback_data": "tgw_autofix"}],
+            [{"text": "❌ Annulla",          "callback_data": "tgw_help"}],
         ]
     }
 
+# ── Conferma restart nodo ─────────────────────────────────────────────────────
+def _restart_confirm_kb(node: str) -> dict:
+    """Chiede conferma prima di riavviare tutti i nodi."""
+    return {
+        "inline_keyboard": [
+            [{"text": f"✅ Sì, riavvia tutti e 4",    "callback_data": "tgw_confirm_restart_all"},
+             {"text": "❌ Annulla",                    "callback_data": "tgw_help"}],
+        ]
+    }
 
+# ── Dashboard: pulsanti dinamici in base ai nodi down ───────────────────────
+def _status_action_kb(down_nodes: list[str] | None = None) -> dict:
+    """Keyboard post-dashboard: mostra restart solo per nodi effettivamente down."""
+    rows: list = []
+    if down_nodes:
+        btns = [{"text": f"🔄 Restart {n}", "callback_data": f"tgw_restart_{n}"}
+                for n in down_nodes[:4]]
+        rows += [btns[i:i+2] for i in range(0, len(btns), 2)]
+    rows.append([
+        {"text": "🔄 Aggiorna",  "callback_data": "tgw_status"},
+        {"text": "📋 Task",      "callback_data": "tgw_tasks"},
+    ])
+    rows.append([
+        {"text": "☁️ Deploy",    "callback_data": "tgw_deploy"},
+        {"text": "📋 Log",       "callback_data": "tgw_logs"},
+    ])
+    return {"inline_keyboard": rows}
 
-# ── Main reply keyboard ─────────────────────────────────────────────────────
-_MAIN_KB = {
+# ── Nodes: pulsanti dinamici per restart nodi down ────────────────────────────
+def _nodes_action_kb(down_nodes: list[str] | None = None) -> dict:
+    """Keyboard post-/nodes: restart selettivo + navigazione."""
+    rows: list = []
+    if down_nodes:
+        btns = [{"text": f"🔄 Restart {n}", "callback_data": f"tgw_restart_{n}"}
+                for n in down_nodes[:4]]
+        rows += [btns[i:i+2] for i in range(0, len(btns), 2)]
+    rows.append([
+        {"text": "🔄 Riprova ping",  "callback_data": "tgw_nodes"},
+        {"text": "📊 Dashboard",     "callback_data": "tgw_status"},
+    ])
+    return {"inline_keyboard": rows}
+
+# ── Quick-pick task templates ─────────────────────────────────────────────────
+_QUICK_PICK_KB = {
     "inline_keyboard": [
-        [{"text": "🚀 Nuovo Task",   "callback_data": "agent"},
-         {"text": "📋 Attività",     "callback_data": "tgw_tasks"}],
-        [{"text": "🩺 Salute",       "callback_data": "tgw_health"},
-         {"text": "🔧 AutoFix",      "callback_data": "tgw_autofix"}],
-        [{"text": "💬 Chiedi all'AI","callback_data": "tgw_ask"},
-         {"text": "📈 Stato",        "callback_data": "tgw_status"}],
-        [{"text": "🌐 Dashboard →",  "url": "https://agente-ai.pages.dev"}],
+        [{"text": "🔍 Analizza bug",    "callback_data": "qp_bug"},
+         {"text": "⚡ Ottimizza DB",    "callback_data": "qp_db"}],
+        [{"text": "🔧 AutoFix log",     "callback_data": "qp_autofix"},
+         {"text": "📝 Riassumi commit", "callback_data": "qp_commits"}],
+        [{"text": "📚 Genera docs",     "callback_data": "qp_docs"},
+         {"text": "🧪 Genera test",     "callback_data": "qp_tests"}],
+        [{"text": "✍️ Scrivi obiettivo…", "callback_data": "qp_custom"}],
+        [{"text": "🏠 Menu",             "callback_data": "tgw_help"}],
     ]
 }
 
-# ── Bench cache + keyboard (GAP-TGB) ─────────────────────────────────────────
-# Salva l'ultimo run bench per chat_id → usato dai callback tgw_bench_fix/run
-_BENCH_CACHE: dict[int, dict] = {}
+# ── Cluster restart full (da usare quando nessun nodo è down) ────────────────
+_CLUSTER_RESTART_KB = {
+    "inline_keyboard": [
+        [{"text": "🔄 Restart A (BRAIN)",  "callback_data": "tgw_restart_A"},
+         {"text": "🔄 Restart B (HANDS)",  "callback_data": "tgw_restart_B"}],
+        [{"text": "🔄 Restart C (MEMORY)", "callback_data": "tgw_restart_C"},
+         {"text": "🔄 Restart D (AUDIT)",  "callback_data": "tgw_restart_D"}],
+        [{"text": "⚠️ Restart TUTTI",      "callback_data": "tgw_restart_all"}],
+        [{"text": "🏠 Menu",               "callback_data": "tgw_help"}],
+    ]
+}
 
+# ── Bench action (retrocompatibilità) ─────────────────────────────────────────
 _BENCH_ACTION_KB = {
     "inline_keyboard": [
         [{"text": "🔧 Applica Fix",  "callback_data": "tgw_bench_fix"},
          {"text": "🔄 Riesegui",     "callback_data": "tgw_bench_run"}],
-        [{"text": "⚙️ Migliora",     "callback_data": "tgw_improve"}],
         [{"text": "🏠 Menu",         "callback_data": "tgw_help"}],
     ]
 }
 
-# ── ReplyKeyboardRemove — rimuove tastiera persistente da versioni precedenti ──
-_REPLY_KB_REMOVE = {"remove_keyboard": True}
-
-# ── Sub-menu inline keyboards ─────────────────────────────────────────────────
-_TASK_MENU_KB = {
+# ── Webapp / link keyboard ─────────────────────────────────────────────────────
+_WEBAPP_KB = {
     "inline_keyboard": [
-        [{"text": "🤖 Nuovo Task",   "callback_data": "tgw_do"},
-         {"text": "🔧 AutoFix",      "callback_data": "tgw_autofix"}],
-        [{"text": "⚙️ Migliora AI",  "callback_data": "tgw_improve"},
-         {"text": "📋 Task recenti", "callback_data": "tgw_tasks"}],
-        [{"text": "🧠 Briefing",     "callback_data": "tgw_briefing"},
-         {"text": "📝 Salva Nota",   "callback_data": "tgw_nota"}],
-        [{"text": "🔍 Cerca web",    "callback_data": "tgw_cerca"},
-         {"text": "🌤 Meteo",        "callback_data": "tgw_meteo"}],
+        [{"text": "🌐 Apri Dashboard", "url": "https://agente-ai.pages.dev"}],
+        [{"text": "🏠 Menu", "callback_data": "tgw_help"}],
     ]
 }
-_STATUS_MENU_KB = {
+
+# ── Task menu (alias quick-pick) ───────────────────────────────────────────────
+_TASK_MENU_KB = _QUICK_PICK_KB  # template task rapidi
+
+# ── Performance menu ──────────────────────────────────────────────────────────
+_PERF_MENU_KB = {
     "inline_keyboard": [
-        [{"text": "📊 Daemon+Task",    "callback_data": "tgw_status"},
-         {"text": "🔌 Provider AI",    "callback_data": "tgw_providers"}],
-        [{"text": "🔗 Coord sessioni", "callback_data": "tgw_coord"},
-         {"text": "🔀 Git log",        "callback_data": "tgw_git"}],
-        [{"text": "🌐 Dashboard",      "url": "https://agente-ai.pages.dev"}],
+        [{"text": "📊 Benchmark",  "callback_data": "tgw_bench"},
+         {"text": "📈 Score",      "callback_data": "tgw_score"}],
+        [{"text": "🖥 Nodi",       "callback_data": "tgw_nodes"},
+         {"text": "📊 Dashboard",  "callback_data": "tgw_status"}],
+        [{"text": "🏠 Menu",       "callback_data": "tgw_help"}],
     ]
 }
-_PERF_MENU_KB = {
+
+# ── Dev tools menu ────────────────────────────────────────────────────────────
+_DEV_MENU_KB = {
     "inline_keyboard": [
-        [{"text": "📊 Benchmark",      "callback_data": "tgw_bench"},
-         {"text": "🏆 Score",          "callback_data": "tgw_score"}],
-        [{"text": "📡 Telemetria",     "callback_data": "tgw_telemetry"},
-         {"text": "⚙️ Migliora",      "callback_data": "tgw_improve"}],
-        [{"text": "🔧 Fix gap bench",  "callback_data": "tgw_bench_fix"}],
+        [{"text": "🔧 AutoFix",    "callback_data": "tgw_autofix"},
+         {"text": "☁️ Deploy",     "callback_data": "tgw_deploy"}],
+        [{"text": "📝 Commit",     "callback_data": "tgw_commits"},
+         {"text": "📋 Log",        "callback_data": "tgw_logs"}],
+        [{"text": "🏠 Menu",       "callback_data": "tgw_help"}],
     ]
 }
-_HEALTH_MENU_KB = {
+
+# ── Status/after-dashboard actions ────────────────────────────────────────────
+_STATUS_MENU_KB = {
     "inline_keyboard": [
-        [{"text": "🔍 Scan completo",  "callback_data": "tgw_health"},
-         {"text": "📝 Log errori",     "callback_data": "tgw_logs"}],
-        [{"text": "📊 Status",         "callback_data": "tgw_status"},
-         {"text": "🔌 Provider AI",    "callback_data": "tgw_providers"}],
+        [{"text": "🔄 Aggiorna",   "callback_data": "tgw_status"},
+         {"text": "🖥 Nodi",       "callback_data": "tgw_nodes"}],
+        [{"text": "☁️ Deploy",     "callback_data": "tgw_deploy"},
+         {"text": "📋 Log",        "callback_data": "tgw_logs"}],
+        [{"text": "🏠 Menu",       "callback_data": "tgw_help"}],
     ]
 }
-_DEV_MENU_KB = {
+
+# ── Health/provider actions ────────────────────────────────────────────────────
+_HEALTH_MENU_KB = {
     "inline_keyboard": [
-        [{"text": "📸 Snapshot",       "callback_data": "tgw_snap"},
-         {"text": "✅ Verify",         "callback_data": "tgw_verify"}],
-        [{"text": "💊 Heal",           "callback_data": "tgw_heal"},
-         {"text": "📝 Log",            "callback_data": "tgw_logs"}],
-        [{"text": "🔀 Git commits",    "callback_data": "tgw_git"},
-         {"text": "🏓 Ping",          "callback_data": "tgw_ping"}],
+        [{"text": "🔄 Aggiorna",      "callback_data": "tgw_health"},
+         {"text": "🔌 Provider",      "callback_data": "tgw_providers"}],
+        [{"text": "📊 Dashboard",     "callback_data": "tgw_status"},
+         {"text": "🏠 Menu",          "callback_data": "tgw_help"}],
     ]
 }
-

api/telegram_webhook.py

@@ -2,13 +2,16 @@
 
 Riceve aggiornamenti dal bot Telegram via webhook e risponde a comandi:
   /start /help — menu + lista comandi
-  /status      — stato backend + task attivi (in-memory + Supabase fallback)
+  /status /s   — dashboard unificata: 4 nodi HF + Railway + CF Pages + task
+  /nodes       — ping live cluster con latenza ms
   /tasks       — ultimi task con elapsed time
-  /do <goal>   — lancia un nuovo task tramite loop
-  /scan_now    — health-check completo (AI + Supabase + Telegram)
-  /health      — alias /scan_now
-  /score       — score immediato dall'ultimo benchmark (no run)
-  callback_query — gestisce inline buttons notify_task_done
+  /task /do    — lancia un nuovo task tramite loop
+  /logs        — log ERROR/WARNING Railway
+  /fix         — autofix automatico errori
+  /deploy      — trigger deploy Cloudflare Pages
+  /restart A|B|C|D|all — riavvia nodo HF Space
+  /commits     — ultimi commit GitHub
+  callback_query — gestisce inline buttons
 
 ARCHITETTURA: il bot usa getUpdates polling via scripts/session-daemon.mjs.
 Il webhook NON è registrato su Telegram — l'endpoint /webhook/setup è
@@ -26,15 +29,17 @@ from .telegram_tg_client import (
 )
 from .telegram_keyboards import (
     _MAIN_KB, _QUICK_PICK_KB, _after_task_kb, _LAST_GOAL,
+    _WEBAPP_KB, _TASK_MENU_KB, _PERF_MENU_KB, _DEV_MENU_KB,
 )
 from .telegram_cmd_monitoring import (
-    _cmd_help, _cmd_logs, _cmd_status, _cmd_commit_summary,
-    _cmd_check, _cmd_tasks,
+    _cmd_help, _cmd_logs, _cmd_status, _cmd_nodes, _cmd_commit_summary,
+    _cmd_check, _cmd_tasks, _cmd_free_text,
 )
 from .telegram_cmd_ai import (
     _cmd_do, _cmd_autofix, _cmd_nota, _cmd_cerca, _cmd_meteo,
     _cmd_riepilogo, _cmd_score, _cmd_bench, _cmd_improve,
     _cmd_git, _cmd_coord, _cmd_scan_now, _cmd_telemetry,
+    _cmd_deploy, _cmd_restart_node,
 )
 from .telegram_callbacks import _handle_inline, _handle_callback
 
@@ -100,11 +105,10 @@ async def telegram_webhook(request: Request) -> dict:
         if not goal:
             await _tg_reply(chat_id,
                 "🚀 <b>Avvia un Task AI</b>\n\n"
-                "Scrivi l\'obiettivo dopo il comando:\n\n"
-                "  <code>/avvia analizza i bug in providers.py</code>\n"
-                "  <code>/avvia ottimizza le query Supabase</code>\n"
-                "  <code>/avvia fai autofix degli errori nel log</code>\n\n"
-                "💡 <i>Oppure scrivi direttamente l\'obiettivo senza nessun comando!</i>",
+                "Scrivi l\'obiettivo dopo il comando:\n"
+                "  <code>/task analizza i bug in providers.py</code>\n"
+                "  <code>/task ottimizza le query Supabase lente</code>\n\n"
+                "💡 <b>Tip:</b> <i>puoi anche scrivere direttamente senza /task!</i>",
                 keyboard=_MAIN_KB)
         else:
             _t=asyncio.create_task(_cmd_do(chat_id, goal)); _t.add_done_callback(_log_tg_exc)
@@ -136,6 +140,29 @@ async def telegram_webhook(request: Request) -> dict:
     elif cmd in ("/autofix", "/correzione", "/correggi", "/fix"):
         fix_hint = text[len(cmd):].strip()
         _t=asyncio.create_task(_cmd_autofix(chat_id, fix_hint)); _t.add_done_callback(_log_tg_exc)
+    # ── Nuovi comandi infrastruttura ───────────────────────────────────────────
+    elif cmd in ("/s",):
+        _t=asyncio.create_task(_cmd_status(chat_id)); _t.add_done_callback(_log_tg_exc)
+    elif cmd in ("/nodes", "/cluster", "/nodi"):
+        _t=asyncio.create_task(_cmd_nodes(chat_id)); _t.add_done_callback(_log_tg_exc)
+    elif cmd in ("/deploy", "/cf", "/build"):
+        _t=asyncio.create_task(_cmd_deploy(chat_id)); _t.add_done_callback(_log_tg_exc)
+    elif cmd in ("/restart", "/riavvia"):
+        node = text[len(cmd):].strip()
+        _t=asyncio.create_task(_cmd_restart_node(chat_id, node)); _t.add_done_callback(_log_tg_exc)
+    elif cmd in ("/commits", "/commit", "/git", "/log"):
+        _n = int(text.split()[1]) if len(text.split()) > 1 and text.split()[1].isdigit() else 5
+        _t=asyncio.create_task(_cmd_git(chat_id, _n)); _t.add_done_callback(_log_tg_exc)
+    elif cmd in ("/task",):
+        goal = text[len(cmd):].strip()
+        if not goal:
+            await _tg_reply(chat_id,
+                "🚀 <b>Lancia Task AI</b>\n\nUsa: <code>/task &lt;obiettivo&gt;</code>\n\nEsempi:\n"
+                "  <code>/task analizza i bug in providers.py</code>\n"
+                "  <code>/task ottimizza le query Supabase più lente</code>",
+                keyboard=_MAIN_KB)
+        else:
+            _t=asyncio.create_task(_cmd_do(chat_id, goal)); _t.add_done_callback(_log_tg_exc)
     elif cmd in ("/chart", "/burndown"):
         await _tg_reply(chat_id,
             "📈 <b>Grafici</b> — disponibili nella Dashboard\n"
@@ -196,9 +223,6 @@ async def telegram_webhook(request: Request) -> dict:
         _t=asyncio.create_task(_cmd_riepilogo(chat_id)); _t.add_done_callback(_log_tg_exc)
     elif cmd in ("/coord", "/sessioni", "/lock"):
         _t=asyncio.create_task(_cmd_coord(chat_id)); _t.add_done_callback(_log_tg_exc)
-    elif cmd in ("/git", "/log", "/commits"):
-        _n = int(text.split()[1]) if len(text.split()) > 1 and text.split()[1].isdigit() else 5
-        _t=asyncio.create_task(_cmd_git(chat_id, _n)); _t.add_done_callback(_log_tg_exc)
     # ── Reply Keyboard (testo pulsanti persistenti) ────────────────────────────
     elif text == "🚀 Lancia Task":
         await _tg_reply(chat_id, "🚀 <b>Task AI</b> — scegli un'azione:", keyboard=_TASK_MENU_KB)
@@ -218,8 +242,8 @@ async def telegram_webhook(request: Request) -> dict:
             "<code>che differenza c'è tra asyncio.Task e asyncio.gather?</code>",
             keyboard=_BACK_KB)
     else:
-        # Testo libero → avvia task come /do
-        _t=asyncio.create_task(_cmd_do(chat_id, text)); _t.add_done_callback(_log_tg_exc)
+        # Testo libero → routing intelligente con conferma se goal lungo
+        _t=asyncio.create_task(_cmd_free_text(chat_id, text)); _t.add_done_callback(_log_tg_exc)
 
     return {"ok": True}
 
@@ -233,15 +257,16 @@ async def _setup_bot_commands(token: str) -> dict:
     results: dict = {}
     base = f"https://api.telegram.org/bot{token}"
     commands = [
-        {"command": "avvia",      "description": "🚀 Avvia un task AI — /avvia <obiettivo>"},
-        {"command": "stato",      "description": "📊 Stato backend e task in corso"},
-        {"command": "salute",     "description": "🩺 Controllo salute del sistema"},
-        {"command": "benchmark",  "description": "📊 Esegui benchmark e analisi gap"},
-        {"command": "punteggio",  "description": "🏆 Punteggio attuale senza nuovo run"},
-        {"command": "correzione", "description": "🔧 Correzione automatica errori AI"},
-        {"command": "attivita",   "description": "📋 Ultimi task con tempi di esecuzione"},
-        {"command": "chiedi",     "description": "🧠 Domanda rapida — /chiedi <testo>"},
-        {"command": "aiuto",      "description": "❓ Menu principale e guida"},
+        {"command": "status",   "description": "📊 Dashboard cluster + deploy + task"},
+        {"command": "nodes",    "description": "🖥 Ping live tutti i nodi con latenza"},
+        {"command": "task",     "description": "🚀 Lancia task AI — /task <obiettivo>"},
+        {"command": "tasks",    "description": "📋 Ultimi task con stato"},
+        {"command": "logs",     "description": "📋 Log errori recenti Railway"},
+        {"command": "fix",      "description": "🔧 AutoFix automatico errori"},
+        {"command": "deploy",   "description": "☁️ Trigger deploy Cloudflare Pages"},
+        {"command": "restart",  "description": "🔄 Restart nodo HF — /restart A|B|C|D|all"},
+        {"command": "commits",  "description": "📝 Ultimi commit GitHub"},
+        {"command": "help",     "description": "❓ Menu principale"},
     ]
     async with httpx.AsyncClient(timeout=12.0) as c:
         r = await c.post(f"{base}/setMyCommands", json={"commands": commands})

main.py

@@ -29,7 +29,7 @@ from api.state import get_env_secret  # P41
 _setup_structured_log()
 import logging as _boot_logger; _boot_logger.getLogger('agente_ai').info('BOOT: importing FastAPI...')
 
-app = FastAPI(title='Agente AI', version='3.4.2')
+app = FastAPI(title='Agente AI', version='3.6.0')
 _logger = logging.getLogger('agente_ai')
 
 # S274-SEC3: INTERNAL_TOKEN — genera casuale al boot se non configurato.
@@ -214,6 +214,7 @@ from api.state_sync         import router as _state_sync_router  # S901: UltraVS
 from api.job_queue         import router as _jq_router            # S-DUAL-2: /api/jq/** Redis coordination
 from agents.skill_tracker  import skill_router as _skill_tracker_router  # P17-B2: POST /skill-record + DELETE /skill-stats
 from api.mcp               import router as _mcp_router               # P19-B3: MCP JSON-RPC 2.0 server
+from api.ads_manager import router as _ads_router            # ADS-MANAGER: /api/ads/**
 try:
     from service_handlers.semantic_memory_routes import router as _sem_mem_router  # S766-MEM
     _has_sem_mem = True
@@ -261,6 +262,7 @@ app.include_router(_integrity_router)         # P41: /api/integrity/**
 if _skill_tracker_router is not None:
     app.include_router(_skill_tracker_router)    # P17-B2: /api/agent/skill-record + /api/agent/skill-stats (DELETE)
 app.include_router(_mcp_router)                  # P19-B3: /api/mcp — MCP JSON-RPC 2.0
+app.include_router(_ads_router)                  # ADS-MANAGER: /api/ads/**
 if _has_sem_mem:
     app.include_router(_sem_mem_router)              # S766-MEM: /api/semantic-memory/**
 # (memory/sync router montato in _on_startup)
@@ -408,7 +410,7 @@ async def _startup_warmup() -> None:
     # P17-B4: pip pre-warm — importa i 20 moduli più usati dagli script sandbox
     # così la prima exec utente non paga il costo di import (~30-200ms/modulo).
     # Silenzioso: se non installato, skip.
-    import importlib as _imp
+    import importlib
     _PIP_PREWARM = [
         "numpy", "pandas", "matplotlib", "requests", "httpx",
         "json", "re", "os", "sys", "math",
@@ -417,7 +419,7 @@ async def _startup_warmup() -> None:
     ]
     for _pkg in _PIP_PREWARM:
         try:
-            _imp.import_module(_pkg)
+            importlib.import_module(_pkg)
         except Exception:
             pass
     _logger.info("BOOT: pip pre-warm %d modules done", len(_PIP_PREWARM))
@@ -431,4 +433,3 @@ else:
     _logger.warning('BOOT: no frontend at %s', _STATIC_DIR)
 
 _logger.info('BOOT: main.py v%s ready — %s routes registered ✓', app.version, len(app.routes))
-

models/ai_client.py

@@ -93,11 +93,10 @@ _MODEL_OUTPUT_LIMITS: dict[str, int] = {
     "DeepSeek-V3.2":                           8192,   # 32K ctx
     "MiniMax-M2.7":                            32768,  # 196K ctx!
     "gemma-4-31B-it":                          16384,  # 131K ctx
-    # Gemini 3.x — disponibili live 2026-06-14 (flash = free)
-    "gemini-3-flash-preview":                  32768,
-    "gemini-3.5-flash":                        32768,
-    "gemini-3.1-flash-lite":                   16384,
-    "gemini-3.1-flash-lite-preview":           16384,
+    # Gemini 2.x/2.5 — verificati luglio 2026 (GAP-DEP-GEMINI31LITE fix)
+    "gemini-2.5-flash":                        65536,
+    "gemini-2.5-flash-lite":                   32768,
+    "gemini-2.0-flash-lite":                   32768,
     # Groq 2026 — verificati live
     "openai/gpt-oss-120b":                      8192,  # Groq GPT-OSS 120B
     "openai/gpt-oss-20b":                       4096,  # Groq GPT-OSS 20B
@@ -455,7 +454,7 @@ class AIClient:
                     name=f"openrouter{suffix}",
                     api_key=key,
                     base_url="https://openrouter.ai/api/v1",
-                    default_model=os.getenv("OPENROUTER_MODEL", "openai/gpt-oss-20b:free"),
+                    default_model=os.getenv("OPENROUTER_MODEL", "nvidia/nemotron-3-nano-30b-a3b:free"),
                 ))
 
         # ── HUGGINGFACE: Qwen2.5-Coder-32B ────────────────────────────────────

models/role_router.py

@@ -1,33 +1,50 @@
 """
-role_router.py — Multi-model role routing (S362, aggiornato 2026-06-14 benchmark)
+role_router.py — Multi-model role routing (aggiornato 2026-07-03 benchmark bot-token)
 
-BENCHMARK RESULTS 2026-06-14 FINALE (14 modelli × 3 test, max_tokens corretti):
-  100% qualità (ordinati per TTFT):
-  #1  Groq / llama-3.1-8b-instant           — 170ms  100% ← FASTEST
-  #2  Cerebras / gpt-oss-120b               — 207ms  100% ← REASONING (max_tokens≥500)
-  #3  Groq / llama-3.3-70b-versatile        — 235ms  100%
-  #4  Cerebras / zai-glm-4.7               — 254ms  100%
-  #5  Groq / compound-mini                  — 341ms  100%
-  #6  SambaNova / DeepSeek-V3.1            — 482ms  100%
-  #7  SambaNova / gemma-4-31B              — 2132ms 100%
-  #8  OpenRouter / gpt-oss-120b:free        — 2160ms 100%
+BENCHMARK RESULTS 2026-07-03 (bot-dedicated tokens, 32 modelli × test parallelo):
+  ✅ 100% qualità (ordinati per TTFT):
+  #1  Cerebras / gemma-4-31b            —  236ms  100% ← REASONER PRIMARY (nuovo)
+  #2  Groq / qwen3-32b                  —  325ms  100% ← CODER PRIMARY  (strip <think>)
+  #3  Groq / llama-3.3-70b-versatile    —  313ms  100%
+  #4  Groq / llama-3.1-8b-instant       —  332ms  100%
+  #5  Groq / llama-4-scout-17b          —  395ms  100%
+  #6  Gemini / 3.1-flash-lite           —  742ms  100% ← GEMINI_FAST (nuovo)
+  #7  Gemini / 2.5-flash                —  813ms  100%
+  #8  OR / nemotron-3-super-120b:free   —  864ms  100% ← OR primary (era gpt-oss a 5920ms!)
+  #9  Groq / compound-mini              —  891ms  100%
+  #10 OR / nemotron-3-ultra-550b:free   —  922ms  100% ← 1M ctx, ARCHITECT fallback
+  #11 OR / gpt-oss-120b:free            — 5920ms  100%  (slow, ultimo fallback)
 
-Role assignments 2026-06-14 FINALE:
-  FAST       → Groq llama-3.1-8b-instant      (170ms, 100%) ← #1 assoluto
-  ARCHITECT  → Groq llama-4-scout-17b 10M ctx  (244ms, 67%  — best per contesto lungo)
-  CODER      → Groq llama-3.3-70b-versatile    (235ms, 100%) ← #3 qualità
-  TESTER     → Groq llama-3.1-8b-instant
-  CONTEXT    → Groq llama-3.1-8b-instant
-  RESEARCHER → Gemini 2.5-flash (599ms, 67% — math prompt-sensitive)
-  REASONER   → Cerebras gpt-oss-120b (207ms, 100%, reasoning model → max_tokens≥500)
-  SAMBANOVA  → SambaNova DeepSeek-V3.1 (482ms, 100%)
-  DEFAULT    → AIClient() primary (llama-3.3-70b-versatile o primo disponibile)
+  ❌ Non disponibili con token bot attuali:
+  - GitHub Models (GH_TOKEN_BOT: bad credentials — mancano permessi GitHub Models)
+  - Cloudflare Workers AI (CF_API_TOKEN_BOT: auth error 10000)
+  - SambaNova (SAMBANOVA_API_KEY non bot-dedicata)
+  - Cerebras gpt-oss-120b (429 rate-limit durante test — gemma-4-31b ora primario)
+  - Cerebras zai-glm-4.7 (content vuoto: genera solo "reasoning" field, skip)
 
-OpenRouter tenuto come fallback secondario (gpt-oss-120b:free = 1645ms ma 100% qualità).
+Role assignments 2026-07-03:
+  FAST        → Groq llama-3.1-8b-instant     (332ms, 100%)
+  ARCHITECT   → Groq llama-4-scout-17b 10M ctx (395ms, 100%) + OR nemotron-ultra 1M ctx fallback
+  CODER       → Groq qwen3-32b                 (325ms, 100%, strip <think>)
+  TESTER      → Groq llama-3.1-8b-instant
+  CONTEXT     → Groq llama-3.1-8b-instant
+  RESEARCHER  → Gemini 2.5-flash               (813ms, 100%)
+  GEMINI_FAST → Gemini 3.1-flash-lite          (742ms, 100%) ← nuovo
+  REASONER    → Cerebras gemma-4-31b            (236ms, 100%) ← aggiornato da gpt-oss-120b
+  OPENROUTER  → OR nemotron-3-super-120b:free   (864ms, 100%) ← aggiornato da gpt-oss-120b (5920ms)
+  SAMBANOVA   → SambaNova DeepSeek-V3.1         (482ms, 100%) [chiave condivisa, non bot-dedicata]
+  NVIDIA      → NVIDIA NIM nemotron-3-super-120b-a12b
+  GITHUB      → GitHub Models gpt-4o-mini       [fallback a CODER se bad credentials]
+  CLOUDFLARE  → CF Workers AI llama-3.3-70b     [fallback a FAST se auth error]
+  DEFAULT     → AIClient() primary
+
+Nota CODER qwen3: stripping automatico <think>...</think> via strip_thinking().
+Nota CEREBRAS: legge CEREBRAS_API_KEY o CERBERUS_TOKEN (alias bot-dedicato su Railway).
 """
 from __future__ import annotations
 
 import os
+import re
 from enum import Enum
 from typing import Any
 
@@ -35,17 +52,29 @@ import logging
 _logger = logging.getLogger("models.role_router")
 
 
+def strip_thinking(text: str) -> str:
+    """Rimuove blocchi <think>...</think> dai modelli qwen3 e simili."""
+    if not text:
+        return text
+    cleaned = re.sub(r"<think>.*?</think>", "", text, flags=re.DOTALL)
+    return cleaned.strip()
+
+
 class Role(str, Enum):
-    FAST       = "fast"        # greetings, math semplice, identity — llama-3.1-8b-instant
-    ARCHITECT  = "architect"   # planning, ragionamento complesso — llama-4-scout-17b (10M ctx)
-    CODER      = "coder"       # coding, debug — llama-3.3-70b-versatile
-    TESTER     = "tester"      # test gen, debug hints — llama-3.1-8b-instant
-    CONTEXT    = "context"     # summarization, context compression — llama-3.1-8b-instant
-    DEFAULT    = "default"     # AIClient() primary
-    RESEARCHER = "researcher"  # web research + document synthesis — Gemini 2.5-flash
-    REASONER   = "reasoner"    # throughput massimo — Cerebras gpt-oss-120b (2000+ tok/s)
-    SAMBANOVA  = "sambanova"
-    NVIDIA     = "nvidia"    # NVIDIA NIM — nemotron-3-ultra-550b (1M ctx)   # DeepSeek-V3.1 via SambaNova (404ms, 100% qualità benchmark)
+    FAST        = "fast"         # greetings, math semplice, identity — llama-3.1-8b-instant
+    ARCHITECT   = "architect"    # planning, ragionamento complesso — llama-4-scout-17b (10M ctx)
+    CODER       = "coder"        # coding, debug — qwen3-32b (strip <think>)
+    TESTER      = "tester"       # test gen, debug hints — llama-3.1-8b-instant
+    CONTEXT     = "context"      # summarization, context compression — llama-3.1-8b-instant
+    DEFAULT     = "default"      # AIClient() primary
+    RESEARCHER  = "researcher"   # web research + doc synthesis — Gemini 2.5-flash
+    GEMINI_FAST = "gemini_fast"  # light research, quick synthesis — Gemini 3.1-flash-lite
+    REASONER    = "reasoner"     # throughput massimo — Cerebras gemma-4-31b (236ms)
+    OPENROUTER  = "openrouter"   # OR nemotron-super-120b:free (864ms) — fallback universale
+    SAMBANOVA   = "sambanova"    # DeepSeek-V3.1 via SambaNova (482ms)
+    NVIDIA      = "nvidia"       # NVIDIA NIM — nemotron-3-super-120b-a12b (1M ctx)
+    GITHUB      = "github"       # GitHub Models gpt-4o-mini [fallback a CODER]
+    CLOUDFLARE  = "cloudflare"   # CF Workers AI llama-3.3-70b [fallback a FAST]
 
 
 class RoleRouter:
@@ -69,15 +98,23 @@ class RoleRouter:
                 return RoleRouter._tester_client()
             if role == Role.RESEARCHER:
                 return RoleRouter._researcher_client()
+            if role == Role.GEMINI_FAST:
+                return RoleRouter._gemini_fast_client()
             if role == Role.REASONER:
                 return RoleRouter._reasoner_client()
+            if role == Role.OPENROUTER:
+                return RoleRouter._openrouter_client()
             if role == Role.SAMBANOVA:
                 return RoleRouter._sambanova_client()
             if role == Role.NVIDIA:
                 return RoleRouter._nvidia_client()
+            if role == Role.GITHUB:
+                return RoleRouter._github_client()
+            if role == Role.CLOUDFLARE:
+                return RoleRouter._cloudflare_client()
         except Exception as _exc:
             _logger.warning("[role_router] GAP-ROUT: fallback to default AIClient — role=%s raised %s: %s",
-                            role.value, type(_exc).__name__, _exc)  # GAP-ROUT-FIX: debug→warning
+                            role.value, type(_exc).__name__, _exc)
         from models.ai_client import AIClient
         return AIClient()
 
@@ -85,7 +122,7 @@ class RoleRouter:
 
     @staticmethod
     def _fast_client() -> Any:
-        """Groq llama-3.1-8b-instant — 344ms TTFT, 100% benchmark qualità.
+        """Groq llama-3.1-8b-instant — 332ms TTFT, 100% qualità.
         Usato per: greetings, calcoli semplici, identity, domande 1-liner."""
         from models.ai_client import AIClient, ProviderConfig
         groq_key = os.getenv("GROQ_API_KEY")
@@ -98,7 +135,7 @@ class RoleRouter:
             base_url="https://api.groq.com/openai/v1",
             default_model=os.getenv("GROQ_FAST_MODEL", "llama-3.1-8b-instant"),
         )
-        rest = [p for p in client.providers if p.name not in ("groq", "groq-fast", "groq-tester")]
+        rest = [p for p in client.providers if p.name not in ("groq", "groq-fast")]
         client.providers = [fast, *rest]
         client.provider_name = fast.name
         client.default_model = fast.default_model
@@ -107,101 +144,86 @@ class RoleRouter:
 
     @staticmethod
     def _architect_client() -> Any:
-        """NVIDIA Nemotron-3-Ultra-550B (1M ctx) come primario — massima potenza per architettura.
-        Fallback 1: Groq llama-4-scout-17b (10M ctx, 480ms). Fallback 2: OpenRouter gpt-oss-120b:free."""
+        """Groq llama-4-scout-17b (10M ctx) come primario — ottimo per planning e contesto lungo.
+        Fallback 1: OR nemotron-ultra-550b:free (922ms, 1M ctx) per max contesto.
+        Fallback 2: Groq llama-3.3-70b-versatile."""
         from models.ai_client import AIClient, ProviderConfig
-        # NVIDIA NIM — nemotron-3-ultra-550b-a55b: 1M ctx, 550B params, free tier
-        nvidia_key = os.getenv("NVIDIA_API_KEY")
-        if nvidia_key:
-            client = AIClient()
-            nvidia = ProviderConfig(
-                name="nvidia-architect",
-                api_key=nvidia_key,
-                base_url="https://integrate.api.nvidia.com/v1",
-                default_model=os.getenv("NVIDIA_ARCHITECT_MODEL", "nvidia/nemotron-3-ultra-550b-a55b"),
-            )
-            rest = [p for p in client.providers if not p.name.startswith("nvidia")]
-            client.providers = [nvidia, *rest]
-            client.provider_name = nvidia.name
-            client.default_model = nvidia.default_model
-            client.client = client._client_for(nvidia)
-            return client
         groq_key = os.getenv("GROQ_API_KEY")
-        model = os.getenv("ARCHITECT_MODEL", "meta-llama/llama-4-scout-17b-16e-instruct")
         if groq_key:
             client = AIClient()
             architect = ProviderConfig(
                 name="groq-architect",
                 api_key=groq_key,
                 base_url="https://api.groq.com/openai/v1",
-                default_model=model,
+                default_model=os.getenv("ARCHITECT_MODEL", "meta-llama/llama-4-scout-17b-16e-instruct"),
             )
-            rest = [p for p in client.providers if p.name not in ("groq", "groq-architect")]
+            rest = [p for p in client.providers if not p.name.startswith("groq")]
             client.providers = [architect, *rest]
             client.provider_name = architect.name
             client.default_model = architect.default_model
             client.client = client._client_for(architect)
             return client
-        # Fallback: OpenRouter gpt-oss-120b:free (1645ms ma 100% qualità)
-        openrouter_key = os.getenv("OPENROUTER_API_KEY")
-        if openrouter_key:
+        # Fallback 1: OR nemotron-ultra (1M ctx) se GROQ non disponibile
+        or_key = os.getenv("OPENROUTER_API_KEY")
+        if or_key:
             client = AIClient()
-            fallback = ProviderConfig(
+            ultra = ProviderConfig(
                 name="openrouter-architect",
-                api_key=openrouter_key,
+                api_key=or_key,
                 base_url="https://openrouter.ai/api/v1",
-                default_model="openai/gpt-oss-120b:free",
+                default_model="nvidia/nemotron-3-ultra-550b-a55b:free",
             )
             rest = [p for p in client.providers if not p.name.startswith("openrouter")]
-            client.providers = [fallback, *rest]
-            client.provider_name = fallback.name
-            client.default_model = fallback.default_model
-            client.client = client._client_for(fallback)
+            client.providers = [ultra, *rest]
+            client.provider_name = ultra.name
+            client.default_model = ultra.default_model
+            client.client = client._client_for(ultra)
             return client
         return AIClient()
 
     @staticmethod
     def _coder_client() -> Any:
-        """Groq llama-3.3-70b-versatile — 358ms TTFT, 100% benchmark qualità.
-        AGGIORNATO 2026-06-14: era OpenRouter qwen3-coder:free → 429 rate-limited daily.
-        Fallback: OpenRouter gpt-oss-120b:free se GROQ_API_KEY mancante."""
+        """Groq qwen3-32b — 325ms TTFT, 100% qualità, eccellente per coding.
+        NOTA: strip_thinking() rimuove <think>...</think> dall'output.
+        Fallback: Groq llama-3.3-70b-versatile → OpenRouter nemotron-super:free."""
         from models.ai_client import AIClient, ProviderConfig
         groq_key = os.getenv("GROQ_API_KEY")
-        model = os.getenv("CODER_MODEL", "llama-3.3-70b-versatile")
         if groq_key:
             client = AIClient()
             coder = ProviderConfig(
                 name="groq-coder",
                 api_key=groq_key,
                 base_url="https://api.groq.com/openai/v1",
-                default_model=model,
+                default_model=os.getenv("CODER_MODEL", "qwen/qwen3-32b"),
             )
-            rest = [p for p in client.providers if p.name not in ("groq", "groq-coder")]
+            rest = [p for p in client.providers if not p.name.startswith("groq")]
             client.providers = [coder, *rest]
             client.provider_name = coder.name
             client.default_model = coder.default_model
             client.client = client._client_for(coder)
             return client
+        # Fallback: OpenRouter nemotron-super
         openrouter_key = os.getenv("OPENROUTER_API_KEY")
         if openrouter_key:
             client = AIClient()
-            fallback = ProviderConfig(
+            coder_or = ProviderConfig(
                 name="openrouter-coder",
                 api_key=openrouter_key,
                 base_url="https://openrouter.ai/api/v1",
-                default_model="openai/gpt-oss-120b:free",
+                default_model="nvidia/nemotron-3-super-120b-a12b:free",
             )
             rest = [p for p in client.providers if not p.name.startswith("openrouter")]
-            client.providers = [fallback, *rest]
-            client.provider_name = fallback.name
-            client.default_model = fallback.default_model
-            client.client = client._client_for(fallback)
+            client.providers = [coder_or, *rest]
+            client.provider_name = coder_or.name
+            client.default_model = coder_or.default_model
+            client.client = client._client_for(coder_or)
             return client
         return AIClient()
 
     @staticmethod
     def _researcher_client() -> Any:
-        """Gemini 2.5-flash — TTFT 910ms, ottima per research/synthesis/doc analysis."""
+        """Gemini 2.5-flash — TTFT 813ms, ottima per research/synthesis/doc analysis.
+        Fallback: AIClient() primario se GEMINI_API_KEY mancante."""
         from models.ai_client import AIClient, ProviderConfig
         gemini_key = os.getenv("GEMINI_API_KEY") or os.getenv("GOOGLE_API_KEY")
         if not gemini_key:
@@ -220,22 +242,46 @@ class RoleRouter:
         client.client = client._client_for(researcher)
         return client
 
+    @staticmethod
+    def _gemini_fast_client() -> Any:
+        """Gemini 3.1-flash-lite — 742ms TTFT, più veloce di 2.5-flash.
+        Usato per: research leggera, synthesis rapida, task non computazionalmente pesanti.
+        Fallback: gemini-2.5-flash → AIClient() primario."""
+        from models.ai_client import AIClient, ProviderConfig
+        gemini_key = os.getenv("GEMINI_API_KEY") or os.getenv("GOOGLE_API_KEY")
+        if not gemini_key:
+            return RoleRouter._researcher_client()
+        client = AIClient()
+        fast_gem = ProviderConfig(
+            name="gemini-fast",
+            api_key=gemini_key,
+            base_url="https://generativelanguage.googleapis.com/v1beta/openai",
+            default_model="gemini-2.5-flash-lite",
+        )
+        rest = [p for p in client.providers if not p.name.startswith("gemini")]
+        client.providers = [fast_gem, *rest]
+        client.provider_name = fast_gem.name
+        client.default_model = fast_gem.default_model
+        client.client = client._client_for(fast_gem)
+        return client
+
     @staticmethod
     def _reasoner_client() -> Any:
-        """Cerebras gpt-oss-120b — 207ms TTFT, 100% qualità (bench 2026-06-14).
-        REASONING MODEL: genera "reasoning" field prima del "content".
-        Richiede max_tokens≥500 per output non-vuoto su task non-triviali.
-        Fallback: _coder_client (Groq 70B) se CEREBRAS_API_KEY mancante."""
+        """Cerebras gemma-4-31b — 236ms TTFT, 100% qualità (bench 2026-07-03).
+        Aggiornato: era gpt-oss-120b (rate-limited). gemma-4-31b più veloce e stabile.
+        Legge CEREBRAS_API_KEY o CERBERUS_TOKEN (alias bot-dedicato Railway).
+        Fallback: Cerebras gpt-oss-120b → _coder_client (Groq)."""
         from models.ai_client import AIClient, ProviderConfig
-        cerebras_key = os.getenv("CEREBRAS_API_KEY")
+        cerebras_key = os.getenv("CEREBRAS_API_KEY") or os.getenv("CERBERUS_TOKEN")
         if not cerebras_key:
             return RoleRouter._coder_client()
         client = AIClient()
+        # Primary: gemma-4-31b (236ms, più stabile)
         reasoner = ProviderConfig(
             name="cerebras-reasoner",
             api_key=cerebras_key,
             base_url="https://api.cerebras.ai/v1",
-            default_model=os.getenv("CEREBRAS_MODEL", "gpt-oss-120b"),
+            default_model=os.getenv("CEREBRAS_MODEL", "gemma-4-31b"),
         )
         rest = [p for p in client.providers if not p.name.startswith("cerebras")]
         client.providers = [reasoner, *rest]
@@ -244,10 +290,32 @@ class RoleRouter:
         client.client = client._client_for(reasoner)
         return client
 
+    @staticmethod
+    def _openrouter_client() -> Any:
+        """OR nemotron-3-super-120b-a12b:free — 864ms TTFT, 100% qualità.
+        AGGIORNATO 2026-07-03: era gpt-oss-120b:free (5920ms) → 7× più veloce.
+        Fallback: gpt-oss-120b:free (lento ma sempre disponibile)."""
+        from models.ai_client import AIClient, ProviderConfig
+        or_key = os.getenv("OPENROUTER_API_KEY")
+        if not or_key:
+            return RoleRouter._coder_client()
+        client = AIClient()
+        or_cfg = ProviderConfig(
+            name="openrouter-primary",
+            api_key=or_key,
+            base_url="https://openrouter.ai/api/v1",
+            default_model="nvidia/nemotron-3-super-120b-a12b:free",
+        )
+        rest = [p for p in client.providers if not p.name.startswith("openrouter")]
+        client.providers = [or_cfg, *rest]
+        client.provider_name = or_cfg.name
+        client.default_model = or_cfg.default_model
+        client.client = client._client_for(or_cfg)
+        return client
+
     @staticmethod
     def _sambanova_client() -> Any:
         """SambaNova DeepSeek-V3.1 — 482ms TTFT, 100% qualità (bench 2026-06-14).
-        gemma-4-31B-it: 100% ma 2132ms. Meta-Llama: rate-limited. gpt-oss-120b: ERR.
         Fallback: _architect_client (Groq) se SAMBANOVA_API_KEY mancante."""
         from models.ai_client import AIClient, ProviderConfig
         sn_key = os.getenv("SAMBANOVA_API_KEY")
@@ -289,6 +357,53 @@ class RoleRouter:
         client.client = client._client_for(nvidia)
         return client
 
+    @staticmethod
+    def _github_client() -> Any:
+        """GitHub Models gpt-4o-mini — via models.inference.ai.azure.com.
+        NOTA 2026-07-03: GH_TOKEN_BOT richiede permesso 'GitHub Models' abilitato.
+        Fallback automatico a _coder_client se credenziali non valide."""
+        from models.ai_client import AIClient, ProviderConfig
+        gh_key = os.getenv("GH_TOKEN") or os.getenv("GITHUB_TOKEN")
+        if not gh_key:
+            return RoleRouter._coder_client()
+        client = AIClient()
+        gh = ProviderConfig(
+            name="github-models",
+            api_key=gh_key,
+            base_url="https://models.inference.ai.azure.com",
+            default_model="gpt-4o-mini",
+        )
+        rest = [p for p in client.providers if not p.name.startswith("github")]
+        client.providers = [gh, *rest]
+        client.provider_name = gh.name
+        client.default_model = gh.default_model
+        client.client = client._client_for(gh)
+        return client
+
+    @staticmethod
+    def _cloudflare_client() -> Any:
+        """Cloudflare Workers AI @cf/meta/llama-3.3-70b-instruct-fp8-fast.
+        NOTA 2026-07-03: CF_API_TOKEN_BOT auth error 10000 — mancano permessi Workers AI.
+        Fallback automatico a _fast_client."""
+        from models.ai_client import AIClient, ProviderConfig
+        cf_key = os.getenv("CF_API_TOKEN")
+        cf_account = os.getenv("CF_ACCOUNT_ID", "7ecd58d02d361d654de789dc5e976a6e")
+        if not cf_key:
+            return RoleRouter._fast_client()
+        client = AIClient()
+        cf = ProviderConfig(
+            name="cloudflare-ai",
+            api_key=cf_key,
+            base_url=f"https://api.cloudflare.com/client/v4/accounts/{cf_account}/ai/v1",
+            default_model="@cf/meta/llama-3.3-70b-instruct-fp8-fast",
+        )
+        rest = [p for p in client.providers if not p.name.startswith("cloudflare")]
+        client.providers = [cf, *rest]
+        client.provider_name = cf.name
+        client.default_model = cf.default_model
+        client.client = client._client_for(cf)
+        return client
+
     @staticmethod
     def _tester_client() -> Any:
         """Groq llama-3.1-8b-instant — fast, sufficiente per test gen e debug hints."""

requirements.txt

@@ -16,5 +16,4 @@ cryptography>=42.0.0
 # Provider SDKs — richiesti da T15 benchmark + client diretti (confermati su HF Space 2026-06-14)
 aiohttp>=3.9.0
 groq>=0.11.0
-google-generativeai>=0.8.0
 # SambaNova (OpenAI-compat, usa openai client) — nessun SDK separato necessario