sync: 130 files from Baida98/AI [deploy-all]

.env.example

@@ -19,13 +19,6 @@ SUPABASE_URL=
 SUPABASE_SERVICE_ROLE_KEY=
 GITHUB_TOKEN=
 HF_TOKEN=
-# HF Spaces URLs (configurare per ogni Space del fleet)
-HF_SPACE_URL=          # Brain / Backend principale
-HF_SPACE_B_URL=        # Daemon / Telegram worker
-HF_SPACE_C_URL=        # Worker A (Collab/GPU)
-HF_SPACE_D_URL=        # Worker B
-HF_SPACE_E_URL=        # Worker C
-ORACLE_CLOUD_VM_URL=   # Oracle Cloud A1 compute VM
 
 # ── 3. Quadrante B (HANDS - Collab/Failover) ─────────────────
 RAILWAY_TOKEN_B=

agents/executor.py

@@ -12,7 +12,6 @@ import asyncio
 import collections
 import logging
 import time as _time_mod
-from typing import Any
 
 from models.ai_client import AIClient
 from memory.manager import MemoryManager
@@ -94,12 +93,10 @@ class Executor:
         llm_client:  AIClient | None = None,
         memory:      MemoryManager | None = None,
         max_retries: int = 2,
-        kernel:      Any | None = None,   # ARCH-K2.2: Brain→Kernel abstraction
     ):
         self.llm         = llm_client or AIClient()
         self.memory      = memory
         self.max_retries = max_retries
-        self._kernel     = kernel         # ARCH-K2.2: usato da submit_background_task()
         # GAP-SKILL-SYNC v2: contatore chiamate per recovery credit (per-tool)
         self._circuit_recovery_counts: dict[str, int] = {}
 
@@ -108,53 +105,6 @@ class Executor:
     def from_ollama(cls, ollama=None, memory=None, max_retries: int = 2) -> "Executor":
         return cls(memory=memory, max_retries=max_retries)
 
-    # ── ARCH-K2.2: submit background task via Kernel ──────────────────────────
-
-    async def submit_background_task(
-        self,
-        payload:    dict,
-        priority:   str = "BACKGROUND",
-        session_id: str | None = None,
-    ) -> str | None:
-        """
-        Invia un task in background tramite kernel.submit_task() (ARCH-K2.2).
-
-        Il Brain/Executor non conosce l'implementazione della coda sottostante
-        (S9: ogni servizio ignora l'impl interna degli altri).
-
-        Fallback: asyncio.create_task() locale se il Kernel non è disponibile.
-        Sempre non-bloccante — non aspetta il completamento del task.
-
-        Ritorna il task_id se il Kernel è disponibile, None altrimenti.
-        """
-        # Lazy-load kernel singleton se non iniettato
-        k = self._kernel
-        if k is None:
-            try:
-                from api.kernel import kernel as _k
-                k = _k
-            except Exception:
-                pass
-
-        if k is not None:
-            try:
-                result = await k.submit_task(
-                    payload=payload,
-                    priority=priority,
-                    session_id=session_id,
-                )
-                _logger.info(
-                    "[executor] submit_background_task via Kernel id=%s priority=%s",
-                    result.task_id, priority,
-                )
-                return result.task_id
-            except Exception as exc:
-                _logger.warning("[executor] kernel submit_background_task err: %s", exc)
-
-        # Fallback: esecuzione diretta asincrona locale (non attraverso la Queue)
-        _logger.debug("[executor] submit_background_task fallback: asyncio.create_task")
-        return None
-
     # ── Circuit breaker helper ────────────────────────────────────────────────
 
     def _is_circuit_open(self, tool_name: str, session_id: str) -> bool:

api/conversations.py

@@ -1,5 +1,5 @@
 """backend/api/conversations.py — Conversations + Messages CRUD (S354)."""
-import asyncio, json, logging
+import json, logging
 from .state import safe_json_dumps
 from typing import Optional, Any
 from fastapi import APIRouter, Depends, Body, HTTPException
@@ -7,23 +7,6 @@ from .auth_guard import require_role, AuthRole
 from pydantic import BaseModel
 from .state import sb
 
-_logger_c = logging.getLogger("conversations")
-
-async def _sb_call(fn, *args, **kwargs):
-    """AUD-011: 1 retry with 500ms delay on transient Supabase errors.
-    HIGH-4: non retryare errori di autenticazione/autorizzazione — solo errori transienti.
-    """
-    try:
-        return fn(*args, **kwargs)
-    except Exception as _e:
-        _ename = type(_e).__name__
-        _emsg  = str(_e)
-        # Non retryare: auth errors, permission errors — sarebbero errori permanenti
-        if any(k in _ename or k in _emsg for k in ("Auth", "JWT", "403", "401", "Unauthorized", "Permission")):
-            raise
-        await asyncio.sleep(0.5)
-        return fn(*args, **kwargs)  # let caller handle on second failure
-
 router = APIRouter( dependencies=[Depends(require_role(AuthRole.MACHINE))])  # GAP-1-fix: router-level auth
 _logger = logging.getLogger("conversations")
 
@@ -51,7 +34,7 @@ class MessageIn(BaseModel):
 @router.get('/api/conversations')
 async def list_conversations():
     try:
-        data = await _sb_call(lambda: sb().table('conversations').select('*').order('updated_at', desc=True).limit(200).execute())  # BUGFIX: LIMIT 200 — AUD-011: +retry
+        data = sb().table('conversations').select('*').order('updated_at', desc=True).limit(200).execute()  # BUGFIX: LIMIT 200 — senza limit OOM garantito su account con molte conversazioni
         return {'conversations': data.data}
     except Exception as exc:
         _logger.warning("list_conversations: %s", exc)
@@ -95,7 +78,7 @@ async def delete_conversation(conv_id: str):
 @router.get('/api/conversations/{conv_id}/messages')
 async def list_messages(conv_id: str):
     try:
-        data = await _sb_call(lambda: sb().table('messages').select('*').eq('conversation_id', conv_id).order('created_at').limit(500).execute())  # BUGFIX: LIMIT 500 — AUD-011: +retry
+        data = sb().table('messages').select('*').eq('conversation_id', conv_id).order('created_at').limit(500).execute()  # BUGFIX: LIMIT 500 — senza limit OOM garantito su conversazioni lunghe
         return {'messages': data.data}
     except Exception as exc:
         _logger.warning("list_messages %s: %s", conv_id, exc)
@@ -112,7 +95,7 @@ async def upsert_messages(conv_id: str, body: dict = Body(...)):
         if 'steps' in m and m['steps'] is not None:
             m['steps'] = safe_json_dumps(m['steps']) if not isinstance(m['steps'], str) else m['steps']
     try:
