sync: 125 file da Baida98/AI@4bad3bd3 (2026-07-10 21:37 UTC)

agents/backend_antiregress.py

@@ -5,8 +5,7 @@
 #   1. Import injection — nuove dipendenze esterne non presenti nell'originale
 #   2. Code rewrite — output ha drasticamente meno classi/def dell'originale
 #
-# Chiamato dentro il loop _llm_try di unified_loop_fallback.py (FallbackMixin._run_fallback) prima del `break`.
-# Post-split 2026-06-30: il loop LLM risiede in unified_loop_fallback.py, non in unified_loop.py.
+# Chiamato dentro il loop _llm_try di unified_loop.py prima del `break`.
 # Non bloccante: qualsiasi eccezione interna viene silenziata dal caller.
 
 from __future__ import annotations

agents/context_manager.py

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

agents/executor.py

@@ -17,6 +17,20 @@ from models.ai_client import AIClient
 from memory.manager import MemoryManager
 from tools.registry import TOOL_REGISTRY
 
+# P17-B1: pre-esecuzione syntax check — fail-open se ast_check non disponibile
+try:
+    from tools.ast_check import check_code_syntax as _check_syntax
+    _CHECK_SYNTAX_AVAILABLE = True
+except ImportError:
+    _CHECK_SYNTAX_AVAILABLE = False
+    def _check_syntax(code: str, lang: str):  # type: ignore[misc]
+        class _Ok:
+            ok    = True
+            error = None
+            line  = None
+            col   = None
+        return _Ok()
+
 _logger = logging.getLogger("agente_ai.executor")
 
 # ─── Costanti circuit breaker ────────────────────────────────────────────────
@@ -25,11 +39,14 @@ _MIN_CALLS_FOR_CIRCUIT  = 3      # minimo di chiamate prima che il circuit possa
 _RECOVERY_INTERVAL      = 5      # ogni N chiamate con circuit open → tenta il tool primario
 
 # ─── S-ORCH-8GAP FIX-GAP2: Adaptive Timeout Tracker ─────────────────────────
+# Sliding window (last 5 durations) per tool — calcola P90 adattivo.
+# Strategia iPhone: rete variabile → se tool è stato lento di recente,
+# aumenta timeout; se è stato veloce, non sprecare tempo.
 class _AdaptiveTimeoutTracker:
     """Tracked P90 per-tool timeout con sliding window di 5 call."""
     _WINDOW     = 5
-    _MIN        = 4.0   # mai sotto 4s
-    _MAX        = 55.0  # mai sopra 55s
+    _MIN        = 4.0   # mai sotto 4s — tool veloci non vanno sotto
+    _MAX        = 55.0  # mai sopra 55s — iPhone connection timeout ~60s
     _MULTIPLIER = 1.5   # P90 * 1.5 = headroom conservativo
 
     def __init__(self) -> None:
@@ -41,9 +58,10 @@ class _AdaptiveTimeoutTracker:
         self._times[tool_name].append(elapsed)
 
     def adaptive_timeout(self, tool_name: str, base_timeout: float) -> float:
+        """Ritorna timeout adattivo: P90 * 1.5 se dati sufficienti, else base."""
         times = self._times.get(tool_name)
         if not times or len(times) < 2:
-            return base_timeout
+            return base_timeout  # dati insufficienti → usa base invariato
         sorted_t = sorted(times)
         p90_idx  = min(int(len(sorted_t) * 0.9), len(sorted_t) - 1)
         adaptive = sorted_t[p90_idx] * self._MULTIPLIER
@@ -51,16 +69,24 @@ class _AdaptiveTimeoutTracker:
 
 _timeout_tracker = _AdaptiveTimeoutTracker()
 
+# P17-B1: mapping tool_name → (argomento_codice, linguaggio) per syntax check
+_CODE_EXEC_TOOLS: dict[str, tuple[str, str]] = {
+    "run_python": ("code", "python"),
+    "run_code":   ("code", "python"),
+}
+
 
+# ─── Helper: ottieni session_id dal ContextVar (impostato da unified_loop.py) ─
 def _get_session_id() -> str:
     try:
         from tools.registry import _agent_session_id_var
         return _agent_session_id_var.get()
-    except Exception as e:
-        _logger.debug("[executor] _get_session_id failed: %s", e)
+    except Exception:
         return "default"
 
 
+# ─── Executor ────────────────────────────────────────────────────────────────
+
 class Executor:
     def __init__(
         self,
@@ -71,21 +97,33 @@ class Executor:
         self.llm         = llm_client or AIClient()
         self.memory      = memory
         self.max_retries = max_retries
+        # GAP-SKILL-SYNC v2: contatore chiamate per recovery credit (per-tool)
         self._circuit_recovery_counts: dict[str, int] = {}
 
+    # Backward-compat: vecchia firma aveva ollama=OllamaClient, memory=MemoryManager
     @classmethod
     def from_ollama(cls, ollama=None, memory=None, max_retries: int = 2) -> "Executor":
         return cls(memory=memory, max_retries=max_retries)
 
+    # ── Circuit breaker helper ────────────────────────────────────────────────
+
     def _is_circuit_open(self, tool_name: str, session_id: str) -> bool:
+        """True se il circuit breaker deve aprirsi per questo tool in questa sessione.
+
+        Condizioni (tutte necessarie):
+          1. Wilson score < CIRCUIT_OPEN_THRESHOLD (0.15)
+          2. >= MIN_CALLS_FOR_CIRCUIT (3) chiamate nella sessione
+          3. Il tool ha fallback disponibili in TOOL_REGISTRY
+        Recovery credit: ogni RECOVERY_INTERVAL chiamate, il circuit si chiude
+        temporaneamente per un tentativo di recovery.
+        """
         tool = TOOL_REGISTRY.get(tool_name, {})
         if not tool.get("fallbacks"):
-            return False
+            return False  # senza fallback il circuit non può aprirsi
         try:
             from agents.skill_tracker import get_skill_tracker
             stats = get_skill_tracker().get_stats(session_id).get(tool_name)
-        except Exception as e:
-            _logger.debug("[executor] _is_circuit_open failed to get skill tracker: %s", e)
+        except Exception:
             return False
         if not stats:
             return False
@@ -93,13 +131,19 @@ class Executor:
             return False
         if stats["wilson_score"] >= _CIRCUIT_OPEN_THRESHOLD:
             return False
+        # Recovery credit: conta le chiamate e apri una finestra ogni RECOVERY_INTERVAL
         count = self._circuit_recovery_counts.get(tool_name, 0) + 1
         self._circuit_recovery_counts[tool_name] = count
         if count % _RECOVERY_INTERVAL == 0:
-            _logger.info("[executor] recovery credit: riprovo %s (circuit call #%d)", tool_name, count)
-            return False
+            _logger.info(
+                "[executor] recovery credit: riprovo %s (circuit call #%d)",
+                tool_name, count,
+            )
+            return False   # consenti un tentativo di recovery
         return True
 
+    # ── Fallback execution ────────────────────────────────────────────────────
+
     async def _try_fallbacks(
         self,
         primary_name: str,
@@ -107,6 +151,11 @@ class Executor:
         timeout:      float,
         session_id:   str,
     ) -> "dict | None":
+        """Tenta i fallback definiti in TOOL_REGISTRY ordinati per Wilson score.
+
+        Registra ogni tentativo nel skill_tracker sotto il nome del fallback.
+        Ritorna il primo risultato con successo, o None se tutti falliscono.
+        """
         tool      = TOOL_REGISTRY.get(primary_name, {})
         fallbacks = tool.get("fallbacks", [])
         if not fallbacks:
@@ -115,25 +164,28 @@ class Executor:
         try:
             from agents.skill_tracker import get_skill_tracker
             sorted_fbs = get_skill_tracker().get_sorted_fallbacks(session_id, fallbacks)
-        except Exception as e:
-            _logger.debug("[executor] _try_fallbacks failed to sort: %s", e)
-            sorted_fbs = fallbacks
+        except Exception:
+            sorted_fbs = fallbacks   # ordinamento originale come fallback del fallback
 
         for fb_name in sorted_fbs:
             fb_tool = TOOL_REGISTRY.get(fb_name)
             if not fb_tool or not fb_tool.get("_fn"):
                 continue
-            _logger.info("[executor] %s fallita — provo fallback %s", primary_name, fb_name)
+            _logger.info(
+                "[executor] %s fallita — provo fallback %s (Wilson-sorted)",
+                primary_name, fb_name,
+            )
             try:
                 _t0     = _time_mod.monotonic()
                 _fb_to  = _timeout_tracker.adaptive_timeout(fb_name, timeout)
                 result  = await asyncio.wait_for(fb_tool["_fn"](**inputs), timeout=_fb_to)
                 _timeout_tracker.record(fb_name, _time_mod.monotonic() - _t0)
+                # Registra il successo del fallback nel skill_tracker
                 try:
                     from agents.skill_tracker import get_skill_tracker
                     get_skill_tracker().record(session_id, fb_name, True)
-                except Exception as e:
-                    _logger.debug("[executor] record success failed: %s", e)
+                except Exception as _skt_err:
+                    _logger.debug("[executor] skill_tracker silenced: %s", _skt_err)  # BUG-SILENT-EXC
                 return {
                     "success":            True,
                     "tool":               fb_name,
@@ -147,17 +199,19 @@ class Executor:
                 try:
                     from agents.skill_tracker import get_skill_tracker
                     get_skill_tracker().record(session_id, fb_name, False)
-                except Exception as e:
-                    _logger.debug("[executor] record timeout failed: %s", e)
+                except Exception as _skt_err:
+                    _logger.debug("[executor] skill_tracker silenced: %s", _skt_err)  # BUG-SILENT-EXC
             except Exception as fb_exc:
                 _logger.debug("[executor] fallback %s errore: %s", fb_name, str(fb_exc)[:80])
                 try:
                     from agents.skill_tracker import get_skill_tracker
                     get_skill_tracker().record(session_id, fb_name, False)
-                except Exception as e:
-                    _logger.debug("[executor] record error failed: %s", e)
+                except Exception as _skt_err:
+                    _logger.debug("[executor] skill_tracker silenced: %s", _skt_err)  # BUG-SILENT-EXC
 
-        return None
+        return None   # tutti i fallback hanno fallito
+
+    # ── run_tool ─────────────────────────────────────────────────────────────
 
     async def run_tool(self, tool_name: str, inputs: dict, timeout: float = 30.0) -> dict:
         tool = TOOL_REGISTRY.get(tool_name)
@@ -170,35 +224,79 @@ class Executor:
 
         session_id = _get_session_id()
 
+        # ── GAP-SKILL-SYNC v2: circuit breaker pre-check ──────────────────────
+        # Se il tool ha un Wilson score molto basso (< 0.15) con >= 3 dati in sessione,
+        # bypassa il tool e vai direttamente al miglior fallback disponibile.
         if self._is_circuit_open(tool_name, session_id):
-            _logger.info("[executor] circuit OPEN per %s — routing a fallback", tool_name)
+            _logger.info(
+                "[executor] circuit OPEN per %s — routing diretto a fallback (Wilson < %.2f)",
+                tool_name, _CIRCUIT_OPEN_THRESHOLD,
+            )
             fb_result = await self._try_fallbacks(tool_name, inputs, timeout, session_id)
             if fb_result:
                 return fb_result
-            _logger.warning("[executor] tutti i fallback di %s falliti — provo primario", tool_name)
+            # Tutti i fallback falliti: procedi con il tool primario (ultima spiaggia)
+            _logger.warning(
+                "[executor] tutti i fallback di %s hanno fallito — provo comunque il tool primario",
+                tool_name,
+            )
 
+        # ── Esecuzione normale con retry ──────────────────────────────────────
         fn = tool.get("_fn")
         if fn is None:
             return {"success": False, "error": "Tool non ha funzione di esecuzione", "output": None}
 
+        # P17-B1: syntax check pre-esecuzione — intercetta SyntaxError prima che il
+        # backend-exec spreci un round-trip su codice già rotto. Fail-open: tool non in
+        # mappa, ast_check non importato, o codice vuoto → nessun blocco.
+        if tool_name in _CODE_EXEC_TOOLS:
+            _code_arg, _code_lang = _CODE_EXEC_TOOLS[tool_name]
+            _raw_code = inputs.get(_code_arg, "")
+            if isinstance(_raw_code, str) and _raw_code.strip():
+                _syn = _check_syntax(_raw_code, _code_lang)
+                if not _syn.ok:
+                    _logger.warning(
+                        "[executor] P17-B1 syntax check failed per %s: %s",
+                        tool_name, _syn.error,
+                    )
+                    return {
+                        "success": False,
+                        "error": (
+                            f"SyntaxError pre-esecuzione [{_code_lang}]: {_syn.error}"
+                            + (f" — riga {_syn.line}" if _syn.line else "")
+                        ),
+                        "output": None,
+                        "syntax_check_failed": True,
+                    }
+
         last_error: str = "max_retries"
         for attempt in range(self.max_retries + 1):
             try:
+                # S-ORCH-8GAP FIX-GAP2: usa timeout adattivo basato su P90 ultime 5 chiamate
                 _adaptive_to = _timeout_tracker.adaptive_timeout(tool_name, timeout)
                 _t0          = _time_mod.monotonic()
                 result       = await asyncio.wait_for(fn(**inputs), timeout=_adaptive_to)
                 _timeout_tracker.record(tool_name, _time_mod.monotonic() - _t0)
                 if self.memory:
-                    try:
-                        await self.memory.save_episode("tool", f"{tool_name}: {str(inputs)[:500]}", str(result)[:500], True)
-                    except Exception as e:
-                        _logger.debug("[executor] memory save failed: %s", e)
+                    # S577→S600: inputs 100→500 — parity con altri handler
+                    await self.memory.save_episode(
+                        "tool",
+                        f"{tool_name}: {str(inputs)[:500]}",
+                        str(result)[:500],
+                        True,
+                    )
                 return {"success": True, "tool": tool_name, "output": result, "attempt": attempt + 1}
 
             except asyncio.TimeoutError:
+                # FIX-GAP2: registra il timeout come durata massima per shrink futuro
                 _timeout_tracker.record(tool_name, timeout * 1.2)
                 last_error = f"Timeout dopo {timeout}s (tentativo {attempt + 1})"
                 if attempt == self.max_retries:
+                    # Ultima chance: prova i fallback ordinati per Wilson score
+                    _logger.info(
+                        "[executor] %s timeout definitivo — provo fallback Wilson-sorted",
+                        tool_name,
+                    )
                     fb_result = await self._try_fallbacks(tool_name, inputs, timeout, session_id)
                     if fb_result:
                         return fb_result
@@ -208,6 +306,11 @@ class Executor:
             except Exception as e:
                 last_error = str(e)
                 if attempt == self.max_retries:
+                    # Ultima chance: prova i fallback ordinati per Wilson score
+                    _logger.info(
+                        "[executor] %s errore definitivo (%s) — provo fallback Wilson-sorted",
+                        tool_name, last_error[:60],
+                    )
                     fb_result = await self._try_fallbacks(tool_name, inputs, timeout, session_id)
                     if fb_result:
                         return fb_result

agents/goal_drift_detector.py

@@ -7,10 +7,6 @@ che il loop principale usa per iniettare una micro-guida correttiva.
 
 Tutto sincrono e non-blocking: nessun I/O, nessuna chiamata LLM.
 Zero overhead su task senza drift (guard rapido in should_check_drift).
-
-GAP-DRIFT-THRESHOLD-FIXED fix: threshold dinamica basata sul numero di subtask
-completati — previene falsi positivi su task multi-fase (es. "installa dipendenze"
-come primo subtask di "crea componente React" → overlap = 0% → falso positivo).
 """
 from __future__ import annotations
 
@@ -22,16 +18,8 @@ _logger = logging.getLogger("agente_ai.goal_drift")
 
 # ── Costanti ──────────────────────────────────────────────────────────────────
 DRIFT_CHECK_EVERY_N: int      = 3     # check ogni 3 subtask completati
-DRIFT_OVERLAP_THRESHOLD: float = 0.25  # keyword overlap < 25% → drift (per task maturi)
-_MIN_EXEC_DONE: int            = 4     # GAP-DRIFT-THRESHOLD-FIXED: era 2, ora 4
-                                        # Permette almeno 4 subtask di setup/infra prima
-                                        # di valutare il drift semantico.
-
-# GAP-DRIFT-THRESHOLD-FIXED: threshold dinamica per task giovani.
-# Nei primi _EARLY_EXEC_DONE subtask usiamo una soglia molto bassa (0.05 = 5% overlap)
-# invece di 0.25 — solo drift estremi vengono rilevati in fase di setup.
-_EARLY_EXEC_DONE: int          = 6     # "fase giovane" = < 6 subtask completati
-_EARLY_THRESHOLD: float        = 0.05  # soglia permissiva per fase giovane (5% vs 25%)
+DRIFT_OVERLAP_THRESHOLD: float = 0.25  # keyword overlap < 25% → drift
+_MIN_EXEC_DONE: int            = 2     # non controlla prima di 2 subtask completati
 
 _STOP_WORDS = frozenset({
     # italiano
@@ -90,9 +78,8 @@ def should_check_drift(step_count: int, last_check: int) -> bool:
     """
     True se è ora di eseguire un drift check.
 
-    GAP-DRIFT-THRESHOLD-FIXED fix: _MIN_EXEC_DONE alzato a 4 (era 2).
     Controlla solo se:
-      - step_count >= _MIN_EXEC_DONE  (almeno 4 subtask completati)
+      - step_count >= _MIN_EXEC_DONE  (almeno 2 subtask completati)
       - step_count - last_check >= DRIFT_CHECK_EVERY_N  (ogni 3 step)
     """
     return (
@@ -101,21 +88,6 @@ def should_check_drift(step_count: int, last_check: int) -> bool:
     )
 
 
-def _effective_threshold(step_count: int) -> float:
-    """GAP-DRIFT-THRESHOLD-FIXED: threshold dinamica basata sul numero di subtask.
-
-    Fase giovane (< _EARLY_EXEC_DONE subtask): threshold permissiva (5%).
-    Fase matura (>= _EARLY_EXEC_DONE subtask): threshold standard (25%).
-
-    Motivazione: i primi subtask di un task multi-fase sono spesso setup/infra
-    (installazione dipendenze, creazione directory, init config) con keyword
-    molto diverse dal goal semantico → falsi positivi con threshold fissa 25%.
-    """
-    if step_count < _EARLY_EXEC_DONE:
-        return _EARLY_THRESHOLD
-    return DRIFT_OVERLAP_THRESHOLD
-
-
 def detect_drift(
     goal: str,
     exec_done: list[str],
@@ -156,23 +128,16 @@ def detect_drift(
     score       = compute_drift_score(goal, exec_done)
     out["score"] = round(score, 3)
 
-    # GAP-DRIFT-THRESHOLD-FIXED: usa threshold dinamica invece di fissa 25%
-    effective_thr = _effective_threshold(step_count)
-
-    if score > (1.0 - effective_thr):
+    if score > (1.0 - DRIFT_OVERLAP_THRESHOLD):
         out["drifted"] = True
         goal_kws  = _extract_keywords(goal)
         exec_kws  = _extract_keywords(" ".join(exec_done))
         missing   = sorted(goal_kws - exec_kws)[:5]
         out["reason"] = (
-            f"score={score:.2f} (threshold={effective_thr:.2f}), "
-            f"keyword goal assenti nell'output: {missing}"
+            f"score={score:.2f}, keyword goal assenti nell'output: {missing}"
         )
         _logger.info("COG-5 drift rilevato: %s", out["reason"])
     else:
-        _logger.debug(
-            "COG-5 no drift: score=%.2f threshold=%.2f step=%d",
-            score, effective_thr, step_count,
-        )
+        _logger.debug("COG-5 no drift: score=%.2f step=%d", score, step_count)
 
     return out

agents/goal_verifier.py

@@ -193,18 +193,18 @@ class GoalVerifier:
 
     @classmethod
     def is_code_goal(cls, goal: str) -> bool:
-        return bool(cls._CODE_RE.search(goal[:500]))  # S595: 300->500
+        return bool(cls._CODE_RE.search(goal[:500]))
 
     @classmethod
     def adaptive_threshold(cls, goal: str) -> float:
         g = goal.strip()
         if _SIMPLE_RE.match(g):
             return 0.28
-        if cls._EXPLANATION_RE.search(g[:500]) and not cls._CODE_RE.search(g[:500]):  # S595
+        if cls._EXPLANATION_RE.search(g[:500]) and not cls._CODE_RE.search(g[:500]):
             return 0.25
-        if _COMPLEX_CODE_RE.search(g[:500]):  # S595
+        if _COMPLEX_CODE_RE.search(g[:500]):
             return 0.55
-        if cls._CODE_RE.search(g[:500]):  # S595
+        if cls._CODE_RE.search(g[:500]):
             return 0.42
         return RETRY_THRESHOLD
 
@@ -221,7 +221,7 @@ class GoalVerifier:
             {"role": "user",   "content": f"GOAL: {goal_short}\n\nRISPOSTA:\n{ans_short}"},
         ]
         try:
-            raw = await self.llm.chat(msgs, temperature=0.0, max_tokens=200)  # S586: 120→200
+            raw = await self.llm.chat(msgs, temperature=0.0, max_tokens=200)
             if not raw or raw.startswith("[LLM"):
                 return self._default_ok()
             return self._parse(raw)
@@ -258,7 +258,7 @@ class GoalVerifier:
                 per_req[req_id] = GoalVerificationStatus.UNKNOWN
                 continue
 
-            criteria_text = "\n".join(f"- {c}" for c in criteria[:5])  # S591: 3->5
+            criteria_text = "\n".join(f"- {c}" for c in criteria[:5])
             check_prompt  = (
                 f"Requisito: {req_name}\n"
                 f"Criteri:\n{criteria_text}\n\n"
@@ -287,9 +287,9 @@ class GoalVerifier:
         score   = (n_pass / n_known) if n_known > 0 else 0.5
 
         overall_pass = score >= threshold and not failed_reqs
-        hint = "; ".join(failed_hints[:4]) if failed_hints else ""  # S595: 2->4
+        hint = "; ".join(failed_hints[:4]) if failed_hints else ""
         if failed_reqs:
-            hint = f"Requisiti FAIL: {', '.join(failed_reqs[:5])}. {hint}"  # S595: 3->5
+            hint = f"Requisiti FAIL: {', '.join(failed_reqs[:5])}. {hint}"
 
         status = (
             GoalVerificationStatus.PASS    if overall_pass
@@ -300,7 +300,7 @@ class GoalVerifier:
         return GoalVerifyResult(
             goal_met             = overall_pass,
             coverage_score       = round(score, 3),
-            missing_items        = failed_reqs[:5],  # S595
+            missing_items        = failed_reqs[:5],
             repair_hint          = hint[:MAX_HINT_CHARS],
             verification_status  = status,
         )

agents/planner.py

@@ -221,7 +221,7 @@ class Planner:
             {"role": "user",   "content": f"Obiettivo: {goal}"},
         ]
         if context:
-            ctx_str = "\n".join(m.get("content", "")[:500] for m in context[-5:])  # S594: content[:500] per msg  # S572: 100→300→500 / S590: -3→-5
+            ctx_str = "\n".join(m.get("content", "")[:500] for m in context[-5:])
             msgs[1]["content"] += f"\n\nContesto recente:\n{ctx_str}"
         return msgs
 
@@ -258,7 +258,7 @@ class Planner:
                 plan = _parse_plan(raw)
                 if plan:
                     plan["_speculative"] = True
-                    plan["_raw"] = raw[:400]  # S577: 200→400
+                    plan["_raw"] = raw[:400]
                 return plan
             except Exception:
                 return None

agents/reasoning_core.py

@@ -64,6 +64,8 @@ Return:
 CONTEXT:
 {repo_context}
 """
+        # S665: wrap con asyncio.wait_for — analyze_project usava await self.llm.chat() senza timeout
+        # → hang indefinito se il provider non risponde. Timeout 45s = STREAM_TIMEOUT (ai_client.py).
         try:
             return await asyncio.wait_for(
                 self.llm.chat([{"role": "user", "content": prompt}], temperature=0.2),
@@ -87,6 +89,7 @@ Decide:
 - impact
 - risk level
 """
+        # S665: timeout anche per develop_strategy
         try:
             return await asyncio.wait_for(
                 self.llm.chat([{"role": "user", "content": prompt}], temperature=0.3),
@@ -105,6 +108,7 @@ Return:
 - root cause
 - fix strategy
 """
+        # S665: timeout anche per analyze_error
         try:
             return await asyncio.wait_for(
                 self.llm.chat([{"role": "user", "content": prompt}], temperature=0.1),
@@ -115,6 +119,8 @@ Return:
 
     # ── Prompt builder ──────────────────────────────────────────────────────────
     def _build_prompt(self, state: ReasoningState) -> str:
+        # S590: errors[-3:]→[-5:] — più errori nel contesto per diagnosi più accurata
+        # BUG-2: raggruppa errori per tipo + ultimi 5 dettagliati — diagnosi più accurata
         if state.errors:
             import re as _re_err
             _err_all = state.errors
@@ -137,7 +143,7 @@ STATO:
 - goal: {state.goal}
 - world_model: {'Presente' if state.world_model else 'Mancante'}
 - strategy: {'Definita' if state.strategy else 'Da definire'}
-- last_result: {state.last_result[:500] if state.last_result else 'vuoto'}  # S592: 300->500
+- last_result: {state.last_result[:500] if state.last_result else 'vuoto'}  # S592: 300→500
 - errors: {errors_str}
 - loop_count: {state.loop_count}/{self.MAX_LOOPS}
 
@@ -149,8 +155,16 @@ Rispondi SOLO con JSON valido:
   "reason": "perché questa azione?",
   "confidence": 0.0-1.0
 }}
+
+Regole:
+1. Se manca world_model -> "analyze"
+2. Se manca strategy -> "strategy"
+3. Se strategy c'è ma serve piano -> "plan"
+4. Se ci sono errori -> "fix"
+5. Se tutto ok -> "continue" o "stop" se finito.
 """
 
+        # GAP-2: Deep Context — inietta skeleton dei file rilevanti per ragionamento multi-file
         _ctx_section = ""
         if state.project_files:
             try:
@@ -166,6 +180,9 @@ Rispondi SOLO con JSON valido:
                     if f.get("path") in _top_paths
                 ]
                 if _skels:
+                    # P25-B1: ordina i blocchi skeleton per overlap keyword col goal prima di troncare.
+                    # Zero LLM, zero latenza — stessa logica word-overlap di episodic.py.
+                    # Garantisce che i blocchi più rilevanti per il goal finiscano PRIMA del taglio.
                     _goal_kw_ctx = set(re.findall(r'\w{4,}', state.goal.lower())) if hasattr(state, 'goal') else set()
                     if _goal_kw_ctx:
                         _skels.sort(
@@ -173,6 +190,8 @@ Rispondi SOLO con JSON valido:
                             reverse=True,
                         )
                     _ctx_raw = "\n".join(_skels)
+                    # S780-SMART: Smart Chunking — estrae firme funzioni/classi invece di troncare.
+                    # BUG-SKEL fix: evita allucinazioni su funzioni mancanti nei file complessi.
                     if len(_ctx_raw) > 6000:
                         import re as _re_sk
                         _sig_lines = _re_sk.findall(
@@ -180,22 +199,26 @@ Rispondi SOLO con JSON valido:
                             r'(?:function|const|class)\s+\w|function\s+\w)[^\n]{0,200}',
                             _ctx_raw, _re_sk.MULTILINE
                         )
-                        _ctx_smart = "\n".join(_sig_lines)
+                        _ctx_smart = '\n'.join(_sig_lines)
                         if len(_ctx_smart) >= 500:
                             _ctx_raw = (
-                                f"[SMART CHUNK — {len(_skels)} file — solo firme estratte]\n"
+                                f'[SMART CHUNK — {len(_skels)} file — solo firme estratte]\n'
                                 + _ctx_smart[:10000]
                             )
                         else:
-                            _ctx_raw = _ctx_raw[:6000] + "\n... [troncato — usa file_search per dettagli]"
+                            _ctx_raw = _ctx_raw[:6000] + '\n… [troncato — usa file_search per dettagli]'
                     _ctx_section = "\n\nFILE RILEVANTI (skeleton per ragionamento):\n" + _ctx_raw
             except Exception:
-                pass
+                pass  # non-fatal — degradazione graceful senza deep context
 
         return _base_prompt + _ctx_section
 
     @staticmethod
     def _extract_json(raw: str) -> str | None:
+        """P16-B3: depth-counting bilanciato — sostituisce regex greedy r'{[\s\S]+}'
+        che su JSON nested (es. patch con oggetti interni) estraeva dal primo { all'ULTIMO }
+        producendo JSON malformato → action='continue' per default → agente in loop.
+        Pattern identico a safeJsonParse.ts già in produzione sul frontend."""
         depth = 0
         start = -1
         for i, ch in enumerate(raw):
@@ -229,28 +252,12 @@ Rispondi SOLO con JSON valido:
             return ReasoningResult(action="stop", steps=[], reason="Max loops reached", confidence=1.0)
 
         prompt = self._build_prompt(state)
-        # S42: Speculative Decoding Multi-Nodo
-        # Lanciamo 3 generazioni parallele con temperature e prompt diversi
         try:
-            tasks = [
-                self.llm.chat([{"role": "user", "content": prompt}], temperature=0.1), # BRAIN: Conservativo
-                self.llm.chat([{"role": "user", "content": prompt + "\nSii creativo e pensa fuori dagli schemi."}], temperature=0.7), # HANDS: Creativo
-                self.llm.chat([{"role": "user", "content": prompt + "\nFocalizzati sulla massima efficienza e sicurezza."}], temperature=0.0) # MEMORY: Deterministico
-            ]
-            
-            _logger.info("SPECULATIVE: Avviate 3 generazioni parallele")
-            raw_results = await asyncio.gather(*tasks, return_exceptions=True)
-            
-            # Verificatore (Node D logic): Seleziona il risultato più coerente o il primo valido
-            valid_results = [r for r in raw_results if isinstance(r, str) and r.strip()]
-            
-            if not valid_results:
-                raise Exception("Nessun risultato valido dai nodi speculativi")
-            
-            # Per ora scegliamo il primo (BRAIN), ma potremmo implementare un ranker
-            raw = valid_results[0]
-            _logger.info("SPECULATIVE: Risposta selezionata tra %d varianti", len(valid_results))
-            
+            # S750-GAP-D: asyncio.wait_for — evita hang se LLM provider non risponde
+            raw = await asyncio.wait_for(
+                self.llm.chat([{"role": "user", "content": prompt}], temperature=0.2),
+                timeout=30.0,
+            )
             return self._parse(raw)
         except asyncio.TimeoutError:
             return ReasoningResult(action="continue", steps=[], reason="decide(): LLM timeout 30s", confidence=0.3)
@@ -269,7 +276,7 @@ Rispondi SOLO con JSON valido:
                 await on_step({
                     "loop": state.loop_count,
                     "action": decision.action,
-                    "reason": decision.reason[:200],  # S578: 120→200
+                    "reason": decision.reason,
                     "confidence": decision.confidence
                 })
 
@@ -277,13 +284,11 @@ Rispondi SOLO con JSON valido:
                 break
             
             elif decision.action == "analyze":
-                _wm_raw = await self.analyze_project(context or goal)
-                state.world_model = (_wm_raw or '')[:600]  # S593: world_model 400->600
+                state.world_model = await self.analyze_project(context or goal)
                 results.append({"action": "analyze", "output": "World model built"})
-
+            
             elif decision.action == "strategy":
-                _strat_raw = await self.develop_strategy(state)
-                state.strategy = (_strat_raw or '')[:600]  # S593: strategy 400->600
+                state.strategy = await self.develop_strategy(state)
                 results.append({"action": "strategy", "output": state.strategy})
 
             elif decision.action == "plan" and self.planner:
@@ -294,6 +299,7 @@ Rispondi SOLO con JSON valido:
 
             elif decision.action == "fix":
                 if decision.patch:
+                    # Se c'è una patch, l'executor la applica
                     if self.executor:
                         res = await self.executor.run_tool("file_editor", {"path": "patch.diff", "content": decision.patch})
                         state.last_result = str(res.get("output", ""))
@@ -305,6 +311,7 @@ Rispondi SOLO con JSON valido:
                     results.append({"action": "error_analysis", "output": error_analysis})
 
             elif decision.action == "continue":
+                # S575: direct_response non esiste nel TOOL_REGISTRY — usa LLM diretto
                 if decision.steps:
                     try:
                         _step_prompt = decision.steps[0]
@@ -321,32 +328,102 @@ Rispondi SOLO con JSON valido:
                         state.completed_steps.append(decision.steps[0])
                 results.append({"action": "continue", "steps": decision.steps})
 
+            # Auto-debug check con Critic
             if self.critic and state.last_result and decision.action != "analyze":
                 critique = await self.critic.evaluate(goal, state.last_result)
                 if critique.get("needs_retry"):
-                    state.errors.extend(critique.get("issues", []))  # S590: using errors[-5:] window
+                    state.errors.extend(critique.get("issues", []))
 
             state.loop_count += 1
 
         return {
             "goal": goal,
             "loops": state.loop_count,
+            "success": len(state.errors) == 0,
             "results": results,
-            "final_state": state
+            "final_state": {
+                "has_world_model": state.world_model is not None,
+                "has_strategy": state.strategy is not None
+            }
         }
 
-    async def run_loop_to_answer(self, goal: str, max_loops: int = 5) -> str:
-        """S575: convenience wrapper — never raises, returns '' on failure.
+    async def run_loop_to_answer(self, goal: str, context: str = "",
+                                  on_step=None, max_loops: int = 8,
+                                  project_files: Optional[List[Dict[str, Any]]] = None) -> str:
+        """S575: Versione di run_loop che ritorna una stringa risposta sintetizzata.
 
-        Nota: il path 'continue' usa LLM diretta; direct_response non esiste
-        come tool registrato (S575 — fix: rimosso run_tool('direct_response')).
+        Usata dal gate in UnifiedAgentLoop quando tok_budget >= 6144 e subtask >= 3.
+        Limite max_loops=8 (S701: era 5) — più iterazioni per task profondi.
+        Output: stringa di risultati aggregati da passare come contesto extra al LLM finale.
+        Mai solleva eccezioni.
         """
         try:
-            result = await self.run(goal)
-            fs = result.get("final_state")
-            if fs:
-                return fs.last_result or ""
-            return ""
+            # GAP-2: deep context — inietta i file VFS nella ReasoningState per rank_files_by_relevance()
+            state = ReasoningState(goal=goal, context=context, project_files=project_files)
+            parts: List[str] = []
+            loop_cap = min(max_loops, self.MAX_LOOPS)
+
+            while state.loop_count < loop_cap:
+                try:
+                    decision = await self.decide(state)
+                except Exception:
+                    break
+
+                if on_step:
+                    try:
+                        import asyncio as _aio
+                        coro = on_step({
+                            "loop": state.loop_count,
+                            "action": f"reasoning:{decision.action}",
+                            "reason": decision.reason[:200] if decision.reason else "",  # S578: 120→200
+                            "confidence": decision.confidence,
+                        })
+                        if _aio.iscoroutine(coro):
+                            await coro
+                    except Exception as _exc:
+                        _logger.debug("[reasoning_core] silenced %s", type(_exc).__name__)  # noqa: BLE001
+
+                if decision.action == "stop" or decision.confidence < self.MIN_CONFIDENCE:
+                    break
+
+                elif decision.action == "analyze":
+                    try:
+                        state.world_model = await self.analyze_project(context or goal)
+                        # S593: 400→600 — world_model spesso multi-paragrafo
+                        parts.append(f"[ANALISI PROGETTO]: {(state.world_model or '')[:600]}")
+                    except Exception as _exc:
+                        _logger.debug("[reasoning_core] silenced %s", type(_exc).__name__)  # noqa: BLE001
+
+                elif decision.action == "strategy":
+                    try:
+                        state.strategy = await self.develop_strategy(state)
+                        # S593: 400→600 — strategy spesso multi-step
+                        parts.append(f"[STRATEGIA]: {(state.strategy or '')[:600]}")
+                    except Exception as _exc:
+                        _logger.debug("[reasoning_core] silenced %s", type(_exc).__name__)  # noqa: BLE001
+
+                elif decision.action in ("plan", "continue", "fix"):
+                    # Esegui passo diretto via LLM
+                    step_desc = (decision.steps[0] if decision.steps
+                                 else decision.reason or goal)
+                    try:
+                        _ans = await self.llm.chat(
+                            [{"role": "system", "content":
+                              "Sei un assistente tecnico esperto. "
+                              "Svolgi il passo richiesto in modo preciso e conciso."},
+                             {"role": "user", "content":
+                              f"Goal complessivo: {goal}\n\nPasso: {step_desc}"}],
+                            temperature=0.2, max_tokens=512,
+                        )
+                        if _ans and not _ans.startswith("[LLM"):
+                            parts.append(f"[PASSO {state.loop_count+1}]: {_ans[:600]}")
+                            state.last_result = _ans
+                            state.completed_steps.append(step_desc)
+                    except Exception as _exc:
+                        _logger.debug("[reasoning_core] silenced %s", type(_exc).__name__)  # noqa: BLE001
+
+                state.loop_count += 1
+
+            return "\n\n".join(parts) if parts else ""
         except Exception:
             return ""
-

agents/unified_loop_helpers.py

@@ -27,7 +27,7 @@ import logging
 _logger = logging.getLogger("agents.unified_loop_helpers")
 
 # Import tipi condivisi — zero circular (unified_loop_types ha solo stdlib)
-from agents.unified_loop_types import StepCallback, UnifiedLoopState, _detect_user_lang, _LANG_INSTRUCTIONS, _maybe_await
+from agents.unified_loop_types import StepCallback, UnifiedLoopState
 
 
 class HelpersMixin:

agents/unified_loop_llm.py

@@ -88,6 +88,9 @@ class LLMSelectionMixin:
             elif 'cerebras' in _gen_prov:
                 # Generatore Cerebras → Verifier Gemini
                 self._verifier_llm = _RRv.get_client(_Rolev.RESEARCHER)
+            elif 'nvidia' in _gen_prov:
+                # Generatore NVIDIA → Verifier Groq CODER (per diversificare)
+                self._verifier_llm = _RRv.get_client(_Rolev.CODER)
             else:
                 # OpenRouter / SambaNova / altri → Verifier Groq CODER come default cross-model
                 self._verifier_llm = _RRv.get_client(_Rolev.CODER)

agents/unified_loop_prompts.py

@@ -59,7 +59,10 @@ class PromptBuilderMixin:
         "Questi modelli/versioni NON ESISTONO — non citarli mai. "
         "Se non sei certo della versione esatta → ometti il numero o scrivi 'versione corrente'. "
         "Per la tua identità: di' solo 'Sono un agente AI' senza inventare versioni, parametri o architettura.\n"
-        "14. GENERAZIONE IMMAGINI (S276): Se ti viene chiesto di generare un'immagine AI, "
+        "14. CONTESTO ESTESO (S-CTX-1M): Quando usi modelli NVIDIA con contesto 1M+ (es. `deepseek-v4-flash`), "
+        "sfrutta SEMPRE l'intera finestra di contesto per analisi approfondite, riassunti di documenti lunghi, "
+        "e per mantenere lo stato conversazionale su task complessi. NON riassumere prematuramente o ignorare parti del contesto.\n"
+        "15. GENERAZIONE IMMAGINI (S276): Se ti viene chiesto di generare un'immagine AI, "
         "usa il tool generate_image con il prompt desiderato. "
         "Il tool usa FLUX.1-schnell (backend HF Space) → Pollinations fallback automatico. "
         "Restituisce URL diretto visualizzabile nel browser come link cliccabile. "
@@ -67,7 +70,7 @@ class PromptBuilderMixin:
         "https://image.pollinations.ai/prompt/{PROMPT_URL_ENCODED}?width=512&height=512&nologo=true\n"
         "MAI inventare URL fake tipo example.com, placeholder.com, via.placeholder.com. "
         "L'URL Pollinations funziona nel browser come fallback.\n"
-        "15. SCAFFOLD PROGETTO: Quando i tool_results contengono output scaffold_project "
+        "16. SCAFFOLD PROGETTO: Quando i tool_results contengono output scaffold_project "
         "(files_created, directory, framework), presenta il risultato come: "
         "(a) conferma breve 'Progetto X creato in /path/', "
         "(b) elenco file con descrizione 1-riga per ciascuno, "
@@ -254,9 +257,43 @@ class PromptBuilderMixin:
             "• Struttura obbligatoria: ## Premesse → ## Ragionamento → ## Conclusione → ## Verifica\n"
             "• Aggiungi sempre la confidence: [ALTA/MEDIA/BASSA] con motivazione\n"
         ),
-    }
+          "ANALYST": (
+              "=== MODALITÀ ANALYST (P17-F5) ===\n"
+              "Sei un analista dati e business senior. In questa sessione:\n"
+              "• Ogni insight supportato da numeri, trend o comparazioni\n"
+              "• Framework: SWOT, Pareto, funnel, cohort, time-series\n"
+              "• Distingui: correlazione ≠ causalità\n"
+              "• Per ogni metrica: definizione, formula, limiti interpretativi\n"
+              "• Identifica outlier, stagionalità, anomalie con contesto\n"
+              "• Struttura: ## Dati → ## Pattern → ## Insight → ## Azioni\n"
+              "• Aggiungi: 'Confidence: [ALTA/MEDIA/BASSA] — N={sample_size}'\n"
+          ),
+          "ARCHITECT": (
+              "=== MODALITÀ ARCHITECT (P17-F5) ===\n"
+              "Sei un software architect senior. In questa sessione:\n"
+              "• Ogni decisione architetturale con trade-off espliciti\n"
+              "• Valuta: scalabilità, maintainability, testabilità, costo operativo\n"
+              "• Pattern noti (CQRS, Event Sourcing, Saga) solo se giustificati\n"
+              "• Disegna ASCII art o pseudo-UML per ogni sistema\n"
+              "• Per ogni componente: responsabilità, interfaccia, dipendenze\n"
+              "• Considera: failure modes, recovery, observability, deployment\n"
+              "• Struttura: ## Contesto → ## Opzioni(3) → ## Raccomandazione → ## Rischi\n"
+              "• Aggiungi: 'Tech Debt Score: [BASSO/MEDIO/ALTO]' con motivazione\n"
+          ),
+          "WRITER": (
+              "=== MODALITÀ WRITER (P17-F5) ===\n"
+              "Sei un content writer e copywriter esperto. In questa sessione:\n"
+              "• Adatta tono e vocabolario al pubblico target specificato\n"
+              "• Usa tecniche: AIDA, PAS, storytelling, social proof\n"
+              "• Ottimizza leggibilità: frasi brevi, paragrafi 3-4 righe\n"
+              "• Per copy digitale: CTA chiaro, hook above-the-fold\n"
+              "• Proponi sempre 2-3 varianti A/B per headline e CTA critici\n"
+              "• Struttura: ## Pubblico → ## Messaggio chiave → ## Testo → ## Varianti\n"
+              "• Aggiungi: 'Readability: Flesch~[score] | Tono: [formale/informale]'\n"
+          ),
+      }
 
