Overlay past Toto and NWS forecasts on the historical chart

Every refresh already logs each forecast (p10/p50/p90) keyed by both
forecast_made_at and target_ts. Use that history to plot, for each past
hour, the most-recent forecast that was issued *before* that hour — for
both Toto and NWS — alongside the Ecowitt actuals on every metric panel.

- src/forecast_log.py: historical_predictions(source, metric, since_unix)
joins the forecast table back onto itself per (source, target_ts) to
pick the latest pre-target snapshot, returns a tidy ts-indexed DF.
- app.py: build past_toto / past_nws dicts per metric over the visible
history window, pass them into combined_figure.
- src/weather_ui.py: render two new dimmer overlay traces — a solid
semi-transparent blue line for past Toto p50, dashed semi-transparent
red for past NWS — so the viewer can see at a glance how each model
has been doing on this exact station.

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

app.py

@@ -186,12 +186,33 @@ def refresh(cycle_label: str = "Hourly", horizon_label: str = "24 h"):
             forecast_log.record_nws(log_conn, m["col"], ns)
 
     now = pd.Timestamp.now(tz="UTC").floor("h")
+
+    # Look back: for each metric, build a series of past predictions issued
+    # for actual hours that have already passed. Lets us overlay what each
+    # model thought vs what happened.
+    visible_history = history.tail(int(hist_days * 24 / step_hours))
+    since_unix = (
+        int(visible_history.index.min().timestamp()) if not visible_history.empty else None
+    )
+    past_toto: dict[str, pd.DataFrame] = {}
+    past_nws: dict[str, pd.DataFrame] = {}
+    for m in METRICS:
+        col = m["col"]
+        pt = forecast_log.historical_predictions(log_conn, "toto", col, since_unix=since_unix)
+        if not pt.empty:
+            past_toto[col] = pt
+        pn = forecast_log.historical_predictions(log_conn, "nws", col, since_unix=since_unix)
+        if not pn.empty:
+            past_nws[col] = pn
+
     fig = combined_figure(
-        history=history.tail(int(hist_days * 24 / step_hours)),
+        history=visible_history,
         totos=totos,
         nws_df=nws_future,
         metrics=METRICS,
         now=now,
+        past_toto=past_toto,
+        past_nws=past_nws,
     )
 
     hero = hero_markdown(PLACE_NAME, history, nws_first, DISPLAY_TZ, realtime=realtime)

src/forecast_log.py

@@ -160,6 +160,45 @@ def scoreboard(
     return df
 
 
+def historical_predictions(
+    conn: sqlite3.Connection,
+    source: str,
+    metric: str,
+    since_unix: int | None = None,
+) -> pd.DataFrame:
+    """For each past target_ts, return the most-recent forecast issued for it.
+
+    Useful for overlaying 'what we predicted vs what actually happened' on the
+    historical portion of the chart. Result is a DataFrame indexed by UTC
+    timestamp with columns p10, p50, p90 (NWS rows have NULL p10/p90).
+    """
+    params: list = [source, metric]
+    where_extra = ""
+    if since_unix is not None:
+        where_extra = " AND target_ts >= ?"
+        params.append(since_unix)
+    sql = f"""
+    WITH latest AS (
+        SELECT source, target_ts, metric,
+               MAX(forecast_made_at) AS forecast_made_at
+        FROM forecast_snapshots
+        WHERE source = ? AND metric = ? AND forecast_made_at <= target_ts
+        {where_extra}
+        GROUP BY source, target_ts, metric
+    )
+    SELECT f.target_ts, f.p10, f.p50, f.p90
+    FROM forecast_snapshots f
+    JOIN latest l USING (source, target_ts, metric, forecast_made_at)
+    ORDER BY f.target_ts
+    """
+    df = pd.read_sql_query(sql, conn, params=params)
+    if df.empty:
+        return df
+    df.index = pd.to_datetime(df["target_ts"], unit="s", utc=True)
+    df = df.drop(columns=["target_ts"])
+    return df
+
+
 def scoreboard_summary(
     conn: sqlite3.Connection,
     metric: str = "temp_f",

src/weather_ui.py

@@ -187,6 +187,8 @@ def combined_figure(
     nws_df: pd.DataFrame | None,
     metrics: list[dict],
     now: pd.Timestamp | None = None,
+    past_toto: dict[str, pd.DataFrame] | None = None,
+    past_nws: dict[str, pd.DataFrame] | None = None,
 ) -> go.Figure:
     """Three stacked subplots sharing the x-axis."""
     fig = make_subplots(
@@ -212,6 +214,30 @@ def combined_figure(
             ),
             row=i, col=1,
         )
+        # Past Toto forecasts vs the same hours' actuals.
+        if past_toto and col in past_toto:
+            pt = past_toto[col]
+            fig.add_trace(
+                go.Scatter(
+                    x=pt.index, y=pt["p50"].values,
+                    name="🤖 Toto (past forecasts)", mode="lines",
+                    line=dict(color="rgba(31,119,180,0.55)", width=1.5),
+                    showlegend=showlegend, legendgroup="toto-past",
+                ),
+                row=i, col=1,
+            )
+        # Past NWS forecasts vs the same hours' actuals.
+        if past_nws and col in past_nws:
+            pn = past_nws[col]
+            fig.add_trace(
+                go.Scatter(
+                    x=pn.index, y=pn["p50"].values,
+                    name="🌎 NWS (past forecasts)", mode="lines",
+                    line=dict(color="rgba(214,39,40,0.55)", width=1.5, dash="dash"),
+                    showlegend=showlegend, legendgroup="nws-past",
+                ),
+                row=i, col=1,
+            )
         if toto is not None:
             fig.add_trace(
                 go.Scatter(