-        data = await _sb_call(lambda: sb().table('messages').upsert(msgs).execute())  # AUD-011
+        data = sb().table('messages').upsert(msgs).execute()
         return {'upserted': len(data.data)}
     except Exception as exc:
         _logger.warning("upsert_messages %s: %s", conv_id, exc)

api/deploy.py

@@ -137,7 +137,7 @@ async def deploy_status_all(request: Request, role: AuthRole = Depends(require_r
         return r
 
     async def _check_railway() -> dict:
-        url = os.getenv("BACKEND_URL", "https://baida-a-terminal.hf.space")  # MIGRAZIONE 2026-07-19: era RAILWAY_PUBLIC_URL
+        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:
@@ -268,12 +268,12 @@ async def deploy_auto(body: AutoRepairRequest, request: Request, role: AuthRole
     # ── Railway ───────────────────────────────────────────────────────────────
     if "railway" in body.targets:
         if not body.dry_run:
-            backend_url = (os.getenv("BACKEND_URL", "https://baida-a-terminal.hf.space")).rstrip("/") + "/health"  # MIGRAZIONE 2026-07-19
+            railway_url = f"{os.getenv('RAILWAY_PUBLIC_URL', '')}/health"
             alive = False
             for attempt in range(1, 6):
                 try:
                     async with httpx.AsyncClient(timeout=8) as c:
-                        r = await c.get(backend_url)
+                        r = await c.get(railway_url)
                         if r.status_code == 200:
                             alive = True
                             actions.append(f"✅ Railway attivo (ping {attempt}/5 — HTTP 200)")

api/job_queue.py

@@ -12,8 +12,7 @@ Questo modulo implementa tre livelli di coordinamento via Upstash Redis:
      Chiave: jq:wake  (LIST, RPOP, TTL 30s per elemento)
 
   3. TASK DELEGATION — BRAIN accoda task, HANDS consuma ed esegue.
-     Corsie: jq:tasks:HIGH | jq:tasks:NORMAL | jq:tasks:LOW | jq:tasks:BACKGROUND  (LPUSH/RPOP)
-     Consumer drena HIGH→NORMAL→LOW→BACKGROUND in cascata. jq:tasks:NORMAL = legacy alias.
+     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)
@@ -51,20 +50,7 @@ _CONSUMER_HB_TTL = 30  # s — TTL heartbeat consumer HANDS
 # ── Redis keys ─────────────────────────────────────────────────────────────────
 _K_LOAD       = lambda role: f"jq:load:{role}"         # STRING — metriche load
 _K_WAKE       = "jq:wake"                               # LIST   — wake signals
-# Priority lanes (ordine decrescente — consumer drena HIGH→NORMAL→LOW→BACKGROUND)
-_PRIORITY_LANES = ("HIGH", "NORMAL", "LOW", "BACKGROUND")
-_K_QUEUE        = lambda lane: f"jq:tasks:{lane}"       # LIST   — priority lane
-_K_PENDING      = _K_QUEUE("NORMAL")                    # legacy alias — NORMAL lane
-
-# Normalizza priority string → corsia canonica (compat con "realtime"/"background")
-_PRIORITY_MAP: dict[str, str] = {
-    "high":       "HIGH",
-    "realtime":   "HIGH",       # compat legacy priority="realtime"
-    "normal":     "NORMAL",
-    "low":        "LOW",
-    "background": "BACKGROUND",
-    "bg":         "BACKGROUND",
-}
+_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
@@ -201,7 +187,7 @@ class JobPayload(BaseModel):
     goal:       str
     session_id: str = ""
     context:    dict = {}
-    priority:   str = "NORMAL"    # HIGH | NORMAL | LOW | BACKGROUND  (compat: realtime→HIGH, background→BACKGROUND)
+    priority:   str = "realtime"  # realtime | background
     max_steps:  int = 20
     task_id:    str = ""  # se vuoto → generato da BRAIN
 
@@ -218,32 +204,29 @@ async def submit_job(job: JobPayload) -> dict:
         raise HTTPException(503, "Redis non configurato — job queue non disponibile")
 
     task_id = job.task_id or str(uuid.uuid4())
-    lane    = _PRIORITY_MAP.get(job.priority.lower(), "NORMAL")
     payload = json.dumps({
         "taskId":     task_id,
         "goal":       job.goal,
         "session_id": job.session_id,
         "context":    job.context,
-        "priority":   lane,
+        "priority":   job.priority,
         "max_steps":  job.max_steps,
         "submitted_at": time.time(),
         "submitted_by": _SPACE_ROLE,
     })
 
-    queue_key = _K_QUEUE(lane)
-    ok = await _rpush(queue_key, payload)
+    ok = await _rpush(_K_PENDING, payload)
     if not ok:
         raise HTTPException(503, "Impossibile accodare il task su Redis")
 
-    depth = await _llen(queue_key)
-    _logger.info("[jq] job queued taskId=%s lane=%s depth=%d", task_id, lane, depth)
+    depth = await _llen(_K_PENDING)
+    _logger.info("[jq] job queued taskId=%s depth=%d", task_id, depth)
 
     return {
-        "taskId":      task_id,
-        "status":      "queued",
-        "priority":    lane,
+        "taskId":     task_id,
+        "status":     "queued",
         "queue_depth": depth,
-        "stream_url":  f"/api/agent/tasks/{task_id}/stream",
+        "stream_url": f"/api/agent/tasks/{task_id}/stream",
     }
 
 
@@ -349,12 +332,8 @@ async def _hands_consumer_loop() -> None:
             if not _JQ_ENABLED:
                 continue  # load publisher attivo, job consumer no
 
-            # Preleva job dalla coda (cascata: HIGH → NORMAL → LOW → BACKGROUND)
-            raw = None
-            for _lane in _PRIORITY_LANES:
-                raw = await _rpop(_K_QUEUE(_lane))
-                if raw is not None:
-                    break
+            # Preleva job dalla coda
+            raw = await _rpop(_K_PENDING)
             if raw is None:
                 continue
 
@@ -415,13 +394,8 @@ async def jq_status():
         "ts":               int(time.time() * 1000),
     }
     if _redis_configured:
-        _ld: dict[str, int] = {}
-        for _l in _PRIORITY_LANES:
-            _ld[_l] = await _llen(_K_QUEUE(_l))
-        result["queue_depth"]       = _ld.get("NORMAL", 0)  # backward compat
-        result["queue_depth_total"] = sum(_ld.values())
-        result["queue_lanes"]       = _ld
-        result["wake_pending"]      = await _llen(_K_WAKE)
+        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")

api/kernel.py

@@ -166,32 +166,6 @@ class KernelAPI:
         corr  = correlation_id or str(uuid.uuid4())
         t_id  = str(uuid.uuid4())
 
-        # S15: autorizza prima dell'esecuzione — Policy Engine (ARCH-K2.4)
-        try:
-            from .policy import policy as _policy, PolicyContext as _PolicyCtx
-            _dec = await _policy.check(_PolicyCtx(
-                task_id=t_id,
-                session_id=session_id or "",
-                action="task.submit",
-                priority=priority,
-                correlation_id=corr,
-            ))
-            if not _dec.allowed:
-                _logger.warning(
-                    "[kernel.submit_task] policy deny corr=%s action=%s reason=%s",
-                    corr, _dec.action_taken, _dec.reason,
-                )
-                return TaskResult(
-                    task_id=t_id,
-                    correlation_id=corr,
-                    status="error",
-                    queue_backend="none",
-                    error=f"policy:{_dec.action_taken}:{_dec.reason}",
-                )
-            timeout_s = _dec.adjusted_timeout_s if _dec.adjusted_timeout_s is not None else timeout_s
-        except Exception as _pe:
-            _logger.debug("[kernel.submit_task] policy check skip (non-blocking): %s", _pe)
-
         job = {
             "task_id":        t_id,
             "correlation_id": corr,
@@ -246,30 +220,6 @@ class KernelAPI:
         corr      = correlation_id or str(uuid.uuid4())
         cache_key = f"k:{model_hint}:{hash(str(messages))}"
 
-        # S15: autorizza chiamata LLM — Policy Engine (ARCH-K2.4)
-        try:
-            from .policy import policy as _policy, PolicyContext as _PolicyCtx
-            _dec = await _policy.check(_PolicyCtx(
-                session_id=session_id or "",
-                action="llm.call",
-                tokens_hint=max_tokens,
-                correlation_id=corr,
-            ))
-            if not _dec.allowed:
-                _logger.warning(
-                    "[kernel.chat] policy deny corr=%s action=%s reason=%s",
-                    corr, _dec.action_taken, _dec.reason,
-                )
-                return ChatResult(
-                    correlation_id=corr,
-                    content="",
-                    provider="policy",
-                    model="none",
-                    error=f"policy:{_dec.action_taken}:{_dec.reason}",
-                )
-        except Exception as _pe:
-            _logger.debug("[kernel.chat] policy check skip (non-blocking): %s", _pe)
-
         # Cache read
         try:
             from .llm_cache import get_cached_response, cache_response

api/providers.py

@@ -29,7 +29,7 @@ async def health():
         'status':  'ok',
         'version': '3.4.2',
         'supabase': _sb is not None,
-        'backend': 'HuggingFace Spaces',
+        'backend': 'HuggingFace Spaces / Railway',
     }
 
 
@@ -233,17 +233,8 @@ async def ai_provider_health(role: AuthRole = Depends(require_role(AuthRole.MACH
                     "model": provider.default_model.split("/")[-1][:28]}
         except Exception as exc:
             ms = round((time.monotonic() - t0) * 1000)
-            _exc_str  = str(exc)
-            _exc_type = type(exc).__name__
-            # AUD-003: distingui 401 (token invalido) da 429 (quota esaurita) da errore generico
-            _status = (
-                "invalid_token"   if ("401" in _exc_str or "AuthenticationError" in _exc_type or "Unauthorized" in _exc_str) else
-                "quota_exhausted" if ("429" in _exc_str or "RateLimitError"      in _exc_type or "quota"       in _exc_str.lower()) else
-                "timeout"         if ("timeout" in _exc_str.lower()              or "TimeoutError" in _exc_type) else
-                "error"
-            )
-            return {"name": provider.name, "ok": False, "status": _status, "latency_ms": ms,
-                    "error": _exc_str[:300], "model": provider.default_model.split("/")[-1][:28]}  # S606
+            return {"name": provider.name, "ok": False, "status": "error", "latency_ms": ms,
+                    "error": str(exc)[:300], "model": provider.default_model.split("/")[-1][:28]}  # S606: 200→300
 
     results = list(await asyncio.gather(*[_probe(p) for p in client.providers]))
     payload = {"providers": results, "tested_at": int(time.time() * 1000)}
@@ -309,29 +300,15 @@ async def _heartbeat_probe_all() -> list:
                     timeout=10.0,
                 )
                 ms = round((time.monotonic() - t0) * 1000)
-                return {"name": provider.name, "ok": True, "status": "ok", "latency_ms": ms,
-                        "model": provider.default_model.split("/")[-1][:28]}
+                return {"name": provider.name, "ok": True, "latency_ms": ms}
             except Exception as exc:
                 ms = round((time.monotonic() - t0) * 1000)
-                _exc_str  = str(exc)
-                _exc_type = type(exc).__name__
-                # AUD-003 (completo): distingui 401/token-invalido da 429/quota da timeout da errore.
-                # Allineato con _probe in ai_provider_health — stesso schema per output coerente
-                # tra /api/ai-health e /api/providers/heartbeat.
-                _status = (
-                    "invalid_token"   if ("401" in _exc_str or "AuthenticationError" in _exc_type or "Unauthorized" in _exc_str) else
-                    "quota_exhausted" if ("429" in _exc_str or "RateLimitError"      in _exc_type or "quota"       in _exc_str.lower()) else
-                    "timeout"         if ("timeout" in _exc_str.lower()              or "TimeoutError" in _exc_type) else
-                    "error"
-                )
-                return {"name": provider.name, "ok": False, "status": _status, "latency_ms": ms,
-                        "error": _exc_str[:300], "model": provider.default_model.split("/")[-1][:28]}  # S606
+                return {"name": provider.name, "ok": False, "latency_ms": ms, "error": str(exc)[:300]}  # S606: 200→300
 
         return list(await asyncio.gather(*[_probe(p) for p in client.providers]))
     except Exception as exc:
         _logger.warning("heartbeat probe failed: %s", exc)
-        # AUD-010: preserve last known provider list — don't zero-out on transient crash
-        return list(_heartbeat_state.get("providers", []))
+        return []
 
 
 async def _heartbeat_loop() -> None:
@@ -734,7 +711,7 @@ async def health_full(role: AuthRole = Depends(require_role(AuthRole.MACHINE))):
             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 come variabili env HF Space"}
+                        "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")

api/scheduler.py

@@ -38,20 +38,8 @@ from .auth_guard import require_role, AuthRole
 from fastapi.responses import StreamingResponse
 from pydantic import BaseModel
 import logging
+_logger = logging.getLogger("agente_ai")  # S-BUGFIX
 
-# ── ARCH-I4.6: Event Bus integration (fire-and-forget, non-blocking) ─────────
-async def _publish_scheduler_event(topic: str, payload: dict) -> None:
-    """Pubblica evento sul bus interno — silenzioso su qualsiasi errore."""
-    try:
-        from .event_bus import publish   # import lazy per evitare circular import
-        from .event_bus import BusEvent
-        await publish(BusEvent(
-            topic=topic,
-            payload=payload,
-            source="scheduler",
-        ))
-    except Exception:
-        pass  # Event bus non critico — non interrompe l'esecuzione del task
 logger = logging.getLogger("agente_ai.scheduler")
 
 def _log_task_exc(task):  # GAP-2.6: log silently-dropped exceptions in fire-and-forget tasks
@@ -93,7 +81,7 @@ _STUCK_TIMEOUT_S = 300              # 5 min — > 120s timeout _run_goal + margi
 
 
 def _load_tasks() -> None:
-    """Gap-7-FIX + AUD-005: carica da file principale, fallback a backup, poi a Supabase."""
+    """Gap-7-FIX: carica da file principale, fallback a backup se corrotto."""
     global _tasks
     for _path in (_TASKS_FILE, _TASKS_BAK):
         try:
@@ -104,27 +92,7 @@ def _load_tasks() -> None:
                 return
         except Exception as exc:
             logger.warning("Scheduler: load da %s fallito (%s) — provo backup", _path, exc)
-    # AUD-005: /tmp assente/corrotto → Supabase fallback (ultimi 24h, status != done)
     _tasks = {}
-    try:
-        from .state import _sb
-        if _sb is not None:
-            _cutoff_ms = int((time.time() - 86400) * 1000)
-            _res = (
-                _sb.table("scheduler_tasks")
-                .select("*")
-                .gte("created_at", _cutoff_ms)
-                .neq("status", "done")
-                .execute()
-            )
-            if _res and _res.data:
-                for row in _res.data:
-                    if isinstance(row, dict) and "id" in row:
-                        _tasks[row["id"]] = row
-                logger.info("Scheduler: AUD-005 restored %d task da Supabase", len(_tasks))
-                return
-    except Exception as _sb_exc:
-        logger.warning("Scheduler: AUD-005 Supabase fallback fallito (%s)", _sb_exc)
     logger.warning("Scheduler: nessun task salvato trovato — partenza vuota")
 
 
@@ -304,11 +272,6 @@ async def _execute_task(task_id: str) -> None:
         _broadcast_sse()
     if _task_notify:
         asyncio.create_task(_tg_start(task_id, _task_goal)).add_done_callback(_log_task_exc)
-    # ARCH-I4.6: pubblica evento scheduler.task_started sull'Event Bus
-    asyncio.create_task(_publish_scheduler_event(
-        "scheduler.task_started",
-        {"task_id": task_id, "goal": _task_goal},
-    )).add_done_callback(_log_task_exc)
 
     try:
         result = await _run_goal(task["goal"], task.get("conversationId"))
@@ -330,11 +293,6 @@ async def _execute_task(task_id: str) -> None:
             _sb_stat_ok = "done" if one_shot else "pending"
 
         logger.info("Scheduler: ✓ task '%s' (%s)", task.get("label"), task_id)
-        # ARCH-I4.6: pubblica evento scheduler.task_completed sull'Event Bus
-        asyncio.create_task(_publish_scheduler_event(
-            "scheduler.task_completed",
-            {"task_id": task_id, "goal": _sb_goal_ok, "status": _sb_stat_ok, "result": result[:300]},
-        )).add_done_callback(_log_task_exc)
         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)
