Update hub_dashboard_service.py

hub_dashboard_service.py

@@ -1,21 +1,38 @@
 #!/usr/bin/env python3
 """
 ╔══════════════════════════════════════════════════════════════════════════════════════╗
-║  K1RL QUASAR — HUB DASHBOARD SERVICE (with Trade Log Parser) — FIXED v2.5           ║
+║  K1RL QUASAR — HUB DASHBOARD SERVICE (with Trade Log Parser) — FIXED v2.6           ║
 ║  ──────────────────────────────────────────────────────────────────────────────────  ║
 ║  Architecture role: READ-ONLY subscriber → serves dashboard UI                      ║
-║  VERSION: v2.5 (PORT + LOG PATH FIX)  |  2026-04-04                                 ║
+║  VERSION: v2.6 (REALTIME SIGNALS)  |  2026-04-26                                    ║
 ║                                                                                      ║
-║  FIXES APPLIED:                                                                    ║
-║  ✅ FIX v2.5: Default port 8051→7860 (HF Spaces only exposes port 7860)            ║
-║  ✅ FIX v2.5: WebSocket ws://host:7860 → wss://host (HF Spaces TLS proxy)          ║
-║  ✅ FIX v2.5: _find_files() searches all likely HF Spaces log paths                 ║
-║  ✅ FIX v2.5: Added /api/debug endpoint for live diagnostics                        ║
-║  ✅ FIX v2.4: All /api/ranker/logs/* routes inline — no Blueprint dependency        ║
-║  ✅ FIX v2.4: Training KPI enrichment (_enrich_training) applied on /recent         ║
-║  ✅ FIX #1:  Include rotated log files (*.log, *.log.1, *.log.2, etc.)             ║
-║  ✅ FIX #2:  Improved regex to catch all trade close formats                       ║
-║  ✅ FIX #3:  Added unrealized P&L tracking for open positions                      ║
+║  v2.6 — Wires the dashboard to the hub's actual broadcast contracts:                ║
+║  ✅ MetricsSubscriber → /ws/subscribe — properly unwraps msg["asset"]["snapshot"]   ║
+║     and reads voting.flip_direction / buy_count / sell_count / last_price plus     ║
+║     training.* fields. Previously v2.5 read flat keys that the hub never emits,    ║
+║     so AssetSnapshot defaulted to zero on every message.                           ║
+║  ✅ SignalSubscriber → /ws/signals — NEW. Consumes the per-tick realtime channel   ║
+║     (signal_snapshot + signal_delta), drops out-of-order seq, stores the latest    ║
+║     {action, price, ts, seq, source} per asset.                                    ║
+║  ✅ DashboardState.get_state() merges both streams. flip_direction reflects the    ║
+║     fresh realtime tick (≤1 s old) so the BUY-after-SELL-streak case is visible    ║
+║     within ~30 ms of the V75 tick — same latency budget as the ranker. Falls back  ║
+║     to the cumulative voting direction when the realtime stream is silent/stale.   ║
+║  ✅ Full per-asset payload (buy/sell counts, training_steps, actor/critic/avn      ║
+║     loss, avn_accuracy, signal_confidence, score) so the HTML table populates      ║
+║     instead of rendering empty cells.                                              ║
+║  ✅ Backward-compat alias: HubSubscriberClient = MetricsSubscriberClient.          ║
+║                                                                                      ║
+║  Carried over from v2.5:                                                            ║
+║  ✅ Default port 8051→7860 (HF Spaces only exposes port 7860)                      ║
+║  ✅ WebSocket ws://host:7860 → wss://host (HF Spaces TLS proxy)                    ║
+║  ✅ _find_files() searches all likely HF Spaces log paths                           ║
+║  ✅ /api/debug endpoint for live diagnostics                                        ║
+║  ✅ All /api/ranker/logs/* routes inline — no Blueprint dependency                  ║
+║  ✅ Training KPI enrichment (_enrich_training) applied on /recent                   ║
+║  ✅ Rotated log files (*.log, *.log.1, *.log.2, etc.) included                     ║
+║  ✅ Improved regex to catch all trade close formats                                ║
+║  ✅ Unrealized P&L tracking for open positions                                     ║
 ║                                                                                      ║
 ║  DEPLOYMENT: Just restart the service — routes are already inline in this file.     ║
 ╚══════════════════════════════════════════════════════════════════════════════════════╝
@@ -594,62 +611,267 @@ class FileBasedLoggerAdapter:
 
 from dataclasses import dataclass, field
 
+# ══════════════════════════════════════════════════════════════════════════════════════
+# v2.6 — REWRITTEN to match the hub's actual broadcast contracts.
+#
+# What was broken in v2.5:
+#   1. AssetSnapshot read flat `signal` / `confidence` keys that the hub never emits.
+#      The hub emits `voting.flip_direction`, `voting.buy_count`, `voting.sell_count`
+#      inside the snapshot, plus a derived `metadata.scores.blended_confidence`.
+#   2. _on_message read `msg.get("space_name")` and `msg.get("snapshot")` flat, but
+#      the hub wraps both under `msg["asset"]`. Same for `initial_state`, which uses
+#      the key `assets` (dict of space_name → {metadata, snapshot}), not `snapshots`.
+#   3. There was no subscriber for /ws/signals at all, so the per-tick realtime
+#      action emitted by the hub's signal broadcaster never reached the dashboard.
+#
+# What v2.6 does:
+#   • MetricsSubscriberClient → /ws/subscribe — properly unwraps `msg["asset"]`,
+#     reads `voting.flip_direction` / `voting.buy_count` / `voting.sell_count` /
+#     `voting.last_price`, plus `training.*` for the table columns the HTML reads.
+#   • SignalSubscriberClient → /ws/signals — handles signal_snapshot + signal_delta,
+#     drops out-of-order messages by per-asset `seq`, stores the realtime action
+#     keyed by space_name.
+#   • DashboardState.get_state() merges both streams. For each asset it emits:
+#       - flip_direction:    realtime per-tick action when fresh, else cumulative
+#                            (HTML's vecOf reads this first → realtime wins display)
+#       - latest_signal:     pure realtime action (forward-compat field)
+#       - cumulative_flip_direction: voting.flip_direction (diagnostics)
+#       - signal_confidence: blended_confidence (HTML "Engaged" badge + Certainty)
+#       - buy_count / sell_count / training_steps / actor_loss / critic_loss /
+#         avn_accuracy / score / last_updated  (everything the HTML table reads)
+# ══════════════════════════════════════════════════════════════════════════════════════
+
+# A realtime tick older than this is treated as stale — the cumulative direction
+# wins instead. 1 s is tight: a tick has to land in the second before the /api/state
+# poll for the realtime override to fire, otherwise the badge falls back to the
+# cumulative voting direction. Reflects the design choice that the dashboard should
+# only paint a realtime BUY/SELL when the asset is *actively* ticking.
+_REALTIME_SIGNAL_FRESH_SEC = 1.0
+
+
 @dataclass
 class AssetSnapshot:
+    """Per-asset cumulative state, derived from /ws/subscribe `metrics_update`."""
     space_name: str
-    signal: float = 0.0
-    confidence: float = 0.0
+    # Voting (cumulative)
+    flip_direction: str = "NONE"          # "BUY" | "SELL" | "NONE"
+    flip_action: str    = "HOLD"
+    buy_count: int      = 0
+    sell_count: int     = 0
+    last_price: float   = 0.0
+    # Confidence scores (from hub's signal_metadata)
+    vote_confidence: float    = 0.0
+    train_confidence: float   = 0.0
+    blended_confidence: float = 0.0
+    # Training/learning fields used by the HTML table & detail panel
+    training_steps: int = 0
+    actor_loss: float   = 0.0
+    critic_loss: float  = 0.0
+    avn_accuracy: float = 0.0
+    avn_loss: float     = 0.0
+    # Composite score (HTML reads `r.score` for the bar chart)
+    score: float        = 0.0
+    # Bookkeeping
     last_updated: float = 0.0
 
+
+@dataclass
+class RealtimeSignal:
+    """Per-asset realtime per-tick state, from /ws/signals."""
+    action: str  = "NONE"   # "BUY" | "SELL" | "HOLD" | "NONE"
+    price: float = 0.0
+    seq: int     = 0
+    ts: float    = 0.0
+    source: str  = ""
+
+
 class DashboardState:
-    """Centralized state for the dashboard — collects snapshots from hub."""
-    
+    """Centralized state — merges /ws/subscribe metrics with /ws/signals realtime."""
+
     def __init__(self):
-        self._snapshots: Dict[str, AssetSnapshot] = {}
+        self._snapshots: Dict[str, AssetSnapshot]   = {}
+        self._signals:   Dict[str, RealtimeSignal]  = {}
         self._lock = threading.RLock()
 
-    def update_from_snapshot(self, space_name: str, snap_dict: dict) -> None:
+    # ── Writers ────────────────────────────────────────────────────────────────
+
+    def update_from_metrics(
+        self,
+        space_name: str,
+        snapshot: dict,
+        metadata: Optional[dict] = None,
+    ) -> None:
+        """
+        Apply a metrics_update payload from /ws/subscribe.
+
+        Reads from the snapshot's actual structure (voting.*, training.*) plus
+        the pre-computed `metadata.scores` block the hub attaches.
+        """
+        if not space_name or not snapshot:
+            return
+        metadata = metadata or {}
+        voting   = snapshot.get("voting",   {}) or {}
+        training = snapshot.get("training", {}) or {}
+        scores   = (metadata.get("scores")  or {})
+
+        with self._lock:
+            snap = self._snapshots.get(space_name)
+            if snap is None:
+                snap = AssetSnapshot(space_name=space_name)
+                self._snapshots[space_name] = snap
+
+            # Voting / cumulative direction
+            snap.flip_direction = str(voting.get("flip_direction", "NONE")).upper()
+            snap.flip_action    = str(voting.get("flip_action", "HOLD")).upper()
+            snap.buy_count      = int(voting.get("buy_count", 0)  or 0)
+            snap.sell_count     = int(voting.get("sell_count", 0) or 0)
+            try:
+                snap.last_price = float(voting.get("last_price", 0.0) or 0.0)
+            except (TypeError, ValueError):
+                snap.last_price = 0.0
+
+            # Confidence scores (prefer hub-derived metadata; fall back to local calc)
+            snap.vote_confidence    = float(scores.get("vote_confidence",    0.0) or 0.0)
+            snap.train_confidence   = float(scores.get("train_confidence",   0.0) or 0.0)
+            snap.blended_confidence = float(scores.get("blended_confidence", 0.0) or 0.0)
+            if snap.blended_confidence == 0.0 and snap.vote_confidence == 0.0:
+                # Hub didn't attach metadata for some reason — derive locally.
+                total_votes = snap.buy_count + snap.sell_count
+                if total_votes > 0:
+                    snap.vote_confidence = max(snap.buy_count, snap.sell_count) / total_votes
+                snap.train_confidence   = float(training.get("avn_accuracy", 0.0) or 0.0)
+                if snap.vote_confidence > 0 and snap.train_confidence > 0:
+                    snap.blended_confidence = (snap.vote_confidence + snap.train_confidence) / 2.0
+                else:
+                    snap.blended_confidence = snap.vote_confidence or snap.train_confidence
+
+            # Training fields the HTML table & detail panel read
+            snap.training_steps = int(training.get("training_steps", 0) or 0)
+            snap.actor_loss     = float(training.get("actor_loss",   0.0) or 0.0)
+            snap.critic_loss    = float(training.get("critic_loss",  0.0) or 0.0)
+            snap.avn_accuracy   = float(training.get("avn_accuracy", 0.0) or 0.0)
+            snap.avn_loss       = float(training.get("avn_loss",     0.0) or 0.0)
+
+            # Composite score: prefer an explicit field if the hub ever supplies one,
+            # otherwise fall back to signal_strength (already a [0,1] confidence-weighted
+            # directional score — close enough for the bar chart's relative ranking).
+            score = snapshot.get("score")
+            if score is None:
+                score = scores.get("signal_strength", 0.0)
+            try:
+                snap.score = float(score or 0.0)
+            except (TypeError, ValueError):
+                snap.score = 0.0
+
+            snap.last_updated = float(
+                snapshot.get("last_updated") or time.time()
+            )
+
+    def update_from_signal(self, signal: dict) -> None:
+        """Apply a per-tick signal from /ws/signals. Drops out-of-order seq."""
+        asset = signal.get("asset")
+        if not asset:
+            return
+        try:
+            seq = int(signal.get("seq", 0) or 0)
+        except (TypeError, ValueError):
+            seq = 0
+
         with self._lock:
-            if space_name not in self._snapshots:
-                self._snapshots[space_name] = AssetSnapshot(space_name=space_name)
-            snap = self._snapshots[space_name]
-            snap.signal = snap_dict.get("signal", 0.0)
-            snap.confidence = snap_dict.get("confidence", 0.0)
-            snap.last_updated = snap_dict.get("last_updated", time.time())
+            cur = self._signals.get(asset)
+            if cur is not None and seq <= cur.seq:
+                # Replay or out-of-order — ignore (matches ranker SignalSubscriber semantics)
+                return
+            try:
+                price = float(signal.get("price", 0.0) or 0.0)
+            except (TypeError, ValueError):
+                price = 0.0
+            self._signals[asset] = RealtimeSignal(
+                action = str(signal.get("action", "NONE")).upper(),
+                price  = price,
+                seq    = seq,
+                ts     = float(signal.get("ts") or time.time()),
+                source = str(signal.get("source", "") or ""),
+            )
+
+    # ── Reader ─────────────────────────────────────────────────────────────────
 
     def get_state(self) -> dict:
+        """Merge cumulative + realtime views into the payload `/api/state` returns."""
+        now = time.time()
         with self._lock:
-            snaps = [
-                {
-                    "space_name": s.space_name,
-                    "signal": round(s.signal, 4),
-                    "confidence": round(s.confidence, 4),
-                }
-                for s in self._snapshots.values()
-            ]
-            return {"snapshots": snaps}
+            snaps_out = []
+            for snap in self._snapshots.values():
+                rt = self._signals.get(snap.space_name)
+
+                # Realtime per-tick action (may be empty if /ws/signals never fired)
+                latest_signal = rt.action if rt else ""
+                rt_fresh = (
+                    rt is not None
+                    and rt.action in ("BUY", "SELL")
+                    and (now - rt.ts) <= _REALTIME_SIGNAL_FRESH_SEC
+                )
+
+                # vecOf in the HTML reads flip_direction FIRST. Put the per-tick
+                # action there when it's fresh and directional, so the dashboard
+                # reflects the most recent signal within ~30 ms of the tick.
+                # Otherwise fall back to the cumulative voting direction.
+                display_direction = rt.action if rt_fresh else snap.flip_direction
+
+                snaps_out.append({
+                    "space_name":                snap.space_name,
+                    "flip_direction":            display_direction,
+                    "cumulative_flip_direction": snap.flip_direction,
+                    "latest_signal":             latest_signal,
+                    "flip_action":               snap.flip_action,
+                    "last_price":                round(snap.last_price, 6),
+                    "buy_count":                 snap.buy_count,
+                    "sell_count":                snap.sell_count,
+                    "signal_confidence":         round(snap.blended_confidence, 4),
+                    "confidence":                round(snap.blended_confidence, 4),
+                    "vote_confidence":           round(snap.vote_confidence,    4),
+                    "train_confidence":          round(snap.train_confidence,   4),
+                    "training_steps":            snap.training_steps,
+                    "actor_loss":                round(snap.actor_loss,   6),
+                    "critic_loss":               round(snap.critic_loss,  6),
+                    "avn_loss":                  round(snap.avn_loss,     6),
+                    "avn_accuracy":              round(snap.avn_accuracy, 4),
+                    "score":                     round(snap.score, 4),
+                    "last_updated":              snap.last_updated,
+                    # Realtime diagnostics
+                    "realtime_seq":              rt.seq    if rt else 0,
+                    "realtime_ts":               rt.ts     if rt else 0.0,
+                    "realtime_source":           rt.source if rt else "",
+                })
+            return {"snapshots": snaps_out}
 
-class HubSubscriberClient:
-    """Subscribes to the central hub for live metric updates."""
-    
-    def __init__(self, state: DashboardState):
-        self.state = state
-        self.hub_url = f"wss://{_HUB_HOST}/ws/subscribe"
+
+# ══════════════════════════════════════════════════════════════════════════════════════
+# WebSocket subscriber base — DRY shared reconnect/backoff loop
+# ══════════════════════════════════════════════════════════════════════════════════════
+
+class _BaseSubscriber:
+    """Shared reconnect loop for both metrics and signals subscribers."""
+
+    NAME = "Subscriber"
+    MAX_BACKOFF = 30
+
+    def __init__(self, url: str):
+        self.url = url
         self._ws = None
         self._running = False
-        self._thread = None
+        self._thread: Optional[threading.Thread] = None
         self._reconnect_count = 0
-        self._MAX_BACKOFF = 30
 
     def start(self) -> None:
         if self._running:
             return
         self._running = True
-        self._thread  = threading.Thread(
-            target=self._run_loop, daemon=True, name="HubSubscriberClient"
+        self._thread = threading.Thread(
+            target=self._run_loop, daemon=True, name=self.NAME
         )
         self._thread.start()
-        logger.info(f"[HubSubscriberClient] Starting → {self.hub_url}")
+        logger.info(f"[{self.NAME}] Starting → {self.url}")
 
     def stop(self) -> None:
         self._running = False
@@ -666,12 +888,12 @@ class HubSubscriberClient:
             try:
                 self._connect_and_run()
             except Exception as e:
-                logger.error(f"[HubSubscriberClient] error: {e}")
+                logger.error(f"[{self.NAME}] error: {e}")
             if not self._running:
                 break
-            backoff = min(self._MAX_BACKOFF, 2 ** min(self._reconnect_count, 4))
+            backoff = min(self.MAX_BACKOFF, 2 ** min(self._reconnect_count, 4))
             logger.info(
-                f"[HubSubscriberClient] reconnect in {backoff}s "
+                f"[{self.NAME}] reconnect in {backoff}s "
                 f"(attempt #{self._reconnect_count + 1})"
             )
             time.sleep(backoff)
@@ -679,17 +901,30 @@ class HubSubscriberClient:
 
     def _connect_and_run(self) -> None:
         self._ws = websocket.WebSocketApp(
-            self.hub_url,
+            self.url,
             on_message = self._on_message,
-            on_open    = lambda ws: logger.info("[HubSubscriberClient] ✅ Connected"),
-            on_error   = lambda ws, e: logger.warning(f"[HubSubscriberClient] WS error: {e}"),
-            on_close   = lambda ws, c, m: logger.info(f"[HubSubscriberClient] closed code={c}"),
-        )
-        self._ws.run_forever(
-            ping_interval = 30,
-            ping_timeout  = 10,
-            reconnect     = 0,
+            on_open    = lambda ws: self._on_open(),
+            on_error   = lambda ws, e: logger.warning(f"[{self.NAME}] WS error: {e}"),
+            on_close   = lambda ws, c, m: logger.info(f"[{self.NAME}] closed code={c}"),
         )
+        self._ws.run_forever(ping_interval=30, ping_timeout=10, reconnect=0)
+
+    def _on_open(self) -> None:
+        self._reconnect_count = 0
+        logger.info(f"[{self.NAME}] ✅ Connected")
+
+    def _on_message(self, ws, raw: str) -> None:  # pragma: no cover — overridden
+        raise NotImplementedError
+
+
+class MetricsSubscriberClient(_BaseSubscriber):
+    """Subscribes to /ws/subscribe for cumulative per-asset snapshots."""
+
+    NAME = "MetricsSubscriber"
+
+    def __init__(self, state: DashboardState):
+        super().__init__(f"wss://{_HUB_HOST}/ws/subscribe")
+        self.state = state
 
     def _on_message(self, ws, raw: str) -> None:
         try:
@@ -697,18 +932,64 @@ class HubSubscriberClient:
             kind = msg.get("type", "")
 
             if kind == "metrics_update":
-                space    = msg.get("space_name", "")
-                snapshot = msg.get("snapshot",   {})
-                if space and snapshot:
-                    self.state.update_from_snapshot(space, snapshot)
+                # Hub format: {"type":"metrics_update","asset":{"space_name","metadata","snapshot"},...}
+                asset = msg.get("asset") or {}
+                space_name = asset.get("space_name", "")
+                snapshot   = asset.get("snapshot",   {}) or {}
+                metadata   = asset.get("metadata",   {}) or {}
+                if space_name and snapshot:
+                    self.state.update_from_metrics(space_name, snapshot, metadata)
 
             elif kind == "initial_state":
-                for space, snapshot in msg.get("snapshots", {}).items():
-                    if space and snapshot:
-                        self.state.update_from_snapshot(space, snapshot)
+                # Hub format: {"type":"initial_state","assets":{ "<name>":{"metadata","snapshot"} },...}
+                # NOTE: legacy key was "snapshots" — check both for safety across versions.
+                assets = msg.get("assets") or msg.get("snapshots") or {}
+                if isinstance(assets, dict):
+                    for space_name, payload in assets.items():
+                        if not isinstance(payload, dict):
+                            continue
+                        # New format wraps under {metadata, snapshot}; old format was the snapshot itself.
+                        if "snapshot" in payload:
+                            self.state.update_from_metrics(
+                                space_name,
+                                payload.get("snapshot", {})  or {},
+                                payload.get("metadata", {})  or {},
+                            )
+                        else:
+                            self.state.update_from_metrics(space_name, payload, {})
 
         except Exception as e:
-            logger.debug(f"[HubSubscriberClient] parse error: {e}")
+            logger.debug(f"[{self.NAME}] parse error: {e}")
+
+
+class SignalSubscriberClient(_BaseSubscriber):
+    """Subscribes to /ws/signals for realtime per-tick BUY/SELL/HOLD actions."""
+
+    NAME = "SignalSubscriber"
+
+    def __init__(self, state: DashboardState):
+        super().__init__(f"wss://{_HUB_HOST}/ws/signals")
+        self.state = state
+
+    def _on_message(self, ws, raw: str) -> None:
+        try:
+            msg  = json.loads(raw)
+            kind = msg.get("type", "")
+            if kind not in ("signal_snapshot", "signal_delta"):
+                return
+            signals = msg.get("signals") or []
+            if not isinstance(signals, list):
+                return
+            for sig in signals:
+                if isinstance(sig, dict):
+                    self.state.update_from_signal(sig)
+        except Exception as e:
+            logger.debug(f"[{self.NAME}] parse error: {e}")
+
+
+# Backward-compat alias — anything that imported HubSubscriberClient from earlier
+# revisions of this file keeps working without touching its imports.
+HubSubscriberClient = MetricsSubscriberClient
 
 
 # ══════════════════════════════════════════════════════════════════════════════════════
@@ -719,9 +1000,17 @@ _state = DashboardState()
 _trade_parser = TradeLogParser(log_dir=_LOG_DIR)
 _trade_parser.start_background()
 
-# Start hub subscriber so _state stays in sync with live metrics
-_hub_subscriber = HubSubscriberClient(state=_state)
-_hub_subscriber.start()
+# Start hub subscribers — _state stays in sync with both cumulative metrics
+# (/ws/subscribe) and realtime per-tick signals (/ws/signals). Each runs in
+# its own daemon thread with independent reconnect/backoff.
+_metrics_subscriber = MetricsSubscriberClient(state=_state)
+_metrics_subscriber.start()
+
+_signal_subscriber = SignalSubscriberClient(state=_state)
+_signal_subscriber.start()
+
+# Backward-compat name in case anything else in the process imports this.
+_hub_subscriber = _metrics_subscriber
 
 app = Flask(__name__)
 CORS(app)
@@ -913,7 +1202,7 @@ def api_trades_closed():
 
 @app.route("/api/health")
 def health():
-    return jsonify({"status": "ok", "version": "v2.5-port-fix"})
+    return jsonify({"status": "ok", "version": "v2.6-realtime-signals"})
 
 
 @app.route("/api/debug")
@@ -953,15 +1242,17 @@ def api_debug():
 
 
 if __name__ == "__main__":
-    logger.info("=== K1RL QUASAR HUB DASHBOARD SERVICE v2.5 (PORT + LOG PATH FIX) ===")
+    logger.info("=== K1RL QUASAR HUB DASHBOARD SERVICE v2.6 (REALTIME SIGNALS) ===")
     logger.info(f"Dashboard port: {_DASHBOARD_PORT}  (HF Spaces public port)")
     logger.info(f"Log directory:  {_LOG_DIR}")
-    logger.info("Fixes applied:")
-    logger.info("  ✅ FIX v2.5: Default port 8051→7860 (HF Spaces only exposes 7860)")
-    logger.info("  ✅ FIX v2.5: WebSocket wss:// with no explicit port")
-    logger.info("  ✅ FIX v2.5: _find_files() scans all likely HF Spaces log paths")
-    logger.info("  ✅ FIX v2.5: /api/debug endpoint for live diagnostics")
-    logger.info("  ✅ FIX v2.4: All /api/ranker/logs/* routes inline")
+    logger.info(f"Hub host:       {_HUB_HOST}")
+    logger.info("v2.6 fixes:")
+    logger.info("  ✅ MetricsSubscriber → /ws/subscribe  (unwraps msg.asset, reads voting.*)")
+    logger.info("  ✅ SignalSubscriber  → /ws/signals    (per-tick BUY/SELL within ~30 ms)")
+    logger.info("  ✅ get_state() merges both streams; flip_direction reflects realtime tick")
+    logger.info("  ✅ Full snapshot fields exposed (buy/sell counts, training, confidence)")
+    logger.info("Carried over from v2.5:")
+    logger.info("  ✅ port 7860 / wss:// no explicit port / log path scan / /api/debug")
     logger.info(f"  → Visit /api/debug to inspect log file discovery live")
 
     app.run(host="0.0.0.0", port=_DASHBOARD_PORT, debug=False, use_reloader=False)