Phase 3: MCP HTTP clients + Dockerization

Wrapper async tipizzati sui sei servizi MCP HTTP che Cerbero Bite
consuma in autonomia. 277 test pass, copertura clients 93%, mypy
strict pulito, ruff clean.

Base layer:
- clients/_base.py: HttpToolClient con httpx + tenacity (retry
  esponenziale 3x, timeout 8s, mapping HTTP→eccezioni tipizzate).
- clients/_exceptions.py: McpAuthError, McpServerError, McpToolError,
  McpDataAnomalyError, McpNotFoundError, McpTimeoutError.
- config/mcp_endpoints.py: risoluzione URL via Docker DNS
  (mcp-deribit:9011, ...) con override per servizio via env var;
  caricamento bearer token da secrets/core.token o
  CERBERO_BITE_CORE_TOKEN_FILE.

Wrapper:
- clients/macro.py: next_high_severity_within() per filtro entry §2.5.
- clients/sentiment.py: funding_cross_median_annualized() con
  annualizzazione per period nativo per exchange (Binance/Bybit/OKX
  1095, Hyperliquid 8760).
- clients/hyperliquid.py: funding_rate_annualized() per filtro §2.6.
- clients/portfolio.py: total_equity_eur(), asset_pct_of_portfolio()
  per sizing engine + filtro §2.7.
- clients/telegram.py: notify-only (no callback queue, no
  conferme — Bite auto-execute).
- clients/deribit.py: environment_info, index_price_eth,
  latest_dvol, options_chain, get_tickers, orderbook_depth_top3,
  get_account_summary, get_positions, place_combo_order (combo
  atomico), cancel_order.

CLI:
- cerbero-bite ping: health-check parallelo di tutti gli MCP con
  tabella rich (OK/FAIL/SKIPPED).

Docker:
- Dockerfile multi-stage Python 3.13 + uv, user non-root.
- docker-compose.yml con rete external "cerbero-suite", secret
  core_token montato a /run/secrets/core_token, env per ogni MCP.
- secrets/README.md documenta il setup del token.

Documentazione di intervento:
- docs/12-mcp-deribit-changes.md: spec delle modifiche apportate
  al server mcp-deribit (place_combo_order + override testnet via
  DERIBIT_TESTNET).

Dipendenze:
- aggiunto pytest-httpx per i test HTTP.
- rimosso mcp>=1.0 (non usiamo l'SDK MCP, parliamo via HTTP REST).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

src/cerbero_bite/clients/portfolio.py

@@ -0,0 +1,92 @@
+"""Wrapper around ``mcp-portfolio``.
+
+Cerbero Bite uses two pieces of information from this service:
+
+* total portfolio value (EUR) — fed to the sizing engine after FX
+  conversion to USD;
+* exposure of a specific asset as percentage of the total portfolio —
+  used by entry filter §2.7 (``eth_holdings_pct_max``).
+
+The portfolio service stores everything in EUR. The orchestrator is
+responsible for the EUR→USD conversion using a live FX rate.
+"""
+
+from __future__ import annotations
+
+from decimal import Decimal
+from typing import Any
+
+from cerbero_bite.clients._base import HttpToolClient
+from cerbero_bite.clients._exceptions import McpDataAnomalyError
+
+__all__ = ["PortfolioClient"]
+
+
+class PortfolioClient:
+    SERVICE = "portfolio"
+
+    def __init__(self, http: HttpToolClient) -> None:
+        if http.service != self.SERVICE:
+            raise ValueError(
+                f"PortfolioClient requires service '{self.SERVICE}', got '{http.service}'"
+            )
+        self._http = http
+
+    async def total_equity_eur(self) -> Decimal:
+        """Return the aggregate portfolio value in EUR."""
+        raw = await self._http.call(
+            "get_total_portfolio_value", {"currency": "EUR"}
+        )
+        if not isinstance(raw, dict):
+            raise McpDataAnomalyError(
+                f"portfolio total_value_eur unexpected shape: {type(raw).__name__}",
+                service=self.SERVICE,
+                tool="get_total_portfolio_value",
+            )
+        value = raw.get("total_value_eur")
+        if value is None:
+            raise McpDataAnomalyError(
+                "portfolio response missing 'total_value_eur'",
+                service=self.SERVICE,
+                tool="get_total_portfolio_value",
+            )
+        return Decimal(str(value))
+
+    async def asset_pct_of_portfolio(self, ticker: str) -> Decimal:
+        """Return the fraction (0..1) of the portfolio held in ``ticker``.
+
+        Iterates the holdings list and aggregates ``current_value_eur``
+        for any holding whose ticker contains ``ticker`` (case-insensitive).
+        Empty portfolio → 0.
+        """
+        holdings = await self._http.call("get_holdings", {"min_value_eur": 0})
+        if not isinstance(holdings, list):
+            raise McpDataAnomalyError(
+                f"portfolio get_holdings unexpected shape: {type(holdings).__name__}",
+                service=self.SERVICE,
+                tool="get_holdings",
+            )
+
+        target = ticker.upper()
+        matching_value = Decimal("0")
+        total_value = Decimal("0")
+        for entry in holdings:
+            if not isinstance(entry, dict):
+                continue
+            value = entry.get("current_value_eur")
+            if value is None:
+                continue
+            value_dec = Decimal(str(value))
+            total_value += value_dec
+            entry_ticker = str(entry.get("ticker") or "").upper()
+            if target in entry_ticker:
+                matching_value += value_dec
+
+        if total_value == 0:
+            return Decimal("0")
+        return matching_value / total_value
+
+    async def health(self) -> dict[str, Any]:
+        """Lightweight call used by ``cerbero-bite ping``."""
+        result: Any = await self._http.call("get_last_update_info", {})
+        return result if isinstance(result, dict) else {}