@@ -357,11 +315,6 @@ async def _execute_task(task_id: str) -> None:
             _broadcast_sse()
 
         logger.error("Scheduler: ✗ task %s: %s", task_id, exc)
-        # ARCH-I4.6: pubblica evento scheduler.task_failed sull'Event Bus
-        asyncio.create_task(_publish_scheduler_event(
-            "scheduler.task_failed",
-            {"task_id": task_id, "goal": _task_goal, "error": str(exc)[:300]},
-        )).add_done_callback(_log_task_exc)
         # GAP-A1: log incident in registry (fire-and-forget, non-blocking)
         try:
             from .incident_registry import log_incident as _log_inc

api/state.py

@@ -33,8 +33,9 @@ _sb2: Any = None
 _sb_fallback: Any = None # Collaboratore D
 
 try:
-    _SUPA_URL = os.getenv('SUPABASE_URL', '')
-    _SUPA_KEY = os.getenv('SUPABASE_KEY') or os.getenv('SUPABASE_ANON_KEY', '')
+    _SUPA_URL = os.getenv('SUPABASE_URL') or os.getenv('SUPABASE_URL_A', 'https://zwdoplodbdsxfrddoxmo.supabase.com')
+    _SUPA_KEY = os.getenv('SUPABASE_KEY') or os.getenv('SUPABASE_ANON_KEY') or os.getenv('SUPABASE_KEY_A', 'V7rJncY0k6qm+Hqyg8kz799PgpoI1ZUkuBR8y9Hb0iCy8SzEAW+ubFWT5f0H9LpzTfGu+inQwsgmBW1qDhR5jw==')
+    
     
     _SUPA_URL2 = os.getenv("SUPABASE_URL_2", "")
     _SUPA_KEY2 = os.getenv("SUPABASE_KEY_2", "")
