feat: option lab

backend/routers/portfolio.py

@@ -1,4 +1,4 @@
-from fastapi import APIRouter, HTTPException
+from fastapi import APIRouter, HTTPException, Query
 import traceback as tb_mod
 from pydantic import BaseModel
 from typing import Optional, List, Dict, Any
@@ -179,6 +179,21 @@ def position_payoff(pos_id: str):
     return compute_payoff(pos)
 
 
+@router.get("/positions/{pos_id}/retrospective-optimal")
+def position_retrospective_optimal(pos_id: str, as_of: str = Query(None)):
+    """"What would have been optimal, in hindsight?" — reprices the position's real legs
+    and runs the Strategy Builder optimizer against the REAL historical Saxo chain and the
+    REALIZED spot/IV move since entry (not a guessed scenario) — see
+    services.strategy_comparison.compute_retrospective_comparison. Expensive (runs the full
+    template-search optimizer), so this is on-demand from the Portfolio position detail, not
+    auto-computed for every open position."""
+    from services.strategy_comparison import compute_retrospective_comparison
+    pos = next((p for p in get_positions("open") + get_positions("closed") if p["id"] == pos_id), None)
+    if not pos:
+        raise HTTPException(status_code=404, detail=f"Position '{pos_id}' introuvable")
+    return compute_retrospective_comparison(pos, as_of=as_of)
+
+
 @router.get("/scenario-exposure")
 def scenario_exposure():
     """Reprices every open position under a handful of named macro scenarios (Risk-Off,

backend/routers/saxo.py

@@ -248,3 +248,19 @@ def saxo_iv_snapshot(symbol: str):
 def saxo_iv_history(symbol: str, days: int = Query(90, ge=1, le=730)):
     from services.saxo_iv_engine import get_saxo_iv_history
     return get_saxo_iv_history(symbol, days)
+
+
+@router.get("/pricing-check")
+def saxo_pricing_check(
+    ticker: str = Query(...),
+    date_a: str = Query(..., description="YYYY-MM-DD"),
+    date_b: str = Query(..., description="YYYY-MM-DD"),
+    target_dte: Optional[int] = Query(None, ge=1, le=365, description="Overrides the default (expiry closest to date_b)"),
+):
+    """Options Lab — was this option well priced between two dates? Picks the strike closest
+    to the underlying's actual outcome at date_b (hindsight), and by default the expiry
+    closest to date_b too (same hindsight principle, overridable via target_dte), reprices
+    it at both dates from real Saxo history, and decomposes the price move into
+    Delta/Theta/Vega contributions — see services.pricing_check.analyze_option_pricing."""
+    from services.pricing_check import analyze_option_pricing
+    return analyze_option_pricing(ticker, date_a, date_b, target_dte)

backend/services/option_chain.py

@@ -13,9 +13,10 @@ from typing import Any, Dict, List, Optional
 def get_chain_slice(
     symbol: str, target_days: int = 8, n_expiries: int = 3,
     dte_min: Optional[int] = None, dte_max: Optional[int] = None,
+    as_of: Optional[str] = None,
 ) -> Dict[str, Any]:
     """
-    Builds a chain slice from the latest accumulated Saxo snapshot rows for `symbol`
+    Builds a chain slice from the accumulated Saxo snapshot rows for `symbol`
     (services/database.get_latest_saxo_snapshot_rows). Returns the `n_expiries`
     expirations closest to target_days, each with calls/puts rows shaped
     {strike, bid, ask, mid, last, iv, open_interest, volume} — same shape regardless
