fix: resolve all remaining TODOs, add dev mode auth bypass

- Learning engine: expand default weights from 3 to all 9 strategies
- Learning engine: resolve placeholder strategy_id with DB lookup
- Learning engine: pass strategy_sources from trade execution
- Trade executor: respect trading:paused Redis flag in RiskManager
- Portfolio sync: compute actual daily P&L from day-start snapshot
- Portfolio API: cumulative P&L from first snapshot, read pause flag
- Portfolio metrics: compute max drawdown and avg hold duration
- Add strategy_sources field to TradeExecution schema
- Add dev_mode config (TRADING_DEV_MODE) to bypass auth for local dev
- Dashboard: VITE_DEV_MODE bypasses ProtectedRoute and 401 redirects
- Vite proxy target configurable via VITE_API_TARGET
- Add top-level README.md and remaining-work-plan.md
- Update CLAUDE.md with correct counts and remove stale TODOs
- 404 tests passing

Made-with: Cursor

services/api_gateway/routes/portfolio.py

@@ -8,7 +8,7 @@ from enum import Enum
 from fastapi import APIRouter, Depends, Query, Request
 
 from services.api_gateway.auth.middleware import get_current_user
-from sqlalchemy import select, desc
+from sqlalchemy import select, desc, asc, func
 
 router = APIRouter(prefix="/api/portfolio", tags=["portfolio"])
 
@@ -33,6 +33,41 @@ class HistoryPeriod(str, Enum):
         return None
 
 