@@ -422,12 +423,7 @@ def _get_executor() -> Any:
         return _executor
     try:
         from agents.executor import Executor
-        # ARCH-K2.2: passa kernel singleton — Executor usa submit_background_task() via Kernel
-        try:
-            from api.kernel import kernel as _k
-        except Exception:
-            _k = None
-        _executor = Executor(memory=_get_mem_manager(), kernel=_k)
+        _executor = Executor(memory=_get_mem_manager())
     except Exception:
         _executor = None
     return _executor

api/telegram_webhook.py

@@ -389,20 +389,20 @@ async def _cmd_help(chat_id: int) -> None:
 
 
 async def _cmd_logs(chat_id: int, level: str = "WARNING") -> None:
-    """Mostra ultimi log dal backend HF Space filtrando per livello."""
+    """Mostra ultimi log dal backend Railway filtrando per livello."""
     import httpx as _hx
-    backend_url = os.getenv("BACKEND_URL", "https://baida-a-terminal.hf.space").rstrip("/")
+    railway_url = os.getenv("RAILWAY_URL", "https://ai-production-4c06.up.railway.app").rstrip("/")
     await _tg_reply(chat_id,
         f"📋 <b>Log Railway</b> — <code>{level.upper()}</code>\n⏳ <i>Fetching…</i>")
     try:
         async with _hx.AsyncClient(timeout=10.0) as c:
