Upload runtime.py

runtime.py

@@ -664,6 +664,21 @@ def _archive_tomorrow_latest_to_history() -> None:
         pass
 
 
+def _tomorrow_actual_outcome(
+    target_day: date,
+    day_close: float,
+    closes_by_date: dict[date, float],
+) -> tuple[float | None, str | None]:
+    """Return (move, direction) for Tomorrow scoring: close vs previous session close."""
+    prev_day = previous_trading_day(target_day - timedelta(days=1))
+    prev_close = closes_by_date.get(prev_day)
+    if prev_close is None or not np.isfinite(prev_close) or prev_close == 0:
+        return None, None
+    actual_move = (day_close - prev_close) / prev_close
+    actual_direction = "UP" if day_close > prev_close else "DOWN"
+    return actual_move, actual_direction
+
+
 def _find_tomorrow_prediction_for_target(target_day: date) -> dict[str, Any] | None:
     """Return the Tomorrow prediction that targets ``target_day``."""
     target_iso = target_day.isoformat()
@@ -1307,13 +1322,19 @@ def build_prediction_track_record(
                 {"source": entry.get("source", "live")},
             )
 
+    closes_by_date = {
+        row["date"].date(): float(row["close"])
+        for _, row in daily_rows.iterrows()
+        if pd.notna(row["close"]) and np.isfinite(float(row["close"]))
+    }
+
     records: list[dict[str, Any]] = []
     for _, row in daily_rows.tail(20).iterrows():
         day = row["date"].date().isoformat()
-        day_open = float(row["open"])
         day_close = float(row["close"])
-        actual_move = (day_close - day_open) / day_open
-        actual_direction = "UP" if actual_move >= 0 else "DOWN"
+        actual_move, actual_direction = _tomorrow_actual_outcome(row["date"].date(), day_close, closes_by_date)
+        if actual_direction is None:
+            continue
         pred = predictions_by_date.get(day)
         prediction = pred.get("prediction") if pred else None
         if prediction is None:
@@ -1622,6 +1643,43 @@ def _record_prediction_history(path: Path, row: dict[str, Any], subset: list[str
     append_prediction_history(path, row, subset)
 
 
+def _rescore_tomorrow_live_ledger(ledger: dict[str, Any]) -> bool:
+    """Fix live Tomorrow ledger entries to use close vs previous close. Returns True if modified."""
+    daily = pd.read_parquet(NIFTY_1D_PATH)
+    daily["_date"] = pd.to_datetime(daily["date"], errors="coerce").dt.normalize()
+    closes_by_date: dict[date, float] = {}
+    for _, row in daily.iterrows():
+        if pd.isna(row["_date"]):
+            continue
+        close = row.get("close")
+        if pd.notna(close) and np.isfinite(float(close)):
+            closes_by_date[row["_date"].date()] = float(close)
+
+    changed = False
+    for entry in ledger.get("tomorrow", {}).get("entries", []):
+        if str(entry.get("source", "backtest")).lower() == "backtest":
+            continue
+        try:
+            day = date.fromisoformat(str(entry.get("date", ""))[:10])
+        except Exception:
+            continue
+        day_close = closes_by_date.get(day)
+        if day_close is None:
+            continue
+        _, actual_direction = _tomorrow_actual_outcome(day, day_close, closes_by_date)
+        if actual_direction is None:
+            continue
+        pred = str(entry.get("prediction", "")).upper()
+        if pred not in {"UP", "DOWN"}:
+            continue
+        new_correct = pred == actual_direction
+        if entry.get("actual") != actual_direction or entry.get("correct") != new_correct:
+            entry["actual"] = actual_direction
+            entry["correct"] = new_correct
+            changed = True
+    return changed
+
+
 def ensure_completed_sessions_scored(
     now: datetime | None = None,
     ledger: dict[str, Any] | None = None,
@@ -1633,6 +1691,19 @@ def ensure_completed_sessions_scored(
         return ledger or load_live_accuracy()
 
     ledger = ledger or load_live_accuracy()
+    if _rescore_tomorrow_live_ledger(ledger):
+        for model_id in ("tomorrow",):
+            entries = ledger[model_id]["entries"]
+            total = len(entries)
+            correct = sum(1 for e in entries if e.get("correct"))
+            backtest_count = sum(1 for e in entries if str(e.get("source", "backtest")).lower() == "backtest")
+            ledger[model_id]["total"] = total
+            ledger[model_id]["correct_count"] = correct
+            ledger[model_id]["backtest_count"] = backtest_count
+            ledger[model_id]["live_count"] = total - backtest_count
+            ledger[model_id]["accuracy"] = correct / total if total > 0 else None
+        save_live_accuracy(ledger)
+        clear_dashboard_payload_cache()
     logged_tom = {e["date"] for e in ledger.get("tomorrow", {}).get("entries", [])}
     if completed.isoformat() in logged_tom:
         return ledger
@@ -1703,12 +1774,18 @@ def update_live_accuracy(session_date: date) -> dict[str, Any]:
             except Exception:
                 pass
 
-    # --- Tomorrow: yesterday's prediction targeting today vs close vs open ---
+    # --- Tomorrow: prior close vs today's close (matches forecaster target) ---
     logged_tom = {e["date"] for e in ledger["tomorrow"]["entries"]}
     if session_iso not in logged_tom:
-        actual_tomorrow = "UP" if day_close >= day_open else "DOWN"
+        prev_day = previous_trading_day(session_date - timedelta(days=1))
+        prev_rows = daily[daily["_date"].dt.date == prev_day]
+        actual_tomorrow = None
+        if not prev_rows.empty:
+            prev_close = float(prev_rows.iloc[-1]["close"])
+            if np.isfinite(prev_close) and prev_close != 0:
+                actual_tomorrow = "UP" if day_close > prev_close else "DOWN"
         tom_row = _find_tomorrow_prediction_for_target(session_date)
-        if tom_row:
+        if tom_row and actual_tomorrow is not None:
             try:
                 pred = str(tom_row.get("prediction", "")).upper()
                 if pred in ("UP", "DOWN"):
@@ -1761,6 +1838,8 @@ def update_live_accuracy(session_date: date) -> dict[str, Any]:
             except Exception:
                 pass
 
+    _rescore_tomorrow_live_ledger(ledger)
+
     # Recompute summary stats
     for model_id in ("t5", "tomorrow", "tplus1"):
         entries = ledger[model_id]["entries"]