sync: 194 file da Baida98/AI@3cf07303 (2026-08-30 07:30 UTC)

agents/executor.py

@@ -292,39 +292,15 @@ class Executor:
                 _t0          = _time_mod.monotonic()
                 result       = await asyncio.wait_for(fn(**inputs), timeout=_adaptive_to)
                 _timeout_tracker.record(tool_name, _time_mod.monotonic() - _t0)
-
-                # Il tool ha già prodotto il side effect: la persistenza memoria
-                # è osservabilità e non deve riaprire il retry del tool.
-                _memory_persisted = True
-                _memory_error = None
                 if self.memory:
-                    try:
-                        # S577→S600: inputs 100→500 — parity con altri handler
-                        await self.memory.save_episode(
-                            "tool",
-                            f"{tool_name}: {str(inputs)[:500]}",
-                            str(result)[:500],
-                            True,
-                        )
-                    except Exception as _memory_exc:
-                        _memory_persisted = False
-                        _memory_error = f"{type(_memory_exc).__name__}: {str(_memory_exc)[:240]}"
-                        _logger.warning(
-                            "[executor] tool %s completato ma save_episode fallito; "
-                            "nessun retry del side effect: %s",
-                            tool_name,
-                            _memory_error,
-                        )
-                response = {
-                    "success": True,
-                    "tool": tool_name,
-                    "output": result,
-                    "attempt": attempt + 1,
-                    "memory_persisted": _memory_persisted,
-                }
-                if _memory_error:
-                    response["memory_error"] = _memory_error
-                return response
+                    # 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

agents/unified_loop.py