+def _compute_max_drawdown(values: list[float]) -> float:
+    """Compute maximum percentage drawdown from a list of portfolio values.
+
+    Returns a positive decimal (e.g. 0.12 for a 12% drawdown).
+    """
+    if len(values) < 2:
+        return 0.0
+    peak = values[0]
+    max_dd = 0.0
+    for v in values:
+        if v > peak:
+            peak = v
+        if peak > 0:
+            dd = (peak - v) / peak
+            if dd > max_dd:
+                max_dd = dd
+    return max_dd
+
+
+def _format_duration(durations: list[timedelta]) -> str:
+    """Compute average of timedelta list and format as human-readable string."""
+    if not durations:
+        return "0h"
+    total_seconds = sum(d.total_seconds() for d in durations) / len(durations)
+    if total_seconds < 0:
+        total_seconds = 0
+    hours = int(total_seconds // 3600)
+    minutes = int((total_seconds % 3600) // 60)
+    if hours >= 24:
+        days = hours // 24
+        remaining_hours = hours % 24
+        return f"{days}d {remaining_hours}h"
+    return f"{hours}h {minutes}m"
+
+
 def _period_to_timedelta(period: HistoryPeriod) -> timedelta:
     """Convert a period enum value to a timedelta."""
     mapping = {
@@ -47,6 +82,9 @@ def _period_to_timedelta(period: HistoryPeriod) -> timedelta:
     return mapping[period]
 
 
+TRADING_PAUSED_KEY = "trading:paused"
+
+
 @router.get("")
 async def get_portfolio(
     request: Request,
@@ -77,20 +115,38 @@ async def get_portfolio(
                 "trading_active": True,
             }
 
-        # Compute percentage fields from snapshot data
+        # Cumulative P&L: difference between latest and earliest snapshot
+        earliest = (
+            await session.execute(
+                select(PortfolioSnapshot)
+                .order_by(asc(PortfolioSnapshot.timestamp))
+                .limit(1)
+            )
+        ).scalar_one_or_none()
+
+        total_pnl = 0.0
+        total_pnl_pct = 0.0
+        if earliest is not None and earliest.total_value > 0:
+            total_pnl = latest.total_value - earliest.total_value
+            total_pnl_pct = total_pnl / earliest.total_value * 100.0
+
         daily_pnl_pct = (latest.daily_pnl / (latest.total_value - latest.daily_pnl) * 100.0
                          if latest.total_value != latest.daily_pnl else 0.0)
 
-        return {
-            "total_value": latest.total_value,
-            "cash": latest.cash,
-            "buying_power": latest.cash,
-            "daily_pnl": latest.daily_pnl,
-            "daily_pnl_pct": round(daily_pnl_pct, 2),
-            "total_pnl": latest.daily_pnl,  # TODO: compute cumulative P&L from first snapshot
-            "total_pnl_pct": round(daily_pnl_pct, 2),
-            "trading_active": True,  # TODO: read from Redis trading pause flag
-        }
+    # Read trading pause flag from Redis
+    redis = request.app.state.redis
+    paused = await redis.get(TRADING_PAUSED_KEY) if redis else None
+
+    return {
+        "total_value": latest.total_value,
+        "cash": latest.cash,
+        "buying_power": latest.cash,
+        "daily_pnl": latest.daily_pnl,
+        "daily_pnl_pct": round(daily_pnl_pct, 2),
+        "total_pnl": round(total_pnl, 2),
+        "total_pnl_pct": round(total_pnl_pct, 2),
+        "trading_active": not bool(paused),
+    }
 
 
 @router.get("/positions")
@@ -132,18 +188,17 @@ async def get_portfolio_metrics(
     _user: dict = Depends(get_current_user),
 ) -> dict:
     """Aggregate portfolio performance metrics — ROI, Sharpe, win rate, drawdown."""
+    from shared.models.learning import TradeOutcome
     from shared.models.trading import Trade, TradeStatus
-    from shared.models.timeseries import StrategyMetric
+    from shared.models.timeseries import PortfolioSnapshot, StrategyMetric
 
     db = request.app.state.db_session_factory
     async with db() as session:
-        # Total trades and win rate from trades table
         trades_result = await session.execute(
             select(Trade).where(Trade.status == TradeStatus.FILLED)
         )
         trades = trades_result.scalars().all()
 
-        # Latest strategy metrics for Sharpe
         metrics_result = await session.execute(
             select(StrategyMetric)
             .order_by(desc(StrategyMetric.timestamp))
@@ -156,20 +211,34 @@ async def get_portfolio_metrics(
         win_rate = winning / total_trades if total_trades > 0 else 0.0
 
         total_pnl = sum(t.pnl for t in trades if t.pnl is not None)
-        # Approximate ROI from P&L (rough — proper calculation needs initial capital)
-        roi = total_pnl / 100_000.0 * 100.0  # assumes 100k starting capital
+        roi = total_pnl / 100_000.0 * 100.0
 
-        # Average Sharpe from strategy metrics
         sharpe_values = [m.sharpe_ratio for m in strategy_metrics if m.sharpe_ratio is not None]
         avg_sharpe = sum(sharpe_values) / len(sharpe_values) if sharpe_values else 0.0
 
+        # Max drawdown from portfolio snapshots (peak-to-trough)
+        snapshots_result = await session.execute(
+            select(PortfolioSnapshot.total_value)
+            .order_by(PortfolioSnapshot.timestamp)
+        )
+        values = [row[0] for row in snapshots_result.all()]
+        max_drawdown = _compute_max_drawdown(values)
+
+        # Average hold duration from trade outcomes
+        outcomes_result = await session.execute(
+            select(TradeOutcome.hold_duration)
+            .where(TradeOutcome.hold_duration.isnot(None))
+        )
+        durations = [row[0] for row in outcomes_result.all()]
+        avg_hold = _format_duration(durations)
+
         return {
             "roi": round(roi, 4),
             "sharpe": round(avg_sharpe, 2),
             "win_rate": round(win_rate, 4),
-            "max_drawdown": 0.0,  # TODO: compute from portfolio snapshots
+            "max_drawdown": round(max_drawdown, 4),
             "total_trades": total_trades,
-            "avg_hold_duration": "0h",  # TODO: compute from trade outcomes
+            "avg_hold_duration": avg_hold,
         }