@@ -26,19 +27,27 @@ def get_chain_slice(
     scenario at a short horizon (e.g. target_days=8) while still building legs from
     longer-dated options (e.g. dte_min=20, dte_max=60), which target_days alone can't
     express since it drives both the evaluation date and (until now) the expiry pick.
-    """
-    from services.database import get_latest_saxo_snapshot_rows
 
-    flat_rows = get_latest_saxo_snapshot_rows(symbol.upper())
+    `as_of` (an ISO date/datetime string), when given, reconstructs the chain as it stood
+    at or before that moment instead of "now" — services.database.get_snapshot_rows_asof,
+    same row shape, just filtered by created_at. This is what powers the Portfolio
+    retrospective comparison (services.strategy_comparison): it needs the chain as it
+    really was on a position's entry_date, not today's. Every days-to-expiry figure is
+    computed relative to `as_of` in that case, not date.today() — using today's date to
+    size a historical chain would silently misdate every contract in it.
+    """
+    from services.database import get_latest_saxo_snapshot_rows, get_snapshot_rows_asof
+
+    flat_rows = get_snapshot_rows_asof(symbol.upper(), as_of) if as_of else get_latest_saxo_snapshot_rows(symbol.upper())
     if not flat_rows:
         raise ValueError(
-            f"Aucun historique Saxo pour '{symbol}' — ajoutez-le à la watchlist "
-            f"(Config → Saxo) et attendez le prochain cycle de snapshot (~5 min)."
+            f"Aucun historique Saxo pour '{symbol}'" + (f" à la date {as_of}" if as_of else "") +
+            " — ajoutez-le à la watchlist (Config → Saxo) et attendez le prochain cycle de snapshot (~5 min)."
         )
 
     spot = next((r["spot"] for r in flat_rows if r.get("spot") is not None), None)
-    as_of = max((r["created_at"] for r in flat_rows if r.get("created_at")), default=None)
-    today = date.today()
+    snapshot_as_of = max((r["created_at"] for r in flat_rows if r.get("created_at")), default=None)
+    reference_date = datetime.strptime(as_of[:10], "%Y-%m-%d").date() if as_of else date.today()
 
     by_expiry: Dict[str, List[Dict[str, Any]]] = {}
     for r in flat_rows:
@@ -46,7 +55,7 @@ def get_chain_slice(
             by_expiry.setdefault(r["expiry_date"], []).append(r)
 
     def _days_to(expiry_date: str) -> int:
-        return (datetime.strptime(expiry_date[:10], "%Y-%m-%d").date() - today).days
+        return (datetime.strptime(expiry_date[:10], "%Y-%m-%d").date() - reference_date).days
 
     candidates = list(by_expiry.keys())
     if dte_min is not None or dte_max is not None:
@@ -98,7 +107,7 @@ def get_chain_slice(
         "symbol": symbol.upper(),
         "proxy": symbol.upper(),
         "spot": round(float(spot), 6) if spot is not None else None,
-        "as_of": as_of,
+        "as_of": snapshot_as_of,
         "expiries": expiries_out,
     }
 

backend/services/options_pricer.py

@@ -5,7 +5,10 @@ from datetime import datetime, timedelta
 import math
 
 
-def black_scholes(S: float, K: float, T: float, r: float, sigma: float, option_type: str = "call") -> Dict[str, float]:
+def black_scholes(
+    S: float, K: float, T: float, r: float, sigma: float, option_type: str = "call",
+    include_second_order: bool = True,
+) -> Dict[str, float]:
     """Black-Scholes pricing + Greeks (first-order delta/gamma/theta/vega/rho, plus the
     second-order Greeks used by Strategy Builder's "advanced sensitivities" panel: vanna,
     charm, vomma/volga, veta, speed, color, zomma — vera deliberately omitted, see project
@@ -16,15 +19,24 @@ def black_scholes(S: float, K: float, T: float, r: float, sigma: float, option_t
     is verified against finite-difference bumps of this same function's own first-order
     outputs (see scratchpad test_second_order_greeks.py from the Phase 3 build), not just
     hand-derived from a textbook, since these third-derivative formulas are easy to get
-    subtly wrong."""
+    subtly wrong.
+
+    `include_second_order=False` skips that block entirely — strategy_engine.value_at()
+    (the workhorse of check_bounded_risk's ~700-point grid search per candidate, itself
+    called for every candidate the optimizer scans) only ever reads `["price"]`, so paying
+    for 7 unused derivatives on every one of those hundreds of thousands of calls was pure
+    waste discovered while profiling the Phase 4 retrospective-comparison feature — this
+    flag is what fixed it, not a hypothetical optimization."""
     S = float(S or 100.0)
     K = float(K or S)
     T = float(T or 0.001)
     sigma = float(sigma or 0.25)
     if T <= 0 or sigma <= 0:
         intrinsic = max(0, S - K) if option_type == "call" else max(0, K - S)
-        return {"price": intrinsic, "delta": 0, "gamma": 0, "theta": 0, "vega": 0, "rho": 0,
-                "vanna": 0, "charm": 0, "vomma": 0, "veta": 0, "speed": 0, "color": 0, "zomma": 0}
+        result = {"price": intrinsic, "delta": 0, "gamma": 0, "theta": 0, "vega": 0, "rho": 0}
+        if include_second_order:
+            result.update({"vanna": 0, "charm": 0, "vomma": 0, "veta": 0, "speed": 0, "color": 0, "zomma": 0})
+        return result
 
     sqrtT = math.sqrt(T)
     d1 = (math.log(S / K) + (r + 0.5 * sigma ** 2) * T) / (sigma * sqrtT)
@@ -44,6 +56,17 @@ def black_scholes(S: float, K: float, T: float, r: float, sigma: float, option_t
     theta = (-(S * phi_d1 * sigma) / (2 * sqrtT) - r * K * math.exp(-r * T) * norm.cdf(d2 if option_type == "call" else -d2)) / 365
     vega = S * phi_d1 * sqrtT / 100
 
+    result = {
+        "price": round(price, 4),
+        "delta": round(delta, 4),
+        "gamma": round(gamma, 6),
+        "theta": round(theta, 4),
+        "vega": round(vega, 4),
+        "rho": round(rho, 4),
+    }
+    if not include_second_order:
+        return result
+
     # Second-order — same for calls and puts (this pricer carries no dividend yield, so the
     # extra q-term that would otherwise make charm/veta/color differ by option_type is zero).
     vanna = (-phi_d1 * d2 / sigma) / 100
@@ -54,13 +77,7 @@ def black_scholes(S: float, K: float, T: float, r: float, sigma: float, option_t
     color = (phi_d1 / (2 * S * T * sigma * sqrtT) * (2 * r * T + 1 + d1 * (2 * r * T - d2 * sigma * sqrtT) / (sigma * sqrtT))) / 365
     zomma = (gamma * (d1 * d2 - 1) / sigma) / 100
 
-    return {
-        "price": round(price, 4),
-        "delta": round(delta, 4),
-        "gamma": round(gamma, 6),
-        "theta": round(theta, 4),
-        "vega": round(vega, 4),
-        "rho": round(rho, 4),
+    result.update({
         "vanna": round(vanna, 6),
         "charm": round(charm, 6),
         "vomma": round(vomma, 6),
@@ -68,7 +85,8 @@ def black_scholes(S: float, K: float, T: float, r: float, sigma: float, option_t
         "speed": round(speed, 8),
         "color": round(color, 8),
         "zomma": round(zomma, 6),
-    }
+    })
+    return result
 
 
 def compute_pnl_curve(

backend/services/pricing_check.py

@@ -0,0 +1,164 @@
+"""
+Options Lab — "was this option well priced between two dates?" A fine-grained pricing audit
+for a single contract on an instrument, reusing the same `as_of` historical reconstruction
+built for the Portfolio retrospective comparison (services.strategy_comparison /
+services.option_chain's as_of param — see project memory).
+
+The strike is chosen WITH HINDSIGHT: the one closest to where the underlying actually ended
+up by `date_b` ("as if we'd guessed the strike correctly"). That's deliberate — a contract
+near-the-money-at-the-outcome is the one whose value is most sensitive to the realized move,
+which makes it the most revealing lens on whether the volatility priced in at `date_a` was
+actually justified by what happened, rather than picking an arbitrary strike that stayed
+deep OTM/ITM the whole time and would show almost nothing either way.
+
+The price move for each leg is decomposed via its own real Greeks at date_a — Delta×Δspot +
+Theta×elapsed_days + Vega×ΔIV — the "explained" move; whatever's left over ("residual") is
+what a pure Black-Scholes/Greeks story doesn't account for (gamma curvature, skew shift,
+liquidity/spread noise, or a genuine pricing anomaly).
+"""
+from typing import Any, Dict, List, Optional
+
+
+def _realized_vol(yf_ticker: str, date_a: str, date_b: str) -> Optional[float]:
+    """Annualized realized vol of the underlying's own daily closes over [date_a, date_b] —
+    compared against the option's implied vol at date_a to answer "was IV a good forecast
+    of what actually happened," the classic IV-vs-RV question."""
+    import numpy as np
+    from services.data_fetcher import get_historical
+
+    hist = get_historical(yf_ticker, start=date_a, end=date_b, interval="1d")
+    closes = [h["close"] for h in hist if h.get("close")]
+    if len(closes) < 3:
+        return None
+    log_returns = np.diff(np.log(closes))
+    if len(log_returns) < 2:
+        return None
+    return float(np.std(log_returns, ddof=1) * np.sqrt(252))
+
+
+def _leg_quote(rows: List[Dict[str, Any]], expiry_date: str, strike: float, option_type: str) -> Optional[Dict[str, Any]]:
+    for r in rows:
+        if r.get("expiry_date") == expiry_date and abs((r.get("strike") or -1e9) - strike) < 1e-6 and r.get("option_type") == option_type:
+            bid, ask = r.get("bid") or 0.0, r.get("ask") or 0.0
+            mid = r.get("mid") or (round((bid + ask) / 2, 6) if (bid > 0 and ask > 0) else 0.0)
+            vol_pct = r.get("volatility_pct")
+            return {"bid": bid, "ask": ask, "mid": mid, "iv": (float(vol_pct) / 100.0) if vol_pct is not None else None}
+    return None
+
+
+def analyze_option_pricing(ticker: str, date_a: str, date_b: str, target_dte: Optional[int] = None) -> Dict[str, Any]:
+    from datetime import datetime
+    from services.database import get_saxo_option_symbol_for_ticker, get_snapshot_rows_asof
+    from services.option_chain import get_chain_slice
+    from services.options_pricer import black_scholes
+
+    saxo_symbol = get_saxo_option_symbol_for_ticker(ticker)
+    if not saxo_symbol:
+        return {"available": False, "reason": f"'{ticker}' n'est pas lié à un chain Saxo (Config → Instruments Watchlist)."}
+    if date_b <= date_a:
+        return {"available": False, "reason": "La date de fin doit être postérieure à la date de départ."}
+
+    # Same hindsight principle as the strike selection below: by default, target the expiry
+    # closest to date_b (not an arbitrary fixed DTE) — so the contract is still evaluated
+    # right around the moment we actually care about, rather than risking one that's been
+    # expired for weeks by date_b just because target_dte was picked independently of it.
+    # An explicit target_dte still overrides this, e.g. to deliberately look at a
+    # longer-dated contract than the comparison window itself.
+    if target_dte is None:
+        target_dte = (
+            datetime.strptime(date_b[:10], "%Y-%m-%d").date() - datetime.strptime(date_a[:10], "%Y-%m-%d").date()
+        ).days
+
+    try:
+        chain_a = get_chain_slice(saxo_symbol, target_days=target_dte, n_expiries=1, as_of=date_a)
+    except ValueError as e:
+        return {"available": False, "reason": f"Pas d'historique Saxo au {date_a} : {e}"}
+
+    expiry = chain_a["expiries"][0]
+    expiry_date = expiry["expiry_date"]
+    spot_a = chain_a["spot"]
+    strikes_a = sorted({row["strike"] for row in expiry["calls"]} | {row["strike"] for row in expiry["puts"]})
+    if not strikes_a or spot_a is None:
+        return {"available": False, "reason": "Aucun strike/spot exploitable dans le chain à cette date."}
+
+    rows_b = get_snapshot_rows_asof(saxo_symbol, date_b)
+    if not rows_b:
+        return {"available": False, "reason": f"Pas d'historique Saxo au {date_b}."}
+    spot_b = next((r["spot"] for r in rows_b if r.get("spot") is not None), None)
+    if spot_b is None:
+        return {"available": False, "reason": "Spot manquant dans l'historique Saxo à la date de fin."}
+
+    # "As if we'd guessed the strike" — closest to where the underlying actually ended up.
+    chosen_strike = min(strikes_a, key=lambda k: abs(k - spot_b))
+
+    rows_a = get_snapshot_rows_asof(saxo_symbol, date_a)
+    d_a = datetime.strptime(date_a[:10], "%Y-%m-%d").date()
+    d_b = datetime.strptime(date_b[:10], "%Y-%m-%d").date()
+    d_exp = datetime.strptime(expiry_date[:10], "%Y-%m-%d").date()
+    elapsed_days = (d_b - d_a).days
+    days_to_expiry_a = (d_exp - d_a).days
+    days_to_expiry_b = (d_exp - d_b).days
+    expired_by_b = days_to_expiry_b <= 0
+
+    r = 0.05
+    legs_out: Dict[str, Any] = {}
+    for opt_type in ("call", "put"):
+        q_a = _leg_quote(rows_a, expiry_date, chosen_strike, opt_type)
+        if not q_a or q_a["mid"] <= 0 or q_a["iv"] is None:
+            legs_out[opt_type] = {"available": False}
+            continue
+
+        greeks_a = black_scholes(spot_a, chosen_strike, max(days_to_expiry_a, 1) / 365, r, q_a["iv"], opt_type)
+        intrinsic_a = max(0.0, spot_a - chosen_strike) if opt_type == "call" else max(0.0, chosen_strike - spot_a)
+        time_value_a = q_a["mid"] - intrinsic_a
+
+        if expired_by_b:
+            price_b = max(0.0, spot_b - chosen_strike) if opt_type == "call" else max(0.0, chosen_strike - spot_b)
+            iv_b, intrinsic_b, time_value_b = None, price_b, 0.0
+        else:
+            q_b = _leg_quote(rows_b, expiry_date, chosen_strike, opt_type)
+            if not q_b or q_b["mid"] <= 0:
+                legs_out[opt_type] = {"available": False}
+                continue
+            price_b, iv_b = q_b["mid"], q_b["iv"]
+            intrinsic_b = max(0.0, spot_b - chosen_strike) if opt_type == "call" else max(0.0, chosen_strike - spot_b)
+            time_value_b = price_b - intrinsic_b
+
+        actual_change = price_b - q_a["mid"]
+        delta_pnl = greeks_a["delta"] * (spot_b - spot_a)
+        theta_pnl = greeks_a["theta"] * elapsed_days
+        vega_pnl = greeks_a["vega"] * ((iv_b - q_a["iv"]) * 100) if iv_b is not None else 0.0
+        explained = delta_pnl + theta_pnl + vega_pnl
+
+        legs_out[opt_type] = {
+            "available": True,
+            "price_a": round(q_a["mid"], 4), "price_b": round(price_b, 4), "actual_change": round(actual_change, 4),
+            "iv_a": round(q_a["iv"], 4), "iv_b": round(iv_b, 4) if iv_b is not None else None,
+            "intrinsic_a": round(intrinsic_a, 4), "time_value_a": round(time_value_a, 4),
+            "intrinsic_b": round(intrinsic_b, 4), "time_value_b": round(time_value_b, 4),
+            "greeks_a": {k: greeks_a[k] for k in ("delta", "gamma", "theta", "vega")},
+            "attribution": {
+                "delta_pnl": round(delta_pnl, 4), "theta_pnl": round(theta_pnl, 4), "vega_pnl": round(vega_pnl, 4),
+                "explained": round(explained, 4), "residual": round(actual_change - explained, 4),
+            },
+        }
+
+    realized_vol = _realized_vol(ticker, date_a, date_b)
+    iv_a_ref = next((legs_out[t]["iv_a"] for t in ("call", "put") if legs_out.get(t, {}).get("available")), None)
+
+    return {
+        "available": True,
+        "ticker": ticker, "saxo_symbol": saxo_symbol,
+        "date_a": date_a, "date_b": date_b, "elapsed_days": elapsed_days,
+        "target_dte_used": target_dte,
+        "expiry_date": expiry_date, "expired_by_date_b": expired_by_b,
+        "spot_a": round(spot_a, 6), "spot_b": round(spot_b, 6),
+        "spot_change_pct": round((spot_b - spot_a) / spot_a * 100, 2) if spot_a else None,
+        "chosen_strike": chosen_strike,
+        "iv_a": iv_a_ref,
+        "realized_vol": round(realized_vol, 4) if realized_vol is not None else None,
+        "vol_risk_premium": (
+            round(iv_a_ref - realized_vol, 4) if (iv_a_ref is not None and realized_vol is not None) else None
+        ),
+        "legs": legs_out,
+    }

backend/services/strategy_comparison.py

@@ -0,0 +1,169 @@
+"""
+Retrospective "what would have been optimal" comparison for an existing Portfolio position
+— reuses the Strategy Builder optimizer (services.strategy_optimizer.optimize) against the
+REAL historical option chain reconstructed as of the position's entry_date
+(services.option_chain.get_chain_slice's `as_of` param, backed by
+services.database.get_snapshot_rows_asof — the accumulated Saxo snapshot history, not
+synthetic data), scored against the REALIZED spot/IV move between entry and the comparison
+date rather than a guessed scenario — it's not a forecast, it's what actually happened.
+
+Results are compared in PERCENTAGE terms (return on capital / return on risk), never raw
+dollars: Strategy Builder's own pricer (services.strategy_engine, contract_size configurable,
+FX-lot-style default 100_000) and Portfolio's pricer (services.portfolio_pricing, hardcoded
+qty*100 equity-option-style) use different contract-size conventions for historical reasons —
+comparing their dollar outputs directly would silently misstate the comparison by orders of
+magnitude (the exact class of bug this project hit before with the COMEX copper scale issue).
+A % return is convention-agnostic since the contract size cancels out of the ratio.
+"""
+from datetime import date, datetime
+from typing import Any, Dict, Optional
+
+
+def _reprice_actual_legs_pct(
+    legs: list, chain_entry: Dict[str, Any], surface_entry, surface_realized,
+    horizon_days: int, capital_invested: float, ib_fees_entry: float,
+) -> Optional[float]:
+    """% return of the position's REAL legs, priced at entry (services.portfolio_pricing's
+    own qty*100 convention — mirrored here, not imported, since that module's functions are
+    tied to "now" market data, not a historical `as_of` chain) then repriced under the
+    realized move. Returns None if the position has no legs to price."""
+    from services.options_pricer import black_scholes
+    from services.option_chain import find_quote
+
+    if not legs:
+        return None
+    r = 0.05
+    S_entry = chain_entry["spot"]
+    S_realized = surface_realized.spot
+    T_remaining = max(horizon_days, 0) / 365
+
+    pnl = -ib_fees_entry
+    for leg in legs:
+        K = leg.get("strike") or S_entry
+        opt_type = leg.get("option_type", "call")
+        qty = leg.get("quantity", 1)
+        sign = 1 if leg.get("position", "long") == "long" else -1
+        days_to_expiry = leg.get("days_to_expiry", 90)
+
+        entry_premium = leg.get("premium_paid")
+        if entry_premium is None:
+            quote = find_quote(chain_entry, leg.get("expiry_date", ""), K, opt_type)
+            if quote and quote.get("bid", 0) > 0 and quote.get("ask", 0) > 0:
+                entry_premium = quote["mid"]
+            else:
+                sigma_entry = surface_entry.iv_at(K, days_to_expiry)
+                entry_premium = black_scholes(S_entry, K, max(days_to_expiry, 1) / 365, r, sigma_entry, opt_type)["price"]
+
+        remaining = max(days_to_expiry - horizon_days, 0.001)
+        sigma_realized = surface_realized.iv_at(K, remaining)
+        realized_price = (
+            black_scholes(S_realized, K, remaining / 365, r, sigma_realized, opt_type)["price"]
+            if T_remaining > 0 and remaining > 0.001
+            else (max(0.0, S_realized - K) if opt_type == "call" else max(0.0, K - S_realized))
+        )
+        pnl += sign * qty * 100 * (realized_price - entry_premium)
+
+    if not capital_invested:
+        return None
+    return round(pnl / capital_invested * 100, 2)
+
+
+def compute_retrospective_comparison(pos: Dict[str, Any], as_of: Optional[str] = None) -> Dict[str, Any]:
+    from services.database import get_saxo_option_symbol_for_ticker
+    from services.option_chain import get_chain_slice
+    from services.vol_surface import build_surface, apply_scenario
+    from services.strategy_optimizer import optimize as run_optimizer
+
+    underlying = pos["underlying"]
+    saxo_symbol = get_saxo_option_symbol_for_ticker(underlying)
+    if not saxo_symbol:
+        return {"available": False, "reason": f"'{underlying}' n'est pas lié à un chain Saxo (Config → Instruments Watchlist)."}
+
+    entry_date = pos["entry_date"][:10]
+    as_of_date = (as_of or pos.get("close_date") or date.today().isoformat())[:10]
+    if as_of_date <= entry_date:
+        return {"available": False, "reason": "La date de comparaison doit être postérieure à la date d'entrée."}
+
+    horizon_days = (
+        datetime.strptime(as_of_date, "%Y-%m-%d").date() - datetime.strptime(entry_date, "%Y-%m-%d").date()
+    ).days
+    target_days_entry = pos.get("expiry_days", 90)
+
+    try:
+        chain_entry = get_chain_slice(saxo_symbol, target_days=target_days_entry, n_expiries=3, as_of=entry_date)
+    except ValueError as e:
+        return {"available": False, "reason": f"Pas d'historique Saxo à la date d'entrée ({entry_date}) : {e}"}
+    try:
+        chain_realized = get_chain_slice(
+            saxo_symbol, target_days=max(target_days_entry - horizon_days, 1), n_expiries=3,
+            as_of=as_of_date if as_of else None,
+        )
+    except ValueError as e:
+        return {"available": False, "reason": f"Pas d'historique Saxo à la date de comparaison ({as_of_date}) : {e}"}
+
+    surface_entry = build_surface(chain_entry)
+    surface_realized_base = build_surface(chain_realized)
+
+    spot_entry = chain_entry["spot"]
+    spot_realized = chain_realized["spot"]
+    if not spot_entry or not spot_realized:
+        return {"available": False, "reason": "Spot manquant dans l'historique Saxo à l'une des deux dates."}
+
+    realized_spot_shock_pct = round((spot_realized - spot_entry) / spot_entry * 100, 2)
+    iv_entry = surface_entry.iv_at(spot_entry, target_days_entry)
+    iv_realized = surface_realized_base.iv_at(spot_realized, max(target_days_entry - horizon_days, 1))
+    realized_iv_shift = round(iv_realized - iv_entry, 4)
+
+    # The same realized shock, applied on top of the ENTRY surface — puts the "actual
+    # position" and "optimal candidates" repricing on the exact same footing (both start
+    # from what was really quoted at entry, both move by what really happened afterwards).
+    surface_realized = apply_scenario(surface_entry, spot_shock_pct=realized_spot_shock_pct, iv_level_shift=realized_iv_shift)
+
+    actual_return_pct = _reprice_actual_legs_pct(
+        pos.get("legs", []), chain_entry, surface_entry, surface_realized,
+        horizon_days, pos.get("capital_invested") or 0, pos.get("ib_fees_entry", 0),
+    )
+
+    optimal_candidates = run_optimizer(
+        symbol=saxo_symbol, horizon_days=horizon_days,
+        spot_shock_pct=realized_spot_shock_pct, iv_level_shift=realized_iv_shift,
+        skew_tilt=0.0, term_slope_shift=0.0, manual_grid=None, n_expiries=3, rate=0.05,
+        constraints={"max_legs": 4, "delta_threshold": None, "max_loss_cap": None},
+        objective="net_pnl", top_n=5, as_of=entry_date,
+    )
+
+    # NOT "return on max_loss": check_bounded_risk's worst-case search is unreliable for
+    # multi-expiry (calendar/diagonal) structures — the far leg is still alive and vol-
+    # dependent at the near leg's expiry, so its "max loss" can come out implausibly small
+    # regardless of precise=True/False, producing a nonsense ratio (verified empirically:
+    # >9000% "return on risk" on a diagonal in testing). Comparing against the SAME capital
+    # basis as the actual position (capital_invested) sidesteps that search entirely — "if
+    # you'd put the same money into this instead" is also a more direct answer to "what
+    # should I have done" than a max-loss ratio would be. Repriced at contract_size=100 to
+    # match Portfolio's own per-contract convention (see module docstring) rather than
+    # Strategy Builder's default FX-lot size, so the dollar P&L this produces is actually on
+    # the same footing as capital_invested, not just a same-shaped ratio.
+    from services.strategy_engine import price_combo
+    capital = pos.get("capital_invested") or 0
+    for c in optimal_candidates:
+        try:
+            precise = price_combo(
+                c["legs"], chain_entry, surface_entry, surface_realized, horizon_days,
+                r=0.05, contract_size=100, precise=True,
+            )
+            c["net_pnl"], c["max_gain"], c["max_loss"] = precise["net_pnl"], precise["max_gain"], precise["max_loss"]
+            c["net_delta_now"] = precise["net_delta_now"]
+            c["return_on_capital_pct"] = round(precise["net_pnl"] / capital * 100, 2) if capital else None
+        except Exception:
+            c["return_on_capital_pct"] = None
+
+    return {
+        "available": True,
+        "underlying": underlying, "saxo_symbol": saxo_symbol,
+        "entry_date": entry_date, "as_of": as_of_date, "horizon_days": horizon_days,
+        "spot_entry": round(spot_entry, 6), "spot_realized": round(spot_realized, 6),
+        "realized_spot_shock_pct": realized_spot_shock_pct,
+        "iv_entry": round(iv_entry, 4), "iv_realized": round(iv_realized, 4), "realized_iv_shift": realized_iv_shift,
+        "actual_return_pct": actual_return_pct,
+        "optimal_candidates": optimal_candidates,
+    }

backend/services/strategy_engine.py

@@ -81,7 +81,10 @@ def value_at(
     r: float,
     contract_size: float = DEFAULT_CONTRACT_SIZE,
 ) -> float:
-    """Signed portfolio value (BS reprice for unexpired legs, intrinsic for expired ones)."""
+    """Signed portfolio value (BS reprice for unexpired legs, intrinsic for expired ones).
+    check_bounded_risk calls this ~700 times per candidate it evaluates — second-order
+    Greeks are never read here, so they're skipped (include_second_order=False) rather than
+    computed and discarded on every one of those calls."""
     total = 0.0
     for leg in legs:
         remaining = leg["days_to_expiry"] - eval_days_from_now
@@ -91,7 +94,7 @@ def value_at(
             price = _intrinsic(S, leg["strike"], leg["option_type"])
         else:
             sigma = surface.iv_at(leg["strike"], remaining)
-            price = black_scholes(S, leg["strike"], remaining / 365, r, sigma, leg["option_type"])["price"]
+            price = black_scholes(S, leg["strike"], remaining / 365, r, sigma, leg["option_type"], include_second_order=False)["price"]
         total += sign * price * qty * contract_size
     return total
 

backend/services/strategy_optimizer.py

@@ -273,9 +273,10 @@ def optimize(
     dte_min: Optional[int] = None,
     dte_max: Optional[int] = None,
     greek_profile: Optional[Dict[str, Any]] = None,
+    as_of: Optional[str] = None,
 ) -> List[Dict[str, Any]]:
     r = rate + rate_shock_bps / 10000.0
-    chain_slice = get_chain_slice(symbol, horizon_days, n_expiries, dte_min=dte_min, dte_max=dte_max)
+    chain_slice = get_chain_slice(symbol, horizon_days, n_expiries, dte_min=dte_min, dte_max=dte_max, as_of=as_of)
     surface_now = build_surface(chain_slice)
     surface_scenario = apply_scenario(
         surface_now, spot_shock_pct=spot_shock_pct, iv_level_shift=iv_level_shift,