feat(replay): R1 replay core — clock injection + replay of archived cycles

Re-executes BayesianStrategy.evaluate() over the R0 archive and stores
results in replay_runs/replay_decisions, tagged with git sha + a hash of
the strategy constants (same hash vs archive = determinism check,
different hash = counterfactual run).

- bayesian.py: optional as_of param on evaluate()/_days_to_resolution()
  (clock injection; default None = wall clock, prod behavior unchanged —
  the only touch to frozen code, purely additive)
- bot/replay.py: replay engine + CLI (python -m bot.replay --from --to);
  ReplayNews feeds archived sentiment back (GNews never called, per-cycle
  budget bypassed — archived sentiment already encodes it); manifold/db
  not wired (observational-only in prod); recorded-vs-replayed compare
  at 1e-9 tolerance
- schema.sql: replay_runs + replay_decisions (+ indexes), idempotent
- db.py: 6 replay accessors/writers
- tests: 19 new round-trip fidelity tests (104 total green)

Validated against a real prod cycle (2026-07-02T14:03:15Z, 46 markets,
4 skip paths incl. the Georgia confidence record): 46/46 matched,
max float delta 0.0.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

bot/data/db.py

@@ -747,6 +747,85 @@ class Database:
         except (ValueError, IndexError):
             return 0
 
+    # ── Replay R1: replay core ───────────────────────────────────────────────
+
+    async def get_replay_cycles(self, from_ts, to_ts) -> list:
+        """Return the cycle_ts values with archived decisions in [from_ts, to_ts)."""
+        async with self._pool.acquire() as conn:
+            rows = await conn.fetch("""
+                SELECT DISTINCT cycle_ts FROM signals
+                WHERE cycle_ts >= $1 AND cycle_ts < $2
+                ORDER BY cycle_ts
+            """, from_ts, to_ts)
+        return [r["cycle_ts"] for r in rows]
+
+    async def get_ext_snapshot(self, cycle_ts) -> Optional[dict]:
+        """Return one cycle's ExternalSignals snapshot, or None if missing."""
+        async with self._pool.acquire() as conn:
+            row = await conn.fetchrow(
+                "SELECT * FROM ext_snapshots WHERE cycle_ts = $1", cycle_ts
+            )
+        return dict(row) if row else None
+
+    async def get_cycle_signal_rows(self, cycle_ts) -> list[dict]:
+        """Return one cycle's archived decision rows in original evaluation
+        order (id = insertion order = the order main.py evaluated them)."""
+        async with self._pool.acquire() as conn:
+            rows = await conn.fetch(
+                "SELECT * FROM signals WHERE cycle_ts = $1 ORDER BY id", cycle_ts
+            )
+        return [dict(r) for r in rows]
+
+    async def get_markets_by_ids(self, market_ids: list[str]) -> dict[str, dict]:
+        """Return market metadata rows keyed by id (for Market reconstruction)."""
+        if not market_ids:
+            return {}
+        async with self._pool.acquire() as conn:
+            rows = await conn.fetch(
+                "SELECT * FROM markets WHERE id = ANY($1::text[])", market_ids
+            )
+        return {r["id"]: dict(r) for r in rows}
+
+    async def save_replay_run(self, run: dict) -> None:
+        async with self._pool.acquire() as conn:
+            await conn.execute("""
+                INSERT INTO replay_runs (
+                    run_id, git_sha, config_hash, config_json,
+                    from_ts, to_ts, cycles, decisions, matched, mismatched, note
+                ) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11)
+            """,
+                run["run_id"], run["git_sha"], run["config_hash"],
+                run["config_json"], run["from_ts"], run["to_ts"],
+                run["cycles"], run["decisions"], run["matched"],
+                run["mismatched"], run["note"],
+            )
+
+    async def save_replay_decisions(self, run_id: str, decisions: list[dict]) -> None:
+        if not decisions:
+            return
+        rows = [
+            (
+                run_id, d["cycle_ts"], d["market_id"],
+                d["skip_reason"], d["prior_prob"], d["estimated_prob"],
+                d["raw_final_prob"], d["edge_gross"], d["edge_net"],
+                d["regime_min_edge"], d["days_to_resolution"],
+                d["confidence"], d["direction"], d["would_trade"],
+                d["recorded_skip_reason"], d["matched"], d["mismatch_field"],
+            )
+            for d in decisions
+        ]
+        async with self._pool.acquire() as conn:
+            await conn.executemany("""
+                INSERT INTO replay_decisions (
+                    run_id, cycle_ts, market_id,
+                    skip_reason, prior_prob, estimated_prob,
+                    raw_final_prob, edge_gross, edge_net,
+                    regime_min_edge, days_to_resolution,
+                    confidence, direction, would_trade,
+                    recorded_skip_reason, matched, mismatch_field
+                ) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17)
+            """, rows)
+
     async def mark_manifold_audit_used(self, audit_id: str) -> None:
         async with self._pool.acquire() as conn:
             await conn.execute(