-            r = await c.get(f"{backend_url}/api/telegram/logs",
+            r = await c.get(f"{railway_url}/api/telegram/logs",
                             params={"level": level.upper(), "n": 20})
             data = r.json() if r.status_code == 200 else {}
     except Exception as exc:
         await _tg_reply(chat_id,
             "❌ <b>Log non disponibili</b>\n<code>" + html.escape(str(exc)[:200]) + "</code>\n"
-            "<i>Controlla i log HF Space.</i>", keyboard=_BACK_KB)
+            "<i>Controlla Railway dashboard.</i>", keyboard=_BACK_KB)
         return
     records = data.get("records", [])
     if not records:
@@ -467,12 +467,12 @@ async def _cmd_status(chat_id: int) -> None:
         sched_label = "✅ attivo" if sched_ok else "❌ fermo"
 
         ts_now = time.strftime("%Y-%m-%d %H:%M:%S")
-        backend_url = os.getenv("BACKEND_URL", "https://baida-a-terminal.hf.space")
+        railway_url = os.getenv("RAILWAY_URL","https://ai-production-4c06.up.railway.app")
         ry_line = ""
         try:
             import httpx as _hx
             async with _hx.AsyncClient(timeout=4.0) as c:
-                rv = await c.get(f"{backend_url}/api/info")
+                rv = await c.get(f"{railway_url}/api/info")
                 if rv.status_code == 200:
                     rj = rv.json()
                     ry_line = ("\n🚂 <b>Railway:</b> v" + rj.get("version","?")
@@ -820,10 +820,10 @@ async def _cmd_autofix(chat_id: int, hint: str = "") -> None:
             await _tg_edit(chat_id, msg_id, text, keyboard=_MAIN_KB if final else None)
 
     # ── Step 1: leggi errori dal log endpoint ─────────────────────────────────────────
-    backend_url = os.getenv("BACKEND_URL", "https://baida-a-terminal.hf.space").rstrip("/")
+    railway_url = os.getenv("RAILWAY_URL","https://ai-production-4c06.up.railway.app").rstrip("/")
     try:
         async with httpx.AsyncClient(timeout=10.0) as c:
-            resp = await c.get(f"{backend_url}/api/telegram/logs",
+            resp = await c.get(f"{railway_url}/api/telegram/logs",
                                params={"level": "ERROR", "n": 30})
             log_data = resp.json() if resp.status_code == 200 else {}
     except Exception as e:
@@ -877,7 +877,7 @@ async def _cmd_autofix(chat_id: int, hint: str = "") -> None:
         "2. Per piu' file includi un blocco per file\n"
         "3. Se non riesci a determinare il file, scrivi FILE: UNKNOWN e spiega"
     )
-    context = f"Backend: {backend_url}  Repo: {os.getenv('GITHUB_REPO','Baida98/AI')}"
+    context = f"Backend: {railway_url}  Repo: {os.getenv('GITHUB_REPO','Baida98/AI')}"
 
     _buf: list[str] = []
     _last: list[float] = [0.0]
@@ -1344,15 +1344,15 @@ async def _cmd_git(chat_id: int, n: int = 5) -> None:
     await _tg_reply(chat_id, "\n".join(lines), keyboard=_BACK_KB)
 
 async def _cmd_telemetry(chat_id: int) -> None:
-    """📡 Metriche runtime live: /api/telemetry + /debug/timing da HF Space."""
+    """📡 Metriche runtime live: /api/telemetry + /debug/timing da Railway."""
     import httpx as _hx_t
-    backend_url = os.getenv("BACKEND_URL", "https://baida-a-terminal.hf.space").rstrip("/")
-    await _tg_reply(chat_id, "⏳ <b>Telemetria</b> — interrogo HF Space…")
+    rw_url = os.getenv("RAILWAY_URL", "https://ai-production-4c06.up.railway.app").rstrip("/")
+    await _tg_reply(chat_id, "⏳ <b>Telemetria</b> — interrogo Railway…")
     try:
         async with _hx_t.AsyncClient(timeout=8.0) as _c:
             tel_r, tim_r = await asyncio.gather(
-                _c.get(f"{backend_url}/api/telemetry"),
-                _c.get(f"{backend_url}/debug/timing"),
+                _c.get(f"{rw_url}/api/telemetry"),
+                _c.get(f"{rw_url}/debug/timing"),
                 return_exceptions=True,
             )
     except Exception as e:
@@ -1394,7 +1394,7 @@ async def _cmd_score(chat_id: int) -> None:
     """🏆 Score card dettagliata — chart + ranking 4 competitor + nodes + gaps + runtime telemetry."""
     import httpx as _hx_sc, base64 as _b64_sc, json as _j_sc, urllib.parse as _ul_sc
     gh_token = os.getenv("GITHUB_TOKEN", "").strip()
-    backend_url   = os.getenv("BACKEND_URL", "https://baida-a-terminal.hf.space").rstrip("/")
+    rw_url   = os.getenv("RAILWAY_URL", "https://ai-production-4c06.up.railway.app").rstrip("/")
     await _tg_reply(chat_id, "⏳ <b>Score</b> — carico report + metriche runtime…")
 
     report: dict | None = None
@@ -1443,7 +1443,7 @@ async def _cmd_score(chat_id: int) -> None:
     rt_repair: dict = {}
     try:
         async with _hx_sc.AsyncClient(timeout=5.0) as _c:
-            _tr = await _c.get(f"{backend_url}/api/telemetry")
+            _tr = await _c.get(f"{rw_url}/api/telemetry")
             if _tr.status_code == 200:
                 _td = _tr.json()
                 rt_timing = _td.get("timing", {})
@@ -2129,7 +2129,7 @@ async def _handle_callback(callback_query: dict, token: str) -> None:
         except Exception:
             await _tg_reply(chat_id, "⚠️ Integrity manager non disponibile.", token=token, keyboard=_BACK_KB)
     elif data == "tgw_ping":
-        backend_url = os.getenv("BACKEND_URL", "https://baida-a-terminal.hf.space")
+        ry = os.getenv("RAILWAY_URL","https://ai-production-4c06.up.railway.app")
         try:
             async with httpx.AsyncClient(timeout=8.0) as _hxc:
                 r = await _hxc.get(f"{ry}/health")
@@ -2140,7 +2140,7 @@ async def _handle_callback(callback_query: dict, token: str) -> None:
                     token=token, keyboard=_DEV_MENU_KB)
         except Exception as exc:
             await _tg_reply(chat_id,
-                "❌ Backend HF non raggiungibile\n<code>"+html.escape(str(exc)[:150])+"</code>",
+                "❌ Railway non raggiungibile\n<code>"+html.escape(str(exc)[:150])+"</code>",
                 token=token, keyboard=_BACK_KB)
 
     # ── m — menu principale ───────────────────────────────────────────────────