@@ -214,46 +214,37 @@ class UnifiedAgentLoop(DirectToolsMixin, PromptBuilderMixin, LLMSelectionMixin,
             _logger.debug("[unified_loop] state callback silenced: %s", _state_callback_error)
 
     async def _rollback_writes(self, on_step=None) -> None:
-        """Restore all writes from this run or report an incomplete rollback.
-
-        A None snapshot means the file did not exist and must be removed.
-        Failed restores remain tracked so a supervisor can retry or block the run.
+        """
+        GAP-3: ripristina i file sovrascritti se il loop si interrompe a metà.
+        Chiama dopo un errore grave che ha lasciato il progetto in stato inconsistente.
+        Ogni file in _write_snapshots viene ripristinato al suo contenuto originale.
+        File che non esistevano (snapshot=None) vengono ignorati (non possiamo eliminarli in modo sicuro).
         """
         if not self._write_snapshots or not self.executor:
             return
         if on_step:
             await _maybe_await(on_step({
                 "action": "text_chunk",
-                "token": f"\u23ea Rollback di {len(self._write_snapshots)} file modificati...\n",
+                "token":  f"\u23ea Rollback di {len(self._write_snapshots)} file modificati...\n",
                 "status": "streaming",
             }))
-
-        remaining: dict[str, str | None] = {}
-        rolled = 0
-        for path, original in list(self._write_snapshots.items()):
-            tool_name = "delete_file" if original is None else "write_file"
-            inputs = {"path": path} if original is None else {"path": path, "content": original}
+        _rolled = 0
+        for path, original in self._write_snapshots.items():
+            if original is None:
+                continue  # file non esisteva prima — saltiamo (non eliminiamo)
             try:
-                result = await asyncio.wait_for(
-                    self.executor.run_tool(tool_name, inputs),
+                await asyncio.wait_for(
+                    self.executor.run_tool("write_file", {"path": path, "content": original}),
                     timeout=10.0,
                 )
-                payload = result.get("output") if isinstance(result, dict) else None
-                nested_failed = isinstance(payload, dict) and payload.get("ok") is False
-                if not isinstance(result, dict) or not result.get("success") or nested_failed:
-                    error = (payload or {}).get("error") if isinstance(payload, dict) else None
-                    raise RuntimeError(error or result.get("error", "rollback tool failed"))
-                rolled += 1
-            except Exception as exc:
-                remaining[path] = original
-                _logger.error("GAP-3 rollback fallito per %s: %s", path, str(exc)[:240])
-
-        total = len(self._write_snapshots)
-        self._write_snapshots = remaining
-        _logger.info("GAP-3 rollback: %d/%d file ripristinati", rolled, total)
-        if remaining:
-            raise RuntimeError(f"VFS rollback incompleto: {len(remaining)}/{total} file non ripristinati")
+                _rolled += 1
+            except Exception:
+                pass  # non-fatal — best effort rollback
+        _total = len(self._write_snapshots)  # salva prima del clear
+        self._write_snapshots = {}
+        _logger.info("GAP-3 rollback: %d/%d file ripristinati", _rolled, _total)
 
+    # ── GAP-NEW-4: Git VFS auto-snapshot ────────────────────────────────────────
     async def _vfs_git_backup(self) -> None:
         """GAP-NEW-4: Push _session_files al branch vfs-backup su GitHub.
 
@@ -1328,28 +1319,18 @@ class UnifiedAgentLoop(DirectToolsMixin, PromptBuilderMixin, LLMSelectionMixin,
                                 {"path": _wf_path, "content": _wf_generated} if rn == "write_file"
                                 else {"path": _wf_path, "patch": _wf_generated}
                             )
-                            # GAP-3: snapshot pre-write; read errors are not "file absent".
+                            # GAP-3: snapshot pre-write — cattura originale per rollback atomico
                             if rn == "write_file" and _wf_path not in self._write_snapshots:
-                                _snap_r = await asyncio.wait_for(
-                                    self.executor.run_tool("read_file", {"path": _wf_path}),
-                                    timeout=4.0,
-                                )
-                                _snap_payload = _snap_r.get("output") if isinstance(_snap_r, dict) else None
-                                _snap_failed = isinstance(_snap_payload, dict) and _snap_payload.get("ok") is False
-                                if isinstance(_snap_payload, dict):
-                                    _snap_content = _snap_payload.get("content")
-                                    _snap_error = str(_snap_payload.get("error", ""))
-                                else:
-                                    _snap_content = _snap_payload
-                                    _snap_error = str(_snap_r.get("error", "")) if isinstance(_snap_r, dict) else ""
-                                if isinstance(_snap_content, str) and not _snap_failed:
-                                    self._write_snapshots[_wf_path] = _snap_content
-                                elif "File non trovato" in _snap_error or "File not found" in _snap_error:
-                                    self._write_snapshots[_wf_path] = None
-                                else:
-                                    raise RuntimeError(
-                                        f"Snapshot VFS non disponibile per {_wf_path}: {_snap_error[:240]}"
+                                try:
+                                    _snap_r = await asyncio.wait_for(
+                                        self.executor.run_tool("read_file", {"path": _wf_path}),
+                                        timeout=4.0,
                                     )
+                                    self._write_snapshots[_wf_path] = (
+                                        _snap_r.get("output") if _snap_r.get("success") else None
+                                    )
+                                except Exception:
+                                    self._write_snapshots[_wf_path] = None  # file non esisteva
                             # GAP-VFS: lock per-path — serializza scritture parallele sullo stesso file
                             _vfs_lock = self._get_vfs_lock(_wf_path)
                             async with _vfs_lock:
@@ -3576,12 +3557,6 @@ class UnifiedAgentLoop(DirectToolsMixin, PromptBuilderMixin, LLMSelectionMixin,
                 }
 
             state.errors.append(error_text)
-            if getattr(self, "_write_snapshots", None):
-                try:
-                    await self._rollback_writes(on_step)
-                except Exception as rollback_error:
-                    state.errors.append(str(rollback_error)[:500])
-                    _logger.error("[unified_loop] rollback inatteso incompleto: %s", rollback_error)
             previous = state.state_machine.current
             if previous != AgentState.FAILED:
                 try:
@@ -3739,12 +3714,6 @@ class UnifiedAgentLoop(DirectToolsMixin, PromptBuilderMixin, LLMSelectionMixin,
 
         async def _finish(result: dict[str, Any]) -> dict[str, Any]:
             next_state = AgentState.COMPLETED if result.get("success", True) else AgentState.FAILED
-            if next_state == AgentState.FAILED and getattr(self, "_write_snapshots", None):
-                try:
-                    await self._rollback_writes(on_step)
-                except Exception as rollback_error:
-                    result.setdefault("errors", []).append(str(rollback_error)[:500])
-                    result["rollback_incomplete"] = True
             try:
                 await self._transition_state(state, next_state, on_step)
             finally:

api/background_tasks.py

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

api/event_store.py

@@ -4,7 +4,7 @@ backend/api/event_store.py — Event Store (persistenza, Fase 1 ADR-S26-S30)
 Responsabilità: SALVARE tutti gli eventi per replayability, debugging, benchmark.
 NON instrada — per pub/sub usa event_bus.py.
 
-Schema Supabase (tabella `event_store`, creata dalla migration versionata):
+Schema Supabase (tabella `event_store`, auto-created se non esiste):
   id             UUID      PK default gen_random_uuid()
   topic          TEXT      NOT NULL
   payload        JSONB     NOT NULL default '{}'
@@ -40,24 +40,25 @@ router = APIRouter(
 
 _TABLE = "event_store"
 
-# ── Schema probe (la creazione è gestita esclusivamente dalle migration) ────────
+# ── Auto-create table (best-effort, richiede service role key) ─────────────────
 
 _TABLE_CREATED = False
 
 async def _ensure_table() -> bool:
-    """Verifica che la tabella event_store creata dalla migration sia raggiungibile."""
+    """Crea la tabella event_store su Supabase se non esiste. Best-effort."""
     global _TABLE_CREATED
     if _TABLE_CREATED:
         return True
     if not _sb:
         return False
     try:
-        # La tabella deve esistere: il client runtime non esegue DDL.
+        # Prova una SELECT — se la tabella non esiste, Supabase ritorna un errore
         res = _sb.table(_TABLE).select("id").limit(1).execute()
         _TABLE_CREATED = True
         return True
     except Exception as exc:
-        _logger.warning("[event_store] tabella '%s' non raggiungibile: %s", _TABLE, exc)
+        _logger.warning("[event_store] tabella '%s' non raggiungibile: %s — "
+                        "crea manualmente con migration Supabase", _TABLE, exc)
         return False
 
 
@@ -90,8 +91,9 @@ async def store_event(req: StoreEventRequest) -> StoredEvent:
     Chiamato automaticamente dall'event_bus (via hook) o esplicitamente
     dai componenti che vogliono garantire persistenza.
     """
-    if not await _ensure_table():
-        raise HTTPException(503, detail="Event Store non disponibile (schema Supabase assente o non raggiungibile)")
+    await _ensure_table()
+    if not _sb:
+        raise HTTPException(503, detail="Event Store non disponibile (Supabase non configurato)")
 
     record = {
         "topic":          req.topic,
@@ -130,8 +132,9 @@ async def replay_events(
     Recupera eventi filtrati dall'Event Store. Supporta replay per debugging,
     test di regressione e audit trail.
     """
-    if not await _ensure_table():
-        raise HTTPException(503, detail="Event Store non disponibile (schema Supabase assente o non raggiungibile)")
+    await _ensure_table()
+    if not _sb:
+        raise HTTPException(503, detail="Event Store non disponibile")
 
     try:
         q = _sb.table(_TABLE).select("*").order("created_at", desc=True).limit(limit)
@@ -157,35 +160,19 @@ async def replay_events(
         raise HTTPException(500, detail=f"Event Store query error: {exc}")
 
 
-@router.get("/store/status", summary="Diagnostica Event Store")
-async def store_status():
-    """Verifica connettività dello store e restituisce statistiche."""
-    if not await _ensure_table():
-        return {"status": "unavailable", "reason": "schema event_store assente o non raggiungibile"}
-    try:
-        res = _sb.table(_TABLE).select("topic", count="exact").execute()
-        total = res.count if hasattr(res, "count") and res.count else len(res.data or [])
-        return {
-            "status":     "ok",
-            "component":  "event_store",
-            "total_events": total,
-            "table":      _TABLE,
-        }
-    except Exception as exc:
-        return {"status": "error", "detail": str(exc)}
-@router.get("/store/{event_id:uuid}", summary="Recupera evento singolo")
-async def get_event(event_id: uuid.UUID) -> StoredEvent:
+@router.get("/store/{event_id}", summary="Recupera evento singolo")
+async def get_event(event_id: str) -> StoredEvent:
     """Recupera un evento specifico per ID."""
-    if not await _ensure_table():
-        raise HTTPException(503, detail="Event Store non disponibile (schema Supabase assente o non raggiungibile)")
+    await _ensure_table()
+    if not _sb:
+        raise HTTPException(503, detail="Event Store non disponibile")
     try:
-        event_id_str = str(event_id)
-        res = _sb.table(_TABLE).select("*").eq("id", event_id_str).limit(1).execute()
+        res = _sb.table(_TABLE).select("*").eq("id", event_id).limit(1).execute()
         if not res.data:
             raise HTTPException(404, detail=f"Evento {event_id} non trovato")
         row = res.data[0]
         return StoredEvent(**{
-            "id":             row.get("id", str(event_id)),
+            "id":             row.get("id", event_id),
             "topic":          row.get("topic", ""),
             "payload":        row.get("payload", {}),
             "correlation_id": row.get("correlation_id"),
@@ -199,3 +186,19 @@ async def get_event(event_id: uuid.UUID) -> StoredEvent:
         raise HTTPException(500, detail=f"Event Store get error: {exc}")
 
 
+@router.get("/store/status", summary="Diagnostica Event Store")
+async def store_status():
+    """Verifica connettività dello store e restituisce statistiche."""
+    if not _sb:
+        return {"status": "unavailable", "reason": "Supabase non configurato"}
+    try:
+        res = _sb.table(_TABLE).select("topic", count="exact").execute()
+        total = res.count if hasattr(res, "count") and res.count else len(res.data or [])
+        return {
+            "status":     "ok",
+            "component":  "event_store",
+            "total_events": total,
+            "table":      _TABLE,
+        }
+    except Exception as exc:
+        return {"status": "error", "detail": str(exc)}

api/job_queue.py

@@ -355,11 +355,11 @@ async def _hands_consumer_loop() -> None:
                 continue
 
             # Esegui in background — non blocca il loop consumer
-            from api.background_tasks import spawn_background_task
-            task_id = str(job.get("taskId") or uuid.uuid4())
-            spawn_background_task(
-                _execute_queued_job(job), name=f"job-queue-execution:{task_id}"
-            )
+            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)
@@ -377,15 +377,18 @@ async def start_job_queue_consumer() -> None:
         return
 
     # Load publisher su tutti gli Space
-    from api.background_tasks import spawn_background_task
-    spawn_background_task(_load_publisher_loop(), name="job-queue-load-publisher")
+    def _log_jq_exc(t):
+        if not t.cancelled() and t.exception():
+            _logger.warning("[job_queue] bg loop raised: %s", t.exception())
+
+    asyncio.create_task(_load_publisher_loop()).add_done_callback(_log_jq_exc)
 
     # Consumer per tutti i ruoli worker o legacy 'hands'
     _IS_WORKER = _SPACE_ROLE.startswith("worker-") or _SPACE_ROLE in ("hands", "unknown")
     
     if _IS_WORKER:
         _logger.info("[jq] Avvio consumer loop per ruolo worker: %s", _SPACE_ROLE)
-        spawn_background_task(_hands_consumer_loop(), name="job-queue-hands-consumer")
+        asyncio.create_task(_hands_consumer_loop()).add_done_callback(_log_jq_exc)
     else:
         _logger.info("[jq] SPACE_ROLE=%s — consumer non avviato (ruolo non worker)", _SPACE_ROLE)
 

api/providers.py

@@ -250,13 +250,8 @@ async def ai_provider_readiness(role: AuthRole = Depends(require_role(AuthRole.M
 
 
 @router.get('/api/ai/health')
-async def ai_provider_health(role: AuthRole = Depends(require_role(AuthRole.OPERATOR))):
-    """Restituisce diagnostica dettagliata dei provider ai soli operatori autorizzati.
-
-    Il payload contiene profili, modelli, classi di errore e dati di quota upstream;
-    non deve quindi essere reso disponibile al browser tramite il token interno del
-    proxy. Il controllo pubblico di disponibilità resta `/api/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:
         return _ai_health_cache["data"]

api/public_snapshot.py

@@ -55,14 +55,9 @@ from .version import RUNTIME_VERSION
 
 _logger = logging.getLogger("agente_ai.public_snapshot")
 
-_SNAPSHOT_ATTEMPTS = 3
-_SNAPSHOT_ATTEMPT_TIMEOUT_SECONDS = 4.0
-_SNAPSHOT_RETRY_DELAY_SECONDS = 1.0
-_SNAPSHOT_TOTAL_BUDGET_SECONDS = (
-    _SNAPSHOT_ATTEMPTS * _SNAPSHOT_ATTEMPT_TIMEOUT_SECONDS
-    + (_SNAPSHOT_ATTEMPTS - 1) * _SNAPSHOT_RETRY_DELAY_SECONDS
-)
 _ACTIVE_STATUSES = {"RUNNING", "IN_PROGRESS", "EXECUTING", "PROCESSING"}
+
+
 def _snapshot_row() -> dict[str, Any]:
     tasks = list(_agent_tasks.values())
     return {
@@ -93,12 +88,9 @@ async def write_public_dashboard_snapshot() -> bool:
         client.table("public_dashboard_snapshot").upsert(row, on_conflict="singleton").execute()
 
     last_error: Exception | None = None
-    for attempt in range(1, _SNAPSHOT_ATTEMPTS + 1):
+    for attempt in range(1, 4):
         try:
-            await asyncio.wait_for(
-                asyncio.to_thread(operation),
-                timeout=_SNAPSHOT_ATTEMPT_TIMEOUT_SECONDS,
-            )
+            await asyncio.to_thread(operation)
             _logger.info(
                 "BOOT: public snapshot upserted status=%s sessions=%d queued=%d in_progress=%d version=%s",
                 row["service_status"], row["active_sessions"], row["queued_tasks"],
@@ -107,8 +99,8 @@ async def write_public_dashboard_snapshot() -> bool:
             return True
         except Exception as exc:
             last_error = exc
-            if attempt < _SNAPSHOT_ATTEMPTS:
-                await asyncio.sleep(_SNAPSHOT_RETRY_DELAY_SECONDS)
+            if attempt < 3:
+                await asyncio.sleep(2)
 
     error_code = getattr(last_error, "code", None) or getattr(last_error, "status_code", None)
     _logger.warning(

api/speculative.py

@@ -117,8 +117,8 @@ def _prune_cache() -> None:
 
 # S388: Groq client singleton per speculative — evita new OpenAI() per ogni task.
 _spec_groq_client: Any = None
-_SPEC_GROQ_MAX_CONCURRENCY = 4
-_spec_groq_semaphore = asyncio.Semaphore(_SPEC_GROQ_MAX_CONCURRENCY)
+
+
 def _get_spec_groq_client() -> Any:
     global _spec_groq_client
     if _spec_groq_client is not None:
@@ -127,8 +127,8 @@ def _get_spec_groq_client() -> Any:
     if not groq_key:
         return None
     try:
-        from openai import AsyncOpenAI
-        _spec_groq_client = AsyncOpenAI(
+        from openai import OpenAI
+        _spec_groq_client = OpenAI(
             api_key=groq_key,
             base_url="https://api.groq.com/openai/v1",
             timeout=3.0,
@@ -137,6 +137,8 @@ def _get_spec_groq_client() -> Any:
     except Exception:
         _spec_groq_client = None
     return _spec_groq_client
+
+
 async def _extract_tools_fast(goal: str) -> list[dict]:
     """
     Usa Groq openai/gpt-oss-20b per estrarre tool calls in ~300ms.
@@ -149,16 +151,16 @@ async def _extract_tools_fast(goal: str) -> list[dict]:
         if not client:
             return []
         prompt = _EXTRACTION_PROMPT.format(message=goal[:500])
-        async with _spec_groq_semaphore:
-            resp = await asyncio.wait_for(
-                client.chat.completions.create(
-                    model="openai/gpt-oss-20b",
-                    messages=[{"role": "user", "content": prompt}],
-                    temperature=0.0,
-                    max_tokens=400,  # S587: 256→400 — JSON array da goal[:500] supera 256 tok
-                ),
-                timeout=3.0,
-            )
+        resp = await asyncio.wait_for(
+            asyncio.to_thread(
+                client.chat.completions.create,
+                model="openai/gpt-oss-20b",
+                messages=[{"role": "user", "content": prompt}],
+                temperature=0.0,
+                max_tokens=400,  # S587: 256→400 — JSON array da goal[:500] supera 256 tok
+            ),
+            timeout=3.0,
+        )
         raw = (resp.choices[0].message.content or "").strip()
         # Estrai JSON array anche se ci sono prefissi di testo
         start = raw.find("[")

api/state.py

@@ -139,11 +139,6 @@ _CHECKPOINT_TTL_MS = 2 * 60 * 60 * 1000
 _CHECKPOINT_MAX    = 100
 _AGENT_TASK_TTL_MS = 2 * 60 * 60 * 1000
 _AGENT_TASK_MAX    = 200
-# All statuses that represent a finished task and can therefore expire from the
-# bounded in-memory store. Keep this set aligned with API lifecycle writers.
-_AGENT_TASK_TERMINAL_STATES: frozenset[str] = frozenset({
-    'SUCCESS', 'COMPLETED', 'ERROR', 'CANCELLED', 'RATE_LIMITED',
-})
 
 # ── Telemetry & Health ────────────────────────────────────────────────────────
 _ai_health_cache: dict = {"data": None, "at": 0.0}
@@ -249,7 +244,7 @@ def _prune_checkpoints() -> None:
 def _prune_agent_tasks() -> None:
     now = int(time.time() * 1000)
     expired = [k for k, v in list(_agent_tasks.items())
-               if v.get('status') in _AGENT_TASK_TERMINAL_STATES
+               if v.get('status') in ('SUCCESS', 'ERROR', 'CANCELLED')
                and now - v.get('created_at', 0) > _AGENT_TASK_TTL_MS]
     for k in expired:
         _agent_tasks.pop(k, None)

cors_policy.py

@@ -1,61 +0,0 @@
-"""CORS policy shared by the FastAPI entrypoint.
-
-The backend authenticates browser calls with explicit bearer/internal headers,
-not with ambient browser cookies. Credentials therefore remain disabled unless
-an explicit future policy requires them.
-"""
-from __future__ import annotations
-
-import os
-from urllib.parse import urlsplit
-
-PUBLIC_FRONTEND_ORIGIN = "https://agente-ai.pages.dev"
-_DEVELOPMENT_ORIGINS = frozenset(
-    {
-        "http://localhost:3000",
-        "http://localhost:5173",
-        "http://127.0.0.1:3000",
-        "http://127.0.0.1:5173",
-    }
-)
-_DEVELOPMENT_ENVS = frozenset({"dev", "development", "local", "test"})
-
-
-def _is_valid_origin(origin: str) -> bool:
-    """Return True only for an exact HTTP(S) origin without path or wildcard."""
-    if not origin or origin == "*" or any(char.isspace() for char in origin):
-        return False
-    parsed = urlsplit(origin)
-    return bool(
-        parsed.scheme in {"http", "https"}
-        and parsed.netloc
-        and not parsed.username
-        and not parsed.password
-        and not parsed.path
-        and not parsed.query
-        and not parsed.fragment
-    )
-
-
-def allowed_origins(raw: str | None = None, environment: str | None = None) -> list[str]:
-    """Build the exact CORS allow-list from environment and safe defaults.
-
-    ``CORS_ALLOWED_ORIGINS`` is a comma-separated list of exact origins. An
-    invalid value, including ``*``, is ignored rather than widening access.
-    Local development origins are enabled only for an explicit development or
-    test environment. The production default is the canonical Pages origin.
-    """
-    configured = raw if raw is not None else os.getenv("CORS_ALLOWED_ORIGINS", "")
-    origins = [
-        origin.strip().rstrip("/")
-        for origin in configured.split(",")
-        if origin.strip()
-    ]
-    valid = {origin for origin in origins if _is_valid_origin(origin)}
-
-    env_name = (environment if environment is not None else os.getenv("APP_ENV", os.getenv("ENVIRONMENT", ""))).strip().lower()
-    if not valid:
-        valid.add(PUBLIC_FRONTEND_ORIGIN)
-    if env_name in _DEVELOPMENT_ENVS:
-        valid.update(_DEVELOPMENT_ORIGINS)
-    return sorted(valid)

main.py

@@ -10,7 +10,6 @@ from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
 from api.version import RUNTIME_VERSION
-from cors_policy import allowed_origins
 
 # Configurazione Logging
 logging.basicConfig(
@@ -26,14 +25,13 @@ app = FastAPI(
     version=RUNTIME_VERSION,
 )
 
-# CORS: whitelist esatta e fail-closed. Il frontend usa bearer/internal headers,
-# non cookie cross-origin; le credenziali browser restano quindi disabilitate.
+# CORS
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=allowed_origins(),
-    allow_credentials=False,
-    allow_methods=["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"],
-    allow_headers=["Authorization", "Content-Type", "X-Internal-Token", "X-Requested-With"],
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
 )
 
 # ── P17-F1: RLS Fix & Auto-Migration ──────────────────────────────────────────
@@ -246,20 +244,6 @@ async def run_cli_task(task_description: str):
         sys.exit(1)
 
 # ── Startup ───────────────────────────────────────────────────────────────────
-async def _snapshot_heartbeat() -> None:
-    """Keep the public dashboard snapshot fresh without affecting request handling."""
-    from api.public_snapshot import refresh_public_dashboard_snapshot
-
-    while True:
-        await asyncio.sleep(30)
-        try:
-            await asyncio.wait_for(refresh_public_dashboard_snapshot(), timeout=15.0)
-        except asyncio.CancelledError:
-            raise
-        except Exception as exc:
-            _logger.debug("Public snapshot heartbeat failed (non-blocking): %s", exc)
-
-
 @app.on_event("startup")
 async def startup_event():
     _logger.info("Server starting up...")
@@ -269,26 +253,16 @@ async def startup_event():
         _logger.info("✅ BOOT: apply_rls_fix_sync() eseguito con successo.")
     except Exception as e:
         _logger.warning(f"⚠️ BOOT: apply_rls_fix_sync() fallito (non bloccante): {e}")
-    # Schema e RLS sono gestiti dalle migrazioni versionate Supabase.
-    # Non avviare auto-migrazioni in background: il boot deve restare
-    # deterministico e non può dichiarare successo prima della migrazione.
+    asyncio.create_task(_run_auto_migration())
     try:
         from api.public_snapshot import write_public_dashboard_snapshot
-        snapshot_ok = await asyncio.wait_for(write_public_dashboard_snapshot(), timeout=15.0)
+        snapshot_ok = await asyncio.wait_for(write_public_dashboard_snapshot(), timeout=12.0)
         if snapshot_ok:
             _logger.info("✅ BOOT: public dashboard snapshot writer completato.")
         else:
             _logger.warning("⚠️ BOOT: public dashboard snapshot writer non ha persistito lo snapshot.")
     except Exception as e:
         _logger.warning(f"⚠️ BOOT: avvio public snapshot writer fallito (non bloccante): {e}")
-    try:
-        from api.background_tasks import spawn_background_task
-        from api.telemetry import telemetry_alert_loop
-        spawn_background_task(telemetry_alert_loop(), name="telemetry-alert-loop")
-        spawn_background_task(_snapshot_heartbeat(), name="public-snapshot-heartbeat")
-        _logger.info("✅ BOOT: telemetry e snapshot loops supervisionati.")
-    except Exception as e:
-        _logger.warning(f"⚠️ BOOT: avvio telemetry/snapshot loops fallito (non bloccante): {e}")
     try:
         from api.providers import start_heartbeat
         start_heartbeat()
@@ -297,24 +271,9 @@ async def startup_event():
         _logger.warning(f"⚠️ BOOT: avvio provider heartbeat fallito (non bloccante): {e}")
     if not any(arg in sys.argv for arg in ["--task", "-t"]):
         try:
-            from api.background_tasks import spawn_background_task
             from api.job_queue import start_job_queue_consumer
-            spawn_background_task(
-                start_job_queue_consumer(), name="job-queue-consumer-supervisor"
-            )
-        except Exception as e:
-            _logger.warning("⚠️ BOOT: avvio job queue fallito (non bloccante): %s", e)
-
-
-@app.on_event("shutdown")
-async def shutdown_event():
-    """Cancel and await all registered background tasks before loop shutdown."""
-    try:
-        from api.background_tasks import shutdown_background_tasks
-        await shutdown_background_tasks()
-        _logger.info("✅ SHUTDOWN: background tasks supervisionate arrestate.")
-    except Exception as e:
-        _logger.warning("⚠️ SHUTDOWN: arresto background tasks incompleto: %s", e)
+            asyncio.create_task(start_job_queue_consumer())
+        except Exception: pass
 
 # ── SPA Hosting ────────────────────────────────────────────────────��──────────
 _STATIC_DIR = os.getenv('FRONTEND_DIST', '/app/backend/static')

scripts/lib/report-engine.mjs

@@ -0,0 +1,36 @@
+import { mkdirSync, renameSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+const DEFAULT_REPORT_DIRECTORY = "/tmp/agente-ai";
+
+function safeSegment(value) {
+  return String(value ?? "benchmark")
+    .trim()
+    .replace(/[^a-zA-Z0-9._-]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 96) || "benchmark";
+}
+
+/**
+ * Persiste un artefatto diagnostico del runner senza incidere sui calcoli.
+ * Il write-then-rename evita file JSON parziali in caso di interruzione.
+ */
+export function saveBenchmarkReport(reportName, payload) {
+  const reportDirectory = resolve(process.env.BENCHMARK_REPORT_DIR || DEFAULT_REPORT_DIRECTORY);
+  mkdirSync(reportDirectory, { recursive: true });
+
+  const safeName = safeSegment(reportName);
+  const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const finalPath = join(reportDirectory, `${safeName}-${stamp}.json`);
+  const temporaryPath = `${finalPath}.${process.pid}.tmp`;
+  const document = {
+    schemaVersion: "benchmark-report-v1",
+    generatedAt: new Date().toISOString(),
+    reportName: safeName,
+    ...payload,
+  };
+
+  writeFileSync(temporaryPath, `${JSON.stringify(document, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+  renameSync(temporaryPath, finalPath);
+  return finalPath;
+}

tests/test_agent_task_pruning.py

@@ -1,70 +0,0 @@
-import unittest
-from unittest.mock import patch
-
-import api.state as state
-
-
-_TERMINAL_STATES = (
-    "SUCCESS",
-    "COMPLETED",
-    "ERROR",
-    "CANCELLED",
-    "RATE_LIMITED",
-)
-
-
-class AgentTaskPruningTests(unittest.TestCase):
-    def test_prune_expires_every_terminal_state_and_cleans_byok(self):
-        now_ms = 10_000_000
-        old_ms = now_ms - state._AGENT_TASK_TTL_MS - 1
-        task_ids = {f"old-{status.lower()}" for status in _TERMINAL_STATES}
-        task_ids.update({"running", "queued"})
-        tasks = {
-            task_id: {
-                "status": (
-                    task_id.removeprefix("old-").upper()
-                    if task_id.startswith("old-")
-                    else task_id.upper()
-                ),
-                "created_at": old_ms,
-            }
-            for task_id in task_ids
-        }
-        byok_clients = {task_id: object() for task_id in task_ids}
-
-        with patch.object(state, "_agent_tasks", tasks), patch.object(
-            state, "_task_ai_clients", byok_clients
-        ), patch.object(state.time, "time", return_value=now_ms / 1000):
-            state._prune_agent_tasks()
-            self.assertEqual(set(state._agent_tasks), {"running", "queued"})
-            self.assertEqual(set(state._task_ai_clients), {"running", "queued"})
-
-    def test_prune_keeps_recent_terminal_tasks(self):
-        now_ms = 10_000_000
-        recent_ms = now_ms - state._AGENT_TASK_TTL_MS + 1
-        tasks = {
-            status.lower(): {"status": status, "created_at": recent_ms}
-            for status in _TERMINAL_STATES
-        }
-
-        with patch.object(state, "_agent_tasks", tasks), patch.object(
-            state, "_task_ai_clients", {}
-        ), patch.object(state.time, "time", return_value=now_ms / 1000):
-            state._prune_agent_tasks()
-            self.assertEqual(
-                set(state._agent_tasks),
-                {status.lower() for status in _TERMINAL_STATES},
-            )
-
-    def test_terminal_state_set_matches_pruning_contract(self):
-        self.assertEqual(
-            state._AGENT_TASK_TERMINAL_STATES,
-            frozenset(_TERMINAL_STATES),
-        )
-        self.assertNotIn("QUEUED", state._AGENT_TASK_TERMINAL_STATES)
-        self.assertNotIn("RUNNING", state._AGENT_TASK_TERMINAL_STATES)
-        self.assertNotIn("CREATING", state._AGENT_TASK_TERMINAL_STATES)
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_ai_provider_health_access.py

@@ -1,83 +0,0 @@
-"""Regressioni di accesso alla diagnostica dettagliata dei provider.
-
-Esegui con: python3 -m unittest backend.tests.test_ai_provider_health_access -v
-"""
-from __future__ import annotations
-
-import os
-import sys
-import time
-import unittest
-from unittest.mock import patch
-
-from fastapi import FastAPI
-from fastapi.testclient import TestClient
-
-_BACKEND = os.path.join(os.path.dirname(__file__), "..")
-if _BACKEND not in sys.path:
-    sys.path.insert(0, _BACKEND)
-
-from api import auth_guard, providers
-
-
-class TestAIProviderHealthAccess(unittest.TestCase):
-    """Il payload con profili, quote e dettagli upstream è solo per OPERATOR."""
-
-    @classmethod
-    def setUpClass(cls) -> None:
-        app = FastAPI()
-        app.include_router(providers.router)
-        cls.client = TestClient(app)
-
-    def setUp(self) -> None:
-        self.env_patch = patch.dict(
-            os.environ,
-            {
-                "INTERNAL_TOKEN": "test-internal-token",
-                "OPERATOR_TOKEN": "test-operator-token",
-            },
-            clear=False,
-        )
-        self.env_patch.start()
-        self.previous_health_cache = dict(providers._ai_health_cache)
-        auth_guard._rate_store.clear()
-        auth_guard._rate_store_checks = 0
-
-    def tearDown(self) -> None:
-        self.env_patch.stop()
-        providers._ai_health_cache.clear()
-        providers._ai_health_cache.update(self.previous_health_cache)
-        auth_guard._rate_store.clear()
-        auth_guard._rate_store_checks = 0
-
-    def test_anonymous_browser_cannot_request_detailed_provider_diagnostics(self) -> None:
-        response = self.client.get("/api/ai/health")
-
-        self.assertEqual(response.status_code, 403)
-        self.assertEqual(response.json()["detail"]["required_role"], "OPERATOR")
-
-    def test_proxy_machine_token_cannot_escalate_browser_to_provider_diagnostics(self) -> None:
-        response = self.client.get(
-            "/api/ai/health",
-            headers={"X-Internal-Token": "test-internal-token"},
-        )
-
-        self.assertEqual(response.status_code, 403)
-        self.assertEqual(response.json()["detail"]["your_role"], "MACHINE")
-        self.assertEqual(response.json()["detail"]["required_role"], "OPERATOR")
-
-    def test_operator_can_read_cached_diagnostics_without_triggering_a_probe(self) -> None:
-        providers._ai_health_cache["data"] = {"providers": [], "tested_at": 1}
-        providers._ai_health_cache["at"] = time.monotonic()
-
-        response = self.client.get(
-            "/api/ai/health",
-            headers={"X-Operator-Token": "test-operator-token"},
-        )
-
-        self.assertEqual(response.status_code, 200)
-        self.assertEqual(response.json(), {"providers": [], "tested_at": 1})
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_background_tasks.py

@@ -1,57 +0,0 @@
-import asyncio
-import unittest
-
-from api import background_tasks
-
-
-class BackgroundTaskSupervisorTests(unittest.IsolatedAsyncioTestCase):
-    async def asyncSetUp(self):
-        await background_tasks.shutdown_background_tasks()
-
-    async def asyncTearDown(self):
-        await background_tasks.shutdown_background_tasks()
-
-    async def test_duplicate_name_reuses_task_and_closes_duplicate_coroutine(self):
-        started = asyncio.Event()
-        release = asyncio.Event()
-
-        async def worker():
-            started.set()
-            await release.wait()
-
-        first = background_tasks.spawn_background_task(worker(), name="duplicate")
-        await started.wait()
-        duplicate = background_tasks.spawn_background_task(worker(), name="duplicate")
-        self.assertIs(first, duplicate)
-        release.set()
-        await background_tasks.shutdown_background_tasks()
-        self.assertTrue(first.done())
-
-    async def test_shutdown_cancels_and_awaits_running_task(self):
-        cancelled = asyncio.Event()
-
-        async def worker():
-            try:
-                await asyncio.Event().wait()
-            except asyncio.CancelledError:
-                cancelled.set()
-                raise
-
-        background_tasks.spawn_background_task(worker(), name="cancellable")
-        await asyncio.sleep(0)
-        await background_tasks.shutdown_background_tasks()
-        self.assertTrue(cancelled.is_set())
-        self.assertFalse(background_tasks._tasks)
-
-    async def test_completed_task_is_not_left_in_registry_after_shutdown(self):
-        async def worker():
-            return "ok"
-
-        task = background_tasks.spawn_background_task(worker(), name="completed")
-        await task
-        await background_tasks.shutdown_background_tasks()
-        self.assertFalse(background_tasks._tasks)
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_cors_policy.py

@@ -1,65 +0,0 @@
-from __future__ import annotations
-
-import unittest
-
-from fastapi import FastAPI
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.testclient import TestClient
-
-from cors_policy import PUBLIC_FRONTEND_ORIGIN, allowed_origins
-
-
-class CorsPolicyTests(unittest.TestCase):
-    def test_production_defaults_to_canonical_frontend_only(self) -> None:
-        self.assertEqual(allowed_origins(raw="", environment="production"), [PUBLIC_FRONTEND_ORIGIN])
-
-    def test_custom_origins_are_exact_and_wildcards_are_ignored(self) -> None:
-        origins = allowed_origins(
-            raw=" https://agente-ai.pages.dev/ , * , https://evil.example/path , http://localhost:5173 ",
-            environment="production",
-        )
-        self.assertEqual(origins, ["http://localhost:5173", PUBLIC_FRONTEND_ORIGIN])
-
-    def test_local_origins_are_available_only_in_development(self) -> None:
-        production = allowed_origins(raw="", environment="production")
-        development = allowed_origins(raw="", environment="development")
-        self.assertNotIn("http://localhost:5173", production)
-        self.assertIn("http://localhost:5173", development)
-
-    def test_invalid_configuration_fails_closed_to_public_default(self) -> None:
-        self.assertEqual(allowed_origins(raw="*", environment="production"), [PUBLIC_FRONTEND_ORIGIN])
-
-    def test_middleware_rejects_untrusted_origin_and_does_not_allow_credentials(self) -> None:
-        app = FastAPI()
-        app.add_middleware(
-            CORSMiddleware,
-            allow_origins=allowed_origins(raw=PUBLIC_FRONTEND_ORIGIN, environment="production"),
-            allow_credentials=False,
-            allow_methods=["GET", "OPTIONS"],
-            allow_headers=["Authorization", "Content-Type"],
-        )
-
-        @app.get("/health")
-        def health() -> dict[str, str]:
-            return {"status": "ok"}
-
-        client = TestClient(app)
-        trusted = client.get("/health", headers={"Origin": PUBLIC_FRONTEND_ORIGIN})
-        untrusted = client.get("/health", headers={"Origin": "https://audit-origin.invalid"})
-        preflight = client.options(
-            "/health",
-            headers={
-                "Origin": "https://audit-origin.invalid",
-                "Access-Control-Request-Method": "GET",
-                "Access-Control-Request-Headers": "authorization",
-            },
-        )
-
-        self.assertEqual(trusted.headers.get("access-control-allow-origin"), PUBLIC_FRONTEND_ORIGIN)
-        self.assertNotIn("access-control-allow-credentials", trusted.headers)
-        self.assertNotIn("access-control-allow-origin", untrusted.headers)
-        self.assertNotEqual(preflight.headers.get("access-control-allow-origin"), "https://audit-origin.invalid")
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_executor_side_effect_retry.py

@@ -1,91 +0,0 @@
-from __future__ import annotations
-
-import unittest
-from unittest.mock import patch
-
-from agents import executor as executor_module
-from agents.executor import Executor
-
-
-class FailingMemory:
-    async def save_episode(self, *_args, **_kwargs) -> None:
-        raise RuntimeError("memory unavailable")
-
-
-class RecordingMemory:
-    def __init__(self) -> None:
-        self.calls = 0
-
-    async def save_episode(self, *_args, **_kwargs) -> None:
-        self.calls += 1
-
-
-class ExecutorSideEffectRetryTests(unittest.IsolatedAsyncioTestCase):
-    async def test_memory_failure_does_not_retry_completed_side_effect(self) -> None:
-        calls = 0
-
-        async def non_idempotent_tool(**_inputs):
-            nonlocal calls
-            calls += 1
-            return {"created_id": "resource-1"}
-
-        with patch.dict(
-            executor_module.TOOL_REGISTRY,
-            {"non_idempotent_tool": {"required_inputs": [], "fallbacks": [], "_fn": non_idempotent_tool}},
-            clear=False,
-        ):
-            result = await Executor(llm_client=object(), memory=FailingMemory(), max_retries=2).run_tool(
-                "non_idempotent_tool", {}, timeout=2, worker_hint="test",
-            )
-
-        self.assertTrue(result["success"])
-        self.assertEqual(result["attempt"], 1)
-        self.assertEqual(calls, 1)
-        self.assertFalse(result["memory_persisted"])
-        self.assertIn("memory unavailable", result["memory_error"])
-
-    async def test_tool_failure_still_retries_before_any_side_effect_result(self) -> None:
-        calls = 0
-
-        async def flaky_tool(**_inputs):
-            nonlocal calls
-            calls += 1
-            if calls == 1:
-                raise RuntimeError("transient tool failure")
-            return {"ok": True}
-
-        with patch.dict(
-            executor_module.TOOL_REGISTRY,
-            {"flaky_tool": {"required_inputs": [], "fallbacks": [], "_fn": flaky_tool}},
-            clear=False,
-        ):
-            result = await Executor(llm_client=object(), memory=None, max_retries=2).run_tool(
-                "flaky_tool", {}, timeout=2, worker_hint="test",
-            )
-
-        self.assertTrue(result["success"])
-        self.assertEqual(result["attempt"], 2)
-        self.assertEqual(calls, 2)
-
-    async def test_successful_memory_persistence_is_reported(self) -> None:
-        memory = RecordingMemory()
-
-        async def safe_tool(**_inputs):
-            return "done"
-
-        with patch.dict(
-            executor_module.TOOL_REGISTRY,
-            {"safe_tool": {"required_inputs": [], "fallbacks": [], "_fn": safe_tool}},
-            clear=False,
-        ):
-            result = await Executor(llm_client=object(), memory=memory, max_retries=0).run_tool(
-                "safe_tool", {}, timeout=2, worker_hint="test",
-            )
-
-        self.assertTrue(result["success"])
-        self.assertTrue(result["memory_persisted"])
-        self.assertEqual(memory.calls, 1)
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_model_watch_adapter.py

@@ -171,14 +171,14 @@ class GeminiModelsAdapterTests(unittest.IsolatedAsyncioTestCase):
             provider="gemini",
             profile=profile,
             base_url="https://generativelanguage.googleapis.com/v1beta",
-            api_key="x",
+            api_key="gemini-secret-not-logged",
             default_model=default_model,
             auth_mode="query_key",
         )
 
     async def test_native_models_payload_is_parsed_and_prefix_removed(self):
         async def handler(request):
-            self.assertEqual(request.url.params.get("key"), "x")
+            self.assertEqual(request.url.params.get("key"), "gemini-secret-not-logged")
             return httpx.Response(200, json={"models": [
                 {"name": "models/gemini-3.6-flash"},
                 {"name": "models/gemini-3.5-flash"},

tests/test_public_snapshot_writer.py

@@ -4,14 +4,10 @@ from api import public_snapshot
 
 
 class _FakeTable:
-    def __init__(self, calls, failures=0):
+    def __init__(self, calls):
         self.calls = calls
-        self.failures = failures
 
     def upsert(self, row, on_conflict=None):
-        if self.failures:
-            self.failures -= 1
-            raise RuntimeError("temporary Supabase failure")
         self.calls.append((row, on_conflict))
         return self
 
@@ -20,22 +16,17 @@ class _FakeTable:
 
 
 class _FakeClient:
-    def __init__(self, failures=0):
+    def __init__(self):
         self.calls = []
-        self.failures = failures
 
     def table(self, name):
         assert name == "public_dashboard_snapshot"
-        return _FakeTable(self.calls, self.failures)
-
-
-def _run(coro):
-    return asyncio.run(coro)
+        return _FakeTable(self.calls)
 
 
 def test_snapshot_writer_is_idempotent_and_counts_runtime_state(monkeypatch):
     fake = _FakeClient()
-    monkeypatch.setattr(public_snapshot, "get_snapshot_client", lambda: fake)
+    monkeypatch.setattr(public_snapshot, "sb", lambda: fake)
     monkeypatch.setattr(
         public_snapshot,
         "_agent_tasks",
@@ -47,8 +38,8 @@ def test_snapshot_writer_is_idempotent_and_counts_runtime_state(monkeypatch):
     )
     monkeypatch.setattr(public_snapshot, "_loop_registry", {"session-1": object()})
 
-    assert _run(public_snapshot.write_public_dashboard_snapshot()) is True
-    assert _run(public_snapshot.write_public_dashboard_snapshot()) is True
+    assert asyncio.run(public_snapshot.write_public_dashboard_snapshot()) is True
+    assert asyncio.run(public_snapshot.write_public_dashboard_snapshot()) is True
 
     assert len(fake.calls) == 2
     first, second = fake.calls
@@ -62,34 +53,6 @@ def test_snapshot_writer_is_idempotent_and_counts_runtime_state(monkeypatch):
     assert first[0]["service_status"] == "operational"
 
 
-def test_snapshot_writer_retries_transient_failure(monkeypatch):
-    calls = []
-
-    class _RetryTable:
-        def upsert(self, row, on_conflict=None):
-            calls.append((row, on_conflict))
-            if len(calls) < 3:
-                raise RuntimeError("temporary Supabase failure")
-            return self
-
-        def execute(self):
-            return object()
-
-    class _RetryClient:
-        def table(self, name):
-            assert name == "public_dashboard_snapshot"
-            return _RetryTable()
-
-    monkeypatch.setattr(public_snapshot, "get_snapshot_client", lambda: _RetryClient())
-    async def _no_sleep(_seconds):
-        return None
-
-    monkeypatch.setattr(public_snapshot.asyncio, "sleep", _no_sleep)
-
-    assert _run(public_snapshot.write_public_dashboard_snapshot()) is True
-    assert len(calls) == 3
-
-
-def test_snapshot_writer_returns_false_when_supabase_is_unavailable(monkeypatch):
-    monkeypatch.setattr(public_snapshot, "get_snapshot_client", lambda: None)
-    assert _run(public_snapshot.write_public_dashboard_snapshot()) is False
+def test_snapshot_writer_is_non_blocking_when_supabase_is_unavailable(monkeypatch):
+    monkeypatch.setattr(public_snapshot, "sb", lambda: None)
+    assert asyncio.run(public_snapshot.write_public_dashboard_snapshot()) is False

tests/test_shell_safety_pip.py

@@ -1,32 +0,0 @@
-"""Regression tests for the generic shell package-manager boundary."""
-from __future__ import annotations
-import unittest
-
-from tools._shell_safety import validate_shell_command
-
-
-class TestPipBlockedFromGenericShell(unittest.TestCase):
-    def test_blocks_pip_install(self):
-        self.assertIsNotNone(validate_shell_command("pip install requests"))
-
-    def test_blocks_pip3_install(self):
-        self.assertIsNotNone(validate_shell_command("pip3 install requests"))
-
-    def test_blocks_python_module_pip(self):
-        self.assertIsNotNone(validate_shell_command("python -m pip install requests"))
-
-    def test_blocks_python3_module_pip3(self):
-        self.assertIsNotNone(validate_shell_command("python3 -m pip3 install requests"))
-
-    def test_blocks_python_module_ensurepip(self):
-        self.assertIsNotNone(validate_shell_command("python -m ensurepip"))
-
-    def test_allows_python_without_package_manager(self):
-        self.assertIsNone(validate_shell_command("python -c 'print(1)'"))
-
-    def test_allows_pnpm(self):
-        self.assertIsNone(validate_shell_command("pnpm --version"))
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_telemetry_alert_lifecycle.py

@@ -1,45 +0,0 @@
-import ast
-import pathlib
-import unittest
-
-
-_MAIN = pathlib.Path(__file__).parents[1] / "main.py"
-
-
-class TelemetryAlertLifecycleTests(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        cls.tree = ast.parse(_MAIN.read_text(encoding="utf-8"))
-        cls.source = _MAIN.read_text(encoding="utf-8")
-        cls.functions = {
-            node.name: node
-            for node in cls.tree.body
-            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
-        }
-
-    def test_startup_registers_named_telemetry_task(self):
-        startup = self.functions["startup_event"]
-        source = ast.get_source_segment(self.source, startup)
-        self.assertIn("telemetry_alert_loop", source)
-        self.assertIn('name="telemetry-alert-loop"', source)
-        self.assertIn("_telemetry_alert_task", source)
-
-    def test_shutdown_cancels_and_awaits_telemetry_task(self):
-        shutdown = self.functions["shutdown_event"]
-        source = ast.get_source_segment(self.source, shutdown)
-        self.assertIn("task.cancel()", source)
-        self.assertIn("await task", source)
-        self.assertIn("asyncio.CancelledError", source)
-
-    def test_task_reference_is_module_scoped(self):
-        assignment_names = {
-            target.id
-            for node in self.tree.body
-            if isinstance(node, ast.AnnAssign)
-            and isinstance(target := node.target, ast.Name)
-        }
-        self.assertIn("_telemetry_alert_task", assignment_names)
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_vfs_atomic_rollback.py

@@ -1,76 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import tempfile
-import unittest
-from pathlib import Path
-from unittest.mock import patch
-
-from agents.unified_loop import UnifiedAgentLoop
-from tools.registry import _delete_file, _read_file, _write_file
-
-
-class FakeExecutor:
-    def __init__(self, failures: set[str] | None = None) -> None:
-        self.calls: list[tuple[str, dict]] = []
-        self.failures = failures or set()
-
-    async def run_tool(self, name: str, inputs: dict, timeout: float = 30.0) -> dict:
-        self.calls.append((name, inputs))
-        if name in self.failures:
-            return {"success": False, "error": f"forced failure: {name}", "output": None}
-        return {"success": True, "output": {"ok": True}}
-
-
-class VfsAtomicRollbackTests(unittest.IsolatedAsyncioTestCase):
-    def make_loop(self, executor: FakeExecutor) -> UnifiedAgentLoop:
-        loop = UnifiedAgentLoop.__new__(UnifiedAgentLoop)
-        loop.executor = executor
-        loop._write_snapshots = {}
-        return loop
-
-    async def test_rollback_restores_existing_and_deletes_new_files(self) -> None:
-        executor = FakeExecutor()
-        loop = self.make_loop(executor)
-        loop._write_snapshots = {"existing.txt": "before", "created.txt": None}
-
-        await loop._rollback_writes()
-
-        self.assertEqual(
-            [(name, inputs) for name, inputs in executor.calls],
-            [
-                ("write_file", {"path": "existing.txt", "content": "before"}),
-                ("delete_file", {"path": "created.txt"}),
-            ],
-        )
-        self.assertEqual(loop._write_snapshots, {})
-
-    async def test_failed_restore_is_not_marked_clean(self) -> None:
-        executor = FakeExecutor({"write_file"})
-        loop = self.make_loop(executor)
-        loop._write_snapshots = {"existing.txt": "before", "created.txt": None}
-
-        with self.assertRaisesRegex(RuntimeError, "rollback incompleto"):
-            await loop._rollback_writes()
-
-        self.assertEqual(loop._write_snapshots, {"existing.txt": "before"})
-        self.assertEqual(executor.calls[1][0], "delete_file")
-
-    async def test_delete_file_respects_fs_jail_and_is_idempotent(self) -> None:
-        with tempfile.TemporaryDirectory() as root:
-            with patch.dict("os.environ", {"FS_TOOL_ROOT": root}, clear=False):
-                target = Path(root) / "created.txt"
-                target.write_text("created", encoding="utf-8")
-                deleted = await _delete_file("created.txt")
-                repeated = await _delete_file("created.txt")
-                outside = await _delete_file("../outside.txt")
-
-        self.assertTrue(deleted["ok"])
-        self.assertTrue(deleted["deleted"])
-        self.assertTrue(repeated["ok"])
-        self.assertFalse(repeated["deleted"])
-        self.assertFalse(outside["ok"])
-
-
-if __name__ == "__main__":
-    unittest.main()

tools/_shell_safety.py

@@ -7,7 +7,7 @@ Algoritmo:
 1. Blocca metacaratteri shell (previene bypass allowlist)
 2. shlex.split() — tokenizzazione sicura, rileva quoting anomalo
 3. frozenset argv[0] — allowlist letterale, non regex di prefisso
-4. Regole per git (subcmd), python -m e curl/wget (solo https://)
+4. Regole per git (subcmd) e curl/wget (solo https://)
 5. create_subprocess_exec / subprocess.run con lista argv — NO shell=True
 """
 from __future__ import annotations
@@ -17,12 +17,11 @@ from typing import Optional
 _METACHAR_RE = re.compile(r'[;&|`<>\n\r]|\$[\(\{]')
 _ALLOWED: frozenset = frozenset({
     "ls", "cat", "echo", "pwd", "whoami", "date", "uname",
-    "python3", "python", "node", "npm", "pnpm",
+    "python3", "python", "node", "npm", "pip3", "pip", "pnpm",
     "grep", "find", "head", "tail", "wc", "sort", "uniq", "diff",
     "mkdir", "touch", "cp", "mv", "chmod", "git", "curl", "wget",
 })
 _GIT_OK: frozenset = frozenset({"status", "log", "diff", "show", "branch", "remote"})
-_PYTHON_MODULES_BLOCKED: frozenset = frozenset({"pip", "pip3", "ensurepip"})
 
 
 def safe_shell_env() -> dict:
@@ -73,9 +72,6 @@ def validate_shell_command(command: str) -> Optional[str]:
     if exe == "git":
         if len(argv) < 2 or argv[1].lower() not in _GIT_OK:
             return f"git sub-comando non permesso (ammessi: {', '.join(sorted(_GIT_OK))})"
-    elif exe in ("python", "python3") and len(argv) >= 3 and argv[1] == "-m":
-        if argv[2].lower() in _PYTHON_MODULES_BLOCKED:
-            return f"modulo Python non permesso: '{argv[2]}'"
     elif exe in ("curl", "wget"):
         if not any(a.startswith("https://") for a in argv[1:]):
             return f"{exe}: solo URL https://"

tools/registry.py

@@ -92,7 +92,7 @@ from tools._shell_safety import (
 )
 import re as _re_registry
 _REGISTRY_SAFE_CMD_RE = _re_registry.compile(
-    r'^(ls|cat|echo|pwd|whoami|date|uname|python3?|node|npm|pnpm|'
+    r'^(ls|cat|echo|pwd|whoami|date|uname|python3?|node|npm|pip[3]?|pnpm|'
     r'grep|find|head|tail|wc|sort|uniq|diff|mkdir|touch|cp|mv|chmod|'
     r'git\s+(status|log|diff|show)|curl\s+https?://|wget\s+https?://)(\s|$)',
     _re_registry.IGNORECASE,
@@ -685,24 +685,6 @@ async def _read_file(path: str, encoding: str = "utf-8") -> dict:
         return {"ok": False, "error": str(exc)}
 
 
-async def _delete_file(path: str) -> dict:
-    """Rimuove un file dalla jail VFS in modo idempotente."""
-    try:
-        _p, _err = _safe_fs_path(path)
-        if _err:
-            return {"ok": False, "error": _err}
-        if not _p.exists():
-            return {"ok": True, "path": path, "deleted": False}
-        if not _p.is_file():
-            return {"ok": False, "error": f"Non è un file: {path}"}
-        _p.unlink()
-        return {"ok": True, "path": path, "deleted": True}
-    except PermissionError:
-        return {"ok": False, "error": f"Accesso negato: {path}"}
-    except Exception as exc:
-        return {"ok": False, "error": str(exc)}
-
-
 async def _write_file(path: str, content: str, encoding: str = "utf-8") -> dict:
     """S666/GAP-2/SEC-FS-JAIL: Scrive/sovrascrive un file nel filesystem del backend, confinato a _fs_jail_root().
     Manus Gap fix: read-back verifica completezza scrittura.
@@ -2317,16 +2299,6 @@ TOOL_REGISTRY: dict[str, dict] = {
         "fallbacks": [],
         "_fn": _read_file,
     },
-    "delete_file": {
-        "name": "delete_file",
-        "goal": "Rimuove un file dal filesystem del backend",
-        "description": "Rimuove un file locale confinato alla jail VFS; idempotente se il file è già assente.",
-        "required_inputs": ["path"],
-        "optional_inputs": {},
-        "risk_level": "medium",
-        "fallbacks": [],
-        "_fn": _delete_file,
-    },
     "write_file": {
         "name": "write_file",
         "goal": "Scrive o sovrascrive un file nel filesystem del backend",