-    # ── S200: Context-aware rule injection ──────────────────────────────────────
+      # ── S200: Context-aware rule injection ──────────────────────────────────────
     # Seleziona solo le regole rilevanti per il task corrente.
     # Con llama-3.1-8b-instant (8K context), mettere tutto nel system prompt
     # causa troncamento silenzioso — le regole non vengono mai lette.
@@ -1219,37 +1256,14 @@ class PromptBuilderMixin:
         return None, goal
 
     def _pick_context_rules(self, goal: str) -> str:
-        """Seleziona regole contestuali basate sul task. Max 3 per non saturare il contesto.
-        S-BENCH-PRIORITY (RX-LIVE-01): le regole benchmark (DA/RS) vengono iniettate
-        per prime — garantite nell'output anche se 3 regole generiche le precedono nella lista.
-        Root cause fix: max-3 cut-off tagliava S-BENCH-DA/RS (posizione ~960/864 su 1494 righe).
-        """
+        """Seleziona regole contestuali basate sul task. Max 3 per non saturare il contesto."""
         goal_lower = goal.lower()
         matched: list[str] = []
-
-        # S-BENCH-PRIORITY: benchmark-specific rules — always inject first
-        # Lookup_keys = sottoinsieme unico che identifica la regola nella lista
-        _BENCH_PRIORITY: list[tuple[list[str], str]] = [
-            # DA: "vendite mensili:" + "valore anomalo fuori scala" — ultra-specifici
-            (["vendite mensili:", "copia la struttura, sostituisci", "valore anomalo fuori scala"],
-             "vendite mensili:"),
-            # RS: "coprire:" + "solutions architect" — mai in prompt utente normali
-            (["coprire:", "message queue per use case", "solutions architect"],
-             "coprire:"),
-        ]
-        for trigger_keys, lookup_key in _BENCH_PRIORITY:
-            if any(k in goal_lower for k in trigger_keys):
-                rule = next((r for ps, r in self._CONTEXT_RULES if lookup_key in ps), None)
-                if rule and rule not in matched:
-                    matched.append(rule)
-
-        # Regole generali: riempi fino a max 3
         for patterns, rule in self._CONTEXT_RULES:
+            if any(p in goal_lower for p in patterns):
+                matched.append(rule)
             if len(matched) >= 3:
                 break
-            if rule not in matched and any(p in goal_lower for p in patterns):
-                matched.append(rule)
-
         if not matched:
             return ""
         return "\n\n⚡ REGOLE SPECIFICHE PER QUESTO TASK:\n" + "\n".join(f"• {r}" for r in matched)
@@ -1363,7 +1377,7 @@ class PromptBuilderMixin:
             # Anche: content scoring (keyword nel head del file, +1 per match vs +2 path).
             _goal_hint = (getattr(state, 'goal', '') or '')[:300]
             _step_hint = (
-                (_goal_hint + ' ' + tool_results[:600]).lower()  # S576: 400→600
+                (_goal_hint + ' ' + tool_results[:400]).lower()
                 if tool_results
                 else _goal_hint.lower()
             )

agents/unified_loop_tools.py

@@ -95,10 +95,6 @@ class DirectToolsMixin:
         re.IGNORECASE,
     )
 
