diff --git a/docs/superpowers/specs/2026-04-30-V2.0.0-unified-image-token-routing-design.md b/docs/superpowers/specs/2026-04-30-V2.0.0-unified-image-token-routing-design.md
new file mode 100644
index 0000000..0a503b7
--- /dev/null
+++ b/docs/superpowers/specs/2026-04-30-V2.0.0-unified-image-token-routing-design.md
@@ -0,0 +1,562 @@
+# Cerbero MCP — V2.0.0: Unified Image, Token-Based Environment Routing
+
+**Branch:** `V2.0.0`
+**Data spec:** 2026-04-30
+**Autore:** Adriano
+
+## Sommario esecutivo
+
+Riscrittura architetturale di Cerbero MCP per ridurre superficie operativa e
+semplificare la gestione di testnet/mainnet. Si passa da 7 immagini Docker
+(gateway Caddy + 6 servizi MCP) a una **singola immagine** che ospita tutti
+i router exchange in un unico processo FastAPI. La distinzione fra ambiente
+testnet e mainnet, oggi decisa al boot del container tramite variabili di
+override e flag nei secret JSON, viene spostata **a runtime per-request**:
+il bearer token presentato dal client (`Authorization: Bearer <token>`)
+determina quale endpoint upstream viene contattato per quella specifica
+chiamata. Tutta la configurazione confluisce in un singolo file `.env`,
+eliminando i secret JSON separati. Viene infine esposta documentazione
+OpenAPI interattiva via Swagger UI all'indirizzo `/apidocs`.
+
+## Motivazioni
+
+- **Operatività**: 7 container, 8 secret file, 4 docker-compose overlay e un
+  gateway Caddy con plugin di rate-limit sono troppo per il volume di
+  traffico atteso. Un singolo container è sufficiente.
+- **Flessibilità ambiente**: oggi un bot che vuole leggere mainnet e
+  scrivere testnet deve coordinare due deploy. Con il routing per-request
+  basta scegliere il bearer giusto per ogni chiamata.
+- **Configurazione**: 8 secret JSON + 2 token file + variabili di override
+  in 4 compose file = stato distribuito difficile da auditare. Un singolo
+  `.env` rende ovvio cosa è configurato.
+- **DX dev**: oggi serve `docker compose up` anche per iterare. V2 punta a
+  `uv run cerbero-mcp` diretto su laptop senza Docker.
+- **Discovery API**: senza Swagger l'unica fonte sulle tool è il codice.
+  `/apidocs` rende le tool esplorabili dal browser, e `/openapi.json` le
+  rende leggibili a LLM senza bisogno del protocollo MCP completo.
+
+## Decisioni di design
+
+| # | Domanda | Decisione |
+|---|---|---|
+| 1 | Significato di "passare il token alla funzione" | Routing per-request via bearer: lo stesso container serve testnet e mainnet contemporaneamente, decide URL upstream a runtime |
+| 2 | Granularità token | 2 token globali (`TESTNET_TOKEN`, `MAINNET_TOKEN`) validi per tutti gli exchange |
+| 3 | ACL core/observer (read-only) | Eliminata. Protezione write rimane via leverage cap server-side e via firewall (Traefik su VPS) |
+| 4 | Scope "single image" | Un'unica immagine, **un solo container** con multi-router interno (un processo Python) |
+| 5 | Gateway L7 | Eliminato dal repo. Su VPS prod c'è Traefik gestito esternamente. In dev nessun gateway |
+| 6 | Formato configurazione | Tutto in `.env`. Nessun JSON. La porta è in `.env` |
+| 7 | Swagger | `/apidocs` ON, `/openapi.json` ON, `/redoc` OFF, `/docs` OFF |
+| 8a | Dispatch exchange | Path-based: `/mcp-{exchange}/tools/{tool}` (backward-compat con bot V1) |
+| 8b | Lifecycle client exchange | Cache lazy `(exchange, env) → client`, max 8 client (4 exchange × 2 env) + 2 client read-only (macro, sentiment) |
+
+Decisioni esplicite anche su:
+
+- **Macro e sentiment richiedono token valido**: anche le tool puramente
+  read-only passano dal middleware auth. Bearer assente o non riconosciuto
+  → 401. Il valore del token (testnet o mainnet) è ignorato per macro e
+  sentiment perché non hanno endpoint testnet, ma uno dei due deve essere
+  presente.
+- **Nessuna policy `ALLOW_MAINNET`**: la protezione contro uso accidentale
+  di mainnet è demandata a (a) custodia dei token (mainnet token solo a bot
+  autorizzati), (b) Traefik IP allowlist sul VPS, (c) leverage cap
+  server-side già esistente per ogni exchange.
+- **`docker-compose.yml` minimo** mantenuto per chi vuole usare Docker
+  localmente; `docker-compose.{prod,traefik,local}.yml` eliminati.
+
+## Architettura
+
+### Stack runtime
+
+```
+Prod (VPS):
+  Traefik (TLS, allowlist) ──▶ container cerbero-mcp:9000
+
+Dev (laptop):
+  uv run cerbero-mcp ──▶ http://localhost:9000
+```
+
+Nessun gateway nel repo. Traefik è gestito fuori da questo progetto, con
+label aggiunte tramite override compose esterno. In dev FastAPI è esposto
+direttamente via uvicorn.
+
+### Struttura sorgenti
+
+```
+Cerbero_mcp/
+├── pyproject.toml              # singolo package "cerbero-mcp"
+├── uv.lock
+├── Dockerfile                  # multi-stage builder + runtime slim
+├── docker-compose.yml          # minimo: 1 servizio, env_file: .env
+├── .env.example                # template completo, versionato
+├── .gitignore                  # .env escluso
+├── README.md                   # riscritto V2
+│
+├── docs/
+│   └── superpowers/
+│       ├── specs/
+│       │   ├── 2026-04-27-cot-report-design.md           (storico)
+│       │   └── 2026-04-30-V2.0.0-unified-image-...-design.md
+│       └── plans/
+│           ├── 2026-04-27-cot-report.md                  (storico)
+│           └── 2026-04-30-V2.0.0-unified-image-...-plan.md
+│
+├── src/cerbero_mcp/
+│   ├── __init__.py
+│   ├── __main__.py             # entrypoint: uvicorn.run(app, ...)
+│   ├── settings.py             # Pydantic Settings per .env
+│   ├── auth.py                 # bearer → environment
+│   ├── server.py               # build_app(): FastAPI + middleware + handlers + swagger
+│   ├── client_registry.py      # cache lazy {(exchange, env): client}
+│   ├── routers/
+│   │   ├── __init__.py
+│   │   ├── deribit.py
+│   │   ├── bybit.py
+│   │   ├── hyperliquid.py
+│   │   ├── alpaca.py
+│   │   ├── macro.py
+│   │   └── sentiment.py
+│   ├── exchanges/
+│   │   ├── deribit/{client.py, tools.py, leverage_cap.py}
+│   │   ├── bybit/{client.py, tools.py, leverage_cap.py}
+│   │   ├── hyperliquid/{client.py, tools.py, leverage_cap.py}
+│   │   ├── alpaca/{client.py, tools.py, leverage_cap.py}
+│   │   ├── macro/{client.py, tools.py}
+│   │   └── sentiment/{client.py, tools.py}
+│   └── common/
+│       ├── indicators.py
+│       ├── options.py
+│       ├── microstructure.py
+│       ├── stats.py
+│       ├── http.py
+│       ├── audit.py
+│       ├── logging.py
+│       └── errors.py           # error envelope
+│
+├── tests/
+│   ├── unit/
+│   ├── integration/
+│   └── smoke/
+│
+└── scripts/
+    └── build-push.sh           # build di 1 sola immagine
+```
+
+**Cosa viene eliminato:**
+
+- `services/` (intera struttura monorepo a 7 sub-package, sostituita da
+  `src/cerbero_mcp/`)
+- `gateway/` (Caddy + Caddyfile + landing page)
+- `secrets/` (8 file JSON + 2 token file)
+- `docker/` (7 Dockerfile separati, sostituiti da `Dockerfile` in root)
+- `docker-compose.prod.yml`, `docker-compose.local.yml`,
+  `docker-compose.traefik.yml`
+- `DEPLOYMENT.md` (i contenuti ancora validi confluiscono in `README.md`)
+- `mcp_common.environment` (resolver boot-time, sostituito da `auth.py`
+  runtime)
+- `mcp_common.env_validation` (sostituito da Pydantic Settings)
+- `mcp_common.app_factory` (boilerplate boot, integrato in `server.py`)
+
+**Cosa resta uguale:**
+
+- Path layout `/mcp-{exchange}/tools/{tool}` (backward-compat con bot V1)
+- Tool MCP individuali: firme, response shape, error envelope, header
+  `X-Data-Timestamp` e `X-Duration-Ms`
+- Logica indicatori quantitativi (`indicators`, `options`,
+  `microstructure`, `stats`)
+- Healthcheck `/health` (formato identico)
+- Leverage cap server-side per exchange
+- Tool MCP-bridge (se in uso) preservato in `common/mcp_bridge.py`
+
+### Flusso request
+
+```
+1. Bot HTTP request
+   POST /mcp-deribit/tools/place_order
+   Authorization: Bearer tk_test_xxx
+   { "symbol":"BTC-PERPETUAL", "side":"buy", "qty": 0.1 }
+
+2. Middleware AuthBearer (auth.py)
+   - whitelist path: /apidocs, /openapi.json, /health → bypass
+   - estrae bearer
+   - confronta con settings.testnet_token / settings.mainnet_token
+   - match testnet  → request.state.environment = "testnet"
+   - match mainnet  → request.state.environment = "mainnet"
+   - nessun match   → 401 UNAUTHORIZED
+
+3. Router deribit (routers/deribit.py)
+   - FastAPI valida body con Pydantic schema
+   - dependency get_env(request) -> "testnet"|"mainnet"
+   - dependency get_client(env) -> DeribitClient
+
+4. Client Registry (client_registry.py)
+   - chiave (exchange="deribit", env="testnet")
+   - cache hit → return; miss → costruisce client lazy + auth iniziale + cache
+
+5. Tool impl (exchanges/deribit/tools.py)
+   - leverage_cap.enforce(qty, max_leverage)
+   - client.place_order(...)
+   - response shape standard con data_timestamp, request_id
+
+6. Response middleware
+   - X-Duration-Ms header
+   - data_timestamp injection se mancante
+
+7. 200 JSON
+```
+
+### Auth
+
+```python
+# src/cerbero_mcp/auth.py (esempio sintetico)
+from fastapi import Request, HTTPException, status
+from typing import Literal
+
+Environment = Literal["testnet", "mainnet"]
+
+WHITELIST_PATHS = {"/health", "/apidocs", "/openapi.json"}
+
+async def auth_middleware(request: Request, call_next):
+    if request.url.path in WHITELIST_PATHS:
+        return await call_next(request)
+    auth = request.headers.get("Authorization", "")
+    if not auth.startswith("Bearer "):
+        raise HTTPException(401, "missing bearer token")
+    token = auth[len("Bearer "):].strip()
+    settings = request.app.state.settings
+    if token == settings.testnet_token.get_secret_value():
+        request.state.environment = "testnet"
+    elif token == settings.mainnet_token.get_secret_value():
+        request.state.environment = "mainnet"
+    else:
+        raise HTTPException(401, "invalid token")
+    return await call_next(request)
+```
+
+Confronto token con `secrets.compare_digest` per evitare timing attack.
+
+### Client registry
+
+```python
+# src/cerbero_mcp/client_registry.py (sintesi)
+class ClientRegistry:
+    def __init__(self, settings):
+        self._settings = settings
+        self._clients: dict[tuple[str, Environment], Any] = {}
+        self._locks: dict[tuple[str, Environment], asyncio.Lock] = defaultdict(asyncio.Lock)
+
+    async def get(self, exchange: str, env: Environment) -> Any:
+        key = (exchange, env)
+        if key in self._clients:
+            return self._clients[key]
+        async with self._locks[key]:
+            if key in self._clients:
+                return self._clients[key]
+            client = await self._build(exchange, env)
+            self._clients[key] = client
+            return client
+
+    async def aclose(self):
+        for c in self._clients.values():
+            await c.aclose()
+```
+
+- Costruzione **lazy** al primo uso → boot rapido, no auth verso exchange
+  non usati
+- **Lock per chiave** evita doppia istanziazione in caso di race
+- Macro e sentiment usano stesso client per testnet e mainnet (l'env è
+  ignorato), ma per uniformità API ricevono ugualmente la chiave
+  `(exchange, env)`
+- Lifespan FastAPI: registry creato in `startup`, chiuso in `shutdown`
+  (chiude HTTP pool, websocket eventuali, sessioni)
+
+### Configurazione: `.env`
+
+Singola sorgente di verità, letta da Pydantic Settings al boot. File
+versionato come `.env.example` con placeholder vuoti; `.env` reale
+gitignored.
+
+```bash
+# SERVER
+HOST=0.0.0.0
+PORT=9000
+LOG_LEVEL=info
+
+# AUTH
+TESTNET_TOKEN=
+MAINNET_TOKEN=
+
+# DERIBIT
+DERIBIT_CLIENT_ID=
+DERIBIT_CLIENT_SECRET=
+DERIBIT_URL_LIVE=https://www.deribit.com/api/v2
+DERIBIT_URL_TESTNET=https://test.deribit.com/api/v2
+DERIBIT_MAX_LEVERAGE=3
+
+# BYBIT
+BYBIT_API_KEY=
+BYBIT_API_SECRET=
+BYBIT_URL_LIVE=https://api.bybit.com
+BYBIT_URL_TESTNET=https://api-testnet.bybit.com
+BYBIT_MAX_LEVERAGE=3
+
+# HYPERLIQUID
+HYPERLIQUID_WALLET_ADDRESS=
+HYPERLIQUID_API_WALLET_ADDRESS=
+HYPERLIQUID_PRIVATE_KEY=
+HYPERLIQUID_URL_LIVE=https://api.hyperliquid.xyz
+HYPERLIQUID_URL_TESTNET=https://api.hyperliquid-testnet.xyz
+HYPERLIQUID_MAX_LEVERAGE=3
+
+# ALPACA
+ALPACA_API_KEY_ID=
+ALPACA_SECRET_KEY=
+ALPACA_URL_LIVE=https://api.alpaca.markets
+ALPACA_URL_TESTNET=https://paper-api.alpaca.markets
+ALPACA_MAX_LEVERAGE=1
+
+# MACRO
+FRED_API_KEY=
+FINNHUB_API_KEY=
+
+# SENTIMENT
+CRYPTOPANIC_KEY=
+LUNARCRUSH_KEY=
+```
+
+Pydantic Settings con `SecretStr` per i valori sensibili evita leak nei
+log/repr. `extra="ignore"` ammette env aggiuntive (variabili di sistema,
+Docker) senza crash. Validation fail-fast al boot.
+
+### Swagger / OpenAPI
+
+```python
+app = FastAPI(
+    title="Cerbero MCP",
+    version="2.0.0",
+    description="Multi-exchange MCP server. Bearer token decides environment (testnet/mainnet).",
+    docs_url="/apidocs",
+    redoc_url=None,
+    openapi_url="/openapi.json",
+    swagger_ui_parameters={
+        "persistAuthorization": True,
+        "displayRequestDuration": True,
+        "filter": True,
+        "tryItOutEnabled": True,
+        "tagsSorter": "alpha",
+        "operationsSorter": "alpha",
+    },
+)
+```
+
+Aggiunto `securityScheme = BearerAuth` su tutti gli endpoint sotto `/mcp-*`.
+Click su Authorize in Swagger → input bearer → tutte le richieste "Try it
+out" mandano il header. Cambio token = cambio ambiente senza ricaricare.
+
+Tag organizzati per exchange:
+- `system` → `/health`
+- `deribit`, `bybit`, `hyperliquid`, `alpaca`, `macro`, `sentiment` → tool
+  rispettive
+
+Ogni request body Pydantic include `examples=[...]` con almeno un esempio
+realistico. Per response shape complesse (gamma profile, orderbook
+imbalance) anche le response Pydantic includono examples.
+
+### Dockerfile e immagine
+
+```dockerfile
+# syntax=docker/dockerfile:1.7
+
+FROM python:3.11-slim AS builder
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        build-essential curl && rm -rf /var/lib/apt/lists/*
+RUN pip install --no-cache-dir "uv>=0.5,<0.7"
+WORKDIR /app
+COPY pyproject.toml uv.lock ./
+COPY src ./src
+RUN uv sync --frozen --no-dev
+
+FROM python:3.11-slim AS runtime
+LABEL org.opencontainers.image.title="cerbero-mcp" \
+      org.opencontainers.image.version="2.0.0"
+WORKDIR /app
+COPY --from=builder /app /app
+ENV PATH="/app/.venv/bin:$PATH" \
+    HOST=0.0.0.0 \
+    PORT=9000 \
+    PYTHONUNBUFFERED=1
+RUN useradd -m -u 1000 app && chown -R app:app /app
+USER app
+EXPOSE 9000
+HEALTHCHECK --interval=30s --timeout=5s --retries=3 --start-period=10s \
+    CMD python -c "import os, urllib.request; urllib.request.urlopen(f'http://localhost:{os.environ.get(\"PORT\",\"9000\")}/health', timeout=3).close()"
+CMD ["cerbero-mcp"]
+```
+
+- 1 sola immagine `cerbero-mcp:2.0.0` (+ `:latest`)
+- Build attesa: ~2-3 min (vs ~12 min × 7 immagini in V1)
+- Image size attesa: ~200 MB
+- Non-root user `app:1000`
+- Healthcheck legge `PORT` da env (rispetta override `.env`)
+
+### docker-compose.yml minimo
+
+```yaml
+services:
+  cerbero-mcp:
+    image: cerbero-mcp:2.0.0
+    build: .
+    container_name: cerbero-mcp
+    ports:
+      - "${PORT:-9000}:${PORT:-9000}"
+    env_file: .env
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "python", "-c",
+             "import os, urllib.request; urllib.request.urlopen(f'http://localhost:{os.environ.get(\"PORT\",\"9000\")}/health', timeout=3).close()"]
+      interval: 30s
+      timeout: 5s
+      retries: 3
+```
+
+Su VPS si estende con override esterno per applicare label Traefik (file
+non versionato in questo repo).
+
+## Errori
+
+| Caso | Status | Code |
+|---|---|---|
+| Manca header Authorization | 401 | UNAUTHORIZED |
+| Token non in `{testnet, mainnet}` | 401 | UNAUTHORIZED |
+| Body invalido (Pydantic) | 422 | INVALID_INPUT |
+| Exchange upstream 5xx | 502 | UPSTREAM_ERROR |
+| Rate limit upstream | 429 | RATE_LIMIT |
+| Eccezione non gestita | 500 | UNHANDLED_EXCEPTION |
+
+Error envelope identico a V1: campi `error.{type, code, message,
+retryable, suggested_fix?, details?}`, `request_id`, `data_timestamp`.
+
+## Test plan
+
+**Unit:**
+
+- `auth.py`: 4 casi (no header, header malformato, token testnet, token
+  mainnet, token invalido). Verifica che `request.state.environment` sia
+  settato correttamente.
+- `auth.py`: confronto token usa `secrets.compare_digest` (verifica con
+  test che attivi entrambi i rami).
+- `auth.py`: path whitelist (`/health`, `/apidocs`, `/openapi.json`)
+  bypassano il middleware.
+- `client_registry.py`: concorrenza — 10 task `get(deribit, testnet)` in
+  parallelo, `_build` chiamato 1 sola volta.
+- `client_registry.py`: chiavi diverse istanziano client diversi
+  (deribit/testnet ≠ deribit/mainnet ≠ bybit/testnet).
+- `settings.py`: `.env` valido carica senza errori; campo mandatory
+  mancante solleva ValidationError al boot.
+- `common/`: tutti i test esistenti su indicators, options,
+  microstructure, stats migrano 1:1.
+- Per ogni `exchanges/{exchange}/tools.py`: tool con stub client
+  restituisce response shape attesa (test esistenti V1 migrati).
+
+**Integration:**
+
+- Stub HTTP che intercetta richieste verso URL deribit:
+  - request con `Bearer TESTNET_TOKEN` colpisce `DERIBIT_URL_TESTNET`
+  - request con `Bearer MAINNET_TOKEN` colpisce `DERIBIT_URL_LIVE`
+- Stesso pattern per bybit, hyperliquid, alpaca.
+- Macro e sentiment: request con bearer testnet o mainnet entrambe
+  funzionanti, request senza bearer → 401.
+- Swagger UI: `GET /apidocs` ritorna HTML con securityScheme BearerAuth
+  presente.
+- OpenAPI: `GET /openapi.json` ritorna schema valido OpenAPI 3.1 con tag
+  per ogni exchange.
+
+**Smoke (post-deploy):**
+
+```bash
+curl -s http://localhost:9000/health
+curl -s http://localhost:9000/apidocs | grep -q "Cerbero MCP"
+curl -s -H "Authorization: Bearer $TESTNET_TOKEN" \
+     http://localhost:9000/mcp-deribit/tools/get_ticker \
+     -d '{"instrument": "BTC-PERPETUAL"}'
+```
+
+## Migrazione da V1
+
+Per chi è in produzione su V1:
+
+1. **Backup**: `cp -r secrets/ secrets.v1.bak/`.
+2. **Genera token V2**:
+   ```bash
+   python -c 'import secrets; print("TESTNET_TOKEN=" + secrets.token_urlsafe(32))'
+   python -c 'import secrets; print("MAINNET_TOKEN=" + secrets.token_urlsafe(32))'
+   ```
+3. **Compila `.env`**: mappa V1 → V2 (i campi nei JSON V1 hanno nomi
+   leggermente diversi; vedi tabella in README V2 sezione "Migrazione").
+4. **Aggiorna bot client**:
+   - URL invariato (`/mcp-{exchange}/tools/{tool}` non cambia)
+   - Bearer cambia: dove prima usavi `core.token` o `observer.token`, ora
+     usi `TESTNET_TOKEN` o `MAINNET_TOKEN` a seconda dell'ambiente
+     desiderato per quella richiesta.
+5. **Spegni V1**: `docker compose down` (vecchio compose).
+6. **Avvia V2**: `docker compose up -d` (nuovo compose minimo) +
+   verifica `curl /health` e `curl /apidocs`.
+7. **Rollback** disponibile pullando i tag immagine V1 (`cerbero-mcp-*:1.x`)
+   se necessario, ma .env e secrets/ sono incompatibili tra V1 e V2 —
+   tenere backup separati.
+
+## Pulizia documentazione
+
+| File | V1 | Azione V2 |
+|---|---|---|
+| `README.md` | descrive 6 servizi + Caddy + 8 secret + build push 8 immagini | Riscritto da zero |
+| `DEPLOYMENT.md` | runbook 7 immagini, gateway Caddy, allowlist Caddy, deploy no-clone | **Eliminato**. Contenuti utili in `README.md` |
+| `docs/superpowers/specs/2026-04-27-cot-report-design.md` | spec feature passata | Mantenuto (storico) |
+| `docs/superpowers/plans/2026-04-27-cot-report.md` | plan feature passata | Mantenuto (storico) |
+| `docs/superpowers/specs/2026-04-30-V2.0.0-...-design.md` | (nuovo) | Creato |
+| `docs/superpowers/plans/2026-04-30-V2.0.0-...-plan.md` | (nuovo) | Creato dopo writing-plans |
+
+Razionale eliminazione `DEPLOYMENT.md`: 16 KB di doc su build-push 8
+immagini, gateway Caddy, secret mounts, IP allowlist Caddy, deploy
+no-clone — tutto obsoleto in V2. Le 30 righe ancora valide (smoke test,
+rollback Watchtower) sono integrate nella sezione "Deploy" del nuovo
+`README.md`.
+
+## Out of scope
+
+Per evitare scope creep nello stesso sprint, restano fuori:
+
+- **HSTS / security headers** custom: in V1 li gestiva Caddy. In V2 si
+  delegano a Traefik su VPS (gestito esternamente). Aggiunta a livello
+  applicativo non in V2.
+- **Rate limit applicativo** (`slowapi` o simile): demandato a Traefik.
+- **Metriche Prometheus**: rinviate a iterazione successiva.
+- **Token rotation automatica**: fuori scope V2. Rotation manuale
+  modificando `.env` + restart container.
+- **Telemetria audit trail**: `mcp_common.audit` viene preservato, ma
+  evoluzioni (struttura log, sink) rinviate.
+- **Multi-account per exchange**: V2 supporta 1 account per exchange. Più
+  account = future iterazione.
+
+## Rischi e mitigazioni
+
+| Rischio | Probabilità | Mitigazione |
+|---|---|---|
+| Bug auth → token testnet finisce su URL mainnet | Bassa, alto impatto | Test integration con stub HTTP per ogni exchange; leverage cap server-side resta secondo livello di difesa |
+| Cache `client_registry` non rilascia connessioni → leak fd | Media | Lifespan FastAPI chiama `aclose()` su shutdown; healthcheck monitora processo |
+| Boot fail per env var mancante in `.env` | Alta in dev | Pydantic Settings fail-fast con messaggio chiaro; `.env.example` versionato |
+| Migrazione V1→V2 disallineata bot | Media | Path API invariato; documentare mapping V1→V2 in README |
+| Concorrenza: prima request mainnet e testnet sullo stesso exchange in parallelo | Media | Lock per chiave nel registry impedisce race su `_build` |
+| Image size cresce inattesa | Bassa | Multi-stage slim, base python:3.11-slim, no dipendenze inutili |
+
+## Criteri di successo
+
+- ✅ `docker compose up -d` avvia 1 container che risponde su `/health`
+  entro 5 secondi
+- ✅ `curl /apidocs` rende Swagger UI navigabile
+- ✅ Bot V1 funziona con cambio bearer e basta (path identici)
+- ✅ Stesso bot può alternare testnet e mainnet su request consecutive
+  cambiando solo bearer
+- ✅ Tutti i test V1 migrati passano in V2
+- ✅ Tempo di build immagine ridotto da ~12 min a ~3 min
+- ✅ `services/`, `gateway/`, `secrets/`, `docker/`, `DEPLOYMENT.md`,
+  3 docker-compose overlay rimossi dal repo