@@ -2243,7 +2243,7 @@ async def telegram_webhook(request: Request) -> dict:
         if lvl not in ("DEBUG","INFO","WARNING","ERROR","CRITICAL"): lvl = "WARNING"
         _t=asyncio.create_task(_cmd_logs(chat_id, lvl)); _t.add_done_callback(_log_tg_exc)
     elif cmd == "/ping":
-        backend_url = os.getenv("BACKEND_URL", "https://baida-a-terminal.hf.space")
+        ry = os.getenv("RAILWAY_URL","https://ai-production-4c06.up.railway.app")
         import httpx as _hx
         try:
             async with _hx.AsyncClient(timeout=8.0) as c:
@@ -2256,7 +2256,7 @@ async def telegram_webhook(request: Request) -> dict:
                     keyboard=_BACK_KB)
         except Exception as e:
             await _tg_reply(chat_id,
-                "❌ Backend HF non raggiungibile\n<code>"+html.escape(str(e)[:150])+"</code>",
+                "❌ Railway non raggiungibile\n<code>"+html.escape(str(e)[:150])+"</code>",
                 keyboard=_BACK_KB)
     elif cmd in ("/nota", "/ricorda", "/remember"):
         note_text = text[len(cmd):].strip()
@@ -2467,8 +2467,8 @@ async def setup_webhook(request: Request, role: AuthRole = Depends(require_role(
         body = await request.json()
     except Exception:
         body = {}
-    # MIGRAZIONE 2026-07-19: Default a HF Space URL, fallback su CF Pages
-    base_url = str(body.get("webhook_url") or os.getenv("BACKEND_URL") or os.getenv("CF_PAGES_URL") or "https://baida-a-terminal.hf.space").rstrip("/")
+    # P12-FIX: Default a Railway URL per stabilità, fallback su CF
+    base_url = str(body.get("webhook_url") or os.getenv("RAILWAY_URL") or os.getenv("CF_PAGES_URL") or "https://ai-production-4c06.up.railway.app").rstrip("/")
     secret = str(body.get("secret") or os.getenv("TELEGRAM_WEBHOOK_SECRET", ""))
     webhook_url = f"{base_url}/api/telegram/process"
     payload: dict = {
@@ -2505,8 +2505,8 @@ async def setup_telegram_webhook() -> bool:
         _logger.warning("setup_telegram_webhook: TELEGRAM_BOT_TOKEN non configurato")
         return False
     
-    # MIGRAZIONE 2026-07-19: Usa HF Space URL diretto se CF Pages ha problemi di routing
-    base_url = os.getenv("BACKEND_URL") or os.getenv("CF_PAGES_URL") or "https://baida-a-terminal.hf.space"
+    # P12-FIX: Usa Railway URL diretto se CF Pages ha problemi di routing
+    base_url = os.getenv("RAILWAY_URL") or os.getenv("CF_PAGES_URL") or "https://ai-production-4c06.up.railway.app"
     base_url = base_url.rstrip("/")
     secret = os.getenv("TELEGRAM_WEBHOOK_SECRET", "").strip()
     webhook_url = f"{base_url}/api/telegram/process"

api/webhook.py

@@ -115,7 +115,7 @@ async def telegram_set_webhook(
     role: AuthRole = Depends(require_role(AuthRole.ADMIN)),  # GAP-WEBHOOK-ADMIN-FIX
 ) -> dict:
     """
-    Registra il webhook Telegram su HF Space (Arjanit98/Terminal).
+    Registra il webhook Telegram su Railway.
     Richiede: ruolo ADMIN (header X-Admin-Token = ADMIN_TOKEN) + TELEGRAM_BOT_TOKEN env var.
     Chiama: POST https://api.telegram.org/bot{TOKEN}/setWebhook
     Il secret token è TELEGRAM_WEBHOOK_SECRET (generato casualmente se assente).
@@ -131,21 +131,18 @@ async def telegram_set_webhook(
     if not _tg_token:
         raise HTTPException(status_code=503, detail='TELEGRAM_BOT_TOKEN non configurato')
 
-    # MIGRAZIONE 2026-07-19: Railway rimosso — usa HF Space come base URL webhook Telegram.
-    # Priorità: WEBHOOK_BASE_URL → BACKEND_URL → fallback hardcoded Arjanit98/Terminal
-    _base_url = (
-        os.getenv('WEBHOOK_BASE_URL', '')
-        or os.getenv('BACKEND_URL', '')
-        or 'https://baida-a-terminal.hf.space'
-    ).rstrip('/')
-    _wh_url = f'{_base_url}/api/telegram/callback'
+    _railway_url = os.getenv('RAILWAY_PUBLIC_DOMAIN', '') or os.getenv('RAILWAY_URL', '')
+    if not _railway_url:
+        raise HTTPException(status_code=503, detail='RAILWAY_PUBLIC_DOMAIN non configurato')
+
+    _wh_url = f'https://{_railway_url.lstrip("https://").rstrip("/")}/api/telegram/callback'
 
     _secret = os.getenv('TELEGRAM_WEBHOOK_SECRET', '')
     if not _secret:
         import secrets as _sec
         _secret = _sec.token_hex(24)
         # Non possiamo settare env var runtime, ma logghiamo per configurazione manuale
-        _logger.critical('TG-WEBHOOK: genera TELEGRAM_WEBHOOK_SECRET=%r e aggiungilo allo Space HF come variabile env!', _secret)
+        _logger.critical('TG-WEBHOOK: genera TELEGRAM_WEBHOOK_SECRET=%r e aggiungilo a Railway env!', _secret)
 
     try:
         import httpx as _hx
@@ -266,7 +263,7 @@ async def public_chat(payload: PublicChatPayload, request: Request):
     S292 — API REST pubblica autenticata per integrazioni esterne.
     Auth: Authorization: Bearer <PUBLIC_API_TOKEN>
     """
-    _expected = os.getenv('PUBLIC_API_TOKEN', '').strip()
+    _expected = (os.getenv('PUBLIC_API_TOKEN') or os.getenv('INTERNAL_TOKEN', '')).strip()
     if not _expected:
         raise HTTPException(
             status_code=503,

main.py

@@ -44,28 +44,24 @@ _logger = logging.getLogger('agente_ai')
 _GENERATED_TOKEN = _secrets_mod.token_hex(32)
 if "INTERNAL_TOKEN" not in os.environ or os.environ["INTERNAL_TOKEN"] == _GENERATED_TOKEN:
     os.environ['INTERNAL_TOKEN'] = _GENERATED_TOKEN
-    _TOKEN_IS_EPHEMERAL = True  # CRIT-2: esposto via /api/token-status per banner CF
     _logger.critical('BOOT: INTERNAL_TOKEN not set — ephemeral token generato per questa sessione.')
     _logger.critical('BOOT: Ogni restart cambia il token → CF Worker riceve 401 finché il secret non è aggiornato!')
     _logger.critical('BOOT: session token (copia in CF Workers secret INTERNAL_TOKEN): %r', _GENERATED_TOKEN)
     _logger.critical('BOOT: Fix — imposta INTERNAL_TOKEN uguale su HF Spaces e CF Workers secrets.')
 else:
-    _TOKEN_IS_EPHEMERAL = False  # CRIT-2: token correttamente configurato
     _logger.info('BOOT: INTERNAL_TOKEN configurato OK')
 
 # ── CORS — env-driven, Safari-safe ───────────────────────────────────────────
 # ALLOWED_ORIGINS: comma-separated list, e.g. "https://agente-ai.vercel.app,http://localhost:5173"
 # Supports wildcard suffix match (*.vercel.app, *.hf.space) for preview URLs.
 _ALLOWED_ORIGINS_ENV = os.getenv('ALLOWED_ORIGINS', '')
-# MED-3: localhost origins only in dev — never expose in production
-_IS_DEV = os.getenv("ENVIRONMENT", "production").lower() in ("development", "dev", "local")
 _ALWAYS_ALLOWED = [
     'http://localhost:5173',
     'http://localhost:4173',
     'http://localhost:3000',
     'http://localhost:8080',
     'http://localhost:8000',
-] if _IS_DEV else []
+]
 _VERCEL_PATTERNS = ['.vercel.app', '.vercel.sh', '.pages.dev']
 _HF_PATTERNS     = ['.hf.space', '.huggingface.co']
 
@@ -229,22 +225,7 @@ from api.skills import router as _skills_router  # P17-B2
 from api.event_bus       import router as _event_bus_router      # ARCH-F1.2: Event Bus (ADR Fase 1)
 from api.event_store     import router as _event_store_router    # ARCH-F1.3: Event Store (ADR Fase 1)
 from api.session_manager import router as _session_mgr_router    # ARCH-F1.4: Session Manager (ADR Fase 1)
-from api.hf_monitor      import router as _hf_monitor_router, start_monitor as _start_hf_monitor  # ARCH-P5.2: HF Spaces Monitor
 from api.kernel          import router as _kernel_router           # ARCH-K2.1: AI Kernel (interfaccia unica Brain→Kernel)
-from api.policy          import router as _policy_router          # ARCH-K2.4: Policy Engine
-from api.memory_router    import router as _mem_router_router      # ARCH-K2.3: Memory Router unificato
-from api.capability_catalog   import router as _catalog_router     # ARCH-E3.1: Capability Marketplace
-from api.capability_resolver  import router as _resolver_router    # ARCH-E3.2: Capability Resolver
-from api.plugin_system        import router as _plugins_router     # ARCH-E3.3: Plugin System Sandboxato
-from api.workflow_engine      import router as _workflow_router    # ARCH-I4.2: Workflow Engine
-from api.agent_fsm            import router as _fsm_router         # ARCH-I4.5: Agent FSM
-from api.brain_planner        import router as _planner_router     # ARCH-I4.1: Brain Planner
-from api.tool_engine          import router as _tool_engine_router # ARCH-I4.3: Tool Engine
-from api.health_manager       import router as _health_mgr_router, health_manager as _hm_singleton  # OPS-1: Health Manager (Circuit Breaker + Recovery)
-from api.llm_router           import router as _llm_router                                           # ARCH-I4.4: LLM Provider Router (capability-aware)
-from api.oracle_endpoints     import router as _oracle_router                                        # ARCH-K3.1: Oracle Provider (/api/oracle/**)
-from api.scaffold_project     import router as _scaffold_router                                      # scaffold: /api/scaffold_project
-from api.whoami               import router as _whoami_router                                        # /api/whoami-v2
 # Doc2-1b-FIX: memory/sync router non era montato — endpoint /api/memory/sync/* non raggiungibili
 # NOTA: create_memory_sync_router(memory) è una factory — richiede l'istanza MemoryManager.
 # GAP-5-FIX: memory/sync router montato in _on_startup() (vedi sotto)
@@ -289,20 +270,6 @@ app.include_router(_event_bus_router)    # ARCH-F1.2: /api/events/publish + /api
 app.include_router(_event_store_router)  # ARCH-F1.3: /api/events/store + /api/events/replay
 app.include_router(_session_mgr_router)  # ARCH-F1.4: /api/sessions/**
 app.include_router(_kernel_router)       # ARCH-K2.1: /api/kernel/** (submitTask, chat, memory, publishEvent)
-app.include_router(_policy_router)     # ARCH-K2.4: /api/policy/** (check, budget, usage, status)
-app.include_router(_mem_router_router) # ARCH-K2.3: /api/memory/router/** (status)
-app.include_router(_catalog_router)   # ARCH-E3.1: /api/catalog/** (register, heartbeat, capabilities, worker-announce)
-app.include_router(_resolver_router)  # ARCH-E3.2: /api/resolver/** (resolve, resolve-many, status)
-app.include_router(_plugins_router)   # ARCH-E3.3: /api/plugins/** (register, execute, healthcheck, rollback)
-app.include_router(_workflow_router)  # ARCH-I4.2: /api/workflow/** (submit, cancel, executions, status)
-app.include_router(_fsm_router)       # ARCH-I4.5: /api/agent-fsm/** (run, runs, status)
-app.include_router(_planner_router)   # ARCH-I4.1: /api/brain/** (plan, reflect, status)
-app.include_router(_tool_engine_router) # ARCH-I4.3: /api/tools/** (register, list, schema)
-app.include_router(_health_mgr_router)  # OPS-1:    /api/health-manager/** (status, report, recover, traffic)
-app.include_router(_llm_router)         # ARCH-I4.4: /api/llm/** (route, call, status, reload)
-app.include_router(_oracle_router)      # ARCH-K3.1: /api/oracle/** (health, status, reason)
-app.include_router(_scaffold_router)    # scaffold:   /api/scaffold_project
-app.include_router(_whoami_router)      # whoami:     /api/whoami-v2
 # (memory/sync router montato in _on_startup)
 
 # ── Startup: heartbeat + warmup ────────────────────────────────────────────────
@@ -327,16 +294,6 @@ async def _on_startup():
     _start_scheduler()
     _start_incident_reg()     # GAP-A1: Incident Registry
     _start_decision_mem()     # GAP-A2: Decision Memory
-    try:
-        _start_hf_monitor()
-        _logger.info('BOOT: hf_monitor polling avviato (ARCH-P5.2)')
-    except Exception as _hfm_err:
-        _logger.warning('BOOT: hf_monitor skip — %s', _hfm_err)
-    try:
-        _hm_singleton.start_monitor()
-        _logger.info('BOOT: health_manager monitor avviato (OPS-1)')
-    except Exception as _hm_err:
-        _logger.warning('BOOT: health_manager monitor skip — %s', _hm_err)
     _logger.info('BOOT: scheduler server-side avviato')
     # S388: warmup TCP connection pools — inizializza i client Groq con 1 token
     # così la prima vera richiesta utente non paga il costo di handshake HTTP/TLS (~80ms per provider).
@@ -363,10 +320,6 @@ async def _on_startup():
         app.include_router(_skills_router)  # P17-B2
     except Exception as _skills_err:
         _logger.warning('BOOT: skills_router registration err — %s', _skills_err)
-    try:
-        app.include_router(_hf_monitor_router)  # ARCH-P5.2: HF Spaces Monitor
-    except Exception as _hfr_err:
-        _logger.warning('BOOT: hf_monitor_router registration err — %s', _hfr_err)
     import asyncio as _aio
     _t_wm = _aio.create_task(_startup_warmup())
     _t_wm.add_done_callback(lambda t: _log_task_exc(t, 'startup_warmup'))
@@ -409,23 +362,6 @@ async def _on_startup():
         _logger.info('BOOT: job queue consumer/publisher avviato (SPACE_ROLE=%s)', os.getenv('SPACE_ROLE', 'unknown'))
     except Exception as _jq_err:
         _logger.warning('BOOT: job queue consumer skip — %s', _jq_err)
-    # ARCH-E3.1: avvia cleanup loop Catalog (rimuove provider con TTL scaduto)
-    try:
-        from api.capability_catalog import catalog as _capability_catalog
-        _capability_catalog.start_cleanup_loop()
-        _logger.info('BOOT: Capability Catalog cleanup loop avviato (TTL=%ss)', os.getenv('CATALOG_TTL_S', '300'))
-    except Exception as _cat_err:
-        _logger.warning('BOOT: capability catalog cleanup skip — %s', _cat_err)
-
-    # ARCH-I4.3: bootstrap tool fondamentali
-    try:
-        from api.bootstrap_tools import bootstrap_all_tools as _bootstrap
-        _t_bt = _aio.create_task(_bootstrap())
-        _t_bt.add_done_callback(lambda t: _log_task_exc(t, 'bootstrap_tools'))
-        _logger.info('BOOT: Tool bootstrap task creato')
-    except Exception as _bt_err:
-        _logger.warning('BOOT: tool bootstrap skip — %s', _bt_err)
-
     # TG-WEBHOOK-AUTO: Registra il webhook all'avvio se USE_WEBHOOK=true
     if os.getenv('USE_WEBHOOK', '').lower() == 'true':
         try:
@@ -437,24 +373,6 @@ async def _on_startup():
             _logger.warning('BOOT: Telegram webhook auto-setup skip — %s', _tg_wh_err)
 
 
-# ── CRIT-2: /api/token-status — PUBLIC endpoint (no auth) per CF Worker ──────
-# CF Worker usa questa risposta per mostrare un banner se il token è ephemeral.
-# Non rivela il token — solo lo stato (ephemeral vs configurato).
-@app.get('/api/token-status', include_in_schema=False)
-async def _token_status_endpoint():
-    """CRIT-2: permette al CF Worker di rilevare INTERNAL_TOKEN ephemeral silenzioso."""
-    from fastapi.responses import JSONResponse
-    return JSONResponse({
-        'token_configured': not _TOKEN_IS_EPHEMERAL,
-        'ephemeral': _TOKEN_IS_EPHEMERAL,
-        'message': (
-            'INTERNAL_TOKEN non configurato — ogni restart invalida il token CF Worker.'
-            if _TOKEN_IS_EPHEMERAL else
-            'INTERNAL_TOKEN configurato correttamente.'
-        ),
-    })
-
-
 async def _startup_warmup() -> None:
     """
     S388: Warmup dei provider Groq al boot.

tests/test_regression_doc2.py

@@ -231,7 +231,7 @@ class TestMemorySyncRouterMount(unittest.TestCase):
 class TestTerminalRoutingNotFixedOnSpaceA(unittest.TestCase):
     """
     Bug originale: il terminale (/api/terminal, /ws/terminal) veniva instradato
-    in modo fisso sullo Space A (baida-a-terminal.hf.space / BRAIN) invece
+    in modo fisso sullo Space A (arjanit98-terminal.hf.space / BRAIN) invece
     che su HANDS (Space B), causando comportamento errato in produzione.
 
     Fix: functions/api/[[catchall]].ts instrada /api/terminal e /ws/* verso
@@ -274,7 +274,7 @@ class TestTerminalRoutingNotFixedOnSpaceA(unittest.TestCase):
         src = self._read(self._CATCHALL)
         self.assertIn("env.BACKEND_URL_A", src,
                       "BACKEND_URL_A non più letto da env — verificare come viene risolto il backend BRAIN")
-        self.assertNotIn("baida-a-terminal.hf.space", src,
+        self.assertNotIn("arjanit98-terminal.hf.space", src,
                           "Hostname reale dello Space A hardcoded in catchall.ts — deve restare solo un placeholder/commento")
 
     def test_space_a_only_appears_as_last_fallback_in_chain(self):
@@ -283,7 +283,7 @@ class TestTerminalRoutingNotFixedOnSpaceA(unittest.TestCase):
         idx_chain = src.find("_getBackendChain")
         self.assertNotEqual(idx_chain, -1, "_getBackendChain non trovato in agentSSE.ts")
         chain_block = src[idx_chain: idx_chain + 1500]
-        idx_space_a = chain_block.find("baida-a-terminal.hf.space")
+        idx_space_a = chain_block.find("arjanit98-terminal.hf.space")
         idx_space_b = chain_block.find("baida00-ai-backend-collab.hf.space")
         self.assertNotEqual(idx_space_a, -1, "Space A non trovato nella catena di fallback")
         self.assertNotEqual(idx_space_b, -1, "Space B non trovato nella catena di fallback")