-    _CURL_FALLBACK_RE = re.compile(
-        r"\b(curl|http|request|fetch|api|endpoint|get|post)\b",
-        re.IGNORECASE,
-    )
     _IMAGE_GEN_INTENT_RE = re.compile(
         # S390-B-F: rimosso \b prima di (immagine|...) nel primo branch
         # perché "unimmagine" (typo mobile italiano per "un'immagine") non ha word boundary
@@ -181,14 +177,6 @@ class DirectToolsMixin:
                 return city
         return ""
 
-    def _extract_curl_command(self, goal: str) -> str:
-        # Estrae un comando curl o un URL per il fallback
-        m = re.search(r"(curl\s+[^\"\'?]+)", goal, re.IGNORECASE)
-        if m: return m.group(1).strip()
-        m = re.search(r"(https?://[\w\d\-\./?=&%]+)", goal)
-        if m: return f"curl -s {m.group(1)}"
-        return ""
-
     def _extract_search_query(self, goal: str) -> str:
         m = self._SEARCH_QUERY_RE.search(goal)
         if m:
@@ -448,25 +436,6 @@ class DirectToolsMixin:
             except Exception as exc:
                 return f"[web_search: errore — {str(exc)[:300]}]"  # S605: 200→300
 
-        
-        async def _t_curl_fallback() -> str | None:
-            # S-RECOVERY: fallback se curl è menzionato o implicitamente utile
-            if not self._CURL_FALLBACK_RE.search(goal):
-                return None
-            cmd = self._extract_curl_command(goal)
-            if not cmd or not _gov_check("execute_shell", cmd):
-                return None
-            try:
-                if on_step:
-                    await _maybe_await(on_step({"action": "tool_start", "status": "running",
-                        "title": "Fallback: Shell/Curl", "explanation": f"Eseguo fallback: {cmd[:60]}..."}))
-                r = await asyncio.wait_for(TOOL_REGISTRY["execute_shell"]["_fn"](command=cmd), timeout=15)
-                if r.get("ok"):
-                    return f"[FALLBACK CURL RIUSCITO]\nOutput:\n{r.get('stdout', '')[:1000]}"
-                return f"[fallback_curl: errore — {r.get('stderr', '')[:200]}]"
-            except Exception as exc:
-                return f"[fallback_curl: eccezione — {str(exc)[:200]}]"
-
         async def _t_generate_image() -> str | None:
             if not self._IMAGE_GEN_INTENT_RE.search(goal):
                 return None
@@ -564,14 +533,14 @@ class DirectToolsMixin:
                 if r.get("stderr"):
                     # S573: 200→400 — stderr spesso contiene tracebacks multi-riga
                     # S593: 400→600 — tracebacks Python possono superare 400 chars
-                    return f"[run_python: stderr — {r['stderr'][:600]}]"  # S593: 400->600
+                    return f"[run_python: stderr — {r['stderr'][:600]}]"
                 return None
             except asyncio.TimeoutError:
                 return "[run_python: timeout 18s]"
             except Exception as exc:
                 # S593: 200→300 — exception str può includere path + msg
                 # S600: 300→500 — parity con altri exception handler
-                return f"[run_python: errore — {str(exc)[:500]}]"  # S593: 200->300->500
+                return f"[run_python: errore — {str(exc)[:500]}]"
 
 
         async def _t_web_research() -> str | None:
@@ -788,7 +757,7 @@ class DirectToolsMixin:
             except Exception as _exc:
                 return f"[python_analyze: errore — {str(_exc)[:200]}]"
 
-        _parallel_results = await asyncio.gather(
+                _parallel_results = await asyncio.gather(
             _sem_wrap(_t_get_weather()),
             _sem_wrap(_t_read_page()),
             _sem_wrap(_t_calculate()),
@@ -824,7 +793,7 @@ class DirectToolsMixin:
             "[STRUTTURA PROGETTO",    # S764: directory_tree
             "[FILE TROVATI",          # S764: file_search
             "[NOTIZIE",
-            "[STATO GIT",             # S764: git_status
+    "[STATO GIT",             # S764: git_status
             "[ANALISI PYTHON",        # P30-B1: python_analyze
         )
         _n_success = sum(1 for r in results if any(r.startswith(p) for p in _REAL_DATA_PREFIXES))

agents/unified_loop_types.py

@@ -96,14 +96,10 @@ def _is_goal_ambiguous(goal: str) -> bool:
 
     Un goal e ambiguo se ha meno di 5 parole reali E nessun verbo task riconoscibile.
     Complementare a S-BENCH-REC-AMB: cattura goal brevi come help, aiutami, fix it.
-    Fix: domande (?) e goal con numeri (matematica) non sono ambigui.
     """
     words = re.findall(r'\w+', goal)
     if len(words) >= 5:
         return False
-    g = goal.strip()
-    if g.endswith('?') or re.search(r'\d', goal):
-        return False
     return not bool(_TASK_VERBS_RE.search(goal))
 
 

api/agent.py

@@ -1,20 +1,1520 @@
-"""backend/api/agent.py — Thin Router orchestrator (S359).
-Svolge solo il ruolo di punto di ingresso per i sub-router modularizzati.
+71753
+"""backend/api/agent.py — Agent tasks, SSE streaming, checkpoints, loops, kernel (S359, S369).
+
+S358: stream_agent_task() usa _loop_registry per evitare re-run al reconnect SSE.
+S359: persistenza su Supabase di task metadata + event buffer.
+  - Writes: fire-and-forget, non bloccano mai l'SSE.
+  - Reads: lazy restore SOLO quando la memoria è vuota (dopo restart backend).
+  - Scenario restart HF Space → client riconnette → replay eventi da Supabase.
+    * Task SUCCESS/ERROR → replay completo + chiusura immediata.
+    * Task era RUNNING   → replay parziale + evento task_interrupted (no token sprecati).
 """
-import logging
-from fastapi import APIRouter
+import os, asyncio, json, uuid, time, re
+
+# UTF-8 surrogate fix — Groq occasionally returns lone surrogates in emoji/special chars
+# json.dumps raises UnicodeEncodeError for surrogates → SSE stream crashes, loop never completes
+_RE_SURROGATES = re.compile(r"[�-�]", re.UNICODE)
+def _ss(s: object) -> str:
+    """GAP-SURR-FIX: strip lone UTF-16 surrogates + round-trip encode/decode.
+    I provider (es. Groq) possono spezzare emoji multi-byte su chunk consecutivi.
+    La regex rimuove surrogati isolati; il round-trip cattura byte invalidi residui."""
+    if not isinstance(s, str):
+        return s
+    try:
+        cleaned = _RE_SURROGATES.sub("", s)
+        cleaned = cleaned.encode("utf-8", errors="replace").decode("utf-8", errors="replace")
+    except Exception:
+        cleaned = s
+    return cleaned
 
-# Import dei sub-router modularizzati
-from .agent_loop_routes       import router as _loop_router
-from .agent_task_routes       import router as _task_router
-from .agent_checkpoint_routes import router as _checkpoint_router
 
+def _sanitize_for_json(obj: object) -> object:
+    """BUG-SSE-SURR: ricorsivamente applica _ss() su valori stringa prima
+    di json.dumps() — previene UnicodeEncodeError da surrogati Groq/LLM."""
+    if isinstance(obj, str):
+        return _ss(obj)
+    if isinstance(obj, dict):
+        return {k: _sanitize_for_json(v) for k, v in obj.items()}
+    if isinstance(obj, list):
+        return [_sanitize_for_json(x) for x in obj]
+    return obj
+
+from fastapi import APIRouter, Depends, HTTPException, Request, Body
+from fastapi.responses import StreamingResponse
+from .auth_guard import require_role, AuthRole
+from pydantic import BaseModel, field_validator
+from typing import Literal
+from .state import (
+    _agent_tasks, _task_checkpoints, _loop_registry, _run_stream_tasks,
+    _prune_agent_tasks, _prune_checkpoints, _prune_loop_registry,
+    _get_mem_manager, _get_mem_manager_async, _get_executor, _get_planner, _get_ai_client,
+    ReasonLoopIn, AgentTaskIn,
+    write_ahead_task_created,  # WRITE-AHEAD: persist immediato alla creazione task
+)
+from .speculative import fire_speculative_tools
+try:
+    from .quality_guardian import run_quality_check as _run_quality_check
+except Exception:
+    _run_quality_check = None
+import logging
 _logger = logging.getLogger("api.agent")
+
+from .persistence import (
+    sb_upsert_task, sb_update_status, sb_append_event,
+    sb_restore_task, sb_get_events, sb_delete_task_events,
+    sb_list_tasks, sb_save_checkpoint, sb_get_checkpoint,
+    sb_restore_handoff_context, sb_upsert_handoff, sb_delete_handoff,  # BG-4
+)
+
+def _log_task_exc(task):  # GAP-2.6: log silently-dropped exceptions in fire-and-forget tasks
+    if not task.cancelled():
+        exc = task.exception()
+        if exc:
+            _logger.warning("[agent] background task raised %s: %s", type(exc).__name__, exc)
+try:
+    from .telegram_notify import notify_task_done as _tg_done, notify_task_error as _tg_error, notify_task_start as _tg_start, notify_task_step as _tg_step
+except Exception:
+    async def _tg_done(*_a, **_kw): pass  # type: ignore[misc]
+    async def _tg_error(*_a, **_kw): pass  # type: ignore[misc]
+    async def _tg_start(*_a, **_kw): pass  # type: ignore[misc]
+    async def _tg_step(*_a, **_kw):  pass  # type: ignore[misc]
+
 router = APIRouter()
 
-# Inclusione dei sub-router
-router.include_router(_loop_router)
-router.include_router(_task_router)
-router.include_router(_checkpoint_router)
 
-_logger.info("[agent] Thin Router initialized with Loop, Task and Checkpoint modules.")
+# ── Deprecated run_loop ────────────────────────────────────────────────────────
+
+@router.post('/run_loop', deprecated=True)
+async def run_loop():
+    """Deprecated — use /agent/task instead."""
+    from fastapi import HTTPException
+    raise HTTPException(status_code=410, detail="run_loop is deprecated. Use /agent/task.")
+
+
+# ─── P17-F5: Persona helpers ──────────────────────────────────────────────────
+import re as _re_persona
+
+_PERSONA_KEYWORD_MAP: dict = {}
+
+def _build_persona_kw_map() -> dict:
+    import re
+    return {
+        'researcher': re.compile(
+            r'\b(cerca|ricerca|research|trova|notizie|news|url|leggi|articolo|wikipedia|'
+            r'google|fonte|source|scrape|fetch|sito|pagina|web|http|verifica|fact.?check)\b',
+            re.IGNORECASE
+        ),
+        'coder': re.compile(
+            r'\b(codice|code|funzione|function|bug|script|implementa|python|javascript|'
+            r'typescript|refactor|debug|test|classe|class|api|endpoint|sql|database|html|'
+            r'css|react|app|applicazione|programma|sviluppa)\b',
+            re.IGNORECASE
+        ),
+        'reasoner': re.compile(
+            r'\b(analizza|pianifica|strategia|decide|ragiona|valuta|confronta|'
+            r'piano|roadmap|architettura|valutazione|decisione|ottimale|consiglia)\b',
+            re.IGNORECASE
+        ),
+        'analyst': re.compile(
+            r'\b(dati|statistiche|grafico|dataset|csv|dataframe|pandas|matplotlib|'
+            r'metriche|kpi|trend|visualizza|dashboard|excel|tabella|percentuale|distribuzione)\b',
+            re.IGNORECASE
+        ),
+    }
+
+def _classify_persona_server(goal: str) -> str:
+    """P17-F5: classifica la persona dal goal via regex scoring. Zero LLM — zero latency."""
+    global _PERSONA_KEYWORD_MAP
+    if not _PERSONA_KEYWORD_MAP:
+        _PERSONA_KEYWORD_MAP = _build_persona_kw_map()
+    if not goal or len(goal) < 4:
+        return ''
+    best, best_score = '', 0
+    for persona_id, pattern in _PERSONA_KEYWORD_MAP.items():
+        score = len(pattern.findall(goal))
+        if score > best_score:
+            best_score, best = score, persona_id
+    return best if best_score >= 1 else ''
+
+_PERSONA_CLIENT_CACHE: dict = {}
+
+def _get_persona_llm_client(persona: str, default_client: object) -> object:
+    """P17-F5: ritorna il client LLM persona-appropriate via role_router.
+    Fallback silente su default_client se la chiave API manca o role_router fallisce.
+    Cache in-process — zero overhead dopo il primo accesso.""";
+    if not persona:
+        return default_client
+    if persona in _PERSONA_CLIENT_CACHE:
+        return _PERSONA_CLIENT_CACHE[persona]
+    _ROLE_MAP = {'researcher': 'RESEARCHER', 'analyst': 'RESEARCHER',
+                 'coder': 'CODER', 'reasoner': 'REASONER', 'architect': 'ARCHITECT'}
+    role_name = _ROLE_MAP.get(persona.lower())
+    if not role_name:
+        return default_client
+    try:
+        from models.role_router import RoleRouter, Role as _Role
+        role = getattr(_Role, role_name, None)
+        if role is None:
+            return default_client
+        client = RoleRouter.get_client(role)
+        _PERSONA_CLIENT_CACHE[persona] = client
+        return client
+    except Exception:
+        return default_client
+
+
+async def run_loop_removed():
+    """S352: endpoint rimosso. Usare POST /api/agent/tasks + GET /api/agent/tasks/{id}/stream."""
+    raise HTTPException(
+        status_code=410,
+        detail={
+            "error": "Gone",
+            "message": "Endpoint rimosso. Usare POST /api/agent/tasks + GET /api/agent/tasks/{id}/stream",
+            "migration": "/api/agent/tasks",
+        },
+    )
+
+
+# ── SSE run-stream ────────────────────────────────────────────────────────────
+
+@router.post('/api/agent/run-stream')
+async def agent_run_stream(
+    body: ReasonLoopIn, request: Request,
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),  # GAP-1-fix: era fail-open
+):
+    async def generate():
+        queue: asyncio.Queue = asyncio.Queue()
+
+        async def step_cb(step: dict) -> None:
+            await queue.put(step)
+
+        async def run_loop() -> None:
+            try:
+                from agents.unified_loop import UnifiedAgentLoop
+                # S388: usa singleton _get_ai_client() — nessuna re-istanziazione OpenAI() per request
+                client = _get_ai_client()
+                try:
+                    from agents.critic import Critic
+                    from agents.response_verifier import ResponseVerifier
+                    _critic   = Critic(llm_client=client)
+                    _verifier = ResponseVerifier()
+                except Exception:
+                    _critic   = None
+                    _verifier = None
+                # Resume automatico: inietta contesto checkpoint se disponibile (Case 2.5 fall-through)
+                _resume_ctx = getattr(body, '_resume_context', None)
+                _resume_max = getattr(body, '_resume_max_steps', None) or body.max_steps
+                context_str = '\n'.join(m.get('content', '') for m in body.context) if body.context else ''
+                # Bug-5-FIX: resume context iniettato DOPO che context_str è definito (era NameError)
+                if _resume_ctx:
+                    context_str = f"[RIPRESA AUTOMATICA]\n{_resume_ctx}\n\n{context_str}".strip()
+
+                loop = UnifiedAgentLoop(
+                    llm_client=client, critic=_critic, verifier=_verifier,
+                    memory=await _get_mem_manager_async(), executor=_get_executor(), planner=_get_planner(),
+                )
+                # S456-X5: prepend project context (projectMemory.getContext() dal frontend)
+                if body.project_context:
+                    context_str = f"[PROGETTO CORRENTE]\n{body.project_context}\n\n{context_str}".strip()
+                # S456-X4: inject top failure patterns appresi dal selfLearning frontend
+                if body.learning_hints:
+                    # S591: learning_hints[:3]→[:5] — più pattern appresi nel context
+                    hints_str = "\n".join(f"- {h}" for h in body.learning_hints[:5])
+                    context_str = f"{context_str}\n\n[PATTERN DI ERRORE APPRESI]\n{hints_str}".strip()
+                # P35: vincoli negativi dal frontend (agentConstraints.ts → VFS /.agent/constraints.json)
+                _neg_c = getattr(body, 'negative_constraints', '') or ''
+                if _neg_c:
+                    context_str = f"[VINCOLI OPERATIVI APPRESI — NON VIOLARE]\n{_neg_c}\n\n{context_str}".strip()
+                result = await loop.run(
+                    goal=body.goal, context=context_str,
+                    max_steps=body.max_steps, on_step=step_cb,
+                    session_id=getattr(body, "session_id", "") or "",
+                )
+                await queue.put({
+                    '__done__': True,
+                    'result':   result.get('output',  ''),
+                    'engine':   result.get('engine',  'fallback'),
+                    'success':  result.get('success', False),
+                })
+            except Exception as exc:
+                # GAP-A1: log incident in registry (fire-and-forget, non-blocking)
+                try:
+                    from api.incident_registry import log_incident as _log_inc
+                    asyncio.create_task(_log_inc(
+                        task_id=body.goal[:32].replace(' ', '_'),
+                        goal=body.goal, error=str(exc), source="agent",
+                    )).add_done_callback(_log_task_exc)
+                except Exception as _exc:
+                    _logger.debug("[agent] silenced %s", type(_exc).__name__)  # noqa: BLE001
+                await queue.put({'__error__': str(exc)})
+
+        task    = asyncio.create_task(run_loop())
+        task.add_done_callback(_log_task_exc)  # BUG-CB-1
+        task_id = str(uuid.uuid4())
+        # ABORT-1: registra task + queue per permettere cancellazione via POST /api/agent/abort
+        _run_stream_tasks[task_id] = {"task": task, "queue": queue}
+        yield "retry: 3000\n\n"
+        yield f"data: {json.dumps({'type': 'task_start', 'taskId': task_id})}\n\n"
+
+        # S386: fast-fail — se tutti i provider sono down (heartbeat lo sa già),
+        # non aspettare 120s di tentativi: rispondi subito con errore chiaro.
+        try:
+            from api.state import _heartbeat_state
+            _providers = _heartbeat_state.get("providers", [])
+            if _providers and not any(p.get("ok") for p in _providers):
+                task.cancel()
+                _names = ", ".join(p["name"] for p in _providers)
+                yield f"data: {json.dumps({'type': 'task_error', 'taskId': task_id, 'error': f'Nessun provider AI disponibile al momento ({_names}). Riprova tra qualche minuto.'})}\n\n"
+                yield "data: [DONE]\n\n"
+                return
+        except Exception:
+            pass  # se heartbeat non è inizializzato, prosegui normalmente
+
+        # S386: timeout ridotto 120→60s — risposta entro 1 minuto o errore esplicito
+        timeout_secs    = float(os.getenv('AGENT_STREAM_TIMEOUT', '60'))
+        heartbeat_secs  = 15.0
+        elapsed         = 0.0
+        try:
+            while True:
+                try:
+                    item    = await asyncio.wait_for(queue.get(), timeout=heartbeat_secs)
+                    elapsed = 0.0
+                except asyncio.TimeoutError:
+                    elapsed += heartbeat_secs
+                    if elapsed >= timeout_secs:
+                        yield f"data: {json.dumps({'type': 'task_error', 'error': 'stream timeout'})}\n\n"
+                        break
+                    yield 'data: {"type":"ping"}\n\n'
+                    continue
+                # ABORT-2: segnale abort dall'endpoint POST /api/agent/abort
+                if "__abort__" in item:
+                    yield f"data: {json.dumps({'type': 'task_aborted', 'taskId': task_id})}\n\n"
+                    break
+                if '__error__' in item:
+                    yield f"data: {json.dumps({'type': 'task_error', 'taskId': task_id, 'error': _ss(item['__error__'])})}\n\n"
+                    break
+                # S420: streaming token — emetti subito al frontend senza accumulare
+                if item.get('action') == 'text_chunk':
+                    yield f"data: {json.dumps({'type': 'text_chunk', 'token': _ss(item.get('token', '')), 'taskId': task_id})}\n\n"
+                    continue
+                # S758-P4.1: tool_use — chip pre-esecuzione (agent_run_stream path)
+                _rs_act = item.get('action', '')
+                _rs_st  = item.get('status', '')
+                if ((_rs_act == 'tool_start' and _rs_st == 'running') or
+                        (_rs_act.startswith('executor:') and _rs_st == 'started')):
+                    _rs_tool = _rs_act.replace('executor:', '') if _rs_act.startswith('executor:') else _rs_act
+                    yield f"data: {json.dumps({'type': 'tool_use', 'taskId': task_id, 'tool': _rs_tool, 'name': _rs_tool, 'label': _ss(str(item.get('title', _rs_tool.replace('_', ' ').capitalize())))})}\n\n"  # BUG-SSE-SURR
+                if '__done__' in item:
+                    yield f"data: {json.dumps({'type': 'task_done', 'taskId': task_id, 'result': _ss(item['result']), 'engine': item['engine'], 'success': item['success']})}\n\n"
+                    break
+                # S393 Priority 1: Narrative Streaming — arricchisce step_done con explanation
+                _NARR_QUICK = {
+                    'llm': 'Elaborazione risposta AI',
+                    'direct_tools': 'Strumenti diretti',
+                    'web_search': 'Ricerca web', 'get_weather': 'Dati meteo',
+                    'read_page': 'Lettura pagina', 'calculate': 'Calcolo matematico',
+                    'generate_image': 'Generazione immagine AI',
+                    'execution_validator_fix': 'Auto-correzione codice (S393)',
+                    'tool_governor_skip': 'Tool già eseguito — risultato riutilizzato',
+                    # S661: label narrative per tool aggiunti in S648-S659 — prima usavano
+                    # _act_q.replace('_',' ').capitalize() → "Apply patch", "Call api" (generico)
+                    'apply_patch':   'Applico patch al file…',
+                    'call_api':      'Chiamo API REST…',
+                    'send_email':    'Invio email…',
+                    'create_pdf':    'Genero documento PDF…',
+                    'web_research':  'Ricerca multi-fonte…',
+                    'write_file':    'Scrivo file…',
+                    'read_file':     'Leggo file…',
+                    'execute_shell': 'Eseguo comando shell…',
+                    'analyze_image': 'Analizzo immagine…',
+                    'run_python':    'Eseguo Python (Pyodide)…',
+                    # S-GAP1: narrative fasi strategiche
+                    'plan':             'Analizzo la richiesta e preparo un piano di esecuzione…',
+                    'reflective_debug': 'Ho incontrato un ostacolo — ricalcolo una strategia più efficiente…',
+                    'fallback':         'Adotto un approccio alternativo per completare il task…',
+                    'smolagents':       'Orchestro gli strumenti necessari…',
+                }
+                _act_q = item.get('action', '')
+                if 'explanation' not in item:
+                    item['explanation'] = _NARR_QUICK.get(_act_q, _act_q.replace('_', ' ').capitalize())
+                if 'title' not in item:
+                    item['title'] = item['explanation']
+
+                # S403: SSE Visibility Guard — classifica ogni step event:
+                # "internal"  → mai visibile (pipeline internals: planner, llm, reflection)
+                # "progress"  → visibile come progress card (tool reali, auto-fix)
+                # "debug"     → visibile solo in dev mode (direct_tools, fast_path)
+                # Il frontend filtra per visibility — solo "progress" mostrato all'utente.
+                _STEP_VISIBILITY: dict[str, str] = {
+                    # Internal pipeline — never shown to user
+                    'plan':              'progress',   # S-GAP1
+                    'llm':               'internal',
+                    'smolagents':        'internal',
+                    'fallback':          'progress',   # S-GAP1
+                    'reflective_debug':  'progress',   # S-GAP1
+                    'fast_path':         'internal',
+                    'executor':          'internal',
+                    # Progress — shown as step cards (user-visible)
+                    'tool_start':              'progress',
+                    'execution_validator_fix': 'progress',
+                    'goal_verifier':           'progress',
+                    'web_search':              'progress',
+                    'get_weather':             'progress',
+                    'read_page':               'progress',
+                    'calculate':               'progress',
+                    'generate_image':          'progress',
+                    'run_python':              'progress',
+                    'tool_governor_skip':      'progress',
+                    # S660: tool aggiunti in S648-S659 mancanti da _STEP_VISIBILITY →
+                    # fallback rule: _act_q.startswith('tool_') era False per questi →
+                    # classificati 'debug' → nascosti all'utente durante esecuzione.
+                    'apply_patch':   'progress',
+                    'call_api':      'progress',
+                    'send_email':    'progress',
+                    'create_pdf':    'progress',
+                    'web_research':  'progress',
+                    'write_file':    'progress',
+                    'read_file':     'progress',
+                    'execute_shell': 'progress',
+                    'analyze_image': 'progress',
+                    # Debug — shown only when devMode active
+                    'direct_tools':     'debug',
+                    # S-LOOP2: fase esecuzione avanzata — visibili come progress card
+                    'reasoning_core':    'progress',  # S-LOOP2: ReasoningCore multi-step
+                    'browser_verifier':  'progress',  # S-LOOP2: Browser Goal Verification live
+                }
+                # Fallback: azioni sconosciute con "tool_" prefix → progress; resto → debug
+                _vis = _STEP_VISIBILITY.get(_act_q)
+                if _vis is None:
+                    _vis = 'progress' if _act_q.startswith('tool_') or _act_q.startswith('executor:') else 'debug'
+                item['visibility'] = _vis
+
+                yield f"data: {json.dumps({'type': 'step_done', 'step': _sanitize_for_json(item), 'taskId': task_id})}\n\n"  # BUG-SSE-SURR
+        finally:
+            task.cancel()
+            # ABORT-3: cleanup registro — libera memoria e impedisce abort su task già terminati
+            _run_stream_tasks.pop(task_id, None)
+            yield "data: [DONE]\n\n"
+
+    return StreamingResponse(generate(), media_type="text/event-stream",
+        headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no", "Connection": "keep-alive"})
+
+
+# ── Reason loop / Unified loop ─────────────────────────────────────────────────
+
+@router.post('/api/reason/loop')
+async def reason_loop(body: ReasonLoopIn, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
+    try:
+        from agents.unified_loop import UnifiedAgentLoop
+        # S388: singleton — riusa il client già inizializzato
+        client = _get_ai_client()
+        try:
+            from agents.critic import Critic
+            from agents.response_verifier import ResponseVerifier
+            _critic   = Critic(llm_client=client)
+            _verifier = ResponseVerifier()
+        except Exception:
+            _critic   = None
+            _verifier = None
+        loop = UnifiedAgentLoop(
+            llm_client=client, critic=_critic, verifier=_verifier,
+            memory=await _get_mem_manager_async(), executor=_get_executor(), planner=_get_planner(),
+        )
+        context_str = '\n'.join(m.get('content', '') for m in body.context) if body.context else ''
+        # N-2-FIX: accumula step intermedi tramite on_step — inclusi nel response JSON per debug frontend
+        _steps_log: list[dict] = []
+        async def _on_step(step_data: dict) -> None:
+            _steps_log.append({
+                'action': step_data.get('action', ''),
+                'output': str(step_data.get('output', ''))[:400],  # S577: 200→400
+            })
+        result = await loop.run(goal=body.goal, context=context_str, max_steps=body.max_steps, on_step=_on_step, session_id=getattr(body, "session_id", "") or "")
+        if isinstance(result, dict):
+            output_text = result.get('output', '') or ''
+            engine_used = result.get('engine', 'unknown')
+            errors_list = result.get('errors', [])
+        else:
+            output_text = str(result)
+            engine_used = 'unknown'
+            errors_list = []
+        return {
+            'ok':     bool(output_text and output_text.strip()),
+            'success': bool(output_text and output_text.strip()),  # alias compat frontend
+            'output':  output_text,                                  # alias compat frontend
+            'result': output_text,
+            'source': 'backend_loop',
+            'engine': engine_used,
+            'errors': errors_list,
+            'steps':  _steps_log,  # N-2-FIX: step intermedi per debug/telemetria frontend
+        }
+    except Exception as e:
+        _logger.error("[reason/loop] Error: %s", e)
+        return {
+            'ok':     False,
+            'result': f'Backend reasoning non disponibile: {e}. Il loop browser continua normalmente.',
+            'source': 'fallback',
+            'steps':  [],
+        }
+
+
+@router.post('/api/unified/loop')
+async def unified_loop(body: ReasonLoopIn, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix: alias che chiama reason_loop direttamente — Depends NON si propagano
+    """Alias di /api/reason/loop — compatibilità con tutte le versioni frontend."""
+    return await reason_loop(body)
+
+
+# ── Agent kernel ──────────────���────────────────────────────────────────────────
+
+@router.get('/api/agent-kernel/status')
+async def agent_kernel_status(role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
+    gh_token = os.getenv('GITHUB_TOKEN') or os.getenv('GH_TOKEN', '')
+    return {
+        'dispatch_available': bool(gh_token),
+        'workflow_url': 'https://github.com/Baida98/AI/actions/workflows/agent-kernel.yml',
+        'mobile_url':   'https://github.com/Baida98/AI/actions',
+        'secrets_needed': ['OPENROUTER_API_KEY', 'GROQ_API_KEY', 'GEMINI_API_KEY', 'HF_TOKEN', 'NVIDIA_API_KEY'],
+        'usage': 'Vai su GitHub Actions → Agent Kernel — no PC → Run workflow → inserisci il goal',
+    }
+
+
+# S442-FIX3: modello Pydantic per agent_kernel_dispatch.
+# Prima: body: dict grezzo → mode non validato, goal controllato solo dopo estrazione.
+# Ora: validazione in ingresso → 422 chiaro invece di 500 a runtime.
+class AgentKernelDispatchIn(BaseModel):
+    goal: str
+    mode: Literal["plan", "execute", "analyze"] = "plan"
+
+    @field_validator('goal', mode='before')
+    @classmethod
+    def validate_goal(cls, v: object) -> str:
+        if not isinstance(v, str) or not str(v).strip():
+            raise ValueError('goal must be a non-empty string')
+        return str(v).strip()
+
+
+@router.post('/api/agent-kernel/dispatch')
+async def agent_kernel_dispatch(body: AgentKernelDispatchIn, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
+    gh_token = os.getenv('GITHUB_TOKEN') or os.getenv('GH_TOKEN', '')
+    if not gh_token:
+        raise HTTPException(503, detail={
+            'error': 'no_github_token',
+            'message': 'GITHUB_TOKEN non configurato nel backend.',
+        })
+    goal = body.goal
+    mode = body.mode
+    import httpx as _httpx
+    try:
+        async with _httpx.AsyncClient(timeout=15) as _hc:
+            _resp = await _hc.post(
+                'https://api.github.com/repos/Baida98/AI/actions/workflows/agent-kernel.yml/dispatches',
+                json={'ref': 'main', 'inputs': {'goal': goal, 'mode': mode, 'commit_memory': 'true'}},
+                headers={
+                    'Authorization':       f'Bearer {gh_token}',
+                    'Accept':              'application/vnd.github+json',
+                    'X-GitHub-Api-Version': '2022-11-28',
+                },
+            )
+        if _resp.status_code >= 400:
+            raise HTTPException(_resp.status_code, detail=_resp.text[:500])
+        return {'ok': True, 'status': _resp.status_code, 'goal': goal, 'mode': mode}
+    except _httpx.HTTPError as e:
+        raise HTTPException(502, detail=str(e)[:500])
+
+
+# ── Agent tasks (FASE 2.1 + S359 persistence) ──────────────────────────────────
+
+@router.post('/api/agent/tasks')
+async def create_agent_task(body: AgentTaskIn, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
+    """
+    Crea o recupera un task agent.
+
+    S359: se task_id non è in memoria ma esiste su Supabase (backend ha riavviato),
+    il task viene ripristinato dallo store persistente invece di essere riavviato.
+    Questo preserva lo stato SUCCESS/ERROR precedente senza sprecare token.
+    """
+    _prune_agent_tasks()
+    task_id = body.taskId or str(uuid.uuid4())
+
+    # Already in memory → return immediately (normal path, includes S358 reconnect)
+    if task_id in _agent_tasks:
+        return {'taskId': task_id, 'status': _agent_tasks[task_id]['status']}
+
+    # S359: try Supabase lazy restore (only hit network after backend restart)
+    restored = await sb_restore_task(task_id)
+    if restored:
+        # Put restored metadata back into memory so stream_agent_task can use it.
+        # Use context from the incoming request (not persisted to save space).
+        restored['context'] = body.context
+        _agent_tasks[task_id] = restored
+        return {'taskId': task_id, 'status': restored['status'], 'restored': True}
+
+    # Brand new task
+    created_at = int(time.time() * 1000)
+    _agent_tasks[task_id] = {
+        'id':              task_id,
+        'status':          'QUEUED',
+        'goal':            body.goal,
+        'context':         body.context,
+        'max_steps':       body.max_steps,
+        'created_at':      created_at,
+        'project_context':   body.project_context,  # S456-X5
+        'learning_hints':    body.learning_hints,   # S456-X4
+        'resume_from_step':  body.resume_from_step, # P16-F3: passo resume dalla coda
+        'persona':           body.persona,           # P17-F5: expertise persona hint
+        'session_id':        body.session_id or '',   # P17-F2: BB session key (normalize None→'')
+    }
+    # WRITE-AHEAD: persiste il task su Supabase immediatamente, prima del checkpoint
+    # periodico (15-60s). Finestra di perdita per la fase di creazione → zero.
+    asyncio.create_task(write_ahead_task_created(task_id, body.goal)).add_done_callback(_log_task_exc)
+    # BG-4: restore cross-session handoff context (async, non-blocking)
+    if body.session_id:
+        _hctx = await sb_restore_handoff_context(body.session_id)
+        if _hctx:
+            _agent_tasks[task_id]['_handoff_context'] = _hctx
+            asyncio.create_task(sb_delete_handoff(body.session_id)).add_done_callback(_log_task_exc)
+    # Persist asynchronously — never block the response
+    asyncio.create_task(
+        sb_upsert_task(task_id, body.goal, 'QUEUED', body.max_steps, body.context, created_at)
+    ).add_done_callback(_log_task_exc)
+    # S361: Speculative Tool Firing — pre-fires read-only tools in parallel
+    # while the main model processes. Results cached for _run_direct_tools to consume.
+    asyncio.create_task(fire_speculative_tools(task_id, body.goal)).add_done_callback(_log_task_exc)
+    return {'taskId': task_id, 'status': 'QUEUED'}
+
+
+# ── S369: List agent tasks (in-memory + Supabase merge) ─────────────────────
+
+@router.get('/api/agent/tasks')
+async def list_agent_tasks(limit: int = 50, status: str = '', role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
+    """
+    S369 — Lista tutti i task agent: unione di in-memory (_agent_tasks) e
+    Supabase (ultimi N task persistiti). In-memory ha sempre precedenza.
+
+    Query params:
+      limit  — max task da Supabase (default 50, max 200)
+      status — filtra per status (es. RUNNING, SUCCESS, ERROR); vuoto = tutti
+    """
+    _prune_agent_tasks()
+    now_ms = int(time.time() * 1000)
+    limit  = min(max(limit, 1), 200)
+
+    # 1. Task in-memory (live)
+    mem_tasks = []
+    for tid, t in _agent_tasks.items():
+        reg   = _loop_registry.get(tid)
+        is_live = reg is not None and not reg.get('done', True)
+        mem_tasks.append({
+            'taskId':    tid,
+            'goal':      (t.get('goal') or '')[:300],  # S606: 200→300
+            'status':    t.get('status', 'UNKNOWN'),
+            'maxSteps':  t.get('max_steps', 8),
+            'createdAt': t.get('created_at', 0),
+            'ageMs':     now_ms - t.get('created_at', now_ms),
+            'source':    'memory',
+            'isLive':    is_live,
+        })
+
+    mem_ids = {t['taskId'] for t in mem_tasks}
+
+    # 2. Supabase recent tasks (only if Supabase available)
+    sb_tasks = []
+    try:
+        sb_rows = await sb_list_tasks(limit=limit, status_filter=status or None)
+        for r in sb_rows:
+            if r['task_id'] in mem_ids:
+                continue  # already included from memory
+            sb_tasks.append({
+                'taskId':    r['task_id'],
+                'goal':      (r.get('goal') or '')[:300],  # S606: 200→300
+                'status':    r.get('status', 'UNKNOWN'),
+                'maxSteps':  r.get('max_steps', 8),
+                'createdAt': r.get('created_at', 0),
+                'ageMs':     now_ms - r.get('created_at', now_ms),
+                'source':    'supabase',
+                'isLive':    False,
+            })
+    except Exception as _exc:
+        _logger.debug("[agent] silenced %s", type(_exc).__name__)  # noqa: BLE001
+
+    all_tasks = mem_tasks + sb_tasks
+    # Apply status filter to in-memory tasks too
+    if status:
+        all_tasks = [t for t in all_tasks if t['status'] == status.upper()]
+
+    # Sort by createdAt desc (newest first)
+    all_tasks.sort(key=lambda t: t['createdAt'], reverse=True)
+
+    return {
+        'count':   len(all_tasks),
+        'memory':  len(mem_tasks),
+        'supabase': len(sb_tasks),
+        'tasks':   all_tasks[:limit],
+    }
+
+
+@router.delete('/api/agent/tasks/{task_id}')
+async def cancel_agent_task(task_id: str, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
+    if task_id in _agent_tasks:
+        _agent_tasks[task_id]['status'] = 'CANCELLED'
+    reg = _loop_registry.get(task_id)
+    if reg and not reg.get('done'):
+        at = reg.get('asyncio_task')
+        if at and not at.done():
+            at.cancel()
+    # Persist status + clean up events
+    asyncio.create_task(sb_update_status(task_id, 'CANCELLED')).add_done_callback(_log_task_exc)
+    asyncio.create_task(sb_delete_task_events(task_id)).add_done_callback(_log_task_exc)
+    # S361: clean speculative cache for cancelled task
+    try:
+        goal = _agent_tasks.get(task_id, {}).get('goal', '')
+        if goal:
+            from .speculative import purge_speculative
+            purge_speculative(goal)
+    except Exception as _exc:
+        _logger.debug("[agent] silenced %s", type(_exc).__name__)  # noqa: BLE001
+    return {'cancelled': task_id}
+
+
+
+@router.get('/api/agent/tasks/{task_id}/status')
+async def get_agent_task_status(task_id: str, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
+    """
+    Controlla lo stato di un task agent senza aprire un SSE stream.
+    Usato dal frontend per recovery al boot: verifica se un task in sospeso
+    e` ancora in esecuzione, completato, o scomparso dopo riavvio HF Space.
+    Returns: {taskId, status, goal, source: 'memory'|'supabase'|'not_found'}
+    """
+    if task_id in _agent_tasks:
+        t = _agent_tasks[task_id]
+        return {'taskId': task_id, 'status': t.get('status', 'UNKNOWN'),
+                'goal': (t.get('goal') or '')[:300], 'source': 'memory'}
+    restored = await sb_restore_task(task_id)
+    if restored:
+        return {'taskId': task_id, 'status': restored.get('status', 'UNKNOWN'),
+                'goal': (restored.get('goal') or '')[:300], 'source': 'supabase'}
+    return {'taskId': task_id, 'status': 'NOT_FOUND', 'source': None}
+
+
+@router.get('/api/agent/tasks/{task_id}/stream')
+async def stream_agent_task(task_id: str, request: Request, resume: int = 0, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
+    """
+    SSE stream per un task agent.
+
+    S358: reconnect-safe via _loop_registry fanout (no re-run mentre il backend gira).
+    S359: lazy restore da Supabase dopo restart HF Space:
+      - Task SUCCESS/ERROR → replay event buffer da Supabase → chiusura immediata.
+      - Task era RUNNING   → replay buffer parziale + evento task_interrupted.
+      - Task non trovato   → prova sb_restore_task prima di 404.
+    """
+    # S359: se task_id non è in memoria, prova il restore da Supabase
+    if task_id not in _agent_tasks:
+        restored = await sb_restore_task(task_id)
+        if restored:
+            restored['context'] = []
+            _agent_tasks[task_id] = restored
+        else:
+            raise HTTPException(404, detail=f'Task {task_id} non trovato')
+
+    task = _agent_tasks[task_id]
+    _last_event_id = request.headers.get("Last-Event-ID") or request.headers.get("last-event-id")
+    _resume_from   = int(_last_event_id) if (_last_event_id and _last_event_id.isdigit()) else resume
+
+    sub_q: asyncio.Queue[str | None] = asyncio.Queue()
+
+    async def generate():
+        yield "retry: 3000\n\n"
+
+        reg = _loop_registry.get(task_id)
+
+        is_done_reconnect = reg is not None and reg.get('done', False)
+        is_reconnect      = reg is not None and not reg.get('done', False)
+
+        # ── Case 1: loop già finito in questa sessione → replay buffer in-memory ──
+        if is_done_reconnect:
+            for evt_str in reg['event_buffer'][_resume_from:]:
+                yield evt_str
+            yield "data: [DONE]\n\n"
+            return
+
+        # ── Case 2: loop attivo in questa sessione → reconnect SSE (S358) ─────────
+        if is_reconnect:
+            join_idx = len(reg['event_buffer'])
+            reg['subscriber_queues'].append(sub_q)
+            try:
+                for evt_str in reg['event_buffer'][_resume_from:join_idx]:
+                    yield evt_str
+                while True:
+                    if _agent_tasks.get(task_id, {}).get('status') == 'CANCELLED':
+                        break
+                    try:
+                        item = await asyncio.wait_for(sub_q.get(), timeout=15.0)
+                        if item is None:
+                            break
+                        yield item
+                    except asyncio.TimeoutError:
+                        yield ': heartbeat\n\n'
+            finally:
+                try:
+                    reg['subscriber_queues'].remove(sub_q)
+                except ValueError as _exc:
+                    _logger.debug("[agent] silenced %s", type(_exc).__name__)  # noqa: BLE001
+            yield "data: [DONE]\n\n"
+            return
+
+        # ── Case 2.5 (S359): backend riavviato → prova Supabase event buffer ──────
+        sb_events = await sb_get_events(task_id)
+        if sb_events:
+            task_status = task.get('status', 'UNKNOWN')
+            terminal    = task_status in ('SUCCESS', 'ERROR', 'CANCELLED')
+            # Replay buffer from resume point
+            for evt_str in sb_events[_resume_from:]:
+                yield evt_str
+            if terminal:
+                # Task già completato → niente da fare, client ha tutto
+                yield "data: [DONE]\n\n"
+                return
+            else:
+                # Task era in esecuzione quando il backend è crashato — prova resume automatico
+                _cp_sb = _task_checkpoints.get(task_id) or await sb_get_checkpoint(task_id)
+                _can_resume = (
+                    _cp_sb is not None and
+                    len(_cp_sb.get('plan', [])) >= 1 and
+                    len(_cp_sb.get('logs', [])) >= 2
+                )
+                if _can_resume:
+                    # GAP-SYNC-FIX: usa _backend_steps se disponibili (context preciso per resume)
+                    _bsteps = _cp_sb.get('_backend_steps', [])
+                    if _bsteps:
+                        _steps_text = '\n'.join(
+                            f"  Passo {s['step']}: {s['action']} → {s['result'][:80]}"
+                            for s in _bsteps[-8:]
+                        )
+                        _rctx = (
+                            f"[RESUME AUTOMATICO] Step già completati dal backend:\n{_steps_text}\n"
+                            f"Riprendi dal passo {_cp_sb.get('step', 0)+1} senza ripetere quelli già eseguiti."
+                        )
+                    else:
+                        # Fallback: context semantico (piano + log riassuntivi)
+                        _rctx = (
+                            f"Piano già definito: {' | '.join((_cp_sb.get('plan') or [])[:5])}\n"
+                            f"Log fin qui: {' | '.join((_cp_sb.get('logs') or [])[-5:])}\n"
+                            f"Riprendi dal passo {_cp_sb.get('step', 0)} senza ripetere gli step già fatti."
+                        )
+                    task['_resume_context']   = _rctx
+                    task['_resume_max_steps'] = max(1, task.get('max_steps', 8) - _cp_sb.get('step', 0))
+                    # Fall through a Case 3 — NON fare return
+                else:
+                    # Nessun checkpoint utile → fallback onesto (comportamento precedente)
+                    interrupted_evt = json.dumps({
+                        'event':   'task_interrupted',
+                        'taskId':  task_id,
+                        'reason':  'backend_restarted',
+                        'message': 'Il backend si è riavviato durante l\'esecuzione. '
+                                   'Premi "Riprova" per rieseguire il task.',
+                    })
+                    yield f"data: {interrupted_evt}\n\n"
+                    _agent_tasks[task_id]['status'] = 'ERROR'
+                    asyncio.create_task(sb_update_status(task_id, 'ERROR')).add_done_callback(_log_task_exc)
+                    yield "data: [DONE]\n\n"
+                    return
+        # ── Case 3: nuova esecuzione ──────────────────────────────────────────────
+        _prune_loop_registry()
+        reg_entry: dict = {
+            'asyncio_task':      None,
+            'event_buffer':      [],
+            'subscriber_queues': [sub_q],
+            'done':              False,
+            'finished_at':       0.0,
+        }
+        _loop_registry[task_id] = reg_entry
+        _ctr = [0]
+
+        def _sse(event: str, data: dict) -> None:
+            """Emit one SSE frame: buffer it, fanout to all subscribers, persist async."""
+            _ctr[0] += 1
+            s = f"id: {_ctr[0]}\ndata: {json.dumps({'event': event, **data})}\n\n"
+            # GAP-3-FIX: text_chunk bypass buffer — fanout diretto, no persist.
+            # 800 token x 1 evento/token saturerebbero il cap da 500 evictando step cruciali.
+            # Su reconnect iOS i token non servono replay (streaming completato o ricominciato).
+            if event == 'text_chunk':
+                for q in list(reg_entry['subscriber_queues']):
+                    try:
+                        q.put_nowait(s)
+                    except Exception as _exc:
+                        _logger.debug("[agent] silenced %s", type(_exc).__name__)  # noqa: BLE001
+                return
+            reg_entry['event_buffer'].append(s)
+            # N-5-FIX: cap buffer a 500 eventi — evita crescita illimitata su task lunghi
+            if len(reg_entry['event_buffer']) > 500:
+                reg_entry['event_buffer'] = reg_entry['event_buffer'][-500:]
+            for q in list(reg_entry['subscriber_queues']):
+                try:
+                    q.put_nowait(s)
+                except Exception as _exc:
+                    _logger.debug("[agent] silenced %s", type(_exc).__name__)  # noqa: BLE001
+            # S359: persist event asynchronously (fire-and-forget)
+            asyncio.create_task(sb_append_event(task_id, _ctr[0], s)).add_done_callback(_log_task_exc)
+
+        _agent_tasks[task_id]['status'] = 'RUNNING'
+        asyncio.create_task(sb_update_status(task_id, 'RUNNING')).add_done_callback(_log_task_exc)
+        _prune_agent_tasks()
+
+        async def run_loop() -> None:
+            try:
+                from agents.unified_loop import UnifiedAgentLoop
+                # S388: singleton — evita OpenAI() per ogni task
+                client = _get_ai_client()
+                try:
+                    from agents.critic import Critic
+                    from agents.response_verifier import ResponseVerifier
+                    _critic   = Critic(llm_client=client)
+                    _verifier = ResponseVerifier()
+                except Exception:
+                    _critic   = None
+                    _verifier = None
+
+                context_str = '\n'.join(m.get('content', '') for m in task['context']) if task['context'] else ''
+                # S456-X5/X4: inject project context + learning hints stored at task creation
+                _proj_ctx = task.get('project_context', '')
+                if _proj_ctx:
+                    context_str = f"[PROGETTO CORRENTE]\n{_proj_ctx}\n\n{context_str}".strip()
+                _hints = task.get('learning_hints', [])
+                if _hints:
+                    # S591: _hints[:3]→[:5] — più pattern appresi nel context (task replay)
+                    hints_str = "\n".join(f"- {h}" for h in _hints[:5])
+                    context_str = f"{context_str}\n\n[PATTERN DI ERRORE APPRESI]\n{hints_str}".strip()
+                # P16-F3: inject resume hint if task was promoted from queue at a specific step
+                _resume_step = task.get('resume_from_step')
+                if _resume_step:
+                    context_str = f"[RIPRESA DA PASSO {_resume_step}] Riprendi dall'iterazione {_resume_step} del task.\n\n{context_str}".strip()
+                # P39-UX: Tocco Finale Manus — spiega all'agente come segnalare OAuth mancante
+                _connector_hint = (
+                    "[CONNETTORI OAUTH]\n"
+                    "Se durante il task hai bisogno di un accesso OAuth (GitHub, Google Calendar, Instagram)\n"
+                    "ma non hai il token disponibile, includi nella tua risposta finale o parziale:\n"
+                    "  [CONNECTOR_NEEDED:github] oppure [CONNECTOR_NEEDED:google] oppure [CONNECTOR_NEEDED:instagram]\n"
+                    "Il frontend mostrerà automaticamente un pulsante 'Connetti' all'utente."
+                )
+                context_str = f"{context_str}\n\n{_connector_hint}".strip() if context_str else _connector_hint
+                # GAP-SYNC-FIX: inject _resume_context (set da stream_agent_task su reconnect con checkpoint)
+                # Bug: _resume_context era settato su task{} ma mai letto qui → context perduto su resume.
+                _resume_ctx = task.get('_resume_context', '')
+                if _resume_ctx:
+                    context_str = f"{_resume_ctx}\n\n{context_str}".strip()
+                # P17-F5: inject Expertise Persona hint se specificato
+                _PERSONA_HINTS = {
+                    "researcher": (
+                        "[PERSONA: RICERCATORE ESPERTO]\n"
+                        "- Priorizza sempre la ricerca web aggiornata prima di rispondere\n"
+                        "- Cita fonti specifiche (URL, titolo, data) per ogni claim importante\n"
+                        "- Struttura le risposte: Sommario → Dettaglio → Fonti\n"
+                        "- Verifica incrociando più fonti prima di concludere\n"
+                        "- Strumenti preferiti: web_search, read_page, fetch_url, research"
+                    ),
+                    "coder": (
+                        "[PERSONA: SENIOR ENGINEER]\n"
+                        "- Scrivi codice production-ready: tipizzato, documentato, con error handling\n"
+                        "- Esegui il codice per verificare il funzionamento prima di rispondere\n"
+                        "- Preferisci soluzioni robuste e testate su approcci creativi ma fragili\n"
+                        "- Documenta funzioni e classi con docstring/JSDoc\n"
+                        "- Strumenti preferiti: run_python, write_file, read_file, pip_install"
+                    ),
+                    "architect": (
+                        "[PERSONA: ARCHITECT]\n"
+                        "- Priorizza analisi, design di sistema e decisioni strategiche\n"
+                        "- Struttura l'architettura in componenti chiari e mantenibili\n"
+                        "- Considera scalabilità, manutenibilità e trade-off tecnici\n"
+                        "- Documenta le decisioni architetturali e il loro razionale"
+                    ),
+                    "reasoner": (
+                        "[PERSONA: RAGIONATORE STRATEGICO]\n"
+                        "- Usa ragionamento step-by-step esplicito: mostra il processo di pensiero\n"
+                        "- Analizza ogni prospettiva prima di concludere\n"
+                        "- Struttura la risposta: Analisi → Pro/Contro → Raccomandazione\n"
+                        "- Considera le implicazioni di lungo termine delle scelte"
+                    ),
+                    "analyst": (
+                        "[PERSONA: ANALISTA DATI]\n"
+                        "- Usa Python per elaborare e analizzare dati quando disponibili\n"
+                        "- Produci visualizzazioni chiare (grafici, tabelle) ove possibile\n"
+                        "- Interpreta i risultati con rigore: distingui correlazione da causalità\n"
+                        "- Struttura i report: Executive Summary → Metodologia → Risultati → Conclusioni\n"
+                        "- Strumenti preferiti: run_python, web_search, vision"
+                    ),
+                }
+                _persona = task.get('persona') or ''
+                # P17-F5-IMPROVED: server-side classification se persona vuota/auto
+                _persona_auto = False
+                if not _persona:
+                    _persona = _classify_persona_server(task.get('goal', ''))
+                    if _persona:
+                        _persona_auto = True
+                        task['persona'] = _persona  # persist per history/resume
+                _persona_hint = _PERSONA_HINTS.get(_persona.lower().strip(), '')
+                if _persona_hint:
+                    context_str = f"{_persona_hint}\n\n{context_str}".strip()
+                # P17-F5: emit persona_classified SSE event — UI badge feedback
+                if _persona:
+                    _persona_conf = 0.85 if not _persona_auto else 0.78
+                    _sse('persona_classified', {
+                        'taskId':     task_id,
+                        'persona':    _persona,
+                        'confidence': _persona_conf,
+                        'auto':       _persona_auto,
+                    })
+                # BG-4: inject cross-session handoff context if available
+                _hctx = task.get("_handoff_context", "")
+                if _hctx:
+                    context_str = f"{_hctx}\n\n{context_str}".strip()
+                # P17-F5: route primary LLM to persona-appropriate client
+                _persona_client = _get_persona_llm_client(_persona, client)
+                loop = UnifiedAgentLoop(
+                    llm_client=_persona_client, critic=_critic, verifier=_verifier,
+                    memory=await _get_mem_manager_async(), executor=_get_executor(), planner=_get_planner(),
+                )
+                step_idx = [0]
+                _backend_steps: list[dict] = []  # GAP-SYNC-FIX: log step per resume preciso
+
+                async def step_cb(step_data: dict) -> None:
+                    step_idx[0] += 1
+                    _action = step_data.get('action', f'Step {step_idx[0]}')
+                    # S420: streaming token — emetti direttamente senza passare dal buffer step
+                    if _action == 'text_chunk':
+                        _sse('text_chunk', {'taskId': task_id, 'token': _ss(step_data.get('token', ''))})
+                        return
+
+                    # S363-Blueprint: Narrative Streaming — explanation lookup for ALL step_done events
+                    # S376: _STEP_NARRATIONS espanso — aggiunge 12 tool mancanti
+                    # Il fallback `_action.replace('_', ' ').capitalize()` è troppo generico
+                    # per tool composti — narrativa esplicita migliora la UX del LiveStreamBlock
+                    _STEP_NARRATIONS = {
+                        'plan': 'Analisi del goal e creazione piano di azione',
+                        'llm': 'Elaborazione risposta AI',
+                        'fallback': 'Completamento task',
+                        'smolagents': 'Esecuzione agente autonomo con strumenti',
+                        'web_search': 'Cerco informazioni aggiornate sul web',
+                        'read_page': 'Leggo il contenuto della pagina web',
+                        'fetch_url': 'Recupero dati dall\'URL richiesto',
+                        'fetch_url_content': 'Scarico il contenuto dell\'URL',
+                        'run_code': 'Eseguo il codice nel sandbox',
+                        'write_file': 'Scrivo il file nel progetto',
+                        'read_file': 'Leggo il file dal VFS',
+                        'delete_file': 'Rimuovo il file dal progetto',
+                        'create_file': 'Creo il file nel progetto',
+                        'list_files': 'Elenco i file del progetto',
+                        'search_github': 'Cerco codice e repository su GitHub',
+                        'search_github_code': 'Cerco snippet di codice su GitHub',
+                        'search_wikipedia': 'Consulto Wikipedia per informazioni',
+                        'get_weather': 'Recupero le previsioni meteo',
+                        'get_news': 'Carico le ultime notizie',
+                        'get_currency': 'Consulto il tasso di cambio',
+                        'get_location': 'Rilevo la posizione geografica',
+                        'calculate': 'Calcolo l\'espressione matematica',
+                        'math_eval': 'Valuto l\'espressione matematica',
+                        'generate_image': 'Genero l\'immagine con AI (Pollinations)',
+                        'remember': 'Salvo informazioni in memoria',
+                        'recall': 'Recupero informazioni dalla memoria',
+                        'direct_tools': 'Utilizzo strumenti diretti',
+                        'critic_retry': 'Auto-correzione risposta (Quality Gate)',
+                        'execution_validator_fix': 'Auto-fix codice rilevato (ExecutionValidator)',
+                        '__thinking__': 'Ragionamento interno in corso',
+                        '__plan__': 'Pianificazione step successivo',
+                        '__verify__': 'Verifica e validazione risposta',
+                        'reflective_debug': 'Analisi root cause errore (Chain-of-Verification)',
+                        'lint_result': 'Validazione sintattica file',
+                        'lint_code': 'Analisi statica del codice',
+                        'project_skeleton': 'Mappa aggiornata del progetto',
+                        'tool_governor_skip': 'Tool già eseguito — risultato riutilizzato',
+                        'severity_retry': 'Retry adattivo per tipologia errore (S376)',
+                        # S-LOOP2: narrations per fasi avanzate
+                        'reasoning_core':   'Ragionamento multi-step (ReasoningCore attivo)',
+                        'browser_verifier':  'Verifica app live in tempo reale (Playwright)',
+                    }
+                    _tool_key_narr = _action.replace('executor:', '') if _action.startswith('executor:') else _action
+                    _narration = _STEP_NARRATIONS.get(_tool_key_narr,
+                        _action.replace('executor:', '').replace('_', ' ').capitalize())
+                    # P16-B4: propaga 'truncated' dal loop (finish_reason==length) → frontend
+                    _step_truncated = bool(step_data.get('truncated', False))
+                    _sse('step_done', {
+                        'taskId': task_id,
+                        'step': {
+                            'name':        _action,
+                            'index':       step_idx[0],
+                            'status':      step_data.get('status', 'done'),
+                            'result':      str(step_data.get('result', step_data.get('output', '')))[:500],
+                            'explanation': _narration,  # S363-Blueprint: narrative field
+                            'truncated':   _step_truncated,  # P16-B4: segnala max_tokens raggiunto
+                        },
+                    })
+                    # P39-UX: rileva [CONNECTOR_NEEDED:provider] nel result → emetti SSE connector_needed
+                    import re as _re_cn
+                    _cn_result = str(step_data.get('result', step_data.get('output', '')))
+                    _cn_matches = _re_cn.findall(r'\[CONNECTOR_NEEDED:([\w]+)\]', _cn_result)
+                    for _cn_prov in _cn_matches:
+                        _PROVIDER_LABELS = {'github': 'GitHub', 'google': 'Google Calendar', 'instagram': 'Instagram'}
+                        _cn_label = _PROVIDER_LABELS.get(_cn_prov.lower(), _cn_prov.capitalize())
+                        _sse('connector_needed', {
+                            'taskId':   task_id,
+                            'provider': _cn_prov.lower(),
+                            'label':    _cn_label,
+                            'message':  f"Per completare il task ho bisogno di accedere a {_cn_label}. Connettiti con un tap.",
+                        })
+                    # GAP-SYNC-FIX: accumula step results per resume preciso (checkpoint backend-side)
+                    _backend_steps.append({
+                        'step':   step_idx[0],
+                        'action': _action,
+                        'result': str(step_data.get('result', step_data.get('output', '')))[:150],
+                        'ok':     step_data.get('status', 'done') not in ('error', 'failed'),
+                    })
+                    # Ogni 2 step: persisti il log su Supabase (non saturare Supabase su loop lunghi)
+                    if step_idx[0] % 2 == 0:
+                        asyncio.create_task(
+                            sb_save_checkpoint(task_id, step_idx[0], {
+                                '_backend_steps': _backend_steps[-10:],  # ultime 10 step
+                                'step':           step_idx[0],
+                            })
+                        ).add_done_callback(_log_task_exc)
+                    # TG-STEP: notifica step intermedio rilevante (fire-and-forget, rate-limited 30s)
+                    asyncio.create_task(_tg_step(task_id, _action, _narration)).add_done_callback(_log_task_exc)
+                    # S362: emit vfs_update when a file operation is detected
+                    # SYNC-1: file_written (da unified_loop GAP-1) incluso + content forwarding
+                    _VFS_ACTIONS = ('write_file', 'file_write', 'create_file', 'delete_file', 'file_delete', 'file_written')
+                    if _action in _VFS_ACTIONS or step_data.get('file_path'):
+                        # S581: 120→200 — path file spesso 120-200 chars
+                        # S596: 200→400 — result/output può contenere path completo di progetto
+                        # S604: 400→500 — parity con altri campi step
+                        # SYNC-1: file_written porta path in 'path', non 'file_path'
+                        _vfs_file = (step_data.get('path') or
+                                     step_data.get('file_path') or
+                                     step_data.get('result', '')[:500] or
+                                     step_data.get('output', '')[:500])
+                        _vfs_op = 'delete' if 'delete' in _action else 'write'
+                        _vfs_evt: dict = {'taskId': task_id, 'file': str(_vfs_file)[:500], 'op': _vfs_op}
+                        # SYNC-1: includi content nel SSE event per file_written (≤60KB)
+                        # Frontend scrive direttamente nel VFS locale senza fetch aggiuntivo
+                        if _action == 'file_written' and step_data.get('content'):
+                            _vfs_evt['content'] = str(step_data['content'])[:60_000]
+                        _sse('vfs_update', _vfs_evt)
+
+                    # S363-UI: thought event — emitted when planner completes
+                    if _action == 'plan' and step_data.get('status') == 'done':
+                        _plan_obj = step_data.get('result', step_data.get('output', ''))
+                        _thought = (_plan_obj.get('goal', '') if isinstance(_plan_obj, dict) else str(_plan_obj))[:400]  # S604: 280→400
+                        if _thought:
+                            _sse('thought', {'taskId': task_id, 'text': _thought,
+                                             'complexity': _plan_obj.get('complexity') if isinstance(_plan_obj, dict) else None})
+                        # S367: plan_update — structured subtask list for live plan tracking UI
+                        if isinstance(_plan_obj, dict) and _plan_obj.get('subtasks'):
+                            _sse('plan_update', {
+                                'taskId': task_id,
+                                'subtasks': [
+                                    {
+                                        'id':          s.get('id', _si + 1),
+                                        'description': s.get('description', '')[:200],  # S581: 80→200
+                                        'tool':        s.get('tool', ''),
+                                        'status':      'pending',
+                                    }
+                                    for _si, s in enumerate(_plan_obj['subtasks'])
+                                ],
+                                'goal': _plan_obj.get('goal', ''),
+                            })
+
+                    # S367: subtask_done — mark individual subtask complete for live checkbox update
+                    if step_data.get('subtask_id') and step_data.get('status') == 'done':
+                        _sse('plan_update', {
+                            'taskId':      task_id,
+                            'subtask_done': step_data['subtask_id'],
+                        })
+
+                    # S363-UI: action event — tool execution phase
+                    _TOOL_EXPLAINS_S363 = {
+                        'web_search': 'Cerco informazioni in rete',
+                        'get_weather': 'Recupero dati meteo',
+                        'get_news': 'Carico notizie recenti',
+                        'search_wikipedia': 'Consulto Wikipedia',
+                        'fetch_url': 'Leggo la pagina web',
+                        'search_github': 'Cerco su GitHub',
+                        'run_code': 'Eseguo il codice',
+                        'write_file': 'Scrivo il file',
+                        'read_file': 'Leggo il file',
+                        'direct_tools': 'Eseguo strumenti diretti',
+                    }
+                    _tool_key = _action.replace('executor:', '') if _action.startswith('executor:') else _action
+                    if _action.startswith('executor:') or _tool_key in _TOOL_EXPLAINS_S363:
+                        _sse('action', {
+                            'taskId': task_id,
+                            'log': _tool_key.upper().replace('_', ' ')[:30],
+                            'explain': _TOOL_EXPLAINS_S363.get(_tool_key, f'Esecuzione: {_tool_key}'),
+                        })
+                    # S758-P4.1: tool_use — chip pre-esecuzione (stream_agent_task path)
+                    _is_pre_exec = (
+                        (_action == 'tool_start' and step_data.get('status') == 'running') or
+                        (_action.startswith('executor:') and step_data.get('status') == 'started')
+                    )
+                    if _is_pre_exec:
+                        _sse('tool_use', {
+                            'taskId': task_id,
+                            'tool':   _tool_key,
+                            'name':   _tool_key,
+                            'label':  (step_data.get('title') or
+                                       _TOOL_EXPLAINS_S363.get(_tool_key,
+                                       _tool_key.replace('_', ' ').capitalize())),
+                            'args':   {},
+                        })
+                    # S758-P4.1: task_thinking — chip ragionamento LLM
+                    if (_action in ('__thinking__', 'reflective_debug') and
+                            step_data.get('status') in ('started', 'running', 'running_deep')):
+                        _sse('task_thinking', {
+                            'taskId':  task_id,
+                            'message': (step_data.get('explanation') or step_data.get('title') or
+                                       "L’agente sta elaborando…"),
+                        })
+
+                _sse('task_start', {'taskId': task_id, 'goal': task['goal']})
+                _task_started_ms = int(time.time() * 1000)  # NOTIFY-BOT: elapsed tracking
+                asyncio.create_task(_tg_start(task_id, task['goal'])).add_done_callback(_log_task_exc)
+                _sse('step_start', {'taskId': task_id, 'step': {'name': 'Analisi goal', 'index': 0}})
+
+                # S364: inject project skeleton into context from VFS (Gap 4)
+                if task.get('conversation_id'):
+                    try:
+                        from api.project_manifest import build_manifest_from_vfs, get_skeleton
+                        await asyncio.wait_for(
+                            build_manifest_from_vfs(task['conversation_id']),
+                            timeout=3.0,
+                        )
+                        _skeleton = await get_skeleton(task['conversation_id'])
+                        if _skeleton:
+                            context_str = (_skeleton + '\n\n' + context_str).strip()
+                    except Exception:
+                        pass  # S364: skeleton injection is optional
+
+                result = await loop.run(
+                    goal=task['goal'],
+                    context=context_str,
+                    max_steps=task.get('_resume_max_steps', task.get('max_steps', 8)),  # AG-BUG-1: _resume_max mai definito in questo scope
+                    on_step=step_cb,
+                    session_id=task.get('session_id', '') or '',
+                )
+                _agent_tasks[task_id]['status'] = 'SUCCESS'
+                asyncio.create_task(sb_update_status(task_id, 'SUCCESS')).add_done_callback(_log_task_exc)
+                _result_text = str(result.get('output', result) if isinstance(result, dict) else result)
+                _sse('task_done', {'taskId': task_id, 'result': _result_text[:8000]})
+                asyncio.create_task(_tg_done(task_id, task.get('goal', ''), _result_text[:500], _task_started_ms)).add_done_callback(_log_task_exc)
+
+                # S363: fire-and-forget quality check when code detected in output
+                if _run_quality_check:
+                    _qg_result = str(result.get('output', result) if isinstance(result, dict) else result)
+                    if len(_qg_result) > 500 and _qg_result.count('```') >= 2:  # S373: threshold raised — evita QG su snippet brevi
+                        asyncio.create_task(_run_quality_check(
+                            task_id, task['goal'], _qg_result,
+                            on_event=lambda ev: _sse(ev.get('type', 'test_result'), ev),
+                        )).add_done_callback(_log_task_exc)
+
+
+            except asyncio.CancelledError:
+                _agent_tasks[task_id]['status'] = 'CANCELLED'
+                asyncio.create_task(sb_update_status(task_id, 'CANCELLED')).add_done_callback(_log_task_exc)
+                _sse('task_cancelled', {'taskId': task_id})
+
+            except (ImportError, ModuleNotFoundError):
+                _agent_tasks[task_id]['status'] = 'SUCCESS'
+                asyncio.create_task(sb_update_status(task_id, 'SUCCESS')).add_done_callback(_log_task_exc)
+                _sse('step_done', {'taskId': task_id, 'step': {'name': 'Ragionamento', 'index': 0}})
+                _sse('task_done', {'taskId': task_id, 'result': (
+                    f'Goal ricevuto: {task["goal"]}\n\n'
+                    'Il backend non ha il modulo agents.unified_loop. '
+                    'Configura HuggingFace Spaces con smolagents per l\'esecuzione autonoma.'
+                )})
+
+            except Exception as err:
+                _agent_tasks[task_id]['status'] = 'ERROR'
+                asyncio.create_task(sb_update_status(task_id, 'ERROR')).add_done_callback(_log_task_exc)
+                _logger.error('[agent/stream] %s error: %s', task_id, err, exc_info=True)
+                _sse('task_error', {'taskId': task_id, 'error': str(err)[:1000]})
+                asyncio.create_task(_tg_error(task_id, task.get('goal', ''), str(err))).add_done_callback(_log_task_exc)
+
+            finally:
+                reg_entry['done'] = True
+                reg_entry['finished_at'] = time.time()
+                for q in list(reg_entry['subscriber_queues']):
+                    try:
+                        q.put_nowait(None)
+                    except Exception as _exc:
+                        _logger.debug("[agent] silenced %s", type(_exc).__name__)  # noqa: BLE001
+
+        reg_entry['asyncio_task'] = asyncio.create_task(run_loop())
+        reg_entry['asyncio_task'].add_done_callback(_log_task_exc)  # BUG-CB-2
+
+        try:
+            while True:
+                if _agent_tasks.get(task_id, {}).get('status') == 'CANCELLED':
+                    at = reg_entry.get('asyncio_task')
+                    if at and not at.done():
+                        at.cancel()
+                    break
+                try:
+                    item = await asyncio.wait_for(sub_q.get(), timeout=15.0)
+                    if item is None:
+                        break
+                    yield item
+                except asyncio.TimeoutError:
+                    yield ': heartbeat\n\n'
+        finally:
+            try:
+                reg_entry['subscriber_queues'].remove(sub_q)
+            except ValueError as _exc:
+                _logger.debug("[agent] silenced %s", type(_exc).__name__)  # noqa: BLE001
+
+        yield "data: [DONE]\n\n"
+
+    return StreamingResponse(
+        generate(),
+        media_type='text/event-stream',
+        headers={
+            'Cache-Control':     'no-cache',
+            'X-Accel-Buffering': 'no',
+            'Connection':        'keep-alive',
+        },
+    )
+
+
+# ── Task checkpoints ───────────────────────────────────────────────────────────
+
+class CheckpointIn(BaseModel):
+    taskId:     str
+    step:       int
+    goal:       str
+    plan:       list[str] = []
+    logs:       list[str] = []
+    artifacts:  list[str] = []
+    retryCount: int = 0
+    extra:      dict = {}
+
+
+@router.post('/api/agent/tasks/{task_id}/checkpoint')
+async def save_checkpoint(task_id: str, body: CheckpointIn, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
+    _prune_checkpoints()
+    _task_checkpoints[task_id] = {
+        'taskId':     task_id,
+        'step':       body.step,
+        'goal':       body.goal,
+        'plan':       body.plan,
+        'logs':       body.logs[-50:],
+        'artifacts':  body.artifacts,
+        'retryCount': body.retryCount,
+        'extra':      body.extra,
+        'savedAt':    int(time.time() * 1000),
+    }
+    asyncio.create_task(sb_save_checkpoint(task_id, _task_checkpoints[task_id])).add_done_callback(_log_task_exc)
+    return {'saved': True, 'taskId': task_id, 'step': body.step}
+
+
+@router.get('/api/agent/tasks/{task_id}/checkpoint')
+async def get_checkpoint(task_id: str, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
+    _prune_checkpoints()
+    cp = _task_checkpoints.get(task_id)
+    if not cp:
+        cp = await sb_get_checkpoint(task_id)
+    if not cp:
+        raise HTTPException(404, detail={'error': 'checkpoint_not_found', 'taskId': task_id})
+    return cp
+
+
+@router.delete('/api/agent/tasks/{task_id}/checkpoint')
+async def delete_checkpoint(task_id: str, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
+    _task_checkpoints.pop(task_id, None)
+    return {'deleted': task_id}
+
+
+@router.get('/api/agent/checkpoints')
+async def list_checkpoints(role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
+    _prune_checkpoints()
+    now = int(time.time() * 1000)
+    return {
+        'count': len(_task_checkpoints),
+        'checkpoints': [
+            {'taskId': k, 'step': v['step'], 'goal': v['goal'][:300], 'age_ms': now - v['savedAt']}  # S606: 200→300
+            for k, v in _task_checkpoints.items()
+        ],
+    }
+
+
+# ─── Sprint 5 ITEM 15: /debug/timing — telemetria timing + qualità agente ────
+# Usato da TelemetryDashboard.tsx (frontend) per la sezione "Qualità agente".
+# Espone: timing_stats (avg/count per fase) + repair_stats (contatori qualità).
+# Non richiede auth — dati aggregati, nessun dato sensibile.
+@router.get('/debug/timing')
+async def get_debug_timing(role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix: internal diagnostics
+    """
+    Espone timing breakdown per fase (classify/plan/coder/verifier/browser)
+    e contatori qualità (goal_success, repair_success, tool_failure, req_engine).
+    Formato: { timing_stats: {label: {avg, count}}, repair_stats: {key: count} }
+    """
+    try:
+        from api.state import _TIMING_STORE, _REPAIR_STATS
+        timing_stats: dict = {}
+        for label, samples in _TIMING_STORE.items():
+            if samples:
+                avg_val = round(sum(samples) / len(samples), 1)
+            else:
+                avg_val = None
+            timing_stats[label] = {"avg": avg_val, "count": len(samples)}
+        return {
+            "timing_stats": timing_stats,
+            "repair_stats": dict(_REPAIR_STATS),
+        }
+    except Exception as exc:
+        return {"timing_stats": {}, "repair_stats": {}, "error": str(exc)}
+
+
+# ─── GAP-SKILL-SYNC: /api/agent/skill-stats — statistiche tool adattive ──────
+# Espone i dati del SkillTracker (session-scoped success/fail per tool)
+# al frontend per merge con skillRegistry Dexie — vista cross-runtime unificata.
+@router.get('/api/agent/skill-stats/{session_id}')
+async def get_skill_stats(session_id: str, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
+    """Success/fail rate + Wilson score per ogni tool nella sessione.
+
+    Il frontend usa questa API per arricchire i dati Dexie di skillRegistry.ts
+    con le stats backend: confidence reale (server-side) vs contatori browser-only.
+    """
+    try:
+        from agents.skill_tracker import get_skill_tracker
+        return {
+            "session_id": session_id,
+            "stats":      get_skill_tracker().get_stats(session_id),
+        }
+    except Exception as exc:
+        return {"session_id": session_id, "stats": {}, "error": str(exc)}
+
+
+@router.get('/api/agent/skill-stats')
+async def list_all_skill_sessions(role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
+    """Debug: panoramica di tutte le sessioni SkillTracker attive (tool count, call count)."""
+    try:
+        from agents.skill_tracker import get_skill_tracker
+        return get_skill_tracker().get_all_sessions()
+    except Exception as exc:
+        return {"error": str(exc)}
+
+# ── /api/agent/circuit-status/{session_id} — circuit breaker live status ──────
+# Espone per ogni tool tracciato in sessione: stato circuito, Wilson score,
+# recovery calls effettuate — utile per debug e monitoring real-time.
+@router.get('/api/agent/circuit-status/{session_id}')
+async def get_circuit_status(session_id: str, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
+    """
+    Stato real-time del circuit breaker per ogni tool di una sessione.
+
+    Per ogni tool tracciato, classifica il circuito come:
+      - open   → Wilson score < 0.15 AND total_count >= 3 AND tool ha fallback
+                 (il tool viene bypassato — routing automatico ai fallback)
+      - closed → performance sufficiente o dati insufficienti per aprire il circuit
+
+    Campi per tool:
+      wilson_score:     lower bound dell'intervallo di confidenza al 95% (0–1)
+      success_count:    successi registrati nella sessione
+      fail_count:       fallimenti registrati nella sessione
+      total_count:      chiamate totali
+      success_rate:     raw rate (NON usato dal circuit — solo informativo)
+      avg_latency_ms:   latenza media (ms)
+      has_fallbacks:    True se TOOL_REGISTRY definisce fallback per il tool
+      recovery_calls:   quante volte il recovery credit ha concesso un tentativo
+      circuit_state:    "open" | "closed" | "no_data" | "insufficient_data"
+
+    Thresholds (from executor.py):
+      circuit_open_threshold: 0.15   (Wilson score sotto cui il circuit si apre)
+      min_calls_for_circuit:  3      (chiamate minime prima che il circuit possa aprirsi)
+      recovery_interval:      5      (ogni N call con circuit open → recovery attempt)
+    """
+    try:
+        from agents.skill_tracker import get_skill_tracker
+        from tools.registry import TOOL_REGISTRY
+        from api.state import _get_executor
+        from agents.executor import (
+            _CIRCUIT_OPEN_THRESHOLD,
+            _MIN_CALLS_FOR_CIRCUIT,
+            _RECOVERY_INTERVAL,
+        )
+
+        stats = get_skill_tracker().get_stats(session_id)
+
+        # Recovery counts vivono nell'istanza Executor singleton
+        executor    = _get_executor()
+        rec_counts: dict = {}
+        if executor is not None:
+            rec_counts = getattr(executor, '_circuit_recovery_counts', {})
+
+        circuits_open: list[dict]   = []
+        circuits_closed: list[dict] = []
+
+        for tool_name, s in stats.items():
+            has_fallbacks = bool(TOOL_REGISTRY.get(tool_name, {}).get('fallbacks'))
+            recovery_calls = rec_counts.get(tool_name, 0)
+
+            # Replica logica _is_circuit_open() di executor.py
+            if s['total_count'] == 0:
+                state = 'no_data'
+            elif s['total_count'] < _MIN_CALLS_FOR_CIRCUIT:
+                state = 'insufficient_data'
+            elif s['wilson_score'] < _CIRCUIT_OPEN_THRESHOLD and has_fallbacks:
+                state = 'open'
+            else:
+                state = 'closed'
+
+            entry = {
+                'tool':            tool_name,
+                'circuit_state':   state,
+                'wilson_score':    s['wilson_score'],
+                'success_count':   s['success_count'],
+                'fail_count':      s['fail_count'],
+                'total_count':     s['total_count'],
+                'success_rate':    s['success_rate'],
+                'avg_latency_ms':  s['avg_latency_ms'],
+                'has_fallbacks':   has_fallbacks,
+                'recovery_calls':  recovery_calls,
+            }
+            if state == 'open':
+                circuits_open.append(entry)
+            else:
+                circuits_closed.append(entry)
+
+        # Ordina open per Wilson score asc (peggiori prima), closed per desc (migliori prima)
+        circuits_open.sort(key=lambda x: x['wilson_score'])
+        circuits_closed.sort(key=lambda x: x['wilson_score'], reverse=True)
+
+        return {
+            'session_id':            session_id,
+            'total_tools_tracked':   len(stats),
+            'circuits_open_count':   len(circuits_open),
+            'circuits_closed_count': len(circuits_closed),
+            'circuits_open':         circuits_open,
+            'circuits_closed':       circuits_closed,
+            'thresholds': {
+                'circuit_open_threshold': _CIRCUIT_OPEN_THRESHOLD,
+                'min_calls_for_circuit':  _MIN_CALLS_FOR_CIRCUIT,
+                'recovery_interval':      _RECOVERY_INTERVAL,
+            },
+        }
+    except Exception as exc:
+        return {
+            'session_id':          session_id,
+            'total_tools_tracked': 0,
+            'circuits_open_count': 0,
+            'circuits_open':       [],
+            'circuits_closed':     [],
+            'error':               str(exc),
+        }
+
+@router.post('/api/agent/abort')
+async def abort_agent_task(taskId: str = Body(..., embed=True), role: AuthRole = Depends(require_role(AuthRole.MACHINE))):
+    """
+    ABORT-ENDPOINT: Permette di cancellare un task in streaming (run-stream).
+    Inserisce un segnale __abort__ nella coda del task, che verrà catturato
+    dal loop SSE per interrompere l'esecuzione e pulire le risorse.
+    """
+    if taskId in _run_stream_tasks:
+        queue = _run_stream_tasks[taskId].get("queue")
+        if queue:
+            await queue.put({"__abort__": True})
+            return {"ok": True, "message": f"Abort signal sent to task {taskId}"}
+    return {"ok": False, "message": "Task not found or already finished"}

api/agent_memory.py

@@ -8,22 +8,17 @@ Fix: dopo ogni write Supabase riuscita, schedula un tentativo di sync del
 fallback — se ci sono voci orfane le pubblica su Supabase e le rimuove dal
 fallback locale. Nessun job periodico (troppo pesante su free-tier) — lazy
 reconciliation al primo write riuscito dopo un periodo di downtime Supabase.
-
-GAP-AUTH-MEMORY fix: POST e DELETE protetti con require_role(AuthRole.MACHINE).
-GAP-MEM-RECONCILE-BREAK fix: continue invece di break per errori record-level.
-GAP-AGENT-MEMORY-RECONCILE-TASK fix: create_task wrappato in try/except RuntimeError.
 """
 import time, asyncio
 from fastapi import APIRouter, Depends
+from .auth_guard import require_role, AuthRole
 from pydantic import BaseModel
 from .state import _sb, _mem_fallback
-from .auth_guard import require_role, AuthRole
-from .global_state_sync import get_global_state_sync
 
 import logging
 _logger = logging.getLogger("api.agent_memory")
 
-router = APIRouter()
+router = APIRouter( dependencies=[Depends(require_role(AuthRole.MACHINE))])  # GAP-1-fix: router-level auth
 
 
 class MemoryEntry(BaseModel):
@@ -41,10 +36,6 @@ async def _reconcile_fallback() -> int:
     solo in fallback (es. dopo un periodo di downtime Supabase), le pubblica.
     Ritorna il numero di voci sincronizzate.
     Non solleva mai eccezioni — fire-and-forget.
-
-    GAP-MEM-RECONCILE-BREAK fix: break solo su errori network/connessione;
-    continue per errori specifici al record (tipo sbagliato, valore too large, ecc.)
-    per non bloccare la riconciliazione delle voci successive.
     """
     if not _sb or not _mem_fallback:
         return 0
@@ -60,14 +51,8 @@ async def _reconcile_fallback() -> int:
             }, on_conflict='key').execute()
             synced += 1
         except Exception as _e:
-            # GAP-MEM-RECONCILE-BREAK: distingui errore network (stop tutto) da errore record
-            _is_network = isinstance(_e, (ConnectionError, TimeoutError, OSError))
-            if _is_network:
-                _logger.debug("[memory] reconcile: network error at key=%s — stopping: %s", key, _e)
-                break  # Supabase non raggiungibile — interrompi, riprova al prossimo write
-            # Errore specifico al record (tipo sbagliato, valore corrotto, ecc.) — salta e continua
-            _logger.debug("[memory] reconcile: record-level error at key=%s — skipping: %s", key, _e)
-            continue
+            _logger.debug("[memory] reconcile stopped at key=%s: %s", key, _e)
+            break  # Supabase non disponibile — interrompi, riprova al prossimo write
     if synced:
         _logger.info("[memory] GAP-MEM-FIX: reconciled %d fallback entries to Supabase", synced)
     return synced
@@ -75,21 +60,6 @@ async def _reconcile_fallback() -> int:
 
 @router.get('/api/memory/agent')
 async def list_agent_memory():
-    # S766-GRID: Global State Sync layer (Supabase Federation)
-    sync = get_global_state_sync()
-    try:
-        unified = await sync.get_unified_memory("all_entries")
-        if unified and unified.get("data"):
-            # Mappa i dati unificati nel formato atteso dal frontend
-            entries = [
-                {'key': r['key'], 'value': r['value'], 'category': r.get('category', 'general'),
-                 'createdAt': r.get('created_at', 0), 'updatedAt': r.get('updated_at', 0)}
-                for r in unified["data"]
-            ]
-            return {'entries': entries}
-    except Exception as _exc:
-        _logger.debug("[memory] grid sync list fail: %s", _exc)
-
     if _sb:
         try:
             data = _sb.table('agent_memory').select('*').order('updated_at', desc=True).execute()
@@ -118,13 +88,7 @@ async def get_agent_memory(key: str):
 
 
 @router.post('/api/memory/agent')
-async def set_agent_memory(
-    entry: MemoryEntry,
-    _auth: AuthRole = Depends(require_role(AuthRole.MACHINE)),
-):
-    """GAP-AUTH-MEMORY fix: endpoint protetto con require_role(MACHINE).
-    Richiede X-Internal-Token header (aggiunto dal CF Worker su tutte le route non-public).
-    """
+async def set_agent_memory(entry: MemoryEntry):
     now = int(time.time() * 1000)
     record = {
         'key': entry.key, 'value': entry.value, 'category': entry.category,
@@ -140,12 +104,9 @@ async def set_agent_memory(
                 'created_at': entry.createdAt or now, 'updated_at': entry.updatedAt or now,
             }, on_conflict='key').execute()
             # GAP-MEM-FIX: Supabase disponibile → schedula riconciliazione fallback orfano
-            # GAP-AGENT-MEMORY-RECONCILE-TASK fix: wrappa in try/except per contesti senza event loop
+            # (voci scritte solo in fallback durante downtime precedente)
             if len(_mem_fallback) > 1:
-                try:
-                    asyncio.create_task(_reconcile_fallback())
-                except RuntimeError:
-                    pass  # Event loop non attivo (test/startup context) — task silently dropped
+                asyncio.create_task(_reconcile_fallback())
         except Exception as _e:
             _logger.warning('[memory] Supabase write error (fallback attivo): %s', _e)
 
@@ -153,13 +114,7 @@ async def set_agent_memory(
 
 
 @router.delete('/api/memory/agent/{key}')
-async def delete_agent_memory(
-    key: str,
-    _auth: AuthRole = Depends(require_role(AuthRole.MACHINE)),
-):
-    """GAP-AUTH-MEMORY fix: endpoint protetto con require_role(MACHINE).
-    Richiede X-Internal-Token header (aggiunto dal CF Worker su tutte le route non-public).
-    """
+async def delete_agent_memory(key: str):
     if _sb:
         try:
             _sb.table('agent_memory').delete().eq('key', key).execute()

api/agent_telemetry.py

@@ -18,11 +18,12 @@ Merge: additive — per ogni (system, verdict) prende max(count) e max(lastSeenM
 """
 import os, json, logging, time, asyncio
 from pathlib import Path
-from fastapi import APIRouter
+from fastapi import APIRouter, Depends
+from .auth_guard import require_role, AuthRole
 from fastapi.responses import JSONResponse
 from pydantic import BaseModel
 
-router = APIRouter()
+router = APIRouter( dependencies=[Depends(require_role(AuthRole.MACHINE))])  # GAP-1-fix: router-level auth
 _logger = logging.getLogger("agente_ai")
 
 # ─── Storage ──────────────────────────────────────────────────────────────────

api/auth_guard.py

@@ -59,14 +59,8 @@ _upstash_token = os.getenv('UPSTASH_REDIS_TOKEN', '')
 _use_redis = bool(_upstash_url and _upstash_token)
 
 def _redis_rate_check(key: str, limit: int, window_s: int) -> tuple[bool, int]:
-    """Rate check via Upstash Redis REST API (zero dipendenze extra).
-
-    GAP-RATE-LIMIT-REDIS-FAILOPEN fix: distingue errori network/timeout (fail-open
-    silenzioso — corretto) da errori di parsing/logica (fail-open MA loggati a WARNING
-    per visibilità nel monitoraggio). In entrambi i casi non blocca l'utente, ma gli
-    errori non-network diventano visibili nei log invece di essere silenziosi.
-    """
-    import urllib.request as _ur, urllib.error as _ue, json as _js, time as _rt
+    """Rate check via Upstash Redis REST API (zero dipendenze extra)."""
+    import urllib.request as _ur, json as _js, time as _rt
     now_s = int(_rt.time())
     window_key = f'{key}:{now_s // window_s}'
     try:
@@ -85,18 +79,9 @@ def _redis_rate_check(key: str, limit: int, window_s: int) -> tuple[bool, int]:
         if count > limit:
             return False, window_s
         return True, 0
-    except (_ue.URLError, _ue.HTTPError, TimeoutError, OSError):
-        # Rete/Redis non raggiungibile — fail-open silenzioso (comportamento atteso)
-        return True, 0
-    except Exception as _e:
-        # GAP-RATE-LIMIT-REDIS-FAILOPEN fix: errore di parsing JSON o bug nel codice —
-        # fail-open ma loggato a WARNING per visibilità (non silenzioso come prima).
-        # Causa tipica: struttura risposta Upstash cambiata, bug nel codice di parsing.
-        logger.warning(
-            "redis_rate_check: non-network error — rate limiter disabled for this request "
-            "(key=%s): %s: %s", key, type(_e).__name__, _e
-        )
-        return True, 0  # fail-open: mai bloccare per bug infrastrutturale
+    except Exception as _exc:  # SEC2-5: Redis irraggiungibile → fallback in-memory, non fail-open puro
+        logger.warning('[auth_guard] Redis rate check fallito (%s), fallback in-memory', _exc)
+        return _inmem_rate_check(key, limit, window_s)
 
 
 import time as _rl_time
@@ -128,6 +113,31 @@ def _rate_key(role: int, token_header: str | None, client_ip: str | None = None)
     return _rl_hash.sha256(raw.encode()).hexdigest()[:16]
 
 
+
+def _inmem_rate_check(key: str, limit: int, window_s: float) -> tuple[bool, int]:
+    """Rate check in-memory sliding window.
+
+    SEC2-5: usata sia quando Redis non è configurato, sia come fallback quando
+    Redis è temporaneamente irraggiungibile (prima era fail-open puro).
+    Thread-safe in asyncio (GIL, nessun await interno).
+    """
+    now = _rl_time.monotonic()
+    window_start = now - window_s
+
+    if key not in _rate_store:
+        _rate_store[key] = _col.deque()
+    dq = _rate_store[key]
+
+    while dq and dq[0] < window_start:
+        dq.popleft()
+
+    if len(dq) >= limit:
+        retry_after = int(window_s - (now - dq[0])) + 1
+        return False, max(retry_after, 1)
+
+    dq.append(now)
+    return True, 0
+
 def _check_rate_limit(
     role: int,
     token_header: str | None,
@@ -146,26 +156,10 @@ def _check_rate_limit(
 
     key = _rate_key(role, token_header, client_ip)
     # DoS-FIX: usa Redis se disponibile (persiste cross-restart HF Space)
+    # SEC2-5: se Redis fallisce, _redis_rate_check fa fallback su _inmem_rate_check
     if _use_redis:
         return _redis_rate_check(key, limit, int(_RATE_WINDOW_S))
-    now = _rl_time.monotonic()
-    window_start = now - _RATE_WINDOW_S
-
-    if key not in _rate_store:
-        _rate_store[key] = _col.deque()
-    dq = _rate_store[key]
-
-    # Rimuovi timestamp fuori dalla finestra
-    while dq and dq[0] < window_start:
-        dq.popleft()
-
-    if len(dq) >= limit:
-        # Prossima slot disponibile = timestamp più vecchio + finestra
-        retry_after = int(_RATE_WINDOW_S - (now - dq[0])) + 1
-        return False, max(retry_after, 1)
-
-    dq.append(now)
-    return True, 0
+    return _inmem_rate_check(key, limit, int(_RATE_WINDOW_S))
 
 
 class AuthRole(IntEnum):
@@ -186,21 +180,22 @@ async def _resolve_role(
     x_admin_token:     Optional[str] = Header(None, alias="X-Admin-Token"),
 ) -> AuthRole:
     """Risolve il ruolo del chiamante in base agli header presenti."""
+    import secrets as _sec_comp
     # ADMIN (massima priorità)
     admin_tok = _get_token("ADMIN_TOKEN")
-    if admin_tok and x_admin_token == admin_tok:
+    if admin_tok and x_admin_token and _sec_comp.compare_digest(x_admin_token, admin_tok):
         logger.debug("auth: ADMIN role granted")
         return AuthRole.ADMIN
 
     # OPERATOR
     op_tok = _get_token("OPERATOR_TOKEN")
-    if op_tok and x_operator_token == op_tok:
+    if op_tok and x_operator_token and _sec_comp.compare_digest(x_operator_token, op_tok):
         logger.debug("auth: OPERATOR role granted")
         return AuthRole.OPERATOR
 
     # MACHINE (INTERNAL_TOKEN, già generato al boot da main.py)
     int_tok = _get_token("INTERNAL_TOKEN")
-    if int_tok and x_internal_token == int_tok:
+    if int_tok and x_internal_token and _sec_comp.compare_digest(x_internal_token, int_tok):
         logger.debug("auth: MACHINE role granted")
         return AuthRole.MACHINE
 
@@ -277,4 +272,4 @@ def require_role(min_role: AuthRole):
 async def any_role(resolved: AuthRole = Depends(_resolve_role)) -> AuthRole:
     """Dependency che accetta qualsiasi ruolo (incluso USER senza token).
     Usare per endpoint pubblici che vogliono loggare il ruolo del chiamante."""
-    return resolved
+    return resolved

api/auth_managed.py

@@ -9,11 +9,12 @@ Rotte:
 Provider supportati: github, google, instagram.
 I CLIENT_ID/SECRET vanno nei secret HF Spaces (mai nel codice).
 
-Cifratura token: Fernet(VAULT_KEY[:32] base64url-padded) — richiede cryptography>=42.
+Cifratura token: Fernet(PBKDF2HMAC-SHA256, 260k iter, salt fisso) — richiede cryptography>=42.
 """
 import os, time, secrets, json, logging, asyncio
 from typing import Optional
-from fastapi import APIRouter, Request, HTTPException
+from fastapi import APIRouter, Depends, Request, HTTPException
+from .auth_guard import require_role, AuthRole
 from fastapi.responses import RedirectResponse, JSONResponse
 import httpx
 
@@ -21,62 +22,134 @@ _logger = logging.getLogger('api.auth_managed')
 router  = APIRouter()
 
 # ── Fernet encryption setup ──────────────────────────────────────────────────
+# Salt statico pubblico: accettabile per chiave macchina (non password utente).
+# Il VAULT_KEY è il segreto; il salt previene rainbow-table cross-application.
+# ⚠️  ATTENZIONE MIGRAZIONE: cambiare questo salt o la derivazione invalida
+#     tutti i token OAuth cifrati esistenti → gli utenti dovranno riconnettere
+#     i provider. Questo è intenzionale quando si corregge una derivazione debole.
+_FERNET_SALT = b'agente-ai-vault-v1-pbkdf2'
+
 def _get_fernet():
-    """Lazy-init Fernet cipher from VAULT_KEY. Returns None if not configured."""
-    try:
-        from cryptography.fernet import Fernet
-        import base64
-        vault_key = os.getenv('VAULT_KEY', '')
-        if not vault_key:
-            return None
-        # Derive 32-byte key from VAULT_KEY (pad/truncate) → Fernet requires 32-byte urlsafe-b64
-        raw = (vault_key[:32] + '0' * 32)[:32].encode('utf-8')
-        fernet_key = base64.urlsafe_b64encode(raw)
-        return Fernet(fernet_key)
-    except Exception as e:
-        _logger.warning('[auth_managed] Fernet init failed: %s', e)
-        return None
+    """Lazy-init Fernet cipher da VAULT_KEY via PBKDF2HMAC-SHA256 (260k iter).
+
+    Fix P19-SEC2-4: SHA-256 raw (veloce, GPU-bruteforce in ore su chiavi brevi)
+    sostituito con PBKDF2HMAC 260_000 iter — conforme NIST SP 800-132 (2023).
+    ⚠️  Cambio di derivazione: i token cifrati con SHA-256 non sono più decifrabili.
+        _decrypt() ritorna '' su InvalidToken — gli utenti devono riconnettersi.
+    """
+    from cryptography.fernet import Fernet
+    from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+    from cryptography.hazmat.primitives import hashes as _hashes
+    import base64
+    vault_key = os.getenv('VAULT_KEY', '')
+    if not vault_key:
+        raise RuntimeError('VAULT_KEY non configurata — impossibile cifrare/decifrare i token OAuth')
+    kdf = PBKDF2HMAC(
+        algorithm=_hashes.SHA256(),
+        length=32,
+        salt=_FERNET_SALT,
+        iterations=260_000,  # NIST SP 800-132 (2023): ≥ 210_000 per PBKDF2-SHA256
+    )
+    fernet_key = base64.urlsafe_b64encode(kdf.derive(vault_key.encode('utf-8')))
+    return Fernet(fernet_key)
 
 def _encrypt(text: str) -> str:
-    f = _get_fernet()
-    if not f or not text:
-        return text  # fallback: plain (discouraged in prod)
+    if not text:
+        return text
+    f = _get_fernet()  # P19-SEC2-4: propaga eccezione — niente più plaintext fallback
     return f.encrypt(text.encode()).decode()
 
 def _decrypt(token: str) -> str:
-    f = _get_fernet()
-    if not f or not token:
+    if not token:
         return token
+    f = _get_fernet()
     try:
         return f.decrypt(token.encode()).decode()
     except Exception:
+        _logger.error('[auth_managed] decrypt fallito — token corrotto o VAULT_KEY cambiata')
         return ''  # corrotto o key cambiata
 
-# ── In-memory OAuth state store (CSRF) ──────────────────────────────────────
-# {state_token: {'provider': str, 'user_id': str, 'created_at': float}}
-_oauth_states: dict[str, dict] = {}
+# ── OAuth state store (CSRF) — P19-SEC2-5 ────────────────────────────────────
+# Era in-memory dict: rotto con >1 worker/replica (state creato su worker A,
+# consumato su worker B → 404/invalid_state) e perso a ogni restart.
+# Ora persistito su Supabase tabella `oauth_states` (vedi sec01_rls_agent_tasks.sql).
 _STATE_TTL = 600  # 10 minuti
 
-def _make_state(provider: str, user_id: str) -> str:
-    _purge_states()
+# Fallback in-memory SOLO per sviluppo locale senza Supabase configurato.
+_oauth_states_fallback: dict[str, dict] = {}
+
+async def _make_state(provider: str, user_id: str) -> str:
+    from api.state import _sb
     state = secrets.token_urlsafe(32)
-    _oauth_states[state] = {'provider': provider, 'user_id': user_id, 'created_at': time.time()}
+    now = time.time()
+    if _sb:
+        try:
+            await asyncio.to_thread(
+                lambda: _sb.table('oauth_states').insert({
+                    'state':    state,
+                    'provider': provider,
+                    'user_id':  user_id,
+                    # created_at: lasciato al DEFAULT NOW() della tabella (TIMESTAMPTZ)
+                }).execute()
+            )
+            return state
+        except Exception as e:
+            _logger.warning('[auth_managed] oauth_states insert fallito, fallback memoria: %s', e)
+            # SEC2-7: in produzione (Railway/HF Spaces) il fallback in-memory è pericoloso
+            # su multi-replica: state creato su replica A, consumato su replica B → CSRF bypass.
+            # In dev locale (_sb assente o Supabase non configurato) il fallback rimane attivo.
+            if os.getenv('RAILWAY_ENVIRONMENT') or os.getenv('SPACE_ID'):
+                raise HTTPException(503, detail={
+                    'error':  'oauth_state_store_unavailable',
+                    'detail': 'Il database OAuth (Supabase) non è raggiungibile. Riprova tra qualche secondo.',
+                })
+    _purge_states_fallback()
+    _oauth_states_fallback[state] = {'provider': provider, 'user_id': user_id, 'created_at': now}
     return state
 
-def _consume_state(state: str) -> Optional[dict]:
-    _purge_states()
-    entry = _oauth_states.pop(state, None)
+async def _consume_state(state: str) -> Optional[dict]:
+    from api.state import _sb
+    if _sb:
+        try:
+            res = await asyncio.to_thread(
+                lambda: _sb.table('oauth_states').select('*').eq('state', state).limit(1).execute()
+            )
+            if res.data:
+                row = res.data[0]
+                await asyncio.to_thread(
+                    lambda: _sb.table('oauth_states').delete().eq('state', state).execute()
+                )
+                # created_at è TIMESTAMPTZ (stringa ISO8601) — parse per calcolare l'età
+                try:
+                    from datetime import datetime, timezone
+                    created_raw = row.get('created_at', '')
+                    created_dt = datetime.fromisoformat(created_raw.replace('Z', '+00:00'))
+                    age_s = (datetime.now(timezone.utc) - created_dt).total_seconds()
+                except Exception:
+                    age_s = 0  # se il parsing fallisce, non blocchiamo il flow OAuth per questo
+                if age_s > _STATE_TTL:
+                    return None
+                return {'provider': row['provider'], 'user_id': row['user_id']}
+            return None
+        except Exception as e:
+            _logger.warning('[auth_managed] oauth_states select fallito, fallback memoria: %s', e)
+            # SEC2-7: in produzione, se Supabase è irraggiungibile rifiutiamo il state
+            # (sicuro: l'utente deve ripetere il flow OAuth). Meglio un 400 che un bypass CSRF.
+            if os.getenv('RAILWAY_ENVIRONMENT') or os.getenv('SPACE_ID'):
+                return None
+    _purge_states_fallback()
+    entry = _oauth_states_fallback.pop(state, None)
     if not entry:
         return None
     if time.time() - entry['created_at'] > _STATE_TTL:
         return None
     return entry
 
-def _purge_states():
+def _purge_states_fallback():
     now = time.time()
-    expired = [k for k, v in _oauth_states.items() if now - v['created_at'] > _STATE_TTL]
+    expired = [k for k, v in _oauth_states_fallback.items() if now - v['created_at'] > _STATE_TTL]
     for k in expired:
-        _oauth_states.pop(k, None)
+        _oauth_states_fallback.pop(k, None)
 
 # ── Provider configs ──────────────────────────────────────────────────────────
 _BACKEND_URL = os.getenv('BACKEND_URL', '').rstrip('/')
@@ -101,7 +174,9 @@ _PROVIDER_CONFIGS = {
         'authorize_url': 'https://accounts.google.com/o/oauth2/v2/auth',
         'token_url':     'https://oauth2.googleapis.com/token',
         'userinfo_url':  'https://www.googleapis.com/oauth2/v2/userinfo',
-        'scope':         'openid email profile https://www.googleapis.com/auth/calendar',
+        # P19-SEC2-6: rimosso scope 'calendar' (accesso full R/W al calendario) —
+        # non richiesto da nessuna feature attuale, violava il principio del minimo privilegio.
+        'scope':         'openid email profile',
         'client_id_env':     'GOOGLE_OAUTH_CLIENT_ID',
         'client_secret_env': 'GOOGLE_OAUTH_CLIENT_SECRET',
     },
@@ -151,7 +226,7 @@ async def _sb_get_token(user_id: str, provider: str) -> Optional[dict]:
     try:
         res = await asyncio.to_thread(
             lambda: _sb.table('managed_tokens')
-                .select('provider,scope,expires_at,updated_at,raw_meta,access_token')
+                .select('provider,scope,expires_at,updated_at,raw_meta,access_token,refresh_token')
                 .eq('user_id', user_id)
                 .eq('provider', provider)
                 .limit(1)
@@ -198,17 +273,81 @@ async def _sb_delete_token(user_id: str, provider: str) -> None:
 
 # Public helper: altri moduli chiamano questa per ottenere un token decifrato
 async def get_managed_token(user_id: str, provider: str) -> Optional[str]:
-    """Restituisce il token d'accesso decifrato per (user_id, provider). None se non connesso."""
+    """Restituisce il token d'accesso decifrato per (user_id, provider). None se non connesso.
+
+    P19-SEC2-8: prima ritornava sempre il token salvato, anche se scaduto da
+    tempo (provider come Google li invalidano dopo ~1h) → chiamate a valle
+    fallivano silenziosamente con 401. Ora, se scaduto e c'è un refresh_token,
+    tenta il refresh presso il provider prima di restituire.
+    """
     row = await _sb_get_token(user_id, provider)
     if not row:
         return None
-    return _decrypt(row['access_token'])
+
+    exp = row.get('expires_at', 0)
+    now_ms = int(time.time() * 1000)
+    if exp and exp > now_ms + 60_000:  # ancora valido per >60s
+        return _decrypt(row['access_token'])
+
+    encrypted_refresh = row.get('refresh_token', '')
+    if not encrypted_refresh:
+        # Niente refresh_token: ritorna quello che c'è (potrebbe essere già scaduto)
+        return _decrypt(row['access_token'])
+
+    cfg = _PROVIDER_CONFIGS.get(provider)
+    if not cfg:
+        return _decrypt(row['access_token'])
+
+    refresh_token = _decrypt(encrypted_refresh)
+    if not refresh_token:
+        return _decrypt(row['access_token'])
+
+    client_id     = os.getenv(cfg['client_id_env'], '')
+    client_secret = os.getenv(cfg['client_secret_env'], '')
+    try:
+        async with httpx.AsyncClient(timeout=15) as http:
+            resp = await http.post(
+                cfg['token_url'],
+                data={
+                    'grant_type':    'refresh_token',
+                    'refresh_token': refresh_token,
+                    'client_id':     client_id,
+                    'client_secret': client_secret,
+                },
+                headers={'Accept': 'application/json'},
+            )
+        if resp.status_code != 200:
+            _logger.warning('[auth_managed] refresh token fallito %s/%s: %s', user_id, provider, resp.text[:200])
+            return _decrypt(row['access_token'])
+
+        tok_json = resp.json()
+        new_access  = tok_json.get('access_token', '')
+        new_refresh = tok_json.get('refresh_token', refresh_token)  # alcuni provider non lo riemettono
+        expires_in  = tok_json.get('expires_in', 0)
+        new_expires_at = int((time.time() + expires_in) * 1000) if expires_in else 0
+        if not new_access:
+            return _decrypt(row['access_token'])
+
+        await _sb_upsert_token(user_id, provider, new_access, new_refresh,
+                                new_expires_at, row.get('scope', cfg['scope']),
+                                json.loads(row.get('raw_meta') or '{}') if isinstance(row.get('raw_meta'), str) else {})
+        _logger.info('[auth_managed] token refreshed %s/%s (expires_at=%d)', user_id, provider, new_expires_at)
+        return new_access
+    except Exception as e:
+        _logger.error('[auth_managed] refresh exception %s/%s: %s', user_id, provider, e)
+        return _decrypt(row['access_token'])
 
 
 # ── Routes ────────────────────────────────────────────────────────────────────
 
 def _user_id(request: Request) -> str:
-    return request.headers.get('X-User-ID', 'default')
+    # P19-SEC2-7: NON fidarsi di X-User-ID lato client — permetteva a chiunque di
+    # impersonare/leggere i token OAuth di un altro utente semplicemente inviando
+    # un header diverso. L'app è single-tenant (un solo utente reale), quindi si
+    # usa sempre 'default'. Se in futuro serve multi-tenant, l'identità va
+    # derivata da una sessione autenticata server-side (JWT/cookie firmato),
+    # mai da un header controllato dal client.
+    return 'default'
 
 
 @router.get('/api/auth/connect/{provider}')
@@ -227,7 +366,7 @@ async def connect_provider(provider: str, request: Request):
         })
 
     user_id  = _user_id(request)
-    state    = _make_state(provider, user_id)
+    state    = await _make_state(provider, user_id)
     callback = _get_callback_url(provider)
 
     params = {
@@ -265,7 +404,7 @@ async def oauth_callback(provider: str, request: Request):
         _logger.warning('[auth_managed] callback %s error=%s', provider, error)
         return RedirectResponse(url=f"{frontend}?oauth_error={error}&provider={provider}")
 
-    state_data = _consume_state(state)
+    state_data = await _consume_state(state)
     if not state_data:
         _logger.warning('[auth_managed] invalid/expired state %s', state[:20])
         return RedirectResponse(url=f"{frontend}?oauth_error=invalid_state&provider={provider}")
@@ -331,7 +470,7 @@ async def oauth_callback(provider: str, request: Request):
 
 
 @router.get('/api/auth/providers')
-async def list_providers(request: Request):
+async def list_providers(request: Request, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix: info-disclosure
     """Restituisce stato connessione di tutti i provider per l'utente corrente."""
     user_id = _user_id(request)
     rows    = await _sb_list_tokens(user_id)
@@ -373,7 +512,7 @@ async def list_providers(request: Request):
 
 
 @router.delete('/api/auth/disconnect/{provider}')
-async def disconnect_provider(provider: str, request: Request):
+async def disconnect_provider(provider: str, request: Request, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
     """Rimuove il token salvato per il provider specificato."""
     if provider not in _PROVIDER_CONFIGS:
         raise HTTPException(400, detail={'error': 'unknown_provider'})

api/benchmark.py

@@ -17,13 +17,14 @@ Uso da Replit:
   tok  = hmac.new(seed.encode(), day.encode(), hashlib.sha256).hexdigest()
   print(tok)
   "
-  curl 'https://arjanit98-terminal.hf.space/api/debug/benchmark?token=<tok>'
+  curl '<hf-space-a-url>/api/debug/benchmark?token=<tok>'
 """
 import os, sys, asyncio, time, hmac, hashlib, datetime, importlib, tempfile, subprocess, re, uuid
-from fastapi import APIRouter, BackgroundTasks, HTTPException, Query, Request
+from fastapi import APIRouter, Depends, BackgroundTasks, HTTPException, Query, Request
+from .auth_guard import require_role, AuthRole
 from fastapi.responses import JSONResponse
 
-router = APIRouter()
+router = APIRouter( dependencies=[Depends(require_role(AuthRole.MACHINE))])  # GAP-1-fix: router-level auth
 
 # ── Seed per HMAC daily token — NON è un secret, è solo anti-scraping ─────────
 _BENCH_SEED = "agente-ai-bench-2026"
@@ -700,7 +701,7 @@ async def run_self_benchmark(request: "Request"):
     e ritorna lo scorecard completo.
 
     Esempio:
-        curl -X POST https://arjanit98-terminal.hf.space/api/benchmark/run-self \
+        curl -X POST <hf-space-a-url>/api/benchmark/run-self \
              -H "X-Internal-Token: <token>"
     """
     import os as _os

api/blackboard.py

@@ -6,13 +6,9 @@ in backend/api/llm_cache.py — zero setup aggiuntivo.
 
 TTL: 600s (10 minuti) — session-scoped.
 Endpoint:
-  POST /api/blackboard/{session_id}/write  — scrive una entry (MACHINE auth)
-  GET  /api/blackboard/{session_id}/read   — legge tutte le entry (pubblico)
-  DEL  /api/blackboard/{session_id}        — pulisce il blackboard (MACHINE auth)
-
-GAP-BLACKBOARD-NOAUTH fix: write e delete protetti con require_role(MACHINE).
-La lettura rimane pubblica (solo findings, nessun segreto) ma con struttura
-che non espone dati sensibili — i valori nel blackboard sono findings agente.
+  POST /api/blackboard/{session_id}/write  — scrive una entry
+  GET  /api/blackboard/{session_id}/read   — legge tutte le entry
+  DEL  /api/blackboard/{session_id}        — pulisce il blackboard
 
 Pattern: i sub-agenti scrivono via frontend in-memory (agentBlackboard.ts);
 il backend persiste su Upstash per cross-tab/cross-reload continuity.
@@ -22,10 +18,10 @@ import json
 import httpx
 import asyncio
 from fastapi import APIRouter, Depends
-from pydantic import BaseModel
 from .auth_guard import require_role, AuthRole
+from pydantic import BaseModel
 
-router = APIRouter(prefix="/api/blackboard", tags=["blackboard"])
+router = APIRouter(prefix="/api/blackboard", tags=["blackboard"], dependencies=[Depends(require_role(AuthRole.MACHINE))])  # GAP-1-fix: router-level auth
 
 _URL   = os.getenv("UPSTASH_REDIS_REST_URL", "")
 _TOKEN = os.getenv("UPSTASH_REDIS_REST_TOKEN", "")
@@ -92,15 +88,8 @@ async def _redis_scan(pattern: str) -> list[str]:
 
 
 @router.post("/{session_id}/write")
-async def bb_write(
-    session_id: str,
-    entry: BBEntry,
-    _auth: AuthRole = Depends(require_role(AuthRole.MACHINE)),
-):
-    """GAP-BLACKBOARD-NOAUTH fix: scrittura protetta con require_role(MACHINE).
-    Richiede X-Internal-Token header (aggiunto dal CF Worker su route non-public).
-    Senza auth, un attaccante poteva avvelenare il contesto dei sub-agenti.
-    """
+async def bb_write(session_id: str, entry: BBEntry):
+    """Scrive una entry nel blackboard Upstash. Fail-safe: ritorna ok=True anche se Upstash non disponibile."""
     rkey    = f"bb:{session_id}:{entry.agentId}:{entry.key}"
     payload = json.dumps({
         "agentId":  entry.agentId,
@@ -116,7 +105,7 @@ async def bb_write(
 
 @router.get("/{session_id}/read")
 async def bb_read(session_id: str):
-    """Legge tutte le entries del blackboard per la sessione. Pubblico (solo findings)."""
+    """Legge tutte le entries del blackboard per la sessione."""
     keys = await _redis_scan(f"bb:{session_id}:*")
     if not keys:
         return {"entries": [], "session_id": session_id}
@@ -134,14 +123,8 @@ async def bb_read(session_id: str):
 
 
 @router.delete("/{session_id}")
-async def bb_clear(
-    session_id: str,
-    _auth: AuthRole = Depends(require_role(AuthRole.MACHINE)),
-):
-    """GAP-BLACKBOARD-NOAUTH fix: delete protetto con require_role(MACHINE).
-    Senza auth, un attaccante poteva cancellare il blackboard di sessioni attive
-    → VALIDATOR cieco, self-healing disabilitato silenziosamente.
-    """
+async def bb_clear(session_id: str):
+    """Pulisce il blackboard al termine della sessione."""
     keys = await _redis_scan(f"bb:{session_id}:*")
     if keys:
         await _redis_post(["DEL"] + keys)

api/browser.py

@@ -33,9 +33,9 @@ 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, Depends
-from .auth_guard import require_role, AuthRole
+from fastapi import APIRouter, Depends, HTTPException, Request
 from pydantic import BaseModel
+from .auth_guard import require_role, AuthRole
 
 router  = APIRouter(prefix="/api/browser", tags=["browser"])
 _logger = logging.getLogger("browser")
@@ -711,7 +711,7 @@ async def verify_goal_browser(
 # ─── /screenshot ─────────────────────────────────────────────────────────────
 
 @router.post("/screenshot", response_model=BrowserResult)
-async def browser_screenshot(req: ScreenshotRequest):
+async def browser_screenshot(req: ScreenshotRequest, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
     """Screenshot headless di una pagina web (stateless)."""
     if not _safe_url(req.url):
         raise HTTPException(400, "URL non consentita")
@@ -745,7 +745,7 @@ async def browser_screenshot(req: ScreenshotRequest):
 # ─── /navigate ────────────────────────────────────────────────────────────────
 
 @router.post("/navigate", response_model=BrowserResult)
-async def browser_navigate(req: NavigateRequest):
+async def browser_navigate(req: NavigateRequest, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
     """
     Naviga, esegui azioni, restituisce screenshot + testo (stateless).
     W-NAV: text_content ora estratto via trafilatura (da 2000→5000 chars utili).
@@ -794,8 +794,8 @@ async def browser_navigate(req: NavigateRequest):
 
 @router.post("/open", response_model=BrowserResult)
 async def browser_open(
-    req: BrowserOpenRequest,
-    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+    req: BrowserOpenRequest, request: Request,
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),  # P19-SEC2-1: era fail-open
 ):
     """
     Apre una sessione Playwright persistente, naviga all'URL, restituisce
@@ -858,8 +858,8 @@ async def browser_open(
 
 @router.post("/act", response_model=BrowserResult)
 async def browser_act(
-    req: BrowserActRequest,
-    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+    req: BrowserActRequest, request: Request,
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),  # P19-SEC2-1: era fail-open
 ):
     """
     Esegue azioni su una sessione aperta.
@@ -940,7 +940,7 @@ async def browser_act(
 # ─── /close ───────────────────────────────────────────────────────────────────
 
 @router.post("/close", response_model=BrowserResult)
-async def browser_close(req: BrowserCloseRequest):
+async def browser_close(req: BrowserCloseRequest, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
     """Chiude esplicitamente una sessione persistente e libera risorse."""
     if req.session_id not in _sessions:
         return BrowserResult(ok=True, session_id=req.session_id)
@@ -951,7 +951,7 @@ async def browser_close(req: BrowserCloseRequest):
 # ─── GET /screenshot/{session_id} ─────────────────────────────────────────────
 
 @router.get("/screenshot/{session_id}", response_model=BrowserResult)
-async def browser_session_screenshot(session_id: str, full_page: bool = False):
+async def browser_session_screenshot(session_id: str, full_page: bool = False, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
     """Snapshot della pagina corrente senza azioni. Aggiorna last_used."""
     sess = _sessions.get(session_id)
     if not sess:
@@ -976,7 +976,7 @@ async def browser_session_screenshot(session_id: str, full_page: bool = False):
 # ─── /sessions ────────────────────────────────────────────────────────────────
 
 @router.get("/sessions")
-async def list_sessions():
+async def list_sessions(role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
     now = time.time()
     return {
         sid: {

api/coding.py

@@ -18,7 +18,8 @@ import textwrap
 import time
 from typing import Optional, List
 
-from fastapi import APIRouter
+from fastapi import APIRouter, Depends
+from .auth_guard import require_role, AuthRole
 from fastapi.responses import JSONResponse
 from pydantic import BaseModel, field_validator
 
@@ -134,7 +135,7 @@ def _suggestions(lint: dict, cc: dict, code_lines: int) -> list[str]:
 # ── Routes ────────────────────────────────────────────────────────────────────
 
 @router.post("/analyze")
-async def analyze(req: AnalyzeReq) -> JSONResponse:
+async def analyze(req: AnalyzeReq, role: AuthRole = Depends(require_role(AuthRole.MACHINE))) -> JSONResponse:  # GAP-1-fix: run_code=True esegue Python
     """
     Analisi statica Python: sintassi, complessità ciclomatica, imports, suggerimenti.
     Se run_code=True: esegue in sandbox isolata via exec_sandbox (max _MAX_RUN_LINES righe).
@@ -215,5 +216,5 @@ class _SR(BaseModel):
 
 
 @router.post("/session")
-async def session(_req: _SR) -> JSONResponse:
+async def session(_req: _SR, role: AuthRole = Depends(require_role(AuthRole.MACHINE))) -> JSONResponse:  # GAP-1-fix: stub 501 ma consistent
     return JSONResponse(status_code=501, content={"error": _STUB_MSG})

api/conversations.py

@@ -2,11 +2,12 @@
 import json, logging
 from .state import safe_json_dumps
 from typing import Optional, Any
-from fastapi import APIRouter, Body, HTTPException
+from fastapi import APIRouter, Depends, Body, HTTPException
+from .auth_guard import require_role, AuthRole
 from pydantic import BaseModel
 from .state import sb
 
-router = APIRouter()
+router = APIRouter( dependencies=[Depends(require_role(AuthRole.MACHINE))])  # GAP-1-fix: router-level auth
 _logger = logging.getLogger("conversations")
 
 

api/daemon_status.py

@@ -14,11 +14,12 @@ import logging
 import time
 from typing import Any
 
-from fastapi import APIRouter
+from fastapi import APIRouter, Depends
+from .auth_guard import require_role, AuthRole
 
 _logger = logging.getLogger("api.daemon_status")
 
-router = APIRouter(prefix="/api/daemon", tags=["daemon-status"])
+router = APIRouter(prefix="/api/daemon", tags=["daemon-status"], dependencies=[Depends(require_role(AuthRole.MACHINE))])  # GAP-1-fix: router-level auth
 
 # ACTIVE_TTL: allineato a session-daemon.mjs (5 * 60_000 ms)
 _ACTIVE_TTL_MS = 5 * 60 * 1000  # 5 minuti

api/database.py

@@ -20,10 +20,20 @@ Sicurezza:
   MAX 500 righe per query per evitare payload giganti.
 """
 import asyncio, os, logging, re as _re
-from fastapi import APIRouter, HTTPException, Request
+from fastapi import APIRouter, HTTPException, Request, Depends
 from pydantic import BaseModel
 
-router  = APIRouter(prefix="/api/database", tags=["database"])
+from .auth_guard import require_role, AuthRole
+
+# P19-SEC2: era fail-open (nessuna auth su /api/database). Il fix concorrente
+# (backend/auth/auth_managed.get_user_session_token) usava un token placeholder
+# hardcoded ("secure-session-token") e non importava Depends: rotto e insicuro.
+# Usiamo lo stesso pattern require_role(AuthRole.MACHINE) già in uso su
+# exec/search/browser/research/email per coerenza con l'architettura esistente.
+router  = APIRouter(
+    prefix="/api/database", tags=["database"],
+    dependencies=[Depends(require_role(AuthRole.MACHINE))],
+)
 _logger = logging.getLogger("database")
 
 _DANGEROUS = frozenset({"drop","truncate","delete","update","insert","alter","create","grant","revoke"})
@@ -67,10 +77,8 @@ def _is_dangerous(sql: str) -> str | None:
 
 
 @router.post("/query")
-async def database_query(req: QueryRequest, 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 database_query(req: QueryRequest):
+    # Auth gestita dal router-level Depends(require_role(AuthRole.MACHINE)) — nessun doppio check.
     db_url = os.getenv("DATABASE_URL", "").strip()
     if not db_url:
         return {
@@ -150,4 +158,4 @@ async def _sqlite_query(db_url: str, sql: str, params: list):
     return {
         "ok": True, "rows": rows, "columns": cols, "count": len(rows),
         "truncated": len(rows) == _MAX_ROWS,
-    }
+    }

api/decision_memory.py

@@ -22,13 +22,14 @@ import json
 import time
 from typing import Optional
 
-from fastapi import APIRouter, HTTPException
+from fastapi import APIRouter, Depends, HTTPException
+from .auth_guard import require_role, AuthRole
 from pydantic import BaseModel
 import logging
 _logger = logging.getLogger("agente_ai")  # S-BUGFIX
 
 logger = logging.getLogger("agente_ai.decision_memory")
-router = APIRouter(prefix="/api/memory/decision", tags=["decision-memory"])
+router = APIRouter(prefix="/api/memory/decision", tags=["decision-memory"], dependencies=[Depends(require_role(AuthRole.MACHINE))])  # GAP-1-fix: router-level auth
 
 # ─── In-memory store ─────────────────────────────────────────────────────────
 _decisions: dict[str, dict] = {}   # signature → decision
@@ -125,13 +126,6 @@ def get_blacklist() -> list[dict]:
 
 async def _sb_save(decision: dict) -> None:
     try:
-        # ─── Mirroring su Hugging Face Dataset (Zero-Cost Backup) ─────────────
-        try:
-            from .hf_storage import hf_fire_and_forget
-            hf_fire_and_forget("decisions.jsonl", decision)
-        except Exception as hf_exc:
-            logger.debug("HF Mirroring silenced: %s", hf_exc)
-
         from .state import _sb
         if not _sb:
             return

api/deploy.py

@@ -1,6 +1,7 @@
 """backend/api/deploy.py — S750: CI status + deploy trigger (Railway) + S754-C: Quick Preview."""
 import os, time, json, pathlib, asyncio, secrets as _prv_secrets, mimetypes as _prv_mimetypes
-from fastapi import APIRouter, HTTPException, Request
+from fastapi import APIRouter, Depends, HTTPException, Request
+from .auth_guard import require_role, AuthRole
 from fastapi.responses import HTMLResponse as _HtmlResp, Response as _BinResp
 from pydantic import BaseModel
 import httpx
@@ -20,7 +21,7 @@ _INT_TOKEN = os.getenv("INTERNAL_TOKEN", "")
 # S-GAP4: parametrizzati da env — portabili su qualsiasi repo
 GH_OWNER   = os.getenv("GH_OWNER", "Baida98")
 GH_REPO    = os.getenv("GH_REPO",  "AI")
-HF_SPACE_ID = os.getenv("HF_SPACE_ID", "Arjanit98/Terminal")  # GAP-3: parametrizzato da env
+HF_SPACE_ID = os.getenv("HF_SPACE_ID", "")  # S-DYN: rimosso default hardcoded  # GAP-3: parametrizzato da env
 
 
 def _auth(request: Request) -> None:
@@ -32,9 +33,9 @@ def _auth(request: Request) -> None:
 
 
 @router.get("/api/ci/status")
-async def ci_status(request: Request):
+async def ci_status(request: Request, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix: era _auth fail-open
     """Controlla stato GitHub Actions + ultimo deploy CF Pages."""
-    _auth(request)
+    # auth gestita da Depends(require_role(MACHINE))
     result: dict = {
         "ci_ok": False, "billing_ok": True,
         "last_run_status": "unknown", "last_run_conclusion": "unknown",
@@ -87,7 +88,7 @@ class DeployRequest(BaseModel):
 
 # ── Deploy Status multi-target (S-DEPLOY-UNIFY) ──────────────────────────────
 @router.get("/api/deploy/status")
-async def deploy_status_all(request: Request):
+async def deploy_status_all(request: Request, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
     """
     S-DEPLOY-UNIFY: Stato in tempo reale di tutti e 3 i target di deploy.
 
@@ -98,7 +99,7 @@ async def deploy_status_all(request: Request):
 
     Non richiede token se _CF_TOKEN è assente: risponde ugualmente con stato parziale.
     """
-    _auth(request)
+    # auth gestita da Depends(require_role(MACHINE))
     checked_at = time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())
 
     async def _check_cloudflare() -> dict:
@@ -136,7 +137,7 @@ async def deploy_status_all(request: Request):
         return r
 
     async def _check_railway() -> dict:
-        url = "https://ai-production-4c06.up.railway.app"
+        url = os.getenv("RAILWAY_PUBLIC_URL", "")  # S-DYN: usa env var
         r: dict = {"ok": False, "status": "unknown", "url": url, "latency_ms": None, "error": None}
         t0 = time.monotonic()
         try:
@@ -192,7 +193,7 @@ class AutoRepairRequest(BaseModel):
 
 
 @router.post("/api/deploy/auto")
-async def deploy_auto(body: AutoRepairRequest, request: Request):
+async def deploy_auto(body: AutoRepairRequest, request: Request, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
     """
     S-AUTO: Diagnostica + auto-riparazione di tutti i target in un'unica chiamata.
 
@@ -203,7 +204,7 @@ async def deploy_auto(body: AutoRepairRequest, request: Request):
 
     dry_run=True restituisce il piano senza eseguire azioni reali.
     """
-    _auth(request)
+    # auth gestita da Depends(require_role(MACHINE))
     t0      = time.time()
     actions: list[str] = []
     fixed:   list[str] = []
@@ -267,7 +268,7 @@ async def deploy_auto(body: AutoRepairRequest, request: Request):
     # ── Railway ───────────────────────────────────────────────────────────────
     if "railway" in body.targets:
         if not body.dry_run:
-            railway_url = "https://ai-production-4c06.up.railway.app/health"
+            railway_url = f"{os.getenv('RAILWAY_PUBLIC_URL', '')}/health"
             alive = False
             for attempt in range(1, 6):
                 try:
@@ -323,9 +324,16 @@ async def deploy_auto(body: AutoRepairRequest, request: Request):
                 woke = False
                 try:
                     async with httpx.AsyncClient(timeout=15, follow_redirects=True) as c:
-                        wr = await c.get("https://arjanit98-terminal.hf.space")
-                        woke = wr.status_code < 500
-                        actions.append(f"  GET wake-up: HTTP {wr.status_code}")
+                        # S-DYN: usa HF_SPACE_URL se disponibile, altrimenti prova a costruirlo
+                        hf_url = os.getenv("HF_SPACE_URL")
+                        if not hf_url and os.getenv("SPACE_ID"):
+                            hf_url = f"https://{os.getenv('SPACE_ID').replace('/', '-').lower()}.hf.space"
+                        if hf_url:
+                            wr = await c.get(hf_url)
+                            woke = wr.status_code < 500
+                            actions.append(f"  GET wake-up: HTTP {wr.status_code}")
+                        else:
+                            woke = False; actions.append("  ⚠️ HF_SPACE_URL non configurato")
                 except Exception as e:
                     actions.append(f"  GET wake-up: {str(e)[:50]}")
 
@@ -362,9 +370,9 @@ async def deploy_auto(body: AutoRepairRequest, request: Request):
 
 
 @router.post("/api/deploy-trigger")
-async def deploy_trigger_endpoint(body: DeployRequest, request: Request):
+async def deploy_trigger_endpoint(body: DeployRequest, request: Request, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
     """Triggera deploy: prima Actions dispatch, poi fallback HF + Replit CF."""
-    _auth(request)
+    # auth gestita da Depends(require_role(MACHINE))
     t0    = time.time()
     steps: list[str] = []
 
@@ -519,16 +527,16 @@ def _get_base_url(request: Request) -> str:
     invece che al backend HF/Railway → 404 garantito in produzione.
 
     Priorità corretta:
-    1. HF_SPACE_URL env var — config esplicita, raccomandata (es. 'https://arjanit98-terminal.hf.space')
-    2. SPACE_HOST env var  — iniettata da HF Spaces automaticamente (es. 'arjanit98-terminal.hf.space')
+    1. HF_SPACE_URL env var — config esplicita, raccomandata (es. '<hf-space-a-url>')
+    2. SPACE_HOST env var  — iniettata da HF Spaces automaticamente (es. '<hf-space-a-url>')
     3. X-Forwarded-Host    — iniettato da proxy/ingress Railway o Traefik
     4. '' (stringa vuota)  — nessuna fonte disponibile → quick_preview risponde con errore strutturato
     """
-    # 1. Variabile esplicita: HF_SPACE_URL=https://arjanit98-terminal.hf.space
+    # 1. Variabile esplicita: HF_SPACE_URL=<hf-space-a-url>
     explicit = os.getenv('HF_SPACE_URL', '').rstrip('/')
     if explicit:
         return explicit
-    # 2. SPACE_HOST — iniettata da HF Spaces (es. 'arjanit98-terminal.hf.space')
+    # 2. SPACE_HOST — iniettata da HF Spaces (es. '<hf-space-a-url>')
     space_host = os.getenv('SPACE_HOST', '')
     if space_host:
         return f'https://{space_host}'
@@ -552,7 +560,7 @@ _PREVIEW_HEADERS = {
 
 
 @router.post('/api/preview/quick')
-async def quick_preview(body: QuickPreviewRequest, request: Request):
+async def quick_preview(body: QuickPreviewRequest, request: Request, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix: era aperto
     """
     S754-C: Deploy rapido su backend HF Space.
     Salva i file in /data/previews/<id>/ → restituisce URL pubblico < 1s.
@@ -602,7 +610,7 @@ async def quick_preview(body: QuickPreviewRequest, request: Request):
             'files':      saved,
             'error':      'URL backend non rilevabile: nessun env var HF_SPACE_URL / SPACE_HOST trovato.',
             'hint':       (
-                'Imposta la variabile d\'ambiente HF_SPACE_URL=https://arjanit98-terminal.hf.space '
+                'Imposta la variabile d\'ambiente HF_SPACE_URL=<hf-space-a-url> '
                 'nelle impostazioni del backend (Railway → Variables o HF Space → Settings → Variables). '
                 'I file della preview sono stati salvati con ID: ' + preview_id
             ),

api/email.py

@@ -6,7 +6,9 @@ Endpoint:
 
 Configurazione:
   RESEND_API_KEY env var — richiesto (chiave Resend, formato re_...)
-  Default from: noreply@<dominio configurato in Resend>
+  RESEND_FROM_EMAIL     — indirizzo mittente default (es. noreply@tuodominio.com)
+  RESEND_ALLOWED_DOMAINS — domini FROM consentiti, separati da virgola (SEC2-9)
+  Default from: noreply@resend.dev (sandbox Resend)
 
 Comportamento:
   - body può essere testo plain o HTML
@@ -14,6 +16,11 @@ Comportamento:
   - Supporta cc, bcc, reply_to, allegati (future extension)
   - Rate limit Resend free tier: 100 email/day, 1 email/sec
 
+Sicurezza (SEC2-9):
+  - Dominio mittente (from_email) validato contro allowlist RESEND_ALLOWED_DOMAINS
+    o dominio di RESEND_FROM_EMAIL. Impedisce open relay su domini arbitrari.
+  - Indirizzi to/cc/bcc validati con regex prima della chiamata Resend.
+
 Error handling:
   - Resend 422: validazione campi (to/from non validi)
   - Resend 429: rate limit
@@ -21,15 +28,59 @@ Error handling:
 """
 from __future__ import annotations
 
-import os, logging, httpx
-from fastapi import APIRouter, Request, Depends, HTTPException
+import os, re, logging, httpx
+from fastapi import APIRouter, Depends, Request
+from pydantic import BaseModel, field_validator
 from .auth_guard import require_role, AuthRole
-from pydantic import BaseModel, EmailStr, field_validator
 from typing import Optional, List
 
 router = APIRouter(prefix="/api/email", tags=["email"])
 _logger = logging.getLogger("email_api")
 
+# ── Validazione indirizzi e domini (SEC2-9) ───────────────────────────────────
+
+# Regex RFC 5321 semplificata: accetta "nome@dominio.tld"
+_EMAIL_RE = re.compile(r'^[^@\s<>,;]+@([a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)+)$')
+
+
+def _extract_email(addr: str) -> str:
+    """Estrae l'indirizzo grezzo da 'Nome <email>' o 'email'."""
+    addr = addr.strip()
+    m = re.search(r'<([^>]+)>', addr)
+    return m.group(1).strip() if m else addr
+
+
+def _valid_email(addr: str) -> bool:
+    """True se addr è un indirizzo email valido (ammette anche 'Nome <email>')."""
+    return bool(_EMAIL_RE.match(_extract_email(addr)))
+
+
+def _from_domain_allowed(email: str) -> bool:
+    """Controlla che il dominio di email sia nell'allowlist FROM.
+
+    Allowlist (in ordine di priorità):
+      1. RESEND_ALLOWED_DOMAINS  — lista separata da virgola
+      2. Dominio estratto da RESEND_FROM_EMAIL
+      3. Fallback: resend.dev (sandbox Resend, valido in test)
+
+    SEC2-9: impedisce di usare /api/email/send come open relay
+    su domini arbitrari non verificati in Resend.
+    """
+    explicit = os.getenv('RESEND_ALLOWED_DOMAINS', '')
+    if explicit:
+        allowed = {d.strip().lower() for d in explicit.split(',') if d.strip()}
+    else:
+        default_from = os.getenv('RESEND_FROM_EMAIL', '')
+        m = _EMAIL_RE.match(default_from)
+        allowed = {m.group(1).lower()} if m else {'resend.dev'}
+
+    raw = _extract_email(email)
+    m2 = _EMAIL_RE.match(raw)
+    if not m2:
+        return False
+    return m2.group(1).lower() in allowed
+
+
 # ── Modelli ─────────────────────────────────────────────────────────────────
 
 class SendEmailRequest(BaseModel):
@@ -50,6 +101,23 @@ class SendEmailRequest(BaseModel):
             raise ValueError("Il campo non può essere vuoto")
         return v.strip()
 
+    @field_validator("to", "reply_to")
+    @classmethod
+    def validate_single_addr(cls, v: str) -> str:  # noqa: N805
+        """SEC2-9: valida formato indirizzo singolo."""
+        if v and not _valid_email(v):
+            raise ValueError(f"Indirizzo email non valido: {v!r}")
+        return v.strip()
+
+    @field_validator("cc", "bcc")
+    @classmethod
+    def validate_list_addrs(cls, v: list) -> list:  # noqa: N805
+        """SEC2-9: valida formato di ogni indirizzo in cc/bcc."""
+        for addr in v:
+            if not _valid_email(addr):
+                raise ValueError(f"Indirizzo email non valido: {addr!r}")
+        return v
+
 
 class SendEmailResponse(BaseModel):
     ok:       bool
@@ -62,8 +130,8 @@ class SendEmailResponse(BaseModel):
 
 @router.post("/send", response_model=SendEmailResponse)
 async def send_email(
-    req: SendEmailRequest,
-    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+    req: SendEmailRequest, request: Request,
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),  # P19-SEC2-1: era fail-open
 ) -> SendEmailResponse:
     """
     Invia email via Resend API.
@@ -84,20 +152,21 @@ async def send_email(
             ),
         )
 
-    # ── 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"}
+    # Costruisci e valida dominio mittente (SEC2-9)
     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
+    if not _from_domain_allowed(from_email):
+        _allowed_hint = os.getenv("RESEND_ALLOWED_DOMAINS") or os.getenv("RESEND_FROM_EMAIL", "resend.dev")
+        return SendEmailResponse(
+            ok=False,
+            message=(
+                f"❌ Dominio mittente non consentito: '{_extract_email(from_email)}'. "
+                "Usa un dominio verificato in Resend. "
+                "Per aggiungere domini extra: imposta RESEND_ALLOWED_DOMAINS=dominio1.com,dominio2.com "
+                f"nei Secrets HF Space. Domini correnti consentiti: {_allowed_hint!r}."
+            ),
+        )
+
     from_field = f"{req.from_name} <{from_email}>" if req.from_name else from_email
 
     # Payload Resend

api/exec.py

@@ -1,6 +1,7 @@
 """backend/api/exec.py — Code execution, shell, pip-install, LLM fix (S354)."""
 import os, asyncio, sys, tempfile, time, resource as _resource, signal as _signal
 import re as _re_exec
+from tools._shell_safety import validate_shell_command as _validate_shell
 import ast as _ast_mod
 from fastapi import APIRouter, Depends, HTTPException, Request
 from pydantic import BaseModel, model_validator
@@ -51,6 +52,28 @@ def _get_venv_pip_cmd(pkgs: list) -> list:
 
 BLOCKED_CMDS = {'rm -rf /', 'mkfs', ':(){:|:&};:', 'dd if=/dev/zero'}
 
+# Shell validation -> tools._shell_safety (_validate_shell)
+
+# ── P19-SEC2-3: blocklist minima per execute-code JS (era assente) ──────────
+_JS_BLOCKED_RE = _re_exec.compile(
+    r'\brequire\s*\(\s*[\'"]child_process[\'"]\s*\)'
+    r'|\bprocess\.env\b'
+    r'|\bfs\s*\.\s*(read|write|unlink|rm)'
+    r'|\bexecSync\b|\bspawnSync\b|\bexec\s*\('
+    r'|\brequire\s*\(\s*[\'"](net|http|https|dgram|cluster|worker_threads)[\'"]\s*\)',
+    _re_exec.IGNORECASE,
+)
+
+# ── P19-SEC2-2: env sanificata per execute-shell — niente secret ereditati ───
+def _safe_shell_env(tmpdir: str) -> dict:
+    return {
+        'HOME': tmpdir, 'TMPDIR': tmpdir,
+        'PATH': os.environ.get('PATH', '/usr/local/bin:/usr/bin:/bin'),
+        'LANG': os.environ.get('LANG', 'en_US.UTF-8'),
+        'TERM': 'xterm-256color',
+        # Deliberatamente ESCLUSI: HF_TOKEN, INTERNAL_TOKEN, SUPABASE_*, VAULT_KEY, ADMIN_TOKEN, ecc.
+    }
+
 # ── GAP-EXEC-FIX: resource limits per subprocess child ───────────────────────
 # Chiamato come preexec_fn DOPO fork/PRIMA exec nel processo figlio.
 # Ogni setrlimit è in try/except isolato — non blocca su piattaforme che non
@@ -269,29 +292,22 @@ def _ast_sandbox_check(code: str) -> tuple[bool, str]:
 
 @router.post('/api/exec')
 async def exec_code(
-    req: ExecRequest,
-    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+    req: ExecRequest, request: Request,
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),  # P19-SEC2-1: era fail-open
 ):
     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:
@@ -300,13 +316,30 @@ async def exec_code(
                 try:
                     if lang == 'python':
                         cmd = [_get_venv_python(), '-c', code]
-                    elif lang in ('javascript', 'js'):
-                        cmd = ['node', '-e', code]
-                    elif lang in ('typescript', 'ts'):
-                        fname = os.path.join(tmpdir, 'snippet.ts')
-                        with open(fname, 'w') as f:
-                            f.write(code)
-                        cmd = ['npx', '--yes', 'ts-node', '--transpile-only', fname]
+                    elif lang in ('javascript', 'js', 'typescript', 'ts'):
+                        # P20-JS-SANDBOX: real sandbox — Deno deny-all (primary) or Node vm.createContext (fallback)
+                        # Belt: module-level _JS_BLOCKED_RE pre-filter (O(1) check before subprocess spawn)
+                        _js_pre = _JS_BLOCKED_RE.search(code)
+                        if _js_pre:
+                            return {'stdout': '', 'stderr': f'js_blocked: pattern "{_js_pre.group()}" non permesso', 'exit_code': 1, 'durationMs': 0}
+                        from .js_sandbox import run_js_sandbox as _run_js_sandbox
+                        _sb = await _run_js_sandbox(
+                            code=code, lang=lang, tmpdir=tmpdir,
+                            timeout=12.0,
+                            preexec_fn=_child_resource_limits,
+                            safe_env={
+                                'HOME': tmpdir, 'TMPDIR': tmpdir, 'NODE_ENV': 'production',
+                                'PATH': os.environ.get('PATH', '/usr/local/bin:/usr/bin:/bin'),
+                                'npm_config_cache': '/data/npm-cache',
+                                'NODE_OPTIONS': '--max-old-space-size=384',
+                            },
+                        )
+                        return {
+                            'stdout':     _sb['stdout'],
+                            'stderr':     _sb['stderr'],
+                            'exit_code':  _sb['returncode'],
+                            'durationMs': int(time.time() * 1000) - t0,
+                        }
                     else:
                         return {'stdout': '', 'stderr': f'Unsupported lang: {lang}', 'exit_code': 1, 'durationMs': 0}
 
@@ -355,22 +388,16 @@ async def exec_code(
 
 @router.post('/api/execute-shell')
 async def execute_shell(
-    cmd: ShellCmd,
-    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+    cmd: ShellCmd, request: Request,
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),  # P19-SEC2-1: era fail-open
 ):
     raw = cmd.command.strip()
-    # ── 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')
+    _shell_err = _validate_shell(raw)
+    if _shell_err:
+        raise HTTPException(400, {'error':'shell_command_rejected','hint':_shell_err})
+    for bad in BLOCKED_CMDS:
+        if bad in raw:
+            raise HTTPException(400, 'Command blocked for safety')
     timeout = min(max(cmd.timeout, 1), 60)
     try:
         async with _realtime_job(timeout_s=90.0):
@@ -382,11 +409,7 @@ async def execute_shell(
                         stderr=asyncio.subprocess.PIPE,
                         cwd=tmpdir,
                         preexec_fn=_child_resource_limits,  # GAP-EXEC-FIX: RLIMIT_AS/CPU/NOFILE/NPROC
-                        env={
-                            'HOME': tmpdir, 'TMPDIR': tmpdir,
-                            'PATH': os.environ.get('PATH', '/usr/local/bin:/usr/bin:/bin'),
-                            'PYTHONPATH': os.environ.get('PYTHONPATH', ''),
-                        },
+                        env=_safe_shell_env(tmpdir),  # P19-SEC2-2: era **os.environ (leak totale secret)
                     )
                     stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=timeout)
                     return {
@@ -580,8 +603,8 @@ class ToolDispatchRequest(BaseModel):
 
 @router.post('/api/exec/tool')
 async def exec_tool_dispatch(
-    req: ToolDispatchRequest,
-    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+    req: ToolDispatchRequest, request: Request,
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),  # P19-SEC2-1: era fail-open
 ):
     """GAP-2: dispatcher generico — risolve tool nel TOOL_REGISTRY e chiama _fn."""
     try:

api/files.py

@@ -10,10 +10,16 @@ GAP-VFS-FIX (P37):
 """
 import uuid, time, asyncio
 from typing import Optional
-from fastapi import APIRouter, Body, HTTPException
+from fastapi import APIRouter, Body, HTTPException, Depends
 from .state import sb
 
-router = APIRouter()
+from .auth_guard import require_role, AuthRole
+from tools.registry import _scaffold_project
+
+# P19-SEC2: era fail-open. Il fix concorrente (backend/auth/auth_managed.get_user_session_token)
+# usava un token placeholder hardcoded e non importava Depends (NameError a runtime).
+# Allineato al pattern require_role(AuthRole.MACHINE) usato su tutti gli altri endpoint interni.
+router = APIRouter(dependencies=[Depends(require_role(AuthRole.MACHINE))])
 
 
 # ─── S364: fire-and-forget lint + manifest helper ────────────────────────────
@@ -131,41 +137,8 @@ async def get_file(file_id: str):
         raise HTTPException(status_code=404, detail='File not found')
 
 
-import os
-
-# S42: Soglia per offloading su HF Storage (512 KB)
-VFS_OFFLOAD_THRESHOLD_BYTES = 512 * 1024
-
-async def _offload_to_hf(content: str, filename: str) -> str:
-    """Carica il contenuto su HF Storage e restituisce l'URL."""
-    from .hf_storage import hf_append_record
-    record = {
-        "filename": filename,
-        "content_preview": content[:1000],
-        "full_content": content,
-        "offloaded_at": int(time.time() * 1000)
-    }
-    # Usiamo hf_append_record per salvare il file nel dataset
-    success = await hf_append_record("offloaded_files.jsonl", record)
-    if success:
-        # Nota: In produzione qui genereremmo un URL diretto R2 o HF
-        return f"https://huggingface.co/datasets/{os.getenv('HF_DATASET_REPO', 'Arjanit98/agent-memory')}/raw/main/offloaded_files.jsonl"
-    return ""
-
-
 @router.post('/api/files')
 async def save_file(body: dict = Body(...)):
-    _content = body.get('content', '') or ''
-    _path = body.get('path', 'unnamed')
-    
-    # S42: Offloading logic
-    if len(_content.encode('utf-8')) > VFS_OFFLOAD_THRESHOLD_BYTES:
-        body['is_offloaded'] = True
-        body['original_size'] = len(_content)
-        # Per ora simuliamo l'offload salvando un riferimento
-        # In un'implementazione reale, caricheremmo su R2/S3 qui
-        body['download_url'] = f'/api/files/raw/{_path}'
-
     if 'id' not in body:
         body['id'] = str(uuid.uuid4())
     if 'updated_at' not in body:
@@ -385,7 +358,7 @@ async def scaffold_project_endpoint(body: dict = Body(...)):
     project_name: slug del progetto (verrà sanitizzato)
     """
     import re as _re_ep
-    from tools.registry import _scaffold_project as _do_scaffold
+    _do_scaffold = _scaffold_project
 
     framework    = str(body.get('framework', 'react')).strip().lower()
     project_name = str(body.get('project_name', 'my-project')).strip()
@@ -411,4 +384,4 @@ async def scaffold_project_endpoint(body: dict = Body(...)):
     except Exception as e:
         return {'success': False, 'error': str(e)[:300], 'files': {}}
 
-    return result
+    return result

api/gemini_vision.py

@@ -15,7 +15,8 @@ Gap chiuso (P48):
 @module gemini_vision
 """
 import os, base64, httpx, logging
-from fastapi import APIRouter
+from fastapi import APIRouter, Depends
+from .auth_guard import require_role, AuthRole
 from pydantic import BaseModel
 
 router  = APIRouter(prefix="/api/vision", tags=["gemini_vision"])
@@ -100,7 +101,7 @@ async def gemini_analyze(
 # ─── Endpoints ────────────────────────────────────────────────────────────────
 
 @router.post("/gemini")
-async def gemini_vision_direct(req: GeminiAnalyzeRequest):
+async def gemini_vision_direct(req: GeminiAnalyzeRequest, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
     """
     POST /api/vision/gemini — Analisi diretta Gemini Vision (bypass fallback chain).
     Accetta url o base64_image. Provider primario zero-cost per vision tasks.
@@ -127,7 +128,7 @@ async def gemini_vision_direct(req: GeminiAnalyzeRequest):
 
 
 @router.post("/screenshot_analyze")
-async def screenshot_analyze(req: ScreenshotAnalyzeRequest):
+async def screenshot_analyze(req: ScreenshotAnalyzeRequest, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
     """
     POST /api/vision/screenshot_analyze — Playwright screenshot + Gemini analyze.
 

api/incident_registry.py

@@ -24,13 +24,14 @@ import json
 import time
 from typing import Any, Optional
 
-from fastapi import APIRouter, HTTPException
+from fastapi import APIRouter, Depends, HTTPException
+from .auth_guard import require_role, AuthRole
 from pydantic import BaseModel
 import logging
 _logger = logging.getLogger("agente_ai")  # S-BUGFIX
 
 logger = logging.getLogger("agente_ai.incident_registry")
-router = APIRouter(prefix="/api/incidents", tags=["incidents"])
+router = APIRouter(prefix="/api/incidents", tags=["incidents"], dependencies=[Depends(require_role(AuthRole.MACHINE))])  # GAP-1-fix: router-level auth
 
 # ─── In-memory store ─────────────────────────────────────────────────────────
 _incidents: dict[str, dict] = {}   # id → incident
@@ -151,13 +152,6 @@ def get_delta(since_ms: int) -> list[dict]:
 
 async def _sb_save(incident: dict) -> None:
     try:
-        # ─── Mirroring su Hugging Face Dataset (Zero-Cost Backup) ─────────────
-        try:
-            from .hf_storage import hf_fire_and_forget
-            hf_fire_and_forget("incidents.jsonl", incident)
-        except Exception as hf_exc:
-            logger.debug("HF Mirroring (incident) silenced: %s", hf_exc)
-
         from .state import _sb
         if not _sb:
             return

api/integrity_manager.py

@@ -26,11 +26,12 @@ import os
 import time
 from typing import Any, Callable, Coroutine, Optional
 
-from fastapi import APIRouter, Body
+from fastapi import APIRouter, Depends, Body
+from .auth_guard import require_role, AuthRole
 from fastapi.responses import JSONResponse
 
 _logger = logging.getLogger("api.integrity")
-router  = APIRouter(prefix="/api/integrity", tags=["integrity"])
+router  = APIRouter(prefix="/api/integrity", tags=["integrity"], dependencies=[Depends(require_role(AuthRole.MACHINE))])  # GAP-1-fix: router-level auth
 
 # In-memory fallback (usato quando Supabase non disponibile o per rapidita')
 _SNAP_CACHE: dict[str, dict] = {}   # snap_id -> snapshot dict

api/job_queue.py

@@ -1,345 +1,468 @@
-import os
-import json
-import time
-import asyncio
-import logging
-import uuid
-try:
-    import resource as _resource
-    _HAS_RESOURCE = True
-except ImportError:
-    _HAS_RESOURCE = False
-from typing import Optional, List, Dict, Any
-from fastapi import APIRouter, HTTPException, Request, Depends
+"""
+backend/api/job_queue.py — Redis coordination BRAIN↔HANDS (S-DUAL-2)
+
+Questo modulo implementa tre livelli di coordinamento via Upstash Redis:
+
+  1. LOAD EXCHANGE — entrambi gli Space pubblicano metriche ogni 30s su Redis.
+     Il CF router legge via /api/jq/load/{role} senza HTTP probe costosi.
+     Chiavi: jq:load:brain  jq:load:hands  (TTL 90s)
+
+  2. WAKE-UP — BRAIN segnala HANDS di scaldarsi prima che il circuito si chiuda.
+     HANDS consumer legge i segnali e chiama /health su se stesso.
+     Chiave: jq:wake  (LIST, RPOP, TTL 30s per elemento)
+
+  3. TASK DELEGATION — BRAIN accoda task, HANDS consuma ed esegue.
+     Chiave: jq:tasks:pending  (LIST, LPUSH/RPOP)
+     Chiave: jq:result:{taskId}  (STRING, TTL 300s)
+     Chiave: jq:events:{taskId}  (LIST, TTL 300s)
+     Chiave: jq:consumer:alive   (STRING, TTL 30s — heartbeat HANDS consumer)
+
+  Abilitazione:
+     JQ_ENABLED=1 + UPSTASH_REDIS_REST_URL + UPSTASH_REDIS_REST_TOKEN + SPACE_ROLE
+     Se JQ_ENABLED non è impostato → modulo in standby (load publish attivo, queue no)
+
+  Endpoints:
+     GET  /api/jq/status              — diagnostica queue
+     GET  /api/jq/load/{role}         — metriche load da Redis (brain|hands)
+     POST /api/jq/wake                — segnala wake-up HANDS (solo BRAIN)
+     POST /api/jq/submit              — sottometti job a HANDS via Redis (solo BRAIN)
+     GET  /api/jq/result/{taskId}     — leggi risultato job da Redis
+     GET  /api/jq/events/{taskId}     — leggi eventi SSE da Redis
+"""
+import os, asyncio, json, time, uuid, logging
+from fastapi import APIRouter, Depends, Request, HTTPException
 from .auth_guard import require_role, AuthRole
 from pydantic import BaseModel
-from .load_balancer import balancer  # S951
-import httpx
 
-_logger = logging.getLogger("agente_ai.jq")
-router = APIRouter(prefix="/jq", tags=["job_queue"])
+_logger = logging.getLogger("api.job_queue")
 
-# ── Configurazione ────────────────────────────────────────────────────────────
-_SPACE_ROLE     = os.getenv("SPACE_ROLE", "unknown")
-_JQ_ENABLED     = os.getenv("JQ_ENABLED", "0") == "1"
-_INTERNAL_TOKEN = os.getenv("INTERNAL_TOKEN", "")
+router = APIRouter(prefix="/api/jq", tags=["job-queue"], dependencies=[Depends(require_role(AuthRole.MACHINE))])  # GAP-1-fix: router-level auth
 
-# C2-FIX: contatore reale di job attivi — incrementato/decrementato intorno a loop_inst.run()
-_active_job_count: int = 0
+# ── Config ─────────────────────────────────────────────────────────────────────
+_SPACE_ROLE  = os.getenv("SPACE_ROLE", "unknown")       # brain | hands | unknown
+_JQ_ENABLED  = os.getenv("JQ_ENABLED", "0").strip() == "1"
+_LOAD_TTL    = 90    # s — TTL metriche load su Redis
+_RESULT_TTL  = 300   # s — TTL risultato job su Redis
+_EVENTS_TTL  = 300   # s — TTL lista eventi SSE su Redis
+_WAKE_TTL    = 30    # s — TTL singolo wake signal
+_CONSUMER_HB_TTL = 30  # s — TTL heartbeat consumer HANDS
 
-# Redis keys (Upstash)
-_K_PENDING  = "jq:pending"
-_K_WAKE     = "jq:wake"
-_K_CONSUMER = f"jq:consumer:{_SPACE_ROLE}"
-_K_RESULT   = lambda tid: f"jq:result:{tid}"
-_K_EVENTS   = lambda tid: f"jq:events:{tid}"
-_K_LOAD     = lambda role: f"jq:load:{role}"
+# ── Redis keys ─────────────────────────────────────────────────────────────────
+_K_LOAD       = lambda role: f"jq:load:{role}"         # STRING — metriche load
+_K_WAKE       = "jq:wake"                               # LIST   — wake signals
+_K_PENDING    = "jq:tasks:pending"                      # LIST   — job queue
+_K_RESULT     = lambda tid: f"jq:result:{tid}"          # STRING — risultato job
+_K_EVENTS     = lambda tid: f"jq:events:{tid}"          # LIST   — eventi SSE
+_K_CONSUMER   = "jq:consumer:alive"                     # STRING — HB consumer
 
-class JobPayload(BaseModel):
-    taskId: str
-    goal: str
-    context: Optional[Dict[str, Any]] = None
-    priority: int = 1
-
-# ── Helper Redis (via HTTP REST per stabilità mobile/serverless) ──────────────
-async def _rcmd(cmd: List[Any]) -> Optional[Dict[str, Any]]:
-    url = os.getenv("UPSTASH_REDIS_REST_URL")
-    tok = os.getenv("UPSTASH_REDIS_REST_TOKEN")
-    if not url or not tok:
-        return None
+# ── Bootstrap check ────────────────────────────────────────────────────────────
+def _redis_ok() -> bool:
+    """Verifica che Redis sia configurato (non controlla la connettività)."""
+    return bool(
+        os.getenv("UPSTASH_REDIS_REST_URL") and
+        os.getenv("UPSTASH_REDIS_REST_TOKEN")
+    )
+
+
+async def _rcmd(command: list, timeout: float = 3.0) -> dict | None:
+    """Esegue comando Redis via modulo centralizzato backend/redis.py."""
     try:
-        async with httpx.AsyncClient() as client:
-            r = await client.post(
-                url,
-                headers={"Authorization": f"Bearer {tok}"},
-                json=cmd,
-                timeout=5.0
-            )
-            return r.json()
-    except Exception as e:
-        _logger.error("[jq] redis error: %s", e)
+        from redis import redis_cmd
+        return await redis_cmd(command, timeout=timeout)
+    except Exception as exc:
+        _logger.debug("[jq] redis_cmd error: %s", exc)
         return None
 
-def _redis_ok() -> bool:
-    return bool(os.getenv("UPSTASH_REDIS_REST_URL") and os.getenv("UPSTASH_REDIS_REST_TOKEN"))
+
+async def _rpush(key: str, value: str, ttl: int | None = None) -> bool:
+    """LPUSH key value + EXPIRE key ttl (se ttl != None)."""
+    r = await _rcmd(["LPUSH", key, value])
+    if r and ttl:
+        await _rcmd(["EXPIRE", key, ttl])
+    return r is not None
+
+
+async def _rpop(key: str) -> str | None:
+    """RPOP key. Ritorna None se lista vuota o errore."""
+    r = await _rcmd(["RPOP", key])
+    if r and r.get("result") is not None:
+        return r["result"]
+    return None
+
 
 async def _llen(key: str) -> int:
-    res = await _rcmd(["LLEN", key])
-    return int(res.get("result", 0)) if res else 0
+    """LLEN key."""
+    r = await _rcmd(["LLEN", key])
+    return int(r.get("result", 0)) if r else 0
+
 
-async def _lrange(key: str, start: int, end: int = -1) -> List[str]:
-    res = await _rcmd(["LRANGE", key, start, end])
-    return res.get("result", []) if res else []
+async def _lrange(key: str, start: int = 0, stop: int = -1) -> list[str]:
+    """LRANGE key start stop."""
+    r = await _rcmd(["LRANGE", key, start, stop])
+    return r.get("result", []) if r else []
 
-# ── Core Logic ────────────────────────────────────────────────────────────────
-async def publish_load_metrics():
-    """Pubblica il carico corrente su Redis per il bilanciamento (S951).
-    C2-FIX: usa _active_job_count (contatore reale) invece di asyncio.all_tasks()-5.
+
+# ── Load metric exchange ───────────────────────────────────────────────────────
+
+async def publish_load_metrics(role: str | None = None) -> bool:
+    """
+    Pubblica le metriche di carico di questo Space su Redis.
+    Chiamato ogni 30s dal background loop _load_publisher_loop().
+    Complementa /api/health/load (HTTP) con uno snapshot Redis consultabile
+    senza HTTP call dall'altro Space.
     """
-    if not _redis_ok(): return
-    # Memoria processo in MB (Linux: ru_maxrss è in kB)
-    mem_mb = 0
-    if _HAS_RESOURCE:
+    if not _redis_ok():
+        return False
+    _role = role or _SPACE_ROLE
+    try:
+        from api.priority import get_load_metrics as _glm
+        metrics = _glm()
+    except Exception:
+        metrics = {}
+    try:
+        from api.state import _agent_tasks
+        active = sum(1 for t in _agent_tasks.values() if t.get("status") in ("RUNNING", "running"))
+    except Exception:
+        active = 0
+
+    payload = json.dumps({
+        "space_role":         _role,
+        "active_agent_tasks": active,
+        "realtime_active":    metrics.get("realtime_active", 0),
+        "background_active":  metrics.get("background_active", 0),
+        "realtime_available": metrics.get("realtime_available", 6),
+        "consumer_enabled":   _JQ_ENABLED,
+        "ts":                 int(time.time() * 1000),
+    })
+    r = await _rcmd(["SET", _K_LOAD(_role), payload, "EX", _LOAD_TTL])
+    return r is not None
+
+
+async def get_remote_load(role: str) -> dict | None:
+    """Legge le metriche load dell'altro Space da Redis. Ritorna None se stale."""
+    if not _redis_ok():
+        return None
+    r = await _rcmd(["GET", _K_LOAD(role)])
+    if not r or r.get("result") is None:
+        return None
+    try:
+        return json.loads(r["result"])
+    except Exception:
+        return None
+
+
+# ── Wake-up signaling ──────────────────────────────────────────────────────────
+
+async def publish_wake_signal(reason: str = "circuit_open") -> bool:
+    """
+    BRAIN pubblica un segnale di wake-up per HANDS.
+    HANDS consumer legge il segnale e chiama /health su se stesso
+    per prevenire il cold start di HF Space free tier.
+    """
+    if not _redis_ok():
+        return False
+    payload = json.dumps({"reason": reason, "ts": int(time.time() * 1000), "from": _SPACE_ROLE})
+    return await _rpush(_K_WAKE, payload, ttl=_WAKE_TTL)
+
+
+async def _consume_wake_signals() -> int:
+    """HANDS: legge e processa tutti i wake signal in coda. Ritorna il count."""
+    count = 0
+    while True:
+        raw = await _rpop(_K_WAKE)
+        if raw is None:
+            break
         try:
-            mem_mb = _resource.getrusage(_resource.RUSAGE_SELF).ru_maxrss // 1024
+            sig = json.loads(raw)
+            _logger.info("[jq] wake signal from %s — reason: %s", sig.get("from"), sig.get("reason"))
         except Exception:
-            mem_mb = 0
-    data = {
-        "role":         _SPACE_ROLE,
-        "ts":           int(time.time() * 1000),
-        "active_tasks": max(0, _active_job_count),  # mai negativo
-        "cpu":          0,                            # placeholder — psutil non installato
-        "mem":          mem_mb,
+            pass
+        count += 1
+    return count
+
+
+# ── Task delegation ────────────────────────────────────────────────────────────
+
+class JobPayload(BaseModel):
+    goal:       str
+    session_id: str = ""
+    context:    dict = {}
+    priority:   str = "realtime"  # realtime | background
+    max_steps:  int = 20
+    task_id:    str = ""  # se vuoto → generato da BRAIN
+
+
+async def submit_job(job: JobPayload) -> dict:
+    """
+    BRAIN: accoda un task per HANDS via Redis.
+    Ritorna {taskId, status, stream_url, queue_depth}.
+    
+    Il client usa stream_url per connettersi direttamente a HANDS (via CF routing)
+    e ricevere gli eventi SSE una volta che HANDS ha consumato il job.
+    """
+    if not _redis_ok():
+        raise HTTPException(503, "Redis non configurato — job queue non disponibile")
+
+    task_id = job.task_id or str(uuid.uuid4())
+    payload = json.dumps({
+        "taskId":     task_id,
+        "goal":       job.goal,
+        "session_id": job.session_id,
+        "context":    job.context,
+        "priority":   job.priority,
+        "max_steps":  job.max_steps,
+        "submitted_at": time.time(),
+        "submitted_by": _SPACE_ROLE,
+    })
+
+    ok = await _rpush(_K_PENDING, payload)
+    if not ok:
+        raise HTTPException(503, "Impossibile accodare il task su Redis")
+
+    depth = await _llen(_K_PENDING)
+    _logger.info("[jq] job queued taskId=%s depth=%d", task_id, depth)
+
+    return {
+        "taskId":     task_id,
+        "status":     "queued",
+        "queue_depth": depth,
+        "stream_url": f"/api/agent/tasks/{task_id}/stream",
     }
-    await _rcmd(["SET", _K_LOAD(_SPACE_ROLE), json.dumps(data), "EX", "60"])
 
-async def _load_publisher_loop():
-    """Loop periodico per aggiornare lo stato del nodo."""
+
+async def _execute_queued_job(job: dict) -> None:
+    """
+    HANDS: esegue un job prelevato dalla coda Redis.
+    Crea il task nel registro locale e avvia unified_loop.
+    Gli eventi SSE vengono scritti sia nel registro locale (per streaming diretto)
+    sia su Redis (per relay da BRAIN).
+    """
+    task_id = job.get("taskId", str(uuid.uuid4()))
+    goal    = job.get("goal", "")
+    _logger.info("[jq] executing queued job taskId=%s goal=%.60s", task_id, goal)
+
+    try:
+        from api.state import _agent_tasks
+        _agent_tasks[task_id] = {
+            "status":     "QUEUED",
+            "goal":       goal,
+            "session_id": job.get("session_id", ""),
+            "created_at": time.time() * 1000,
+            "source":     "jq",
+        }
+
+        # Pubblica evento di start su Redis
+        await _rcmd(["LPUSH", _K_EVENTS(task_id), json.dumps({
+            "type": "task_queued", "taskId": task_id, "ts": int(time.time() * 1000)
+        })])
+        await _rcmd(["EXPIRE", _K_EVENTS(task_id), _EVENTS_TTL])
+
+        # Lancia il loop tramite agent.py create_agent_task
+        try:
+            from api.agent import _create_task_internal
+            await _create_task_internal(task_id=task_id, goal=goal, job=job)
+        except (ImportError, AttributeError):
+            # Fallback: usa unified_loop direttamente
+            from agents.unified_loop import UnifiedLoop
+            loop = UnifiedLoop()
+            result = await loop.run(
+                goal=goal,
+                context=json.dumps(job.get("context", {})),
+                max_steps=job.get("max_steps", 20),
+                session_id=job.get("session_id", ""),
+            )
+            # Pubblica risultato
+            await _rcmd(["SET", _K_RESULT(task_id), json.dumps({
+                "taskId":       task_id,
+                "status":       "success" if result.get("success") else "error",
+                "output":       result.get("output", ""),
+                "error":        result.get("error"),
+                "completed_at": time.time(),
+            }), "EX", _RESULT_TTL])
+            _agent_tasks[task_id]["status"] = "SUCCESS" if result.get("success") else "ERROR"
+
+    except Exception as exc:
+        _logger.error("[jq] job execution failed taskId=%s: %s", task_id, exc, exc_info=True)
+        await _rcmd(["SET", _K_RESULT(task_id), json.dumps({
+            "taskId":       task_id,
+            "status":       "error",
+            "error":        str(exc),
+            "completed_at": time.time(),
+        }), "EX", _RESULT_TTL])
+        try:
+            from api.state import _agent_tasks
+            _agent_tasks[task_id]["status"] = "ERROR"
+        except Exception:
+            pass
+
+
+# ── Background loops ───────────────────────────────────────────────────────────
+
+async def _load_publisher_loop() -> None:
+    """Background loop: pubblica metriche load ogni 30s su Redis."""
+    _logger.info("[jq] load publisher avviato (role=%s)", _SPACE_ROLE)
     while True:
+        await asyncio.sleep(30)
         try:
             await publish_load_metrics()
-        except Exception as e:
-            _logger.debug("[jq] load publisher error: %s", e)
-        await asyncio.sleep(30)
+        except Exception as exc:
+            _logger.debug("[jq] load publish error: %s", exc)
 
-async def _hands_consumer_loop():
-    """Loop consumer reale per nodi distribuiti (S42)."""
-    global _active_job_count
-    _logger.info("[jq] consumer loop avviato per ruolo: %s", _SPACE_ROLE)
-    _consecutive_errors = 0
-    _MAX_CONSECUTIVE_ERRORS = 3  # INV-R1: dopo 3 errori infra → pausa 30s
 
+async def _hands_consumer_loop() -> None:
+    """
+    Background loop HANDS: ogni 1s legge dalla queue Redis.
+    - Consuma wake signals (log + no-op — siamo già svegli)
+    - Consuma job dalla coda e li esegue in background
+    - Pubblica heartbeat consumer ogni 10s
+    """
+    _logger.info("[jq] HANDS job consumer avviato")
+    _hb_tick = 0
     while True:
+        await asyncio.sleep(1)
         try:
-            # 1. Heartbeat consumer
-            await _rcmd(["SET", _K_CONSUMER, "1", "EX", "15"])
-
-            # 2. Prelievo job
-            res = await _rcmd(["RPOP", _K_PENDING])
-            if res and res.get("result"):
-                job_raw = res["result"]
-                try:
-                    job_data = json.loads(job_raw)
-                    # S951: Check assignment
-                    assigned_to = job_data.get("assignedTo", "hands")
-                    if assigned_to != _SPACE_ROLE and _SPACE_ROLE != "brain":
-                        await _rcmd(["LPUSH", _K_PENDING, job_raw])
-                        await asyncio.sleep(1)
-                        continue
-                except Exception:
-                    pass
-                task_id = job_data.get("taskId", str(uuid.uuid4()))
-                goal = job_data.get("goal", "")
-                context_raw = job_data.get("context", {})
-                _logger.info("[jq] job ricevuto: %s | goal: %.80s", task_id, goal)
-
-                if isinstance(context_raw, dict):
-                    context_str = "\n".join(f"{k}: {v}" for k, v in context_raw.items() if v)
-                elif isinstance(context_raw, str):
-                    context_str = context_raw
-                else:
-                    context_str = ""
-
-                result_payload: Dict[str, Any] = {}
-                try:
-                    from agents.unified_loop import UnifiedAgentLoop
-                    from .state import (
-                        _get_ai_client, _get_mem_manager_async,
-                        _get_executor, _get_planner,
-                    )
-                    ai_client = _get_ai_client()
-                    try:
-                        from agents.critic import Critic
-                        from agents.response_verifier import ResponseVerifier
-                        _critic   = Critic(llm_client=ai_client)
-                        _verifier = ResponseVerifier()
-                    except Exception:
-                        _critic   = None
-                        _verifier = None
-
-                    _steps: list = []
-
-                    async def _on_step(step: dict) -> None:
-                        _steps.append({
-                            "action": step.get("action", ""),
-                            "output": str(step.get("output", ""))[:200],
-                        })
-
-                    loop_inst = UnifiedAgentLoop(
-                        llm_client=ai_client,
-                        critic=_critic,
-                        verifier=_verifier,
-                        memory=await _get_mem_manager_async(),
-                        executor=_get_executor(),
-                        planner=_get_planner(),
-                    )
-
-                    _priority = int(job_data.get("priority", 1))
-                    _max_steps = max(5, min(4 + _priority * 2, 16))
-
-                    # C2-FIX: incrementa contatore PRIMA di run(), decrementa in finally
-                    _active_job_count += 1
-                    try:
-                        raw_result = await loop_inst.run(
-                            goal=goal,
-                            context=context_str,
-                            max_steps=_max_steps,
-                            on_step=_on_step,
-                            session_id=task_id,
-                        )
-                    finally:
-                        _active_job_count = max(0, _active_job_count - 1)
-
-                    output  = raw_result.get("output", "") if isinstance(raw_result, dict) else str(raw_result)
-                    success = bool(raw_result.get("success", False)) if isinstance(raw_result, dict) else bool(output)
-                    engine  = raw_result.get("engine", "unknown") if isinstance(raw_result, dict) else "unknown"
-
-                    result_payload = {
-                        "taskId":  task_id,
-                        "status":  "completed" if success else "failed",
-                        "worker":  _SPACE_ROLE,
-                        "output":  output[:4000],
-                        "engine":  engine,
-                        "success": success,
-                        "steps":   len(_steps),
-                        "ts":      int(time.time() * 1000),
-                    }
-                    _consecutive_errors = 0
-                    _logger.info("[jq] job completato: %s | engine: %s | success: %s", task_id, engine, success)
-
-                except (ImportError, ModuleNotFoundError) as imp_err:
-                    _logger.warning("[jq] agents.unified_loop non disponibile su %s: %s", _SPACE_ROLE, imp_err)
-                    result_payload = {
-                        "taskId": task_id,
-                        "status": "unavailable",
-                        "worker": _SPACE_ROLE,
-                        "error":  f"UnifiedAgentLoop non disponibile su nodo {_SPACE_ROLE}: {imp_err}",
-                        "ts":     int(time.time() * 1000),
-                    }
-
-                except Exception as exec_err:
-                    _consecutive_errors += 1
-                    _logger.error("[jq] job execution error task=%s: %s", task_id, exec_err)
-                    result_payload = {
-                        "taskId": task_id,
-                        "status": "error",
-                        "worker": _SPACE_ROLE,
-                        "error":  str(exec_err)[:500],
-                        "ts":     int(time.time() * 1000),
-                    }
-                    if _consecutive_errors >= _MAX_CONSECUTIVE_ERRORS:
-                        _logger.error(
-                            "[jq] INV-R1: %d errori consecutivi — pausa 30s (nodo: %s)",
-                            _consecutive_errors, _SPACE_ROLE,
-                        )
-                        await asyncio.sleep(30)
-
-                # 3. Salva risultato su Redis (TTL 1h) — Tool Success Contract S429
-                await _rcmd(["SET", _K_RESULT(task_id), json.dumps(result_payload), "EX", "3600"])
-                _logger.info("[jq] risultato Redis: %s → %s", task_id, result_payload.get("status"))
-
-            else:
-                _consecutive_errors = 0
-                await asyncio.sleep(2)
-
-        except Exception as e:
-            _logger.error("[jq] consumer loop error: %s", e)
-            await asyncio.sleep(5)
+            # Wake signals — siamo già svegli ma logghiamo
+            await _consume_wake_signals()
+
+            # Heartbeat consumer ogni ~10s
+            _hb_tick += 1
+            if _hb_tick % 10 == 0:
+                await _rcmd(["SET", _K_CONSUMER, str(int(time.time())), "EX", _CONSUMER_HB_TTL])
+
+            if not _JQ_ENABLED:
+                continue  # load publisher attivo, job consumer no
+
+            # Preleva job dalla coda
+            raw = await _rpop(_K_PENDING)
+            if raw is None:
+                continue
+
+            try:
+                job = json.loads(raw)
+            except Exception:
+                _logger.warning("[jq] invalid job payload — skipping")
+                continue
+
+            # Esegui in background — non blocca il loop consumer
+            t = asyncio.create_task(_execute_queued_job(job))
+            t.add_done_callback(lambda task: (
+                _logger.error("[jq] job task crashed: %s", task.exception(), exc_info=task.exception())
+                if not task.cancelled() and task.exception() else None
+            ))
+
+        except Exception as exc:
+            _logger.debug("[jq] consumer tick error: %s", exc)
+
 
 async def start_job_queue_consumer() -> None:
-    """Punto di ingresso per main.py _on_startup()."""
+    """
+    Punto di ingresso per main.py _on_startup().
+    Avvia:
+    - _load_publisher_loop() (sempre, su tutti gli Space)
+    - _hands_consumer_loop() (solo se SPACE_ROLE=hands o unknown)
+    """
     if not _redis_ok():
         _logger.warning("[jq] Redis non configurato — job queue disabilitato")
         return
-    _bg_tasks.append(asyncio.create_task(_load_publisher_loop()))
-    if _SPACE_ROLE in ("hands", "memory", "audit", "unknown"):
-        _bg_tasks.append(asyncio.create_task(_hands_consumer_loop()))
+
+    # Load publisher su tutti gli Space
+    asyncio.create_task(_load_publisher_loop())
+
+    # Consumer solo su HANDS (o se role non impostato per compatibilità)
+    if _SPACE_ROLE in ("hands", "unknown"):
+        asyncio.create_task(_hands_consumer_loop())
     else:
         _logger.info("[jq] SPACE_ROLE=%s — consumer non avviato (solo load publisher)", _SPACE_ROLE)
 
+    # Pubblica subito le metriche al boot
+    await publish_load_metrics()
+
+
 # ── FastAPI endpoints ──────────────────────────────────────────────────────────
+
 @router.get("/status")
-async def jq_status(
-    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
-):
-    return {
+async def jq_status():
+    """Diagnostica completa della job queue."""
+    _redis_configured = _redis_ok()
+    result = {
         "space_role":       _SPACE_ROLE,
         "jq_enabled":       _JQ_ENABLED,
-        "redis_configured": _redis_ok(),
-        "active_tasks":     max(0, _active_job_count),
+        "redis_configured": _redis_configured,
         "ts":               int(time.time() * 1000),
     }
+    if _redis_configured:
+        result["queue_depth"]     = await _llen(_K_PENDING)
+        result["wake_pending"]    = await _llen(_K_WAKE)
+        _hb = await _rcmd(["GET", _K_CONSUMER])
+        result["consumer_alive"]  = bool(_hb and _hb.get("result"))
+        result["brain_load"]      = await get_remote_load("brain")
+        result["hands_load"]      = await get_remote_load("hands")
+    return result
+
 
 @router.get("/load/{role}")
-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)])
-    if not res or not res.get("result"):
-        raise HTTPException(404, f"Metriche {role} non disponibili")
-    try:
-        return json.loads(res["result"])
-    except json.JSONDecodeError as _je:
-        raise HTTPException(500, f"Metriche Redis corrotte per {role}: {_je}")
+async def jq_load(role: str):
+    """Legge le metriche load di uno Space da Redis. role: brain | hands"""
+    if role not in ("brain", "hands"):
+        raise HTTPException(400, "role deve essere 'brain' o 'hands'")
+    data = await get_remote_load(role)
+    if data is None:
+        raise HTTPException(404, f"Metriche {role} non disponibili (stale o Redis non configurato)")
+    return data
+
+
+@router.post("/wake")
+async def jq_wake(request: Request):
+    """BRAIN: invia segnale wake-up a HANDS. Solo da BRAIN o con X-Internal-Token."""
+    _tok = os.getenv("INTERNAL_TOKEN", "")
+    if _tok and request.headers.get("X-Internal-Token", "") != _tok:
+        raise HTTPException(401, "Unauthorized")
+    ok = await publish_wake_signal(reason="manual_wake")
+    return {"sent": ok, "ts": int(time.time() * 1000)}
+
 
 @router.post("/submit")
-async def jq_submit(
-    job: JobPayload,
-    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
-):
-    """S42 — Grid Orchestrator: sottomissione job reale su Redis."""
-    if not _redis_ok():
-        raise HTTPException(503, "Job queue non disponibile: Redis non configurato")
-
-    task_id = job.taskId if job.taskId else str(uuid.uuid4())
-
-    # S951: Dynamic Load Balancing
-    target_role = job.context.get('preferred_role', 'hands') if job.context else 'hands'
-    assigned_role = await balancer.get_best_node(target_role)
-
-    job_payload = {
-        'taskId':      task_id,
-        'goal':        job.goal,
-        'context':     job.context or {},
-        'priority':    job.priority,
-        'submittedAt': int(time.time() * 1000),
-        'submittedBy': _SPACE_ROLE,
-        'assignedTo':  assigned_role,
-    }
-    res = await _rcmd(["LPUSH", _K_PENDING, json.dumps(job_payload)])
-    if res is None:
-        raise HTTPException(503, "Errore Redis durante la sottomissione del job")
+async def jq_submit(job: JobPayload, request: Request):
+    """
+    BRAIN: sottomette un job a HANDS via Redis.
+    Richiede X-Internal-Token.
+    Ritorna {taskId, status, stream_url} — il client usa stream_url per SSE.
+    """
+    _tok = os.getenv("INTERNAL_TOKEN", "")
+    if _tok and request.headers.get("X-Internal-Token", "") != _tok:
+        raise HTTPException(401, "Unauthorized")
+    if not _JQ_ENABLED:
+        raise HTTPException(503, "JQ_ENABLED non impostato — job queue disabilitato")
+    return await submit_job(job)
 
-    queue_len = int(res.get("result", 0)) if res else 0
-    await _rcmd(["SET", _K_WAKE, "1", "EX", "10"])
-    _logger.info("[jq] job sottomesso: %s (coda: %d)", task_id, queue_len)
-    return {
-        "taskId":      task_id,
-        "status":      "queued",
-        "queueLength": queue_len,
-        "ts":          int(time.time() * 1000),
-    }
 
 @router.get("/result/{task_id}")
-async def jq_result(
-    task_id: str,
-    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
-):
-    """S429 — Tool Success Contract: recupero risultato job per taskId."""
+async def jq_result(task_id: str):
+    """Legge il risultato di un job delegato da Redis. Disponibile per ~5 min post-completamento."""
     if not _redis_ok():
-        raise HTTPException(503, "Job queue non disponibile: Redis non configurato")
-
-    res = await _rcmd(["GET", _K_RESULT(task_id)])
-    if not res or not res.get("result"):
-        return {"taskId": task_id, "status": "pending", "ts": int(time.time() * 1000)}
+        raise HTTPException(503, "Redis non configurato")
+    r = await _rcmd(["GET", _K_RESULT(task_id)])
+    if not r or r.get("result") is None:
+        raise HTTPException(404, f"Risultato per {task_id} non trovato (non ancora pronto o scaduto)")
     try:
-        return json.loads(res["result"])
-    except json.JSONDecodeError as _je:
-        _logger.error("[jq] risultato Redis corrotto task=%s: %s", task_id, _je)
-        raise HTTPException(500, f"Risultato corrotto in Redis per {task_id}: {_je}")
+        return json.loads(r["result"])
+    except Exception:
+        raise HTTPException(500, "Risultato malformato in Redis")
+
 
-# Lista dei background tasks (popolata da start_job_queue_consumer)
-_bg_tasks: List[asyncio.Task] = []
+@router.get("/events/{task_id}")
+async def jq_events(task_id: str, from_idx: int = 0):
+    """
+    Legge gli eventi SSE di un task da Redis (per relay da BRAIN).
+    from_idx: indice da cui iniziare (0 = tutti).
+    """
+    if not _redis_ok():
+        raise HTTPException(503, "Redis non configurato")
+    events_raw = await _lrange(_K_EVENTS(task_id), from_idx)
+    events = []
+    for e in events_raw:
+        try:
+            events.append(json.loads(e))
+        except Exception:
+            events.append({"raw": e})
+    return {"taskId": task_id, "events": events, "count": len(events), "from_idx": from_idx}

api/llm_cache.py

@@ -24,9 +24,10 @@ import logging
 import os
 
 import httpx
-from fastapi import APIRouter
+from fastapi import APIRouter, Depends
+from .auth_guard import require_role, AuthRole
 
-router  = APIRouter(prefix="/api/cache", tags=["cache"])
+router  = APIRouter(prefix="/api/cache", tags=["cache"], dependencies=[Depends(require_role(AuthRole.MACHINE))])  # GAP-1-fix: router-level auth
 _logger = logging.getLogger("llm_cache")
 
 _CACHE_TTL_S     = int(os.getenv("LLM_CACHE_TTL",       "3600"))

api/mcp.py

@@ -28,10 +28,11 @@ import time
 from typing import Any
 import uuid
 
-from fastapi import APIRouter, Request
+from fastapi import APIRouter, Depends, Request
+from .auth_guard import require_role, AuthRole
 from fastapi.responses import JSONResponse, StreamingResponse
 
-router = APIRouter(tags=["mcp"])
+router = APIRouter(tags=["mcp"], dependencies=[Depends(require_role(AuthRole.MACHINE))])  # GAP-1-fix: INTERNAL_TOKEN sempre richiesto + MCP_API_KEY opzionale come secondo layer
 _logger = logging.getLogger("agente_ai.mcp")
 
 # P20-Q1: Auth — se MCP_API_KEY è impostato nell'env, richiede Authorization: Bearer <key>.

api/persistence.py

@@ -49,13 +49,6 @@ async def sb_upsert_task(
         'created_at': created_at,
         'updated_at': now,
     }
-    # ─── Mirroring su Hugging Face Dataset (Zero-Cost Backup) ─────────────
-    try:
-        from .hf_storage import hf_fire_and_forget
-        hf_fire_and_forget("tasks.jsonl", payload)
-    except Exception as hf_exc:
-        _logger.debug("HF Mirroring (task) silenced: %s", hf_exc)
-
     for _attempt in range(_MAX_RETRY):
         try:
             await asyncio.to_thread(
@@ -100,14 +93,6 @@ async def sb_append_event(task_id: str, event_index: int, event_data: str) -> No
         'event_data':  event_data,
         'created_at':  now,
     }
-    # ─── Mirroring su Hugging Face Dataset (Zero-Cost Backup) ─────────────
-    try:
-        from .hf_storage import hf_fire_and_forget
-        # Sharding: i log degli eventi vanno su un dataset potenzialmente diverso (Account B)
-        hf_fire_and_forget("task_events.jsonl", payload, repo_id=os.getenv("HF_DATASET_REPO_LOGS"))
-    except Exception as hf_exc:
-        _logger.debug("HF Mirroring (event) silenced: %s", hf_exc)
-
     for _attempt in range(_MAX_RETRY):
         try:
             await asyncio.to_thread(

api/providers.py

@@ -1,7 +1,9 @@
 """backend/api/providers.py — Health, tools, status, AI health, heartbeat (S354)."""
 import os, asyncio, time, logging
 from fastapi import APIRouter, Request
-from .state import _sb, SENSITIVE, _ai_health_cache, _AI_HEALTH_TTL, _heartbeat_state, _TIMING_STORE, _REPAIR_STATS, get_env_secret
+from fastapi import Depends
+from .auth_guard import require_role, AuthRole
+from .state import _sb, SENSITIVE, _ai_health_cache, _AI_HEALTH_TTL, _heartbeat_state, _TIMING_STORE, _REPAIR_STATS
 
 router = APIRouter()
 _logger    = logging.getLogger('agente_ai')
@@ -22,7 +24,6 @@ _heartbeat_task: asyncio.Task | None = None
 # ── Health / Status ────────────────────────────────────────────────────────────
 
 @router.get('/health')
-@router.get('/api/health')  # alias — Railway health checks usano /api/health
 async def health():
     return {
         'status':  'ok',
@@ -84,15 +85,15 @@ async def health_load():
     }
 
 @router.get('/api/version')
-async def api_version():
+async def api_version(role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
     """S456-X3: versione dettagliata con sprint, capabilities e soglie refusal.
     Il frontend legge questo endpoint all'avvio per verificare l'allineamento
     tra la versione del loop browser (agentLoop.ts) e il loop backend (unified_loop.py).
     """
     return {
-        'sprint':     'S800-RC1',
-        'version':    '3.6.0',
-        'build_date': '2026-07-02',
+        'sprint':     'S766-RC1',
+        'version':    '3.5.0',
+        'build_date': '2026-06-19',
         'capabilities': [
             'never_give_up',           # S197: retry forzato su rifiuto LLM
             'reflective_debug',        # S455-P14: fallback chain _reflective_debug
@@ -130,7 +131,7 @@ async def api_version():
 
 
 @router.get('/api/tools')
-async def list_tools():
+async def list_tools(role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
     try:
         from tools.registry import TOOL_REGISTRY
         tools_list = [
@@ -148,10 +149,54 @@ async def list_tools():
         return {"tools": [], "count": 0, "error": str(exc)}
 
 
+# ── P17-B2: Skill patterns — sync capabilities backend → frontend ─────────────
+@router.get('/api/skills/patterns')
+async def skills_patterns(request: Request, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
+    """
+    P17-B2: Capabilities del backend per sincronizzazione con subAgentRegistry.ts.
+    Il frontend usa questo endpoint per sapere quali tool sono disponibili prima
+    di assegnare subtask agli agenti, evitando routing verso tool non esistenti.
+
+    Risposta:
+      tools:      lista tool con name, goal, description, required, risk, fallbacks
+      tool_count: totale tool registrati
+      version:    versione backend
+      ts:         timestamp ms (cache busting)
+
+    Sicurezza: richiede X-Internal-Token (coerente con /api/status e /api/version).
+    """
+    _tok = os.getenv('INTERNAL_TOKEN', '')
+    if _tok and request.headers.get('X-Internal-Token', '') != _tok:
+        from fastapi.responses import JSONResponse as _JSONResp
+        return _JSONResp({'error': 'Unauthorized — X-Internal-Token required'}, status_code=401)
+    from tools.registry import TOOL_REGISTRY
+    _tools = []
+    for _name, _info in TOOL_REGISTRY.items():
+        if _name.startswith("_"):
+            continue
+        _tools.append({
+            "name":        _name,
+            "goal":        _info.get("goal", ""),
+            "description": (_info.get("description") or "")[:300],
+            "required":    _info.get("required_inputs", []),
+            "risk":        _info.get("risk_level", "low"),
+            "fallbacks":   [
+                (f.get("name", "") if isinstance(f, dict) else str(f))
+                for f in _info.get("fallbacks", [])
+            ],
+        })
+    return {
+        "tools":      _tools,
+        "tool_count": len(_tools),
+        "version":    "3.4.2",
+        "ts":         int(time.time() * 1000),
+    }
+
+
 @router.get('/api/status')
-async def status(request: Request):
+async def status(request: Request, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
     # security-fix: richiede X-Internal-Token — endpoint espone env vars
-    _tok = get_env_secret('INTERNAL_TOKEN')
+    _tok = os.getenv('INTERNAL_TOKEN', '')
     if _tok and request.headers.get('X-Internal-Token', '') != _tok:
         from fastapi import HTTPException as _HTTPEx
         raise _HTTPEx(401, 'Unauthorized')
@@ -160,7 +205,7 @@ async def status(request: Request):
 
 
 @router.get('/api/ai/health')
-async def ai_provider_health():
+async def ai_provider_health(role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
     """Testa tutti i provider AI in parallelo — risultati cachati 60s."""
     now = time.monotonic()
     if _ai_health_cache["data"] and now - _ai_health_cache["at"] < _AI_HEALTH_TTL:
@@ -201,7 +246,7 @@ async def ai_provider_health():
 # ── GAP-PROVIDER-FIX: canonical provider order ──────────────────────────────────
 
 @router.get("/api/providers/canonical")
-async def providers_canonical():
+async def providers_canonical(role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
     """
     GAP-PROVIDER-FIX: espone l'ordine di priorità backend dei provider in modo
     leggibile dal frontend (providerBridge) — elimina la divergenza silenziosa
@@ -296,13 +341,7 @@ async def _heartbeat_loop() -> None:
             _heartbeat_state["status"] = "error"
             _heartbeat_state["error"]  = str(exc)[:300]  # S588: 200→300
             _logger.error("heartbeat error: %s", exc)
-        # MX12-P2: adaptive interval — dimezza quando <2 provider disponibili
-        # per rilevare il recovery più velocemente senza aumentare il carico base.
-        _available_count = len([r for r in _heartbeat_state.get("providers", []) if r.get("ok")])
-        _adaptive_s = max(30, _HEARTBEAT_INTERVAL_S // 2) if _available_count < 2 else _HEARTBEAT_INTERVAL_S
-        if _adaptive_s != _HEARTBEAT_INTERVAL_S:
-            _logger.info("heartbeat adaptive: %ds (providers ok=%d)", _adaptive_s, _available_count)
-        await asyncio.sleep(_adaptive_s)
+        await asyncio.sleep(_HEARTBEAT_INTERVAL_S)
 
 
 def start_heartbeat() -> None:
@@ -324,35 +363,8 @@ def start_heartbeat() -> None:
         _logger.warning("start_heartbeat failed: %s", exc)
 
 
-
-# ── MX12-P1: get_best_provider_fast() — TTL-guarded in-memory read ────────────
-# Usato da unified_loop e qualsiasi client interno che vuole il provider migliore
-# senza trigger network. Se heartbeat è stale (>_PROVIDER_CACHE_TTL_S) restituisce
-# il fallback configurabile via env DEFAULT_PROVIDER (default: "groq").
-# Thread-safe: legge solo dict primitivi Python (GIL garantisce letture atomiche).
-_PROVIDER_CACHE_TTL_S = int(os.getenv("PROVIDER_CACHE_TTL", "60"))
-
-def get_best_provider_fast() -> str:
-    """Provider migliore dalla cache in-memory senza network calls.
-
-    Regola TTL:
-      - Se heartbeat ha girato entro _PROVIDER_CACHE_TTL_S → usa best_provider
-      - Se stale o heartbeat non ancora partito → fallback DEFAULT_PROVIDER
-    Fallback: 'groq' (tier free 900k tok/giorno, latenza <300ms tipica)
-    """
-    last = _heartbeat_state.get("last_run_at") or 0
-    age  = int(time.time()) - last
-    best = _heartbeat_state.get("best_provider")
-    if best and age <= _PROVIDER_CACHE_TTL_S:
-        return best
-    fallback = os.getenv("DEFAULT_PROVIDER", "groq")
-    if age > _PROVIDER_CACHE_TTL_S and last > 0:
-        _logger.debug("get_best_provider_fast: stale (%ds) — fallback %s", age, fallback)
-    return fallback
-
-
 @router.get("/debug/timing")
-async def debug_timing():
+async def debug_timing(role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
     """S385: Latency telemetry — p50/p95/min/max per metrica LLM e tool call."""
     def _pct(values: list[float], p: float) -> float | None:
         if not values:
@@ -396,7 +408,7 @@ async def debug_timing():
 
 
 @router.get("/api/providers/heartbeat")
-async def providers_heartbeat():
+async def providers_heartbeat(role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix
     now = int(time.time())
     return {
         "status":          _heartbeat_state["status"],
@@ -414,138 +426,6 @@ async def providers_heartbeat():
 
 # ── /api/health/full — aggregated health (AI + Supabase + Telegram + backend) ──
 
-@router.get("/api/health/full")
-async def health_full():
-    """
-    Aggregated health check in un'unica chiamata.
-
-    Risponde in <200ms:
-      - ai:       da _heartbeat_state (cache, no LLM probe live)
-      - supabase: probe live SELECT limit 1 (timeout 3s)
-      - telegram: /getMe live (timeout 3s)
-      - backend:  task attivi, heartbeat runs, timing snapshot
-
-    Usato da monitoring, dashboard prod e debug.
-    """
-    import time as _t
-
-    t0 = _t.monotonic()
-    now = int(_t.time())
-
-    # ── 1. AI providers — heartbeat cache, istantaneo ─────────────────────────
-    hb = _heartbeat_state
-    _hb_providers = hb.get("providers", [])
-    _hb_ok        = [p for p in _hb_providers if p.get("ok")]
-    _last_run     = hb.get("last_run_at") or 0
-    ai_section = {
-        "ok":              len(_hb_ok) > 0,
-        "available":       len(_hb_ok),
-        "total":           len(_hb_providers),
-        "best":            hb.get("best_provider"),
-        "best_latency_ms": hb.get("best_latency_ms"),
-        "providers":       _hb_providers,
-        "last_probe_at":   _last_run,
-        "next_probe_at":   hb.get("next_run_at"),
-        "stale":           (now - _last_run) > (_HEARTBEAT_INTERVAL_S * 2) if _last_run else True,
-        "heartbeat_runs":  hb.get("runs", 0),
-    }
-
-    # ── 2. Supabase — probe live (SELECT 1 via table scan, timeout 3s) ────────
-    async def _probe_supabase() -> dict:
-        if _sb is None:
-            return {"ok": False, "configured": False, "error": "not_configured",
-                    "detail": "Imposta SUPABASE_URL + SUPABASE_KEY in Railway/HF Spaces"}
-        _pt = _t.monotonic()
-        try:
-            await asyncio.wait_for(
-                asyncio.to_thread(
-                    lambda: _sb.table("agent_tasks").select("task_id").limit(1).execute()
-                ),
-                timeout=3.0,
-            )
-            return {"ok": True, "configured": True,
-                    "latency_ms": round((_t.monotonic() - _pt) * 1000)}
-        except asyncio.TimeoutError:
-            return {"ok": False, "configured": True, "error": "timeout",
-                    "latency_ms": round((_t.monotonic() - _pt) * 1000)}
-        except Exception as exc:
-            return {"ok": False, "configured": True,
-                    "latency_ms": round((_t.monotonic() - _pt) * 1000),
-                    "error": str(exc)[:150]}
-
-    # ── 3. Telegram — /getMe live (timeout 3s) ────────────────────────────────
-    async def _probe_telegram() -> dict:
-        _pt = _t.monotonic()
-        try:
-            _tg_token = os.getenv("TELEGRAM_BOT_TOKEN", "").strip().replace("\n", "").replace("\r", "")
-            _tg_chat  = os.getenv("TELEGRAM_CHAT_ID", "").strip().replace("\n", "").replace("\r", "")
-            if not _tg_token:
-                return {"ok": False, "configured": False,
-                        "detail": "Imposta TELEGRAM_BOT_TOKEN + TELEGRAM_CHAT_ID in Railway"}
-            import httpx
-            async with httpx.AsyncClient(timeout=3.0) as hc:
-                r = await hc.get(f"https://api.telegram.org/bot{_tg_token}/getMe")
-            ms = round((_t.monotonic() - _pt) * 1000)
-            if r.status_code == 200 and r.json().get("ok"):
-                bot = r.json()["result"]
-                return {
-                    "ok":          True,
-                    "configured":  True,
-                    "latency_ms":  ms,
-                    "username":    bot.get("username"),
-                    "bot_id":      bot.get("id"),
-                    "chat_id_set": bool(_tg_chat),
-                }
-            return {"ok": False, "configured": True, "latency_ms": ms,
-                    "error": f"HTTP {r.status_code}: {r.text[:120]}"}
-        except asyncio.TimeoutError:
-            return {"ok": False, "configured": None, "error": "timeout",
-                    "latency_ms": round((_t.monotonic() - _pt) * 1000)}
-        except Exception as exc:
-            return {"ok": False, "configured": None,
-                    "error": str(exc)[:150],
-                    "latency_ms": round((_t.monotonic() - _pt) * 1000)}
-
-    # ── run supabase + telegram in parallelo ──────────────────────────────────
-    sb_res, tg_res = await asyncio.gather(
-        _probe_supabase(), _probe_telegram(), return_exceptions=True
-    )
-    if isinstance(sb_res, Exception):
-        sb_res = {"ok": False, "error": str(sb_res)[:150]}
-    if isinstance(tg_res, Exception):
-        tg_res = {"ok": False, "error": str(tg_res)[:150]}
-
-    # ── 4. Backend meta ───────────────────────────────────────────────────────
-    from .state import _agent_tasks as _tasks
-    _last_timing = {
-        k: round(_TIMING_STORE[k][-1], 1) if _TIMING_STORE.get(k) else None
-        for k in ("llm_first_token", "llm_total", "tool_call")
-    }
-
-    # ── overall status ────────────────────────────────────────────────────────
-    _all_ok = ai_section["ok"] and bool(sb_res.get("ok"))
-    return {
-        "ok":          _all_ok,
-        "status":      "ok" if _all_ok else ("degraded" if ai_section["ok"] else "down"),
-        "elapsed_ms":  round((_t.monotonic() - t0) * 1000),
-        "server_time": now,
-        "version":     "3.4.2",
-        "ai":          ai_section,
-        "supabase":    sb_res,
-        "telegram":    tg_res,
-        "backend": {
-            "active_tasks":      len(_tasks),
-            "heartbeat_status":  hb.get("status"),
-            "timing_last":       _last_timing,
-            "repair_stats":      dict(_REPAIR_STATS),
-        },
-    }
-
-
-# ── /api/auth/ping — verifica sync INTERNAL_TOKEN (pubblica, no auth richiesta) ──
-# Risponde immediatamente senza chiamate esterne.
-# Utile per verificare dall'iPhone se CF Worker e HF Space usano lo stesso token.
-@router.get('/api/auth/ping')
 async def auth_ping(
     x_internal_token: str | None = None,
     request: 'Request' = None,
@@ -561,7 +441,7 @@ async def auth_ping(
     - header_present: True se il chiamante ha inviato X-Internal-Token.
 
     Uso tipico da iPhone:
-      curl https://arjanit98-terminal.hf.space/api/auth/ping
+      curl <hf-space-a-url>/api/auth/ping
       → { "internal_token_configured": true, "role_resolved": "USER", ... }
 
       curl https://agente-ai.pages.dev/api/auth/ping
@@ -569,7 +449,7 @@ async def auth_ping(
       (CF Worker aggiunge il token → role MACHINE se i due token coincidono)
     """
     import os as _os
-    server_token = _get_env_secret('INTERNAL_TOKEN').strip()
+    server_token = _os.getenv('INTERNAL_TOKEN', '').strip()
 
     # Leggi header sia dal parametro sia dall'oggetto request (FastAPI può passare entrambi)
     hdr_token = x_internal_token
@@ -594,21 +474,373 @@ async def auth_ping(
         ),
     }
 
-# ── /api/status/ping — alias /health non bloccato da Railway Hikari ──────────
-# Railway Hikari intercetta /api/health e /api/healthz come path riservati (405).
-# Questo alias usa /api/status/ping che passa attraverso Hikari normalmente.
-# Usato dal frontend come fallback quando /health non è raggiungibile via CF proxy.
-@router.get('/api/status/ping')
-async def status_ping():
+
+# ── P18-B2: /api/health/full — Health check dettagliato ──────────────────────
+
+@router.get('/api/health/full')
+async def health_full(role: AuthRole = Depends(require_role(AuthRole.MACHINE))):
     """
-    Alias leggero di /health — non bloccato da Railway Hikari.
-    Railway riserva /api/health e /api/healthz come path di sistema (risponde 405).
-    Questo endpoint è identico a /health ma usa un path non riservato.
+    P18-B2: Health check dettagliato di tutti i sottosistemi.
+
+    Auth: MACHINE (X-Internal-Token header obbligatorio).
+
+    Esegue tutti i check in parallelo con timeout individuali (5s ciascuno).
+
+    Risposta:
+      status  "ok" | "degraded" | "critical"
+      checks  { <nome>: { ok, latency_ms?, error?, ... } }
+
+    HTTP 503 se almeno un check CRITICAL fallisce
+    (CRITICAL = almeno un Supabase raggiungibile + env_config ok).
+
+    Non-critical failures → HTTP 200 con status "degraded".
     """
-    return {
-        'status':  'ok',
-        'version': '3.4.2',
-        'supabase': _sb is not None,
-        'backend': 'HuggingFace Spaces / Railway',
+    from fastapi.responses import JSONResponse  # P18-B2: local import — not in module scope
+
+    import shutil as _shu
+
+    _CHECK_TIMEOUT = 5.0  # secondi — timeout per ogni singolo check
+
+    # ── check: Supabase ───────────────────────────────────────────────────────
+    async def _ck_supabase(client: object, label: str) -> dict:
+        if client is None:
+            return {"ok": False, "error": "not configured"}
+        t0 = time.monotonic()
+        try:
+            await asyncio.wait_for(
+                asyncio.to_thread(
+                    lambda: client.table("agent_tasks").select("task_id").limit(1).execute()
+                ),
+                timeout=_CHECK_TIMEOUT,
+            )
+            return {"ok": True, "latency_ms": round((time.monotonic() - t0) * 1000)}
+        except asyncio.TimeoutError:
+            return {
+                "ok": False, "error": "timeout",
+                "latency_ms": round((time.monotonic() - t0) * 1000),
+            }
+        except Exception as exc:
+            return {
+                "ok": False, "error": str(exc)[:200],
+                "latency_ms": round((time.monotonic() - t0) * 1000),
+            }
+
+    # ── check: Redis / Upstash ────────────────────────────────────────────────
+    async def _ck_redis() -> dict:
+        import urllib.request as _ur, json as _js
+        url   = os.getenv("UPSTASH_REDIS_URL",   "").strip()
+        token = os.getenv("UPSTASH_REDIS_TOKEN", "").strip()
+        if not url or not token:
+            return {"ok": False, "error": "not configured"}
+        t0 = time.monotonic()
+        try:
+            def _ping():
+                req = _ur.Request(
+                    f"{url}/ping",
+                    headers={"Authorization": f"Bearer {token}"},
+                    method="GET",
+                )
+                with _ur.urlopen(req, timeout=4) as r:
+                    return _js.loads(r.read())
+            resp = await asyncio.wait_for(asyncio.to_thread(_ping), timeout=_CHECK_TIMEOUT)
+            ok   = resp.get("result") == "PONG"
+            return {
+                "ok":         ok,
+                "latency_ms": round((time.monotonic() - t0) * 1000),
+                **({} if ok else {"error": f"unexpected response: {resp}"}),
+            }
+        except asyncio.TimeoutError:
+            return {"ok": False, "error": "timeout",
+                    "latency_ms": round((time.monotonic() - t0) * 1000)}
+        except Exception as exc:
+            return {"ok": False, "error": str(exc)[:200],
+                    "latency_ms": round((time.monotonic() - t0) * 1000)}
+
+    # ── check: LLM providers (da cache heartbeat — zero latenza) ─────────────
+    async def _ck_llm_providers() -> dict:
+        cache = _ai_health_cache.get("data")
+        if cache and cache.get("providers"):
+            age_s     = round(time.monotonic() - _ai_health_cache.get("at", 0))
+            available = [p for p in cache["providers"] if p.get("ok")]
+            best      = (
+                min(available, key=lambda p: p.get("latency_ms", 99_999))
+                if available else None
+            )
+            return {
+                "ok":              len(available) > 0,
+                "from_cache":      True,
+                "cache_age_s":     age_s,
+                "total":           len(cache["providers"]),
+                "available":       len(available),
+                "best_provider":   best["name"] if best else None,
+                "best_latency_ms": best["latency_ms"] if best else None,
+                "providers":       cache["providers"],
+            }
+        # Heartbeat non ancora eseguito (boot molto recente)
+        return {
+            "ok":         True,
+            "from_cache": False,
+            "note":       "heartbeat non ancora eseguito — dati disponibili dopo il primo ciclo (90s)",
+        }
+
+    # ── check: Python exec ────────────────────────────────────────────────────
+    async def _ck_exec_python() -> dict:
+        import sys
+        t0 = time.monotonic()
+        try:
+            proc = await asyncio.wait_for(
+                asyncio.create_subprocess_exec(
+                    sys.executable, "-c", "print('ok')",
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                ),
+                timeout=_CHECK_TIMEOUT,
+            )
+            stdout, _ = await asyncio.wait_for(proc.communicate(), timeout=_CHECK_TIMEOUT)
+            ok = proc.returncode == 0 and stdout.strip() == b"ok"
+            return {
+                "ok":         ok,
+                "latency_ms": round((time.monotonic() - t0) * 1000),
+                "python":     sys.version.split()[0],
+                **({} if ok else {"error": f"returncode={proc.returncode}"}),
+            }
+        except Exception as exc:
+            return {"ok": False, "error": str(exc)[:200],
+                    "latency_ms": round((time.monotonic() - t0) * 1000)}
+
+    # ── check: JS sandbox (Deno → Node vm fallback) ───────────────────────────
+    async def _ck_js_sandbox() -> dict:
+        t0 = time.monotonic()
+        # Deno
+        deno_candidates = [os.getenv("DENO_PATH", ""), "/root/.deno/bin/deno", "deno"]
+        for c in deno_candidates:
+            if not c:
+                continue
+            bin_path = c if (os.path.isabs(c) and os.path.isfile(c)) else _shu.which(c)
+            if not bin_path:
+                continue
+            try:
+                proc = await asyncio.wait_for(
+                    asyncio.create_subprocess_exec(
+                        bin_path, "eval", "console.log('ok')",
+                        stdout=asyncio.subprocess.PIPE,
+                        stderr=asyncio.subprocess.PIPE,
+                    ),
+                    timeout=_CHECK_TIMEOUT,
+                )
+                stdout, _ = await asyncio.wait_for(proc.communicate(), timeout=_CHECK_TIMEOUT)
+                if proc.returncode == 0 and b"ok" in stdout:
+                    return {"ok": True, "sandbox": "deno", "bin": bin_path,
+                            "latency_ms": round((time.monotonic() - t0) * 1000)}
+            except Exception:
+                pass
+        # Node vm
+        node_bin = _shu.which("node")
+        if node_bin:
+            try:
+                proc = await asyncio.wait_for(
+                    asyncio.create_subprocess_exec(
+                        node_bin, "-e",
+                        "const vm=require('vm');vm.runInNewContext('1+1');console.log('ok')",
+                        stdout=asyncio.subprocess.PIPE,
+                        stderr=asyncio.subprocess.PIPE,
+                    ),
+                    timeout=_CHECK_TIMEOUT,
+                )
+                stdout, _ = await asyncio.wait_for(proc.communicate(), timeout=_CHECK_TIMEOUT)
+                if proc.returncode == 0 and b"ok" in stdout:
+                    return {"ok": True, "sandbox": "node_vm", "bin": node_bin,
+                            "latency_ms": round((time.monotonic() - t0) * 1000)}
+            except Exception:
+                pass
+        return {
+            "ok":         False,
+            "error":      "nessun JS sandbox disponibile (Deno e Node non trovati)",
+            "latency_ms": round((time.monotonic() - t0) * 1000),
+        }
+
+    # ── check: Env config ─────────────────────────────────────────────────────
+    async def _ck_env_config() -> dict:
+        critical  = ["INTERNAL_TOKEN", "SUPABASE_URL", "SUPABASE_KEY"]
+        important = ["UPSTASH_REDIS_URL", "ALLOWED_ORIGINS", "RESEND_API_KEY"]
+        optional  = ["OPERATOR_TOKEN", "ADMIN_TOKEN", "OPENAI_API_KEY",
+                     "GROQ_API_KEY", "HF_TOKEN_A", "HF_TOKEN_B", "HF_TOKEN_C"]
+        miss_crit  = [v for v in critical  if not os.getenv(v, "").strip()]
+        miss_imp   = [v for v in important if not os.getenv(v, "").strip()]
+        miss_opt   = [v for v in optional  if not os.getenv(v, "").strip()]
+        return {
+            "ok":               len(miss_crit) == 0,
+            "missing_critical": miss_crit,
+            "missing_important": miss_imp,
+            "missing_optional": miss_opt,
+            "railway_env":      os.getenv("RAILWAY_ENVIRONMENT", ""),
+            "space_role":       os.getenv("SPACE_ROLE", ""),
+        }
+
+    # ── check: Internal token sync ────────────────────────────────────────────
+    async def _ck_internal_token() -> dict:
+        tok        = os.getenv("INTERNAL_TOKEN", "").strip()
+        on_railway = bool(
+            os.getenv("RAILWAY_ENVIRONMENT") or os.getenv("RAILWAY_PROJECT_ID")
+        )
+        on_hf      = bool(os.getenv("SPACE_ID") or os.getenv("HF_SPACE_ID"))
+        configured = bool(tok)
+        # Ephemeral = configurato solo in locale senza Railway/HF (generato al boot)
+        ephemeral  = configured and not (on_railway or on_hf)
+        return {
+            "ok":         configured,
+            "configured": configured,
+            "ephemeral":  ephemeral,
+            "env":        ("railway" if on_railway else ("hf_space" if on_hf else "local")),
+            **({
+                "warning": "token generato al boot — CF Worker andrà aggiornato ad ogni riavvio"
+            } if ephemeral else {}),
+        }
+
+
+    # ── 3. Telegram — /getMe live (timeout 3s) ────────────────────────────────
+    async def _probe_telegram() -> dict:
+        _pt = time.monotonic()
+        try:
+            from .telegram_notify import _load_config as _tg_cfg
+            cfg = await asyncio.wait_for(_tg_cfg(), timeout=2.0)
+            if not cfg or not cfg.get("token"):
+                return {"ok": False, "configured": False,
+                        "detail": "Imposta TELEGRAM_BOT_TOKEN + TELEGRAM_CHAT_ID in Railway"}
+            import httpx
+            async with httpx.AsyncClient(timeout=3.0) as hc:
+                r = await hc.get(f"https://api.telegram.org/bot{cfg['token']}/getMe")
+            ms = round((time.monotonic() - _pt) * 1000)
+            if r.status_code == 200 and r.json().get("ok"):
+                bot = r.json()["result"]
+                return {
+                    "ok":          True,
+                    "configured":  True,
+                    "latency_ms":  ms,
+                    "username":    bot.get("username"),
+                    "bot_id":      bot.get("id"),
+                    "chat_id_set": bool(cfg.get("chat_id")),
+                }
+            return {"ok": False, "configured": True, "latency_ms": ms,
+                    "error": f"HTTP {r.status_code}: {r.text[:120]}"}
+        except asyncio.TimeoutError:
+            return {"ok": False, "configured": None, "error": "timeout",
+                    "latency_ms": round((time.monotonic() - _pt) * 1000)}
+        except Exception as exc:
+            return {"ok": False, "configured": None,
+                    "error": str(exc)[:150],
+                    "latency_ms": round((time.monotonic() - _pt) * 1000)}
+    # ── check: Processo / Memoria ─────────────────────────────────────────────
+    async def _ck_process() -> dict:
+        result: dict = {"ok": True, "uptime_s": round(time.monotonic() - _BOOT_TIME)}
+        try:
+            import psutil as _ps
+            p   = _ps.Process(os.getpid())
+            mem = p.memory_info()
+            result.update({
+                "mem_rss_mb":  round(mem.rss  / 1024 / 1024, 1),
+                "mem_vms_mb":  round(mem.vms  / 1024 / 1024, 1),
+                "cpu_percent": p.cpu_percent(interval=0.05),
+                "threads":     p.num_threads(),
+            })
+        except ImportError:
+            result["mem_note"] = "psutil non disponibile"
+        except Exception as exc:
+            result["mem_error"] = str(exc)[:100]
+        return result
+
+    # ── check: Disco ──────────────────────────────────────────────────────────
+    async def _ck_disk() -> dict:
+        try:
+            u        = _shu.disk_usage("/")
+            free_gb  = round(u.free  / 1024 ** 3, 2)
+            total_gb = round(u.total / 1024 ** 3, 2)
+            used_pct = round(u.used / u.total * 100, 1)
+            ok       = free_gb > 0.5
+            return {
+                "ok":       ok,
+                "free_gb":  free_gb,
+                "total_gb": total_gb,
+                "used_pct": used_pct,
+                **({
+                    "warning": f"spazio libero basso: {free_gb:.2f} GB"
+                } if not ok else {}),
+            }
+        except Exception as exc:
+            return {"ok": False, "error": str(exc)[:100]}
+
+    # ── Esegui tutti i check in parallelo ─────────────────────────────────────
+    from .state import _sb as _sb_h, _sb2 as _sb2_h, _sb_fallback as _sbf_h
+
+    (
+        c_sb1, c_sb2, c_sbf,
+        c_redis,
+        c_llm,
+        c_py,
+        c_js,
+        c_env,
+        c_tok,
+        c_proc,
+        c_disk,
+    ) = await asyncio.gather(
+        _ck_supabase(_sb_h,   "primary"),
+        _probe_telegram(),
+        _ck_supabase(_sb2_h,  "secondary"),
+        _ck_supabase(_sbf_h,  "fallback"),
+        _ck_redis(),
+        _ck_llm_providers(),
+        _ck_exec_python(),
+        _ck_js_sandbox(),
+        _ck_env_config(),
+        _ck_internal_token(),
+        _ck_process(),
+        _ck_disk(),
+    )
+
+    checks = {
+        "supabase_primary":   c_sb1,
+        "supabase_secondary": c_sb2,
+        "supabase_fallback":  c_sbf,
+        "telegram":          c_tg,
+        "redis":              c_redis,
+        "llm_providers":      c_llm,
+        "exec_python":        c_py,
+        "exec_js_sandbox":    c_js,
+        "env_config":         c_env,
+        "internal_token":     c_tok,
+        "process":            c_proc,
+        "disk":               c_disk,
+    }
+
+    # ── Determina stato complessivo ───────────────────────────────────────────
+    # CRITICAL: almeno un Supabase deve rispondere + env_config deve essere ok
+    supabase_any_ok = c_sb1["ok"] or c_sb2["ok"] or c_sbf["ok"]
+    critical_ok     = supabase_any_ok and c_env["ok"]
+
+    # Non-critical: tutto il resto
+    non_critical_failed = [
+        name for name, c in checks.items()
+        if name != "env_config" and not c.get("ok")
+    ]
+
+    if   not critical_ok:          overall = "critical"
+    elif non_critical_failed:      overall = "degraded"
+    else:                          overall = "ok"
+
+    body = {
+        "status":  overall,
+        "version": "3.4.2",
+        "ts":      int(time.time() * 1000),
+        "checks":  checks,
+        "summary": {
+            "supabase_any_ok":   supabase_any_ok,
+            "critical_ok":       critical_ok,
+            "degraded_checks":   non_critical_failed,
+            "total_checks":      len(checks),
+            "checks_ok":         sum(1 for c in checks.values() if c.get("ok")),
+        },
     }
 
+    if overall == "critical":
+        return JSONResponse(status_code=503, content=body)
+    return body

api/quality_guardian.py

@@ -392,7 +392,7 @@ async def _check(task_id, goal, llm_output, on_event, session_files: dict | None
                 [
                     {"role": "system", "content": _TESTER_SYS},
                     # S589/S597: goal 500 chars
-                    {"role": "user", "content": f"Goal: {goal[:500]}\n\n```python\n{code[:2000]}\n```"},  # S597: 300->500
+                    {"role": "user", "content": f"Goal: {goal[:500]}\n\n```python\n{code[:2000]}\n```"},
                 ],
                 temperature=0,
                 max_tokens=400,
@@ -454,7 +454,7 @@ async def _check(task_id, goal, llm_output, on_event, session_files: dict | None
                 "taskId":  task_id,
                 "passed":  passed,
                 "stdout":  exec_result["stdout"][:500],  # S604
-                "stderr":  exec_result["stderr"][:500]  # S597+S598: 300->500,  # S597
+                "stderr":  exec_result["stderr"][:500],  # S597
             })
             if asyncio.iscoroutine(val):
                 await val

api/research.py

@@ -20,9 +20,9 @@ Budget (iPhone free tier):
 """
 import asyncio, os, re, logging, time
 import httpx
-from fastapi import APIRouter, HTTPException, Request, Depends
-from .auth_guard import require_role, AuthRole
+from fastapi import APIRouter, Depends, HTTPException, Request
 from pydantic import BaseModel
+from .auth_guard import require_role, AuthRole
 
 router  = APIRouter(prefix="/api/web", tags=["web-research"])
 _logger = logging.getLogger("research")
@@ -279,11 +279,9 @@ async def _synthesize(topic: str, sources: list[dict]) -> str:
 
 @router.post("/research")
 async def web_research(
-    req: ResearchRequest,
-    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+    req: ResearchRequest, request: Request,
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),  # P19-SEC2-1: era fail-open
 ):
-    # S-GAP23: X-Internal-Token guard — protegge consumi Groq API da abusi esterni.
-
     n = min(max(int(req.depth), 1), _MAX_URLS_PER_ROUND)
 
     # ── ARL loop ───────────────────────────────────────────────────────────────
@@ -607,11 +605,9 @@ async def _synthesize(topic: str, sources: list[dict]) -> str:
 
 @router.post("/research")
 async def web_research(
-    req: ResearchRequest,
-    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+    req: ResearchRequest, request: Request,
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),  # P19-SEC2-1: era fail-open
 ):
-    # S-GAP23: X-Internal-Token guard — protegge consumi Groq API da abusi esterni.
-
     n = min(max(int(req.depth), 1), _MAX_URLS_PER_ROUND)
 
     # ── ARL loop ───────────────────────────────────────────────────────────────

api/scheduler.py

@@ -19,7 +19,6 @@ Route:
   DELETE /api/scheduler/tasks/{id}        cancella task
   POST   /api/scheduler/sync              bulk upsert da Dexie (idempotente)
   POST   /api/scheduler/trigger/{id}      esecuzione immediata (debug/manuale)
-  POST   /api/scheduler/tick              pacemaker esterno (CF Worker, GHA)
   GET    /api/scheduler/status            stato del loop asyncio
   GET    /api/scheduler/webhook/sse       SSE stream real-time per frontend
 """
@@ -34,10 +33,10 @@ import uuid
 from pathlib import Path
 from typing import Any, AsyncGenerator, Optional
 
-from fastapi import APIRouter, HTTPException, Request, Depends
+from fastapi import APIRouter, Depends, HTTPException, Request
+from .auth_guard import require_role, AuthRole
 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
 
@@ -48,40 +47,31 @@ def _log_task_exc(task):  # GAP-2.6: log silently-dropped exceptions in fire-and
         exc = task.exception()
         if exc:
             logger.warning("[scheduler] background task raised %s: %s", type(exc).__name__, exc)
-router = APIRouter(prefix="/api/scheduler", tags=["scheduler"])
+router = APIRouter(prefix="/api/scheduler", tags=["scheduler"], dependencies=[Depends(require_role(AuthRole.MACHINE))])  # GAP-1-fix: tutti endpoint scheduler ora fail-closed
 
 # ─── Telegram notifications (fire-and-forget) ─────────────────────────────────
+# Definisci sempre le funzioni dummy PRIMA di qualsiasi import tentativo.
+async def _tg_done(*_a, **_kw): pass  # type: ignore[misc]
+async def _tg_error(*_a, **_kw): pass  # type: ignore[misc]
+async def _tg_start(*_a, **_kw): pass  # type: ignore[misc]
+async def _tg_heartbeat(*_a, **_kw): pass  # type: ignore[misc]
+
 try:
     from .telegram_notify import (
-        notify_task_done as _tg_done, notify_task_error as _tg_error,
-        notify_task_start as _tg_start, notify_task_heartbeat as _tg_heartbeat,
+        notify_task_done as _tg_done,
+        notify_task_error as _tg_error,
+        notify_task_start as _tg_start,
+        notify_task_heartbeat as _tg_heartbeat,
     )
-except Exception:
-    async def _tg_done(*_a, **_kw): pass  # type: ignore[misc]
-    async def _tg_error(*_a, **_kw): pass  # type: ignore[misc]
-    async def _tg_start(*_a, **_kw): pass  # type: ignore[misc]
-    async def _tg_heartbeat(*_a, **_kw): pass  # type: ignore[misc]
+except Exception as _tg_import_err:
+    logger.debug("[scheduler] Telegram notifications unavailable: %s", _tg_import_err)
 
 # ─── Persistenza JSON ─────────────────────────────────────────────────────────
 # Usa /tmp su HF Space (ephemeral ma dura ore).
 # Il frontend re-sincronizza Dexie → backend al mount: zero task persi.
 
-def _resolve_tasks_path() -> Path:
-    """GAP-SCHEDULERFILE-TMP fix: usa /data (persistente HF Spaces) con fallback a /tmp."""
-    custom = os.getenv("SCHEDULER_TASKS_FILE", "")
-    if custom:
-        return Path(custom)
-    data_path = Path("/data/agente_scheduler.json")
-    try:
-        data_path.parent.mkdir(parents=True, exist_ok=True)
-        if os.access(str(data_path.parent), os.W_OK):
-            return data_path
-    except (PermissionError, OSError):
-        pass
-    return Path("/tmp/agente_scheduler.json")
-
-_TASKS_FILE = _resolve_tasks_path()
-_TASKS_BAK  = Path(str(_TASKS_FILE) + ".bak")
+_TASKS_FILE = Path(os.getenv("SCHEDULER_TASKS_FILE", "/tmp/agente_scheduler.json"))
+_TASKS_BAK  = Path(str(os.getenv("SCHEDULER_TASKS_FILE", "/tmp/agente_scheduler.json")) + ".bak")
 _tasks: dict[str, dict] = {}        # id → task (in-memory, fonte di verità)
 _lock  = asyncio.Lock()             # serializza tutti i write (no race conditions)
 
@@ -89,104 +79,6 @@ _lock  = asyncio.Lock()             # serializza tutti i write (no race conditio
 # resettati a "pending" dal tick — previene blocco permanente del loop.
 _STUCK_TIMEOUT_S = 300              # 5 min — > 120s timeout _run_goal + margine
 
-# ─── Supabase persistence (MX11-SCHED) ────────────────────────────────────────
-# Backup permanente dei task scheduler: ad ogni mutazione salva su Supabase
-# in modo fire-and-forget. Al boot, se /tmp è vuoto, carica da Supabase.
-# Rende i task immortali: sopravvivono a qualsiasi Railway restart.
-
-_SB_URL = os.getenv("SUPABASE_URL", "").rstrip("/")
-_SB_KEY = os.getenv("SUPABASE_KEY", "") or os.getenv("SUPABASE_SERVICE_ROLE_KEY", "")  # GAP1-FIX
-
-
-async def _sb_upsert_tasks(tasks_snapshot: list) -> None:
-    """Upsert su Supabase scheduler_tasks (fire-and-forget, non bloccante)."""
-    if not _SB_URL or not _SB_KEY or not tasks_snapshot:
-        return
-    try:
-        import httpx
-        rows = [
-            {
-                "id":         t["id"],
-                "data":       t,
-                "updated_at": datetime.datetime.utcnow().isoformat() + "Z",
-            }
-            for t in tasks_snapshot
-            if isinstance(t, dict) and "id" in t
-        ]
-        async with httpx.AsyncClient(timeout=8.0) as client:
-            await client.post(
-                f"{_SB_URL}/rest/v1/scheduler_tasks",
-                headers={
-                    "apikey":        _SB_KEY,
-                    "Authorization": f"Bearer {_SB_KEY}",
-                    "Content-Type":  "application/json",
-                    "Prefer":        "resolution=merge-duplicates",
-                },
-                json=rows,
-            )
-    except Exception as _exc:
-        logger.debug("Scheduler: sb_upsert silenced: %s", _exc)
-
-
-async def _sb_delete_task_row(task_id: str) -> None:
-    """Rimuove un task da Supabase (fire-and-forget)."""
-    if not _SB_URL or not _SB_KEY:
-        return
-    try:
-        import httpx
-        async with httpx.AsyncClient(timeout=5.0) as client:
-            await client.delete(
-                f"{_SB_URL}/rest/v1/scheduler_tasks?id=eq.{task_id}",
-                headers={
-                    "apikey":        _SB_KEY,
-                    "Authorization": f"Bearer {_SB_KEY}",
-                },
-            )
-    except Exception as _exc:
-        logger.debug("Scheduler: sb_delete silenced: %s", _exc)
-
-
-async def _sb_load_tasks_async() -> dict:
-    """Carica task da Supabase — fallback al boot se /tmp è vuoto."""
-    if not _SB_URL or not _SB_KEY:
-        return {}
-    try:
-        import httpx
-        async with httpx.AsyncClient(timeout=10.0) as client:
-            r = await client.get(
-                f"{_SB_URL}/rest/v1/scheduler_tasks?select=id,data&order=updated_at.asc",
-                headers={
-                    "apikey":        _SB_KEY,
-                    "Authorization": f"Bearer {_SB_KEY}",
-                },
-            )
-            rows = r.json()
-            if not isinstance(rows, list):
-                return {}
-            result = {}
-            for row in rows:
-                data = row.get("data")
-                if isinstance(data, dict) and "id" in data:
-                    result[data["id"]] = data
-            logger.info("Scheduler: caricati %d task da Supabase (fallback boot)", len(result))
-            return result
-    except Exception as _exc:
-        logger.warning("Scheduler: sb_load_tasks failed: %s", _exc)
-        return {}
-
-
-def _trigger_sb_sync() -> None:
-    """
-    Schedula Supabase upsert in background dopo ogni mutazione.
-    Chiamato da _broadcast_sse() (già eseguita con _lock acquisito).
-    Fire-and-forget: un fallback non blocca l'operazione principale.
-    """
-    try:
-        snapshot = list(_tasks.values())
-        asyncio.create_task(_sb_upsert_tasks(snapshot)).add_done_callback(_log_task_exc)
-    except RuntimeError:
-        pass   # no event loop attivo (chiamata da contesto sync pre-startup)
-
 
 def _load_tasks() -> None:
     """Gap-7-FIX: carica da file principale, fallback a backup se corrotto."""
@@ -201,7 +93,7 @@ def _load_tasks() -> None:
         except Exception as exc:
             logger.warning("Scheduler: load da %s fallito (%s) — provo backup", _path, exc)
     _tasks = {}
-    logger.warning("Scheduler: nessun task salvato trovato — partenza vuota (proverò Supabase)")
+    logger.warning("Scheduler: nessun task salvato trovato — partenza vuota")
 
 
 def _save_tasks_sync() -> None:
@@ -234,10 +126,8 @@ def _broadcast_sse() -> None:
     Invia la lista task aggiornata a tutti i client SSE connessi.
     Fire-and-forget: chiamato dopo ogni mutazione (create/patch/delete/execute).
     Deve essere chiamato con _lock già acquisito (legge _tasks direttamente).
-    MX11-SCHED: schedula anche Supabase sync (backup permanente).
     """
     if not _sse_clients:
-        _trigger_sb_sync()   # sync Supabase anche senza client SSE
         return
     payload = safe_json_dumps(list(_tasks.values()))
     event   = f"event: tasks_updated\ndata: {payload}\n\n"
@@ -246,7 +136,6 @@ def _broadcast_sse() -> None:
             q.put_nowait(event)
         except asyncio.QueueFull:
             pass   # client lento — skip questo evento, riceverà il prossimo
-    _trigger_sb_sync()       # backup Supabase ad ogni mutazione
 
 
 async def _sse_generator(queue: asyncio.Queue, request: Request) -> AsyncGenerator[str, None]:
@@ -282,14 +171,13 @@ 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", "tiered_scan"):  # MX-SCHED-TIERED
+    if tt in ("interval", "issue_poll"):
         t["nextRun"] = now_ms + t.get("intervalMs", 3_600_000)
     elif tt == "daily":
         hour   = t.get("hour",   9)
@@ -367,95 +255,85 @@ async def _sb_write_scheduler_result(task_id: str, goal: str, status: str, resul
 
 
 async def _execute_task(task_id: str) -> None:
-    """Esegue un task, aggiorna status e salva. GAP-SCHEDULER-CONCURRENT: Semaphore(1)."""
-    async with _get_execute_sem():  # GAP-SCHEDULER-CONCURRENT: un solo task per volta
-        now_ms = int(time.time() * 1000)
+    """Esegue un task, aggiorna status e salva."""
+    now_ms = int(time.time() * 1000)
+
+    # Marca running + broadcast SSE
+    async with _lock:
+        task = _tasks.get(task_id)
+        if not task:
+            return
+        task["status"]    = "running"
+        task["lastRunAt"] = now_ms
+        _task_notify  = task.get("notify", True)
+        _task_label   = task.get("label", task.get("goal", ""))[:200]
+        _task_goal    = task.get("goal", _task_label)[:200]
+        _save_tasks_sync()
+        _broadcast_sse()
+    if _task_notify:
+        asyncio.create_task(_tg_start(task_id, _task_goal)).add_done_callback(_log_task_exc)
+
+    try:
+        result = await _run_goal(task["goal"], task.get("conversationId"))
 
-        # Marca running + broadcast SSE
         async with _lock:
             task = _tasks.get(task_id)
             if not task:
                 return
-            task["status"]    = "running"
-            task["lastRunAt"] = now_ms
-            _task_notify  = task.get("notify", True)
-            _task_label   = task.get("label", task.get("goal", ""))[:200]
-            _task_goal    = task.get("goal", _task_label)[:200]
+            ttype     = task["trigger"].get("type")
+            one_shot  = ttype in ("once", "on_open")
+            task["status"]     = "done" if one_shot else "pending"
+            task["trigger"]    = _advance_trigger(task["trigger"], now_ms)
+            task["lastRunAt"]  = now_ms
+            task["lastResult"] = result
+            task["errorCount"] = 0
             _save_tasks_sync()
             _broadcast_sse()
+            _sb_goal_ok = task.get("goal", task.get("label", ""))[:500]
+            _sb_stat_ok = "done" if one_shot else "pending"
+
+        logger.info("Scheduler: ✓ task '%s' (%s)", task.get("label"), task_id)
+        asyncio.create_task(_sb_write_scheduler_result(task_id, _sb_goal_ok, _sb_stat_ok, result, now_ms)).add_done_callback(_log_task_exc)
         if _task_notify:
-            asyncio.create_task(_tg_start(task_id, _task_goal)).add_done_callback(_log_task_exc)
+            asyncio.create_task(_tg_done(task_id, _task_goal, result[:500])).add_done_callback(_log_task_exc)
 
-        try:
-            result = await _run_goal(task["goal"], task.get("conversationId"))
-
-            async with _lock:
-                task = _tasks.get(task_id)
-                if not task:
-                    return
-                ttype     = task["trigger"].get("type")
-                one_shot  = ttype in ("once", "on_open")
-                task["status"]     = "done" if one_shot else "pending"
-                task["trigger"]    = _advance_trigger(task["trigger"], now_ms)
-                task["lastRunAt"]  = now_ms
-                task["lastResult"] = result
-                task["errorCount"] = 0
-                _save_tasks_sync()
-                _broadcast_sse()
-                _sb_goal_ok = task.get("goal", task.get("label", ""))[:500]
-                _sb_stat_ok = "done" if one_shot else "pending"
-
-            logger.info("Scheduler: ✓ task '%s' (%s)", task.get("label"), task_id)
-            asyncio.create_task(_sb_write_scheduler_result(task_id, _sb_goal_ok, _sb_stat_ok, result, now_ms)).add_done_callback(_log_task_exc)
-            if _task_notify:
-                asyncio.create_task(_tg_done(task_id, _task_goal, result[:500])).add_done_callback(_log_task_exc)
+    except Exception as exc:
+        async with _lock:
+            task = _tasks.get(task_id)
+            if not task:
+                return
+            task["errorCount"] = task.get("errorCount", 0) + 1
+            failed             = task["errorCount"] >= task.get("maxErrors", 3)
+            task["status"]     = "failed" if failed else "pending"
+            if not failed:
+                task["trigger"] = _advance_trigger(
+                    task["trigger"], now_ms + 5 * 60_000
+                )
+            task["lastRunAt"]  = now_ms
+            task["lastResult"] = f"❌ {str(exc)[:300]}"
+            _save_tasks_sync()
+            _broadcast_sse()
 
-        except Exception as exc:
-            async with _lock:
-                task = _tasks.get(task_id)
-                if not task:
-                    return
-                task["errorCount"] = task.get("errorCount", 0) + 1
-                failed             = task["errorCount"] >= task.get("maxErrors", 3)
-                task["status"]     = "failed" if failed else "pending"
-                if not failed:
-                    task["trigger"] = _advance_trigger(
-                        task["trigger"], now_ms + 5 * 60_000
-                    )
-                task["lastRunAt"]  = now_ms
-                task["lastResult"] = f"❌ {str(exc)[:300]}"
-                _save_tasks_sync()
-                _broadcast_sse()
-
-            logger.error("Scheduler: ✗ task %s: %s", task_id, exc)
-            # GAP-A1: log incident in registry (fire-and-forget, non-blocking)
-            try:
-                from .incident_registry import log_incident as _log_inc
-                asyncio.create_task(_log_inc(
-                    task_id=task_id, goal=_task_goal, error=str(exc), source="scheduler"
-                )).add_done_callback(_log_task_exc)
-            except Exception as _exc:
-                _logger.debug("[scheduler] silenced %s", type(_exc).__name__)  # noqa: BLE001
-            _sb_goal_err = task.get("goal", task.get("label", ""))[:500] if task else ""
-            _sb_stat_err = "failed" if failed else "pending"
-            asyncio.create_task(_sb_write_scheduler_result(task_id, _sb_goal_err, _sb_stat_err, f"❌ {str(exc)[:300]}", now_ms)).add_done_callback(_log_task_exc)
-            if _task_notify:
-                asyncio.create_task(_tg_error(task_id, _task_goal, str(exc)[:300])).add_done_callback(_log_task_exc)
+        logger.error("Scheduler: ✗ task %s: %s", task_id, exc)
+        # GAP-A1: log incident in registry (fire-and-forget, non-blocking)
+        try:
+            from .incident_registry import log_incident as _log_inc
+            asyncio.create_task(_log_inc(
+                task_id=task_id, goal=_task_goal, error=str(exc), source="scheduler"
+            )).add_done_callback(_log_task_exc)
+        except Exception as _exc:
+            _logger.debug("[scheduler] silenced %s", type(_exc).__name__)  # noqa: BLE001
+        _sb_goal_err = task.get("goal", task.get("label", ""))[:500] if task else ""
+        _sb_stat_err = "failed" if failed else "pending"
+        asyncio.create_task(_sb_write_scheduler_result(task_id, _sb_goal_err, _sb_stat_err, f"❌ {str(exc)[:300]}", now_ms)).add_done_callback(_log_task_exc)
+        if _task_notify:
+            asyncio.create_task(_tg_error(task_id, _task_goal, str(exc)[:300])).add_done_callback(_log_task_exc)
 
 
 # ─── Background loop ──────────────────────────────────────────────────────────
 
 _loop_task: Optional[asyncio.Task] = None
 _current_running: Optional[str]    = None   # task_id in esecuzione
-_execute_sem: Optional[asyncio.Semaphore] = None  # GAP-SCHEDULER-CONCURRENT
-
-
-def _get_execute_sem() -> asyncio.Semaphore:
-    """GAP-SCHEDULER-CONCURRENT fix: Semaphore(1) lazy — safe senza event loop al module level."""
-    global _execute_sem
-    if _execute_sem is None:
-        _execute_sem = asyncio.Semaphore(1)
-    return _execute_sem
 
 
 async def _tick() -> None:
@@ -526,10 +404,6 @@ def start_scheduler() -> None:
     """
     Avvia il loop scheduler. Chiamato in _on_startup() di main.py.
     Idempotente — sicuro su multipli import.
-
-    MX11-SCHED: usa _boot() coroutine che:
-      1. Carica task da Supabase se /tmp era vuoto (cross-restart recovery)
-      2. Avvia il normal _scheduler_loop()
     """
     global _loop_task
     _load_tasks()
@@ -542,23 +416,7 @@ def start_scheduler() -> None:
     _save_tasks_sync()
 
     if _loop_task is None or _loop_task.done():
-        # MX11-SCHED: boot coroutine — carica Supabase se /tmp vuoto, poi avvia loop
-        _was_empty = len(_tasks) == 0
-
-        async def _boot() -> None:
-            if _was_empty:
-                sb_tasks = await _sb_load_tasks_async()
-                if sb_tasks:
-                    async with _lock:
-                        _tasks.update(sb_tasks)
-                        _save_tasks_sync()
-                    logger.info(
-                        "Scheduler: ripristinati %d task da Supabase (cross-restart)",
-                        len(sb_tasks),
-                    )
-            await _scheduler_loop()
-
-        _loop_task = asyncio.create_task(_boot())
+        _loop_task = asyncio.create_task(_scheduler_loop())
         _loop_task.add_done_callback(_log_task_exc)  # GAP-2.6: log silently-dropped exceptions
         logger.info("Scheduler: asyncio task creato ✓")
 
@@ -584,19 +442,14 @@ class TaskPatch(BaseModel):
 # ─── REST Endpoints ───────────────────────────────────────────────────────────
 
 @router.get("/tasks")
-async def list_tasks(
-    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
-) -> list[dict]:
+async def list_tasks() -> 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,
-    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
-) -> dict:
+async def create_task(body: TaskCreate) -> 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] = {
@@ -623,11 +476,7 @@ async def create_task(
 
 
 @router.patch("/tasks/{task_id}")
-async def patch_task(
-    task_id: str,
-    body: TaskPatch,
-    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
-) -> dict:
+async def patch_task(task_id: str, body: TaskPatch) -> dict:
     """Pausa, riprendi, o aggiorna label/trigger di un task."""
     async with _lock:
         task = _tasks.get(task_id)
@@ -642,26 +491,18 @@ async def patch_task(
 
 
 @router.delete("/tasks/{task_id}", status_code=204)
-async def delete_task(
-    task_id: str,
-    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
-) -> None:
-    """Cancella task dal backend + Supabase (MX11-SCHED)."""
+async def delete_task(task_id: str) -> None:
+    """Cancella task dal backend."""
     async with _lock:
         if task_id not in _tasks:
             raise HTTPException(404, "Task non trovato")
         del _tasks[task_id]
         _save_tasks_sync()
         _broadcast_sse()
-    # Rimuovi anche da Supabase (fire-and-forget)
-    asyncio.create_task(_sb_delete_task_row(task_id)).add_done_callback(_log_task_exc)
 
 
 @router.post("/sync")
-async def sync_tasks(
-    body: list[dict],
-    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
-) -> dict:
+async def sync_tasks(body: list[dict]) -> dict:
     """
     Bulk upsert da Dexie → backend.
     Idempotente: inserisce solo i task assenti. Non sovrascrive quelli esistenti.
@@ -692,10 +533,7 @@ async def sync_tasks(
 
 
 @router.post("/trigger/{task_id}")
-async def trigger_task_now(
-    task_id: str,
-    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
-) -> dict:
+async def trigger_task_now(task_id: str) -> dict:
     """Esecuzione immediata ignorando il trigger temporale (debug / run manuale)."""
     async with _lock:
         task = _tasks.get(task_id)
@@ -705,71 +543,8 @@ async def trigger_task_now(
     return {"triggered": task_id, "label": task.get("label")}
 
 
-@router.post("/tick")
-async def external_tick(
-    request: Request,
-    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
-) -> dict:
-    """
-    Pacemaker esterno — MX11-SCHED.
-
-    Chiamato dal CF Worker ogni 2min e da GHA daemon-cron come backup.
-    Garantisce che lo scheduler giri anche senza browser aperto e
-    sopravviva ai crash del loop asyncio Railway.
-
-    Comportamento:
-      - Esegue _tick() immediatamente (no attesa del ciclo 60s)
-      - Auto-riavvia il loop asyncio se è morto (self-healing)
-      - Idempotente: sicuro da più sorgenti concorrenti
-      - 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")
-
-    # Self-heal: riavvia il loop se morto
-    loop_was_dead = _loop_task is None or _loop_task.done()
-    if loop_was_dead:
-        logger.warning(
-            "Scheduler: loop morto rilevato da external tick (source=%s) — riavvio",
-            source,
-        )
-        _loop_task = asyncio.create_task(_scheduler_loop())
-        _loop_task.add_done_callback(_log_task_exc)
-
-    # Esegui _tick() immediatamente (no attesa 60s)
-    try:
-        await _tick()
-    except Exception as _exc:
-        logger.error("Scheduler: external tick error: %s", _exc)
-
-    async with _lock:
-        total   = len(_tasks)
-        pending = sum(1 for t in _tasks.values() if t.get("status") == "pending")
-        running = sum(1 for t in _tasks.values() if t.get("status") == "running")
-
-    loop_running = _loop_task is not None and not _loop_task.done()
-    logger.info(
-        "Scheduler tick (source=%s): loop=%s revived=%s tasks=%d pending=%d",
-        source, loop_running, loop_was_dead, total, pending,
-    )
-    return {
-        "ok":          True,
-        "source":      source,
-        "loopRevived": loop_was_dead,
-        "loopRunning": loop_running,
-        "tasks":       total,
-        "pending":     pending,
-        "running":     running,
-        "ts":          int(time.time() * 1000),
-    }
-
-
 @router.get("/status")
-async def scheduler_status(
-    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
-) -> dict:
+async def scheduler_status() -> 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:
@@ -787,10 +562,7 @@ async def scheduler_status(
 
 
 @router.get("/delta")
-async def scheduler_delta(
-    since_ms: int = 0,
-    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
-) -> dict:
+async def scheduler_delta(since_ms: int = 0) -> dict:
     """GAP-A7: Delta-only view — solo task aggiornati dopo since_ms (epoch ms).
 
     Permette polling incrementale efficiente dal frontend:
@@ -843,13 +615,6 @@ async def sse_stream(request: Request) -> StreamingResponse:
     Il client riceve uno snapshot immediato alla connessione, poi push ad ogni mutazione.
     Riconnessione automatica gestita dal browser (EventSource ha retry built-in).
     """
-    # GAP-SCHED-SSE-NOAUTH fix: verifica token via query param o header.
-    # EventSource non supporta header custom — frontend passa ?token=; CF Worker aggiunge X-Internal-Token.
-    _req_token = request.query_params.get("token", "") or request.headers.get("X-Internal-Token", "")
-    _svc_token = os.getenv("INTERNAL_TOKEN", "")
-    if _svc_token and _req_token != _svc_token:
-        from fastapi.responses import JSONResponse as _jr
-        return _jr({"error": "non autorizzato — fornire ?token=INTERNAL_TOKEN"}, status_code=401)
     queue: asyncio.Queue = asyncio.Queue(maxsize=16)
     _sse_clients.append(queue)
     logger.info("Scheduler SSE: client connesso (totale: %d)", len(_sse_clients))
@@ -859,8 +624,10 @@ async def sse_stream(request: Request) -> StreamingResponse:
             async for event in _sse_generator(queue, request):
                 yield event
         finally:
-            # GAP-SSE-CLIENT-GROW fix: list comprehension — evita ValueError su race cleanup
-            _sse_clients[:] = [q for q in _sse_clients if q is not queue]
+            try:
+                _sse_clients.remove(queue)
+            except ValueError as _exc:
+                _logger.debug("[scheduler] silenced %s", type(_exc).__name__)  # noqa: BLE001
             logger.info("Scheduler SSE: client disconnesso (totale: %d)", len(_sse_clients))
 
     return StreamingResponse(
@@ -872,3 +639,4 @@ async def sse_stream(request: Request) -> StreamingResponse:
             "Connection":       "keep-alive",
         },
     )
+

api/search.py

@@ -8,7 +8,7 @@ import os, asyncio, html, json
 import re as _re
 import urllib.request, urllib.parse
 from typing import Optional
-from fastapi import APIRouter, HTTPException, Request, Depends
+from fastapi import APIRouter, Depends, HTTPException, Request
 from pydantic import BaseModel
 from .auth_guard import require_role, AuthRole
 
@@ -238,12 +238,8 @@ async def _ddg_instant_search(q: str, limit: int) -> list[dict]:
 
 # ── Search ─────────────────────────────────────────────────────────────────────
 
-@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 ───────────
+@router.post('/api/search')
+async def proxy_search(req: SearchRequest, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):
     q = req.query.strip()[:200]
     if not q:
         return {'results': []}
@@ -342,12 +338,8 @@ async def proxy_search(
 
 # ── Fetch page ─────────────────────────────────────────────────────────────────
 
-@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 ─────────────────────
+@router.post('/api/fetch-page')
+async def proxy_fetch_page(req: FetchPageRequest, role: AuthRole = Depends(require_role(AuthRole.MACHINE))):
     url = req.url.strip()
     if not url.startswith(('http://', 'https://')):
         raise HTTPException(400, detail={'error': 'url_invalido'})
@@ -373,10 +365,10 @@ async def proxy_fetch_page(
 
 # ── Analyze image ──────────────────────────────────────────────────────────────
 
-@router.post('/analyze-image')
+@router.post('/api/analyze-image')
 async def analyze_image(
-    body: AnalyzeImageRequest,
-    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),
+    body: AnalyzeImageRequest, request: Request,
+    role: AuthRole = Depends(require_role(AuthRole.MACHINE)),  # P19-SEC2-1: era fail-open
 ):
     """
     Vision AI — OpenRouter free VL models → Gemini fallback.

api/skills.py

@@ -0,0 +1,92 @@
+"""backend/api/skills.py — P17-B2: Endpoint /api/skills/patterns.
+
+Espone i pattern di tool-usage aggregati dal SkillTracker per sync frontend.
+  GET /api/skills/patterns              → aggregato globale (tutte le sessioni)
+  GET /api/skills/patterns/{session_id} → singola sessione
+"""
+from __future__ import annotations
+import logging
+import math
+from fastapi import APIRouter, Depends, Query
+from .auth_guard import require_role, AuthRole
+
+_logger = logging.getLogger("agente_ai.api.skills")
+router  = APIRouter(prefix="/api/skills", tags=["skills"], dependencies=[Depends(require_role(AuthRole.MACHINE))])  # GAP-1-fix: router-level auth
+
+
+def _wilson(success: int, total: int) -> float:
+    if total == 0:
+        return 0.5
+    p, z = success / total, 1.96
+    num  = p + z*z/(2*total) - z*math.sqrt((p*(1-p) + z*z/(4*total))/total)
+    return max(0.0, min(1.0, num / (1 + z*z/total)))
+
+
+@router.get("/patterns")
+async def get_skill_patterns(
+    limit:    int = Query(default=50, ge=1,  le=200),
+    min_uses: int = Query(default=1,  ge=1,  description="Minimo utilizzi totali"),
+):
+    """Pattern aggregati da tutte le sessioni in memoria, ordinati per Wilson score."""
+    try:
+        from agents.skill_tracker import get_skill_tracker
+        tracker = get_skill_tracker()
+        agg: dict[str, dict] = {}
+        for _sid, sess in tracker._stats.items():
+            for tool, stats in sess.items():
+                if tool not in agg:
+                    agg[tool] = {"s": 0, "f": 0, "lat": 0.0, "sessions": 0, "last": 0.0}
+                agg[tool]["s"]        += stats.success_count
+                agg[tool]["f"]        += stats.fail_count
+                agg[tool]["lat"]      += stats.total_latency_ms
+                agg[tool]["sessions"] += 1
+                agg[tool]["last"]      = max(agg[tool]["last"], stats.last_used)
+
+        out = []
+        for tool, a in agg.items():
+            total = a["s"] + a["f"]
+            if total < min_uses:
+                continue
+            out.append({
+                "tool":           tool,
+                "total":          total,
+                "success":        a["s"],
+                "fail":           a["f"],
+                "success_rate":   round(a["s"] / total if total else 1.0, 4),
+                "wilson_score":   round(_wilson(a["s"], total), 4),
+                "avg_latency_ms": round(a["lat"] / total if total else 0.0, 1),
+                "sessions":       a["sessions"],
+                "last_used":      a["last"],
+            })
+        out.sort(key=lambda x: x["wilson_score"], reverse=True)
+        return {"patterns": out[:limit], "total": len(out)}
+    except Exception as exc:
+        _logger.error("[skills/patterns] %s", exc)
+        return {"patterns": [], "total": 0, "error": str(exc)[:200]}
+
+
+@router.get("/patterns/{session_id}")
+async def get_session_patterns(session_id: str):
+    """Pattern per una singola sessione."""
+    try:
+        from agents.skill_tracker import get_skill_tracker
+        tracker = get_skill_tracker()
+        sess    = tracker._stats.get(session_id, {})
+        out = []
+        for tool, stats in sess.items():
+            total = stats.total_count
+            out.append({
+                "tool":           tool,
+                "total":          total,
+                "success":        stats.success_count,
+                "fail":           stats.fail_count,
+                "success_rate":   round(stats.success_rate, 4),
+                "wilson_score":   round(stats.wilson_score(), 4),
+                "avg_latency_ms": round(stats.avg_latency_ms, 1),
+                "last_used":      stats.last_used,
+            })
+        out.sort(key=lambda x: x["wilson_score"], reverse=True)
+        return {"session_id": session_id, "patterns": out, "total": len(out)}
+    except Exception as exc:
+        _logger.error("[skills/patterns/%s] %s", session_id, exc)
+        return {"session_id": session_id, "patterns": [], "total": 0, "error": str(exc)[:200]}

api/state.py

@@ -5,10 +5,6 @@ Contains: Supabase client, in-memory stores, singleton getters, shared Pydantic
 TTL constants, prune helpers. Extracted from main.py — zero behaviour change.
 """
 import os, time, asyncio as _asyncio_mod, json as _json, re as _re
-
-def get_env_secret(name: str, default: str = "") -> str:
-    """Getter resiliente: prova SECRET_name prima di name per evitare collisioni HF."""
-    return os.getenv(f"SECRET_{name}") or os.getenv(name) or default
 from typing import Optional, Any
 from fastapi import HTTPException
 from pydantic import BaseModel, field_validator, model_validator
@@ -34,33 +30,52 @@ def safe_json_dumps(obj: object, *, ensure_ascii: bool = False, **kw) -> str:
 # ── Supabase client ───────────────────────────────────────────────────────────
 _sb: Any = None
 _sb2: Any = None
+_sb_fallback: Any = None # Collaboratore D
+
 try:
-    _SUPA_URL = get_env_secret('SUPABASE_URL')
-    _SUPA_KEY = get_env_secret('SUPABASE_KEY') or get_env_secret('SUPABASE_ANON_KEY')
+    _SUPA_URL = os.getenv('SUPABASE_URL', '')
+    _SUPA_KEY = os.getenv('SUPABASE_KEY') or os.getenv('SUPABASE_ANON_KEY', '')
+    
+    _SUPA_URL2 = os.getenv("SUPABASE_URL_2", "")
+    _SUPA_KEY2 = os.getenv("SUPABASE_KEY_2", "")
+    
+    _SUPA_URL_D = os.getenv("SUPABASE_URL_D", "")
+    _SUPA_KEY_D = os.getenv("SUPABASE_SERVICE_ROLE_KEY_D", "") or os.getenv("SUPABASE_KEY_D", "")
+
+    from supabase import create_client
+    
     if _SUPA_URL and _SUPA_KEY:
-        from supabase import create_client
         _sb = create_client(_SUPA_URL, _SUPA_KEY)
-        # Leggi SUPABASE_URL_B (canonico multi-instance) con fallback legacy SUPABASE_URL_2
-        _SUPA_URL2 = os.getenv("SUPABASE_URL_B") or os.getenv("SUPABASE_URL_2", "")
-        _SUPA_KEY2 = os.getenv("SUPABASE_KEY_B") or os.getenv("SUPABASE_KEY_2", "")
-        if _SUPA_URL2 and _SUPA_KEY2:
-            _sb2 = create_client(_SUPA_URL2, _SUPA_KEY2)
-            _logger.info("BOOT: Supabase #2 connected OK")
-        _logger.info('BOOT: Supabase connected OK')
-    else:
-        _logger.warning('BOOT: Supabase not configured (SUPABASE_URL / SUPABASE_KEY missing)')
+        _logger.info('BOOT: Supabase #1 connected OK')
+        
+    if _SUPA_URL2 and _SUPA_KEY2:
+        _sb2 = create_client(_SUPA_URL2, _SUPA_KEY2)
+        _logger.info("BOOT: Supabase #2 connected OK")
+        
+    if _SUPA_URL_D and _SUPA_KEY_D:
+        _sb_fallback = create_client(_SUPA_URL_D, _SUPA_KEY_D)
+        _logger.info("BOOT: Supabase #D (Resilience) connected OK")
+
+    if not (_sb or _sb2 or _sb_fallback):
+        _logger.warning('BOOT: Supabase not configured (Missing all keys)')
 except Exception as e:
     _logger.error('BOOT: Supabase init failed: %s', e)
 
 
 
 def sb() -> Any:
-    if not _sb and not _sb2:
+    """Ritorna il miglior client Supabase disponibile, gestendo fallback su quota exceeded (402)."""
+    clients = [s for s in [_sb, _sb2, _sb_fallback] if s]
+    if not clients:
         raise HTTPException(503, detail={
             'error': 'supabase_not_configured',
             'message': 'Imposta SUPABASE_URL e SUPABASE_KEY nelle variabili Railway/HuggingFace per abilitare la persistenza.',
         })
-    return _sb or _sb2
+    
+    # Se abbiamo più client, proviamo il primo. Se fallisce con 402, passiamo al fallback (D).
+    # Nota: In un ambiente asincrono, questa è una semplificazione. 
+    # La logica reale di switch avviene nei chiamanti o tramite un wrapper.
+    return _sb or _sb2 or _sb_fallback
 
 def sb_dual() -> list:
     """Ritorna entrambi i client se disponibili, per sharding o ridondanza."""
@@ -74,6 +89,7 @@ SENSITIVE = {
     # security-fix: tutti i segreti esposti da /api/status
     'TELEGRAM_BOT_TOKEN', 'TELEGRAM_CHAT_ID',
     'CF_API_TOKEN', 'CLOUDFLARE_API_TOKEN', 'CF_ACCOUNT_ID',
+    'CF_API_TOKEN_B', 'CF_ACCOUNT_ID_B',
     'CEREBRAS_API_KEY', 'SAMBANOVA_API_KEY',
     'VAULT_KEY', 'INTERNAL_TOKEN', 'DEPLOY_SECRET', 'WEBHOOK_TOKEN',
     'TERMINAL_SECRET', 'EXEC_TOKEN', 'VITE_INTERNAL_TOKEN', 'VITE_TERMINAL_SECRET',
@@ -154,11 +170,7 @@ async def restore_agent_tasks_from_snap() -> int:
         )
         if not res or not res.data:
             return 0
-        try:
-            snap: dict = _json.loads(res.data["value"])
-        except _json.JSONDecodeError as _snap_jd:
-            _logger.warning("BOOT: GAP-STATE snapshot JSON corrotto: %s", _snap_jd)
-            return 0
+        snap: dict = _json.loads(res.data["value"])
         n = 0
         for task_id, data in snap.items():
             if task_id not in _agent_tasks and isinstance(data, dict):
@@ -351,15 +363,13 @@ async def _get_mem_manager_async() -> Any:
                 _mem_manager = MemoryManager()
                 await _mem_manager.init()
                 _mem_manager_inited = True
-            except Exception as _mm_err:
-                _logger.warning("[state] MemoryManager.init failed (1st): %s", _mm_err)
+            except Exception:
                 _mem_manager = None
         elif not _mem_manager_inited:
             try:
                 await _mem_manager.init()
                 _mem_manager_inited = True
-            except Exception as _mm2_err:
-                _logger.warning("[state] MemoryManager.init failed (2nd, no retry): %s", _mm2_err)
+            except Exception:
                 _mem_manager_inited = True  # evita retry infiniti
     return _mem_manager
 
@@ -397,8 +407,7 @@ def _get_mem_manager() -> Any:
             # Chiamata in contesto sync (es. import-time) — init rimandato al primo call async.
             # _mem_manager_inited resta False → verrà ritentato al prossimo call in loop.
             _logger.debug("[state] silenced %s", type(_exc).__name__)  # noqa: BLE001
-    except Exception as _mm3_err:
-        _logger.warning("[state] MemoryManager get failed: %s", _mm3_err)
+    except Exception:
         _mem_manager = None
     return _mem_manager
 
@@ -414,8 +423,7 @@ def _get_executor() -> Any:
     try:
         from agents.executor import Executor
         _executor = Executor(memory=_get_mem_manager())
-    except Exception as _ex_err:
-        _logger.warning("[state] Executor init failed: %s", _ex_err)
+    except Exception:
         _executor = None
     return _executor
 
@@ -588,4 +596,3 @@ class AgentTaskIn(BaseModel):
         if not isinstance(v, list):
             return []
         return [str(h)[:300] for h in v[:5]]  # S606: 200→300
-

api/structured_log.py

@@ -19,13 +19,14 @@ import time
 from collections import deque
 from typing import Any
 
-from fastapi import APIRouter, Query
+from fastapi import APIRouter, Depends, Query
+from .auth_guard import require_role, AuthRole
 from fastapi.responses import JSONResponse
 from pydantic import BaseModel
 import logging
 _logger = logging.getLogger("agente_ai")  # S-BUGFIX
 
-router = APIRouter()
+router = APIRouter( dependencies=[Depends(require_role(AuthRole.MACHINE))])  # GAP-1-fix: router-level auth
 
 # ── Ring buffer ─────────────────────────────────────────────────────────────
 _LOG_RING: deque[dict] = deque(maxlen=500)

api/telemetry.py

@@ -8,10 +8,11 @@ Response: { ok, timing: { <key>: { avg, p50, p90, n } }, repair: { <key>: int }
 Nessuna autenticazione richiesta (dati aggregati, zero PII).
 """
 import statistics
-from fastapi import APIRouter
+from fastapi import APIRouter, Depends
+from .auth_guard import require_role, AuthRole
 from fastapi.responses import JSONResponse
 
-router = APIRouter()
+router = APIRouter( dependencies=[Depends(require_role(AuthRole.MACHINE))])  # GAP-1-fix: router-level auth
 
 
 def _percentile(data: list[float], p: int) -> float:

api/terminal.py

@@ -2,6 +2,8 @@
 import os, asyncio, pty, fcntl, struct, termios, json, shlex, time, logging
 from pathlib import Path
 from fastapi import APIRouter, WebSocket, WebSocketDisconnect
+from fastapi import Depends
+from .auth_guard import require_role, AuthRole
 
 router  = APIRouter()
 _logger = logging.getLogger("terminal")
@@ -165,7 +167,7 @@ def _schedule_save(loop: asyncio.AbstractEventLoop) -> None:
 # ── /api/terminal/packages ────────────────────────────────────────────────────
 
 @router.get('/api/terminal/packages')
-async def terminal_packages():
+async def terminal_packages(role: AuthRole = Depends(require_role(AuthRole.MACHINE))):  # GAP-1-fix: info-disclosure
     """
     Restituisce i pacchetti installati nel venv Python (/data/venv) e i pacchetti
     npm globali (/data/npm-global).

api/vault.py

@@ -2,8 +2,6 @@
 
 GAP-VAULT-CRYPTO (fix): sostituisce XOR-stream (two-time-pad) con Fernet (AES-128-CBC + HMAC-SHA256 + nonce univoco).
 GAP-VAULT-AUTH   (fix): aggiunge _require_vault_auth (Bearer VAULT_ADMIN_TOKEN) su endpoint con accesso ai valori.
-GAP-VAULT-AUTH-DEFAULT (fix): fallback su X-Internal-Token quando VAULT_ADMIN_TOKEN assente — non più fail-open.
-GAP-VAULT-ENC-FILE (fix): vault_get_token migra automaticamente XOR→Fernet al primo decrypt riuscito.
 Backward-compat: _vault_decrypt tenta Fernet, poi fallback XOR per segreti già salvati (migrazione trasparente).
 """
 import os, base64 as _b64, hashlib as _hashlib, hmac as _hmac_mod, json as _json_v, secrets as _secrets_mod, logging, time
@@ -64,47 +62,21 @@ if not _HAS_FERNET:
     _vault_logger.error('BOOT: cryptography non installata — Fernet non disponibile, uso XOR legacy (meno sicuro). Aggiungi cryptography>=42 a requirements.txt')
 
 
-# ── GAP-VAULT-AUTH + GAP-VAULT-AUTH-DEFAULT: autenticazione Bearer con fallback X-Internal-Token ──
-_VAULT_ADMIN_TOKEN    = os.getenv('VAULT_ADMIN_TOKEN', '')
-_INTERNAL_TOKEN_VAULT = os.getenv('INTERNAL_TOKEN', '')  # aggiunto da main.py al boot su Railway
+# ── GAP-VAULT-AUTH: autenticazione Bearer ─────────────────────────────────────
+_VAULT_ADMIN_TOKEN = os.getenv('VAULT_ADMIN_TOKEN', '')
 
-async def _require_vault_auth(
-    authorization: Optional[str] = Header(None),
-    x_internal_token: Optional[str] = Header(None, alias="X-Internal-Token"),
-) -> None:
-    """Richiede autenticazione per endpoint vault sensibili (accesso ai valori).
+async def _require_vault_auth(authorization: Optional[str] = Header(None)) -> None:
+    """Richiede Authorization: Bearer VAULT_ADMIN_TOKEN se configurato.
 
-    Priorità:
-    1. VAULT_ADMIN_TOKEN configurato: richiede Authorization: Bearer VAULT_ADMIN_TOKEN
-    2. VAULT_ADMIN_TOKEN assente: fallback su X-Internal-Token (aggiunto dal CF Worker
-       su tutte le route non-public — copre il path production CF→Railway)
-    3. Nessun token configurato: fail-secure 503 (GAP-VAULT-AUTH-DEFAULT fix)
-
-    PRIMA (bug): se VAULT_ADMIN_TOKEN assente → return senza check → fail-open silenzioso.
-    DOPO (fix): se VAULT_ADMIN_TOKEN assente → verifica X-Internal-Token → fail-secure se assente.
+    Se VAULT_ADMIN_TOKEN non è impostato: nessuna protezione aggiuntiva (backward compat).
+    Configura VAULT_ADMIN_TOKEN in HF Spaces secrets per abilitare l'autenticazione.
+    Genera con: python3 -c "import secrets; print(secrets.token_hex(32))"
     """
-    if _VAULT_ADMIN_TOKEN:
-        # Token admin dedicato configurato: richiede Bearer
-        if authorization != f'Bearer {_VAULT_ADMIN_TOKEN}':
-            _vault_logger.warning('vault: unauthorized access attempt (wrong/missing Bearer)')
-            raise HTTPException(status_code=401, detail='Vault: non autorizzato — Bearer token non valido o mancante')
-        return
-    # VAULT_ADMIN_TOKEN non configurato: fallback su X-Internal-Token
-    if _INTERNAL_TOKEN_VAULT:
-        if x_internal_token == _INTERNAL_TOKEN_VAULT:
-            return  # OK — chiamata interna autenticata via CF Worker
-        _vault_logger.warning('vault: unauthorized access attempt (X-Internal-Token mancante o errato)')
-        raise HTTPException(status_code=401, detail='Vault: non autorizzato — X-Internal-Token mancante o errato. Configurare VAULT_ADMIN_TOKEN per autenticazione dedicata.')
-    # Nessun token configurato: fail-secure (non più fail-open)
-    _vault_logger.critical(
-        'vault: GAP-VAULT-AUTH-DEFAULT — VAULT_ADMIN_TOKEN e INTERNAL_TOKEN assenti. '
-        'Accesso al vault bloccato per sicurezza. '
-        'Impostare VAULT_ADMIN_TOKEN su HF Spaces secrets.'
-    )
-    raise HTTPException(
-        status_code=503,
-        detail='Vault non protetto: VAULT_ADMIN_TOKEN non configurato. Impostare VAULT_ADMIN_TOKEN su HF Spaces secrets per abilitare il vault.',
-    )
+    if not _VAULT_ADMIN_TOKEN:
+        return  # Auth disabilitata — imposta VAULT_ADMIN_TOKEN per proteggere il vault
+    if authorization != f'Bearer {_VAULT_ADMIN_TOKEN}':
+        _vault_logger.warning('vault: unauthorized access attempt')
+        raise HTTPException(status_code=401, detail='Vault: non autorizzato — Bearer token non valido o mancante')
 
 
 # ── Crittografia: Fernet (AES-128-CBC + HMAC-SHA256 + nonce univoco) ───────────
@@ -208,8 +180,8 @@ async def vault_health():
         'Imposta VAULT_KEY nei secrets HF Spaces (Settings > Repository secrets).'
     )
     auth_warning = None if _VAULT_ADMIN_TOKEN else (
-        'VAULT_ADMIN_TOKEN non configurato: endpoint vault protetti da X-Internal-Token (fallback). '
-        'Imposta VAULT_ADMIN_TOKEN nei secrets HF Spaces per autenticazione dedicata al vault.'
+        'VAULT_ADMIN_TOKEN non configurato: endpoint vault accessibili senza autenticazione. '
+        'Imposta VAULT_ADMIN_TOKEN nei secrets HF Spaces per proteggere i token.'
     )
     return {
         'persistent':    _VAULT_KEY_IS_PERSISTENT,
@@ -234,7 +206,7 @@ async def vault_save(
     request: Request,
     _auth: None = Depends(_require_vault_auth),
 ):
-    """Salva un segreto cifrato con Fernet. Richiede autenticazione."""
+    """Salva un segreto cifrato con Fernet. Richiede Bearer VAULT_ADMIN_TOKEN se configurato."""
     _vault_rate_check(request)
     key = req.key.lower().strip().replace(' ', '_')
     if not key or not req.value.strip():
@@ -252,31 +224,13 @@ async def vault_get_token(
     request: Request,
     _auth: None = Depends(_require_vault_auth),
 ):
-    """Restituisce il valore decifrato.
-    GAP-VAULT-ENC-FILE fix: se il ciphertext è in formato XOR legacy, dopo il decrypt
-    riscrive la chiave in formato Fernet (migrazione automatica one-shot).
-    """
+    """Restituisce il valore decifrato. Richiede Bearer VAULT_ADMIN_TOKEN se configurato."""
     _vault_rate_check(request)
     data = _vault_load()
     if key not in data:
         raise HTTPException(status_code=404, detail=f"Chiave '{key}' non trovata nel vault")
-    ciphertext = data[key]
-    # Tenta Fernet prima (formato attuale)
-    if _fernet_instance:
-        try:
-            value = _fernet_instance.decrypt(ciphertext.encode('ascii')).decode('utf-8')
-            return {'key': key, 'value': value}
-        except Exception:
-            pass  # Potrebbe essere XOR legacy — tenta fallback con migrazione
-    # Fallback XOR legacy: decrypt + migrazione automatica a Fernet (GAP-VAULT-ENC-FILE)
     try:
-        value = _vault_decrypt_xor(ciphertext)
-        if _fernet_instance:
-            # Riscrivi in formato Fernet — migrazione one-shot trasparente
-            data[key] = _vault_encrypt(value)
-            _vault_save_data(data)
-            _vault_logger.info('vault: GAP-VAULT-ENC-FILE — migrated key=%s from XOR to Fernet', key)
-        return {'key': key, 'value': value}
+        return {'key': key, 'value': _vault_decrypt(data[key])}
     except Exception as e:
         raise HTTPException(status_code=500, detail=f'Decryption error: {e}')
 
@@ -287,7 +241,7 @@ async def vault_delete(
     request: Request,
     _auth: None = Depends(_require_vault_auth),
 ):
-    """Elimina un segreto. Richiede autenticazione."""
+    """Elimina un segreto. Richiede Bearer VAULT_ADMIN_TOKEN se configurato."""
     _vault_rate_check(request)
     data = _vault_load()
     if key not in data:

api/vision.py

@@ -18,10 +18,11 @@ Fallback chain analyze_image:
   3. BLIP-large captioning (HF Inference, libero ma solo didascalia)
 """
 import asyncio, base64, os, httpx, logging
-from fastapi import APIRouter
+from fastapi import APIRouter, Depends
+from .auth_guard import require_role, AuthRole
 from pydantic import BaseModel
 
-router  = APIRouter(prefix="/api/vision", tags=["vision"])
+router  = APIRouter(prefix="/api/vision", tags=["vision"], dependencies=[Depends(require_role(AuthRole.MACHINE))])  # GAP-1-fix: router-level auth
 _logger = logging.getLogger("vision")
 
 _HF_API     = "https://api-inference.huggingface.co"