feat: read-only FastAPI dashboard with 7 API endpoints (issue #96)

Add observability dashboard: status, playbook, scorecard, performance,
context browser, decisions, and active scenarios endpoints.
SQLite read-only on separate connections from trading loop.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

pyproject.toml

@@ -9,6 +9,7 @@ dependencies = [
     "pydantic-settings>=2.1,<3",
     "google-genai>=1.0,<2",
     "scipy>=1.11,<2",
+    "fastapi>=0.110,<1",
 ]
 
 [project.optional-dependencies]

src/context/__init__.py

@@ -5,6 +5,7 @@ The context tree implements Pillar 2: hierarchical memory management across
 """
 
 from src.context.layer import ContextLayer
+from src.context.scheduler import ContextScheduler
 from src.context.store import ContextStore
 
-__all__ = ["ContextLayer", "ContextStore"]
+__all__ = ["ContextLayer", "ContextScheduler", "ContextStore"]

src/context/aggregator.py

@@ -18,52 +18,83 @@ class ContextAggregator:
         self.conn = conn
         self.store = ContextStore(conn)
 
-    def aggregate_daily_from_trades(self, date: str | None = None) -> None:
+    def aggregate_daily_from_trades(
+        self, date: str | None = None, market: str | None = None
+    ) -> None:
         """Aggregate L6 (daily) context from trades table.
 
         Args:
             date: Date in YYYY-MM-DD format. If None, uses today.
+            market: Market code filter (e.g., "KR", "US"). If None, aggregates all markets.
         """
         if date is None:
             date = datetime.now(UTC).date().isoformat()
 
-        # Calculate daily metrics from trades
-        cursor = self.conn.execute(
-            """
-            SELECT
-                COUNT(*) as trade_count,
-                SUM(CASE WHEN action = 'BUY' THEN 1 ELSE 0 END) as buys,
-                SUM(CASE WHEN action = 'SELL' THEN 1 ELSE 0 END) as sells,
-                SUM(CASE WHEN action = 'HOLD' THEN 1 ELSE 0 END) as holds,
-                AVG(confidence) as avg_confidence,
-                SUM(pnl) as total_pnl,
-                COUNT(DISTINCT stock_code) as unique_stocks,
-                SUM(CASE WHEN pnl > 0 THEN 1 ELSE 0 END) as wins,
-                SUM(CASE WHEN pnl < 0 THEN 1 ELSE 0 END) as losses
-            FROM trades
-            WHERE DATE(timestamp) = ?
-            """,
-            (date,),
-        )
-        row = cursor.fetchone()
-
-        if row and row[0] > 0:  # At least one trade
-            trade_count, buys, sells, holds, avg_conf, total_pnl, stocks, wins, losses = row
-
-            # Store daily metrics in L6
-            self.store.set_context(ContextLayer.L6_DAILY, date, "trade_count", trade_count)
-            self.store.set_context(ContextLayer.L6_DAILY, date, "buys", buys)
-            self.store.set_context(ContextLayer.L6_DAILY, date, "sells", sells)
-            self.store.set_context(ContextLayer.L6_DAILY, date, "holds", holds)
-            self.store.set_context(
-                ContextLayer.L6_DAILY, date, "avg_confidence", round(avg_conf, 2)
+        if market is None:
+            cursor = self.conn.execute(
+                """
+                SELECT DISTINCT market
+                FROM trades
+                WHERE DATE(timestamp) = ?
+                """,
+                (date,),
             )
-            self.store.set_context(
-                ContextLayer.L6_DAILY, date, "total_pnl", round(total_pnl, 2)
+            markets = [row[0] for row in cursor.fetchall() if row[0]]
+        else:
+            markets = [market]
+
+        for market_code in markets:
+            # Calculate daily metrics from trades for the market
+            cursor = self.conn.execute(
+                """
+                SELECT
+                    COUNT(*) as trade_count,
+                    SUM(CASE WHEN action = 'BUY' THEN 1 ELSE 0 END) as buys,
+                    SUM(CASE WHEN action = 'SELL' THEN 1 ELSE 0 END) as sells,
+                    SUM(CASE WHEN action = 'HOLD' THEN 1 ELSE 0 END) as holds,
+                    AVG(confidence) as avg_confidence,
+                    SUM(pnl) as total_pnl,
+                    COUNT(DISTINCT stock_code) as unique_stocks,
+                    SUM(CASE WHEN pnl > 0 THEN 1 ELSE 0 END) as wins,
+                    SUM(CASE WHEN pnl < 0 THEN 1 ELSE 0 END) as losses
+                FROM trades
+                WHERE DATE(timestamp) = ? AND market = ?
+                """,
+                (date, market_code),
             )
-            self.store.set_context(ContextLayer.L6_DAILY, date, "unique_stocks", stocks)
-            win_rate = round(wins / max(wins + losses, 1) * 100, 2)
-            self.store.set_context(ContextLayer.L6_DAILY, date, "win_rate", win_rate)
+            row = cursor.fetchone()
+
+            if row and row[0] > 0:  # At least one trade
+                trade_count, buys, sells, holds, avg_conf, total_pnl, stocks, wins, losses = row
+
+                key_suffix = f"_{market_code}"
+
+                # Store daily metrics in L6 with market suffix
+                self.store.set_context(
+                    ContextLayer.L6_DAILY, date, f"trade_count{key_suffix}", trade_count
+                )
+                self.store.set_context(ContextLayer.L6_DAILY, date, f"buys{key_suffix}", buys)
+                self.store.set_context(ContextLayer.L6_DAILY, date, f"sells{key_suffix}", sells)
+                self.store.set_context(ContextLayer.L6_DAILY, date, f"holds{key_suffix}", holds)
+                self.store.set_context(
+                    ContextLayer.L6_DAILY,
+                    date,
+                    f"avg_confidence{key_suffix}",
+                    round(avg_conf, 2),
+                )
+                self.store.set_context(
+                    ContextLayer.L6_DAILY,
+                    date,
+                    f"total_pnl{key_suffix}",
+                    round(total_pnl, 2),
+                )
+                self.store.set_context(
+                    ContextLayer.L6_DAILY, date, f"unique_stocks{key_suffix}", stocks
+                )
+                win_rate = round(wins / max(wins + losses, 1) * 100, 2)
+                self.store.set_context(
+                    ContextLayer.L6_DAILY, date, f"win_rate{key_suffix}", win_rate
+                )
 
     def aggregate_weekly_from_daily(self, week: str | None = None) -> None:
         """Aggregate L5 (weekly) context from L6 (daily).
@@ -92,14 +123,25 @@ class ContextAggregator:
             daily_data[row[0]].append(json.loads(row[1]))
 
         if daily_data:
-            # Sum all PnL values
+            # Sum all PnL values (market-specific if suffixed)
             if "total_pnl" in daily_data:
                 total_pnl = sum(daily_data["total_pnl"])
                 self.store.set_context(
                     ContextLayer.L5_WEEKLY, week, "weekly_pnl", round(total_pnl, 2)
                 )
 
-            # Average all confidence values
+            for key, values in daily_data.items():
+                if key.startswith("total_pnl_"):
+                    market_code = key.split("total_pnl_", 1)[1]
+                    total_pnl = sum(values)
+                    self.store.set_context(
+                        ContextLayer.L5_WEEKLY,
+                        week,
+                        f"weekly_pnl_{market_code}",
+                        round(total_pnl, 2),
+                    )
+
+            # Average all confidence values (market-specific if suffixed)
             if "avg_confidence" in daily_data:
                 conf_values = daily_data["avg_confidence"]
                 avg_conf = sum(conf_values) / len(conf_values)
@@ -107,6 +149,17 @@ class ContextAggregator:
                     ContextLayer.L5_WEEKLY, week, "avg_confidence", round(avg_conf, 2)
                 )
 
+            for key, values in daily_data.items():
+                if key.startswith("avg_confidence_"):
+                    market_code = key.split("avg_confidence_", 1)[1]
+                    avg_conf = sum(values) / len(values)
+                    self.store.set_context(
+                        ContextLayer.L5_WEEKLY,
+                        week,
+                        f"avg_confidence_{market_code}",
+                        round(avg_conf, 2),
+                    )
+
     def aggregate_monthly_from_weekly(self, month: str | None = None) -> None:
         """Aggregate L4 (monthly) context from L5 (weekly).
 
@@ -135,8 +188,16 @@ class ContextAggregator:
 
         if weekly_data:
             # Sum all weekly PnL values
+            total_pnl_values: list[float] = []
             if "weekly_pnl" in weekly_data:
-                total_pnl = sum(weekly_data["weekly_pnl"])
+                total_pnl_values.extend(weekly_data["weekly_pnl"])
+
+            for key, values in weekly_data.items():
+                if key.startswith("weekly_pnl_"):
+                    total_pnl_values.extend(values)
+
+            if total_pnl_values:
+                total_pnl = sum(total_pnl_values)
                 self.store.set_context(
                     ContextLayer.L4_MONTHLY, month, "monthly_pnl", round(total_pnl, 2)
                 )

src/context/scheduler.py

@@ -0,0 +1,135 @@
+"""Context aggregation scheduler for periodic rollups and cleanup."""
+
+from __future__ import annotations
+
+import sqlite3
+from calendar import monthrange
+from dataclasses import dataclass
+from datetime import UTC, datetime
+
+from src.context.aggregator import ContextAggregator
+from src.context.store import ContextStore
+
+
+@dataclass(frozen=True)
+class ScheduleResult:
+    """Represents which scheduled tasks ran."""
+
+    weekly: bool = False
+    monthly: bool = False
+    quarterly: bool = False
+    annual: bool = False
+    legacy: bool = False
+    cleanup: bool = False
+
+
+class ContextScheduler:
+    """Run periodic context aggregations and cleanup when due."""
+
+    def __init__(
+        self,
+        conn: sqlite3.Connection | None = None,
+        aggregator: ContextAggregator | None = None,
+        store: ContextStore | None = None,
+    ) -> None:
+        if aggregator is None:
+            if conn is None:
+                raise ValueError("conn is required when aggregator is not provided")
+            aggregator = ContextAggregator(conn)
+        self.aggregator = aggregator
+
+        if store is None:
+            store = getattr(aggregator, "store", None)
+        if store is None:
+            if conn is None:
+                raise ValueError("conn is required when store is not provided")
+            store = ContextStore(conn)
+        self.store = store
+
+        self._last_run: dict[str, str] = {}
+
+    def run_if_due(self, now: datetime | None = None) -> ScheduleResult:
+        """Run scheduled aggregations if their schedule is due.
+
+        Args:
+            now: Current datetime (UTC). If None, uses current time.
+
+        Returns:
+            ScheduleResult indicating which tasks ran.
+        """
+        if now is None:
+            now = datetime.now(UTC)
+
+        today = now.date().isoformat()
+        result = ScheduleResult()
+
+        if self._should_run("cleanup", today):
+            self.store.cleanup_expired_contexts()
+            result = self._with(result, cleanup=True)
+
+        if self._is_sunday(now) and self._should_run("weekly", today):
+            week = now.strftime("%Y-W%V")
+            self.aggregator.aggregate_weekly_from_daily(week)
+            result = self._with(result, weekly=True)
+
+        if self._is_last_day_of_month(now) and self._should_run("monthly", today):
+            month = now.strftime("%Y-%m")
+            self.aggregator.aggregate_monthly_from_weekly(month)
+            result = self._with(result, monthly=True)
+
+        if self._is_last_day_of_quarter(now) and self._should_run("quarterly", today):
+            quarter = self._current_quarter(now)
+            self.aggregator.aggregate_quarterly_from_monthly(quarter)
+            result = self._with(result, quarterly=True)
+
+        if self._is_last_day_of_year(now) and self._should_run("annual", today):
+            year = str(now.year)
+            self.aggregator.aggregate_annual_from_quarterly(year)
+            result = self._with(result, annual=True)
+
+            # Legacy rollup runs after annual aggregation.
+            self.aggregator.aggregate_legacy_from_annual()
+            result = self._with(result, legacy=True)
+
+        return result
+
+    def _should_run(self, key: str, date_str: str) -> bool:
+        if self._last_run.get(key) == date_str:
+            return False
+        self._last_run[key] = date_str
+        return True
+
+    @staticmethod
+    def _is_sunday(now: datetime) -> bool:
+        return now.weekday() == 6
+
+    @staticmethod
+    def _is_last_day_of_month(now: datetime) -> bool:
+        last_day = monthrange(now.year, now.month)[1]
+        return now.day == last_day
+
+    @classmethod
+    def _is_last_day_of_quarter(cls, now: datetime) -> bool:
+        if now.month not in (3, 6, 9, 12):
+            return False
+        return cls._is_last_day_of_month(now)
+
+    @staticmethod
+    def _is_last_day_of_year(now: datetime) -> bool:
+        return now.month == 12 and now.day == 31
+
+    @staticmethod
+    def _current_quarter(now: datetime) -> str:
+        quarter = (now.month - 1) // 3 + 1
+        return f"{now.year}-Q{quarter}"
+
+    @staticmethod
+    def _with(result: ScheduleResult, **kwargs: bool) -> ScheduleResult:
+        return ScheduleResult(
+            weekly=kwargs.get("weekly", result.weekly),
+            monthly=kwargs.get("monthly", result.monthly),
+            quarterly=kwargs.get("quarterly", result.quarterly),
+            annual=kwargs.get("annual", result.annual),
+            legacy=kwargs.get("legacy", result.legacy),
+            cleanup=kwargs.get("cleanup", result.cleanup),
+        )

src/dashboard/__init__.py

@@ -0,0 +1,5 @@
+"""FastAPI dashboard package for observability APIs."""
+
+from src.dashboard.app import create_dashboard_app
+
+__all__ = ["create_dashboard_app"]

src/dashboard/app.py

@@ -0,0 +1,349 @@
+"""FastAPI application for observability dashboard endpoints."""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from fastapi import FastAPI, HTTPException, Query
+from fastapi.responses import FileResponse
+
+
+def create_dashboard_app(db_path: str) -> FastAPI:
+    """Create dashboard FastAPI app bound to a SQLite database path."""
+    app = FastAPI(title="The Ouroboros Dashboard", version="1.0.0")
+    app.state.db_path = db_path
+
+    @app.get("/")
+    def index() -> FileResponse:
+        index_path = Path(__file__).parent / "static" / "index.html"
+        return FileResponse(index_path)
+
+    @app.get("/api/status")
+    def get_status() -> dict[str, Any]:
+        today = datetime.now(UTC).date().isoformat()
+        with _connect(db_path) as conn:
+            markets = ["KR", "US"]
+            market_status: dict[str, Any] = {}
+            total_trades = 0
+            total_pnl = 0.0
+            total_decisions = 0
+            for market in markets:
+                trade_row = conn.execute(
+                    """
+                    SELECT COUNT(*) AS c, COALESCE(SUM(pnl), 0.0) AS p
+                    FROM trades
+                    WHERE DATE(timestamp) = ? AND market = ?
+                    """,
+                    (today, market),
+                ).fetchone()
+                decision_row = conn.execute(
+                    """
+                    SELECT COUNT(*) AS c
+                    FROM decision_logs
+                    WHERE DATE(timestamp) = ? AND market = ?
+                    """,
+                    (today, market),
+                ).fetchone()
+                playbook_row = conn.execute(
+                    """
+                    SELECT status
+                    FROM playbooks
+                    WHERE date = ? AND market = ?
+                    LIMIT 1
+                    """,
+                    (today, market),
+                ).fetchone()
+                market_status[market] = {
+                    "trade_count": int(trade_row["c"] if trade_row else 0),
+                    "total_pnl": float(trade_row["p"] if trade_row else 0.0),
+                    "decision_count": int(decision_row["c"] if decision_row else 0),
+                    "playbook_status": playbook_row["status"] if playbook_row else None,
+                }
+                total_trades += market_status[market]["trade_count"]
+                total_pnl += market_status[market]["total_pnl"]
+                total_decisions += market_status[market]["decision_count"]
+
+            return {
+                "date": today,
+                "markets": market_status,
+                "totals": {
+                    "trade_count": total_trades,
+                    "total_pnl": round(total_pnl, 2),
+                    "decision_count": total_decisions,
+                },
+            }
+
+    @app.get("/api/playbook/{date_str}")
+    def get_playbook(date_str: str, market: str = Query("KR")) -> dict[str, Any]:
+        with _connect(db_path) as conn:
+            row = conn.execute(
+                """
+                SELECT date, market, status, playbook_json, generated_at,
+                       token_count, scenario_count, match_count
+                FROM playbooks
+                WHERE date = ? AND market = ?
+                """,
+                (date_str, market),
+            ).fetchone()
+            if row is None:
+                raise HTTPException(status_code=404, detail="playbook not found")
+            return {
+                "date": row["date"],
+                "market": row["market"],
+                "status": row["status"],
+                "playbook": json.loads(row["playbook_json"]),
+                "generated_at": row["generated_at"],
+                "token_count": row["token_count"],
+                "scenario_count": row["scenario_count"],
+                "match_count": row["match_count"],
+            }
+
+    @app.get("/api/scorecard/{date_str}")
+    def get_scorecard(date_str: str, market: str = Query("KR")) -> dict[str, Any]:
+        key = f"scorecard_{market}"
+        with _connect(db_path) as conn:
+            row = conn.execute(
+                """
+                SELECT value
+                FROM contexts
+                WHERE layer = 'L6_DAILY' AND timeframe = ? AND key = ?
+                """,
+                (date_str, key),
+            ).fetchone()
+            if row is None:
+                raise HTTPException(status_code=404, detail="scorecard not found")
+            return {"date": date_str, "market": market, "scorecard": json.loads(row["value"])}
+
+    @app.get("/api/performance")
+    def get_performance(market: str = Query("all")) -> dict[str, Any]:
+        with _connect(db_path) as conn:
+            if market == "all":
+                by_market_rows = conn.execute(
+                    """
+                    SELECT market,
+                           COUNT(*) AS total_trades,
+                           SUM(CASE WHEN pnl > 0 THEN 1 ELSE 0 END) AS wins,
+                           SUM(CASE WHEN pnl < 0 THEN 1 ELSE 0 END) AS losses,
+                           COALESCE(SUM(pnl), 0.0) AS total_pnl,
+                           COALESCE(AVG(confidence), 0.0) AS avg_confidence
+                    FROM trades
+                    GROUP BY market
+                    ORDER BY market
+                    """
+                ).fetchall()
+                combined = _performance_from_rows(by_market_rows)
+                return {
+                    "market": "all",
+                    "combined": combined,
+                    "by_market": [
+                        _row_to_performance(row)
+                        for row in by_market_rows
+                    ],
+                }
+
+            row = conn.execute(
+                """
+                SELECT market,
+                       COUNT(*) AS total_trades,
+                       SUM(CASE WHEN pnl > 0 THEN 1 ELSE 0 END) AS wins,
+                       SUM(CASE WHEN pnl < 0 THEN 1 ELSE 0 END) AS losses,
+                       COALESCE(SUM(pnl), 0.0) AS total_pnl,
+                       COALESCE(AVG(confidence), 0.0) AS avg_confidence
+                FROM trades
+                WHERE market = ?
+                GROUP BY market
+                """,
+                (market,),
+            ).fetchone()
+            if row is None:
+                return {"market": market, "metrics": _empty_performance(market)}
+            return {"market": market, "metrics": _row_to_performance(row)}
+
+    @app.get("/api/context/{layer}")
+    def get_context_layer(
+        layer: str,
+        timeframe: str | None = Query(default=None),
+        limit: int = Query(default=100, ge=1, le=1000),
+    ) -> dict[str, Any]:
+        with _connect(db_path) as conn:
+            if timeframe is None:
+                rows = conn.execute(
+                    """
+                    SELECT timeframe, key, value, updated_at
+                    FROM contexts
+                    WHERE layer = ?
+                    ORDER BY updated_at DESC
+                    LIMIT ?
+                    """,
+                    (layer, limit),
+                ).fetchall()
+            else:
+                rows = conn.execute(
+                    """
+                    SELECT timeframe, key, value, updated_at
+                    FROM contexts
+                    WHERE layer = ? AND timeframe = ?
+                    ORDER BY key
+                    LIMIT ?
+                    """,
+                    (layer, timeframe, limit),
+                ).fetchall()
+
+            entries = [
+                {
+                    "timeframe": row["timeframe"],
+                    "key": row["key"],
+                    "value": json.loads(row["value"]),
+                    "updated_at": row["updated_at"],
+                }
+                for row in rows
+            ]
+            return {
+                "layer": layer,
+                "timeframe": timeframe,
+                "count": len(entries),
+                "entries": entries,
+            }
+
+    @app.get("/api/decisions")
+    def get_decisions(
+        market: str = Query("KR"),
+        limit: int = Query(default=50, ge=1, le=500),
+    ) -> dict[str, Any]:
+        with _connect(db_path) as conn:
+            rows = conn.execute(
+                """
+                SELECT decision_id, timestamp, stock_code, market, exchange_code,
+                       action, confidence, rationale, context_snapshot, input_data,
+                       outcome_pnl, outcome_accuracy
+                FROM decision_logs
+                WHERE market = ?
+                ORDER BY timestamp DESC
+                LIMIT ?
+                """,
+                (market, limit),
+            ).fetchall()
+            decisions = []
+            for row in rows:
+                decisions.append(
+                    {
+                        "decision_id": row["decision_id"],
+                        "timestamp": row["timestamp"],
+                        "stock_code": row["stock_code"],
+                        "market": row["market"],
+                        "exchange_code": row["exchange_code"],
+                        "action": row["action"],
+                        "confidence": row["confidence"],
+                        "rationale": row["rationale"],
+                        "context_snapshot": json.loads(row["context_snapshot"]),
+                        "input_data": json.loads(row["input_data"]),
+                        "outcome_pnl": row["outcome_pnl"],
+                        "outcome_accuracy": row["outcome_accuracy"],
+                    }
+                )
+            return {"market": market, "count": len(decisions), "decisions": decisions}
+
+    @app.get("/api/scenarios/active")
+    def get_active_scenarios(
+        market: str = Query("US"),
+        date_str: str | None = Query(default=None),
+        limit: int = Query(default=50, ge=1, le=500),
+    ) -> dict[str, Any]:
+        if date_str is None:
+            date_str = datetime.now(UTC).date().isoformat()
+
+        with _connect(db_path) as conn:
+            rows = conn.execute(
+                """
+                SELECT timestamp, stock_code, action, confidence, rationale, context_snapshot
+                FROM decision_logs
+                WHERE market = ? AND DATE(timestamp) = ?
+                ORDER BY timestamp DESC
+                LIMIT ?
+                """,
+                (market, date_str, limit),
+            ).fetchall()
+            matches: list[dict[str, Any]] = []
+            for row in rows:
+                snapshot = json.loads(row["context_snapshot"])
+                scenario_match = snapshot.get("scenario_match", {})
+                if not isinstance(scenario_match, dict) or not scenario_match:
+                    continue
+                matches.append(
+                    {
+                        "timestamp": row["timestamp"],
+                        "stock_code": row["stock_code"],
+                        "action": row["action"],
+                        "confidence": row["confidence"],
+                        "rationale": row["rationale"],
+                        "scenario_match": scenario_match,
+                    }
+                )
+            return {"market": market, "date": date_str, "count": len(matches), "matches": matches}
+
+    return app
+
+
+def _connect(db_path: str) -> sqlite3.Connection:
+    conn = sqlite3.connect(db_path)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+def _row_to_performance(row: sqlite3.Row) -> dict[str, Any]:
+    wins = int(row["wins"] or 0)
+    losses = int(row["losses"] or 0)
+    total = int(row["total_trades"] or 0)
+    win_rate = round((wins / (wins + losses) * 100), 2) if (wins + losses) > 0 else 0.0
+    return {
+        "market": row["market"],
+        "total_trades": total,
+        "wins": wins,
+        "losses": losses,
+        "win_rate": win_rate,
+        "total_pnl": round(float(row["total_pnl"] or 0.0), 2),
+        "avg_confidence": round(float(row["avg_confidence"] or 0.0), 2),
+    }
+
+
+def _performance_from_rows(rows: list[sqlite3.Row]) -> dict[str, Any]:
+    total_trades = 0
+    wins = 0
+    losses = 0
+    total_pnl = 0.0
+    confidence_weighted = 0.0
+    for row in rows:
+        market_total = int(row["total_trades"] or 0)
+        market_conf = float(row["avg_confidence"] or 0.0)
+        total_trades += market_total
+        wins += int(row["wins"] or 0)
+        losses += int(row["losses"] or 0)
+        total_pnl += float(row["total_pnl"] or 0.0)
+        confidence_weighted += market_total * market_conf
+    win_rate = round((wins / (wins + losses) * 100), 2) if (wins + losses) > 0 else 0.0
+    avg_confidence = round(confidence_weighted / total_trades, 2) if total_trades > 0 else 0.0
+    return {
+        "market": "all",
+        "total_trades": total_trades,
+        "wins": wins,
+        "losses": losses,
+        "win_rate": win_rate,
+        "total_pnl": round(total_pnl, 2),
+        "avg_confidence": avg_confidence,
+    }
+
+
+def _empty_performance(market: str) -> dict[str, Any]:
+    return {
+        "market": market,
+        "total_trades": 0,
+        "wins": 0,
+        "losses": 0,
+        "win_rate": 0.0,
+        "total_pnl": 0.0,
+        "avg_confidence": 0.0,
+    }

src/dashboard/static/index.html

@@ -0,0 +1,61 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>The Ouroboros Dashboard</title>
+    <style>
+      :root {
+        --bg: #0b1724;
+        --panel: #12263a;
+        --fg: #e6eef7;
+        --muted: #9fb3c8;
+        --accent: #3cb371;
+      }
+      body {
+        margin: 0;
+        font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+        background: radial-gradient(circle at top left, #173b58, var(--bg));
+        color: var(--fg);
+      }
+      .wrap {
+        max-width: 900px;
+        margin: 48px auto;
+        padding: 0 16px;
+      }
+      .card {
+        background: color-mix(in oklab, var(--panel), black 12%);
+        border: 1px solid #28455f;
+        border-radius: 12px;
+        padding: 20px;
+      }
+      h1 {
+        margin-top: 0;
+      }
+      code {
+        color: var(--accent);
+      }
+      li {
+        margin: 6px 0;
+        color: var(--muted);
+      }
+    </style>
+  </head>
+  <body>
+    <div class="wrap">
+      <div class="card">
+        <h1>The Ouroboros Dashboard API</h1>
+        <p>Use the following endpoints:</p>
+        <ul>
+          <li><code>/api/status</code></li>
+          <li><code>/api/playbook/{date}?market=KR</code></li>
+          <li><code>/api/scorecard/{date}?market=KR</code></li>
+          <li><code>/api/performance?market=all</code></li>
+          <li><code>/api/context/{layer}</code></li>
+          <li><code>/api/decisions?market=KR</code></li>
+          <li><code>/api/scenarios/active?market=US</code></li>
+        </ul>
+      </div>
+    </div>
+  </body>
+</html>

src/db.py

@@ -6,6 +6,7 @@ import json
 import sqlite3
 from datetime import UTC, datetime
 from pathlib import Path
+from typing import Any
 
 
 def init_db(db_path: str) -> sqlite3.Connection:
@@ -26,7 +27,8 @@ def init_db(db_path: str) -> sqlite3.Connection:
             price REAL,
             pnl REAL DEFAULT 0.0,
             market TEXT DEFAULT 'KR',
-            exchange_code TEXT DEFAULT 'KRX'
+            exchange_code TEXT DEFAULT 'KRX',
+            decision_id TEXT
         )
         """
     )
@@ -41,6 +43,8 @@ def init_db(db_path: str) -> sqlite3.Connection:
         conn.execute("ALTER TABLE trades ADD COLUMN exchange_code TEXT DEFAULT 'KRX'")
     if "selection_context" not in columns:
         conn.execute("ALTER TABLE trades ADD COLUMN selection_context TEXT")
+    if "decision_id" not in columns:
+        conn.execute("ALTER TABLE trades ADD COLUMN decision_id TEXT")
 
     # Context tree tables for multi-layered memory management
     conn.execute(
@@ -143,6 +147,7 @@ def log_trade(
     market: str = "KR",
     exchange_code: str = "KRX",
     selection_context: dict[str, any] | None = None,
+    decision_id: str | None = None,
 ) -> None:
     """Insert a trade record into the database.
 
@@ -166,9 +171,9 @@ def log_trade(
         """
         INSERT INTO trades (
             timestamp, stock_code, action, confidence, rationale,
-            quantity, price, pnl, market, exchange_code, selection_context
+            quantity, price, pnl, market, exchange_code, selection_context, decision_id
         )
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
         """,
         (
             datetime.now(UTC).isoformat(),
@@ -182,6 +187,30 @@ def log_trade(
             market,
             exchange_code,
             context_json,
+            decision_id,
         ),
     )
     conn.commit()
+
+
+def get_latest_buy_trade(
+    conn: sqlite3.Connection, stock_code: str, market: str
+) -> dict[str, Any] | None:
+    """Fetch the most recent BUY trade for a stock and market."""
+    cursor = conn.execute(
+        """
+        SELECT decision_id, price, quantity
+        FROM trades
+        WHERE stock_code = ?
+          AND market = ?
+          AND action = 'BUY'
+          AND decision_id IS NOT NULL
+        ORDER BY timestamp DESC
+        LIMIT 1
+        """,
+        (stock_code, market),
+    )
+    row = cursor.fetchone()
+    if not row:
+        return None
+    return {"decision_id": row[0], "price": row[1], "quantity": row[2]}

src/evolution/__init__.py

@@ -1,12 +1,14 @@
 """Evolution engine for self-improving trading strategies."""
 
 from src.evolution.ab_test import ABTester, ABTestResult, StrategyPerformance
+from src.evolution.daily_review import DailyReviewer
 from src.evolution.optimizer import EvolutionOptimizer
 from src.evolution.performance_tracker import (
     PerformanceDashboard,
     PerformanceTracker,
     StrategyMetrics,
 )
+from src.evolution.scorecard import DailyScorecard
 
 __all__ = [
     "EvolutionOptimizer",
@@ -16,4 +18,6 @@ __all__ = [
     "PerformanceTracker",
     "PerformanceDashboard",
     "StrategyMetrics",
+    "DailyScorecard",
+    "DailyReviewer",
 ]

src/evolution/daily_review.py

@@ -0,0 +1,196 @@
+"""Daily review generator for market-scoped end-of-day scorecards."""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+import sqlite3
+from dataclasses import asdict
+
+from src.brain.gemini_client import GeminiClient
+from src.context.layer import ContextLayer
+from src.context.store import ContextStore
+from src.evolution.scorecard import DailyScorecard
+
+logger = logging.getLogger(__name__)
+
+
+class DailyReviewer:
+    """Builds daily scorecards and optional AI-generated lessons."""
+
+    def __init__(
+        self,
+        conn: sqlite3.Connection,
+        context_store: ContextStore,
+        gemini_client: GeminiClient | None = None,
+    ) -> None:
+        self._conn = conn
+        self._context_store = context_store
+        self._gemini = gemini_client
+
+    def generate_scorecard(self, date: str, market: str) -> DailyScorecard:
+        """Generate a market-scoped scorecard from decision logs and trades."""
+        decision_rows = self._conn.execute(
+            """
+            SELECT action, confidence, context_snapshot
+            FROM decision_logs
+            WHERE DATE(timestamp) = ? AND market = ?
+            """,
+            (date, market),
+        ).fetchall()
+
+        total_decisions = len(decision_rows)
+        buys = sum(1 for row in decision_rows if row[0] == "BUY")
+        sells = sum(1 for row in decision_rows if row[0] == "SELL")
+        holds = sum(1 for row in decision_rows if row[0] == "HOLD")
+        avg_confidence = (
+            round(sum(int(row[1]) for row in decision_rows) / total_decisions, 2)
+            if total_decisions > 0
+            else 0.0
+        )
+
+        matched = 0
+        for row in decision_rows:
+            try:
+                snapshot = json.loads(row[2]) if row[2] else {}
+            except json.JSONDecodeError:
+                snapshot = {}
+            scenario_match = snapshot.get("scenario_match", {})
+            if isinstance(scenario_match, dict) and scenario_match:
+                matched += 1
+        scenario_match_rate = (
+            round((matched / total_decisions) * 100, 2)
+            if total_decisions
+            else 0.0
+        )
+
+        trade_stats = self._conn.execute(
+            """
+            SELECT
+                COALESCE(SUM(pnl), 0.0),
+                SUM(CASE WHEN pnl > 0 THEN 1 ELSE 0 END),
+                SUM(CASE WHEN pnl < 0 THEN 1 ELSE 0 END)
+            FROM trades
+            WHERE DATE(timestamp) = ? AND market = ?
+            """,
+            (date, market),
+        ).fetchone()
+        total_pnl = round(float(trade_stats[0] or 0.0), 2) if trade_stats else 0.0
+        wins = int(trade_stats[1] or 0) if trade_stats else 0
+        losses = int(trade_stats[2] or 0) if trade_stats else 0
+        win_rate = round((wins / (wins + losses)) * 100, 2) if (wins + losses) > 0 else 0.0
+
+        top_winners = [
+            row[0]
+            for row in self._conn.execute(
+                """
+                SELECT stock_code, SUM(pnl) AS stock_pnl
+                FROM trades
+                WHERE DATE(timestamp) = ? AND market = ?
+                GROUP BY stock_code
+                HAVING stock_pnl > 0
+                ORDER BY stock_pnl DESC
+                LIMIT 3
+                """,
+                (date, market),
+            ).fetchall()
+        ]
+
+        top_losers = [
+            row[0]
+            for row in self._conn.execute(
+                """
+                SELECT stock_code, SUM(pnl) AS stock_pnl
+                FROM trades
+                WHERE DATE(timestamp) = ? AND market = ?
+                GROUP BY stock_code
+                HAVING stock_pnl < 0
+                ORDER BY stock_pnl ASC
+                LIMIT 3
+                """,
+                (date, market),
+            ).fetchall()
+        ]
+
+        return DailyScorecard(
+            date=date,
+            market=market,
+            total_decisions=total_decisions,
+            buys=buys,
+            sells=sells,
+            holds=holds,
+            total_pnl=total_pnl,
+            win_rate=win_rate,
+            avg_confidence=avg_confidence,
+            scenario_match_rate=scenario_match_rate,
+            top_winners=top_winners,
+            top_losers=top_losers,
+            lessons=[],
+            cross_market_note="",
+        )
+
+    async def generate_lessons(self, scorecard: DailyScorecard) -> list[str]:
+        """Generate concise lessons from scorecard metrics using Gemini."""
+        if self._gemini is None:
+            return []
+
+        prompt = (
+            "You are a trading performance reviewer.\n"
+            "Return ONLY a JSON array of 1-3 short lessons in English.\n"
+            f"Market: {scorecard.market}\n"
+            f"Date: {scorecard.date}\n"
+            f"Total decisions: {scorecard.total_decisions}\n"
+            f"Buys/Sells/Holds: {scorecard.buys}/{scorecard.sells}/{scorecard.holds}\n"
+            f"Total PnL: {scorecard.total_pnl}\n"
+            f"Win rate: {scorecard.win_rate}%\n"
+            f"Average confidence: {scorecard.avg_confidence}\n"
+            f"Scenario match rate: {scorecard.scenario_match_rate}%\n"
+            f"Top winners: {', '.join(scorecard.top_winners) or 'N/A'}\n"
+            f"Top losers: {', '.join(scorecard.top_losers) or 'N/A'}\n"
+        )
+
+        try:
+            decision = await self._gemini.decide(
+                {
+                    "stock_code": "REVIEW",
+                    "market_name": scorecard.market,
+                    "current_price": 0,
+                    "prompt_override": prompt,
+                }
+            )
+            return self._parse_lessons(decision.rationale)
+        except Exception as exc:
+            logger.warning("Failed to generate daily lessons: %s", exc)
+            return []
+
+    def store_scorecard_in_context(self, scorecard: DailyScorecard) -> None:
+        """Store scorecard in L6 using market-scoped key."""
+        self._context_store.set_context(
+            ContextLayer.L6_DAILY,
+            scorecard.date,
+            f"scorecard_{scorecard.market}",
+            asdict(scorecard),
+        )
+
+    def _parse_lessons(self, raw_text: str) -> list[str]:
+        """Parse lessons from JSON array response or fallback text."""
+        raw_text = raw_text.strip()
+        try:
+            parsed = json.loads(raw_text)
+            if isinstance(parsed, list):
+                return [str(item).strip() for item in parsed if str(item).strip()][:3]
+        except json.JSONDecodeError:
+            pass
+
+        match = re.search(r"\[.*\]", raw_text, re.DOTALL)
+        if match:
+            try:
+                parsed = json.loads(match.group(0))
+                if isinstance(parsed, list):
+                    return [str(item).strip() for item in parsed if str(item).strip()][:3]
+            except json.JSONDecodeError:
+                pass
+
+        lines = [line.strip("-* \t") for line in raw_text.splitlines() if line.strip()]
+        return lines[:3]

src/evolution/scorecard.py

@@ -0,0 +1,25 @@
+"""Daily scorecard model for end-of-day performance review."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class DailyScorecard:
+    """Structured daily performance snapshot for a single market."""
+
+    date: str
+    market: str
+    total_decisions: int
+    buys: int
+    sells: int
+    holds: int
+    total_pnl: float
+    win_rate: float
+    avg_confidence: float
+    scenario_match_rate: float
+    top_winners: list[str] = field(default_factory=list)
+    top_losers: list[str] = field(default_factory=list)
+    lessons: list[str] = field(default_factory=list)
+    cross_market_note: str = ""

src/main.py

@@ -20,12 +20,16 @@ from src.brain.gemini_client import GeminiClient, TradeDecision
 from src.broker.kis_api import KISBroker
 from src.broker.overseas import OverseasBroker
 from src.config import Settings
+from src.context.aggregator import ContextAggregator
 from src.context.layer import ContextLayer
+from src.context.scheduler import ContextScheduler
 from src.context.store import ContextStore
 from src.core.criticality import CriticalityAssessor
 from src.core.priority_queue import PriorityTaskQueue
 from src.core.risk_manager import CircuitBreakerTripped, FatFingerRejected, RiskManager
-from src.db import init_db, log_trade
+from src.db import get_latest_buy_trade, init_db, log_trade
+from src.evolution.daily_review import DailyReviewer
+from src.evolution.optimizer import EvolutionOptimizer
 from src.logging.decision_logger import DecisionLogger
 from src.logging_config import setup_logging
 from src.markets.schedule import MarketInfo, get_next_market_open, get_open_markets
@@ -278,7 +282,7 @@ async def trading_cycle(
         "pnl_pct": pnl_pct,
     }
 
-    decision_logger.log_decision(
+    decision_id = decision_logger.log_decision(
         stock_code=stock_code,
         market=market.code,
         exchange_code=market.exchange_code,
@@ -290,6 +294,9 @@ async def trading_cycle(
     )
 
     # 3. Execute if actionable
+    quantity = 0
+    trade_price = current_price
+    trade_pnl = 0.0
     if decision.action in ("BUY", "SELL"):
         # Determine order size (simplified: 1 lot)
         quantity = 1
@@ -345,6 +352,18 @@ async def trading_cycle(
         except Exception as exc:
             logger.warning("Telegram notification failed: %s", exc)
 
+        if decision.action == "SELL":
+            buy_trade = get_latest_buy_trade(db_conn, stock_code, market.code)
+            if buy_trade and buy_trade.get("price") is not None:
+                buy_price = float(buy_trade["price"])
+                buy_qty = int(buy_trade.get("quantity") or 1)
+                trade_pnl = (trade_price - buy_price) * buy_qty
+                decision_logger.update_outcome(
+                    decision_id=buy_trade["decision_id"],
+                    pnl=trade_pnl,
+                    accuracy=1 if trade_pnl > 0 else 0,
+                )
+
     # 6. Log trade with selection context
     selection_context = None
     if stock_code in market_candidates:
@@ -362,9 +381,13 @@ async def trading_cycle(
         action=decision.action,
         confidence=decision.confidence,
         rationale=decision.rationale,
+        quantity=quantity,
+        price=trade_price,
+        pnl=trade_pnl,
         market=market.code,
         exchange_code=market.exchange_code,
         selection_context=selection_context,
+        decision_id=decision_id,
     )
 
     # 7. Latency monitoring
@@ -599,7 +622,7 @@ async def run_daily_session(
                 "pnl_pct": pnl_pct,
             }
 
-            decision_logger.log_decision(
+            decision_id = decision_logger.log_decision(
                 stock_code=stock_code,
                 market=market.code,
                 exchange_code=market.exchange_code,
@@ -611,6 +634,9 @@ async def run_daily_session(
             )
 
             # Execute if actionable
+            quantity = 0
+            trade_price = stock_data["current_price"]
+            trade_pnl = 0.0
             if decision.action in ("BUY", "SELL"):
                 quantity = 1
                 order_amount = stock_data["current_price"] * quantity
@@ -683,6 +709,18 @@ async def run_daily_session(
                     )
                     continue
 
+                if decision.action == "SELL":
+                    buy_trade = get_latest_buy_trade(db_conn, stock_code, market.code)
+                    if buy_trade and buy_trade.get("price") is not None:
+                        buy_price = float(buy_trade["price"])
+                        buy_qty = int(buy_trade.get("quantity") or 1)
+                        trade_pnl = (trade_price - buy_price) * buy_qty
+                        decision_logger.update_outcome(
+                            decision_id=buy_trade["decision_id"],
+                            pnl=trade_pnl,
+                            accuracy=1 if trade_pnl > 0 else 0,
+                        )
+
             # Log trade
             log_trade(
                 conn=db_conn,
@@ -690,13 +728,122 @@ async def run_daily_session(
                 action=decision.action,
                 confidence=decision.confidence,
                 rationale=decision.rationale,
+                quantity=quantity,
+                price=trade_price,
+                pnl=trade_pnl,
                 market=market.code,
                 exchange_code=market.exchange_code,
+                decision_id=decision_id,
             )
 
     logger.info("Daily trading session completed")
 
 
+async def _handle_market_close(
+    market_code: str,
+    market_name: str,
+    market_timezone: Any,
+    telegram: TelegramClient,
+    context_aggregator: ContextAggregator,
+    daily_reviewer: DailyReviewer,
+    evolution_optimizer: EvolutionOptimizer | None = None,
+) -> None:
+    """Handle market-close tasks: notify, aggregate, review, and store context."""
+    await telegram.notify_market_close(market_name, 0.0)
+
+    market_date = datetime.now(market_timezone).date().isoformat()
+    context_aggregator.aggregate_daily_from_trades(
+        date=market_date,
+        market=market_code,
+    )
+
+    scorecard = daily_reviewer.generate_scorecard(market_date, market_code)
+    daily_reviewer.store_scorecard_in_context(scorecard)
+
+    lessons = await daily_reviewer.generate_lessons(scorecard)
+    if lessons:
+        scorecard.lessons = lessons
+        daily_reviewer.store_scorecard_in_context(scorecard)
+
+    await telegram.send_message(
+        f"<b>Daily Review ({market_code})</b>\n"
+        f"Date: {scorecard.date}\n"
+        f"Decisions: {scorecard.total_decisions}\n"
+        f"P&L: {scorecard.total_pnl:+.2f}\n"
+        f"Win Rate: {scorecard.win_rate:.2f}%\n"
+        f"Lessons: {', '.join(scorecard.lessons) if scorecard.lessons else 'N/A'}"
+    )
+
+    if evolution_optimizer is not None:
+        await _run_evolution_loop(
+            evolution_optimizer=evolution_optimizer,
+            telegram=telegram,
+            market_code=market_code,
+            market_date=market_date,
+        )
+
+
+def _run_context_scheduler(
+    scheduler: ContextScheduler, now: datetime | None = None,
+) -> None:
+    """Run periodic context scheduler tasks and log when anything executes."""
+    result = scheduler.run_if_due(now=now)
+    if any(
+        [
+            result.weekly,
+            result.monthly,
+            result.quarterly,
+            result.annual,
+            result.legacy,
+            result.cleanup,
+        ]
+    ):
+        logger.info(
+            (
+                "Context scheduler ran (weekly=%s, monthly=%s, quarterly=%s, "
+                "annual=%s, legacy=%s, cleanup=%s)"
+            ),
+            result.weekly,
+            result.monthly,
+            result.quarterly,
+            result.annual,
+            result.legacy,
+            result.cleanup,
+        )
+
+
+async def _run_evolution_loop(
+    evolution_optimizer: EvolutionOptimizer,
+    telegram: TelegramClient,
+    market_code: str,
+    market_date: str,
+) -> None:
+    """Run evolution loop once at US close (end of trading day)."""
+    if market_code != "US":
+        return
+
+    try:
+        pr_info = await evolution_optimizer.evolve()
+    except Exception as exc:
+        logger.warning("Evolution loop failed on %s: %s", market_date, exc)
+        return
+
+    if pr_info is None:
+        logger.info("Evolution loop skipped on %s (no actionable failures)", market_date)
+        return
+
+    try:
+        await telegram.send_message(
+            "<b>Evolution Update</b>\n"
+            f"Date: {market_date}\n"
+            f"PR: {pr_info.get('title', 'N/A')}\n"
+            f"Branch: {pr_info.get('branch', 'N/A')}\n"
+            f"Status: {pr_info.get('status', 'N/A')}"
+        )
+    except Exception as exc:
+        logger.warning("Evolution notification failed on %s: %s", market_date, exc)
+
+
 async def run(settings: Settings) -> None:
     """Main async loop — iterate over open markets on a timer."""
     broker = KISBroker(settings)
@@ -706,11 +853,18 @@ async def run(settings: Settings) -> None:
     db_conn = init_db(settings.DB_PATH)
     decision_logger = DecisionLogger(db_conn)
     context_store = ContextStore(db_conn)
+    context_aggregator = ContextAggregator(db_conn)
+    context_scheduler = ContextScheduler(
+        aggregator=context_aggregator,
+        store=context_store,
+    )
+    evolution_optimizer = EvolutionOptimizer(settings)
 
     # V2 proactive strategy components
     context_selector = ContextSelector(context_store)
     scenario_engine = ScenarioEngine()
     playbook_store = PlaybookStore(db_conn)
+    daily_reviewer = DailyReviewer(db_conn, context_store, gemini_client=brain)
     pre_market_planner = PreMarketPlanner(
         gemini_client=brain,
         context_store=context_store,
@@ -938,6 +1092,7 @@ async def run(settings: Settings) -> None:
             while not shutdown.is_set():
                 # Wait for trading to be unpaused
                 await pause_trading.wait()
+                _run_context_scheduler(context_scheduler, now=datetime.now(UTC))
 
                 try:
                     await run_daily_session(
@@ -976,6 +1131,7 @@ async def run(settings: Settings) -> None:
             while not shutdown.is_set():
                 # Wait for trading to be unpaused
                 await pause_trading.wait()
+                _run_context_scheduler(context_scheduler, now=datetime.now(UTC))
 
                 # Get currently open markets
                 open_markets = get_open_markets(settings.enabled_market_list)
@@ -989,7 +1145,15 @@ async def run(settings: Settings) -> None:
 
                                 market_info = MARKETS.get(market_code)
                                 if market_info:
-                                    await telegram.notify_market_close(market_info.name, 0.0)
+                                    await _handle_market_close(
+                                        market_code=market_code,
+                                        market_name=market_info.name,
+                                        market_timezone=market_info.timezone,
+                                        telegram=telegram,
+                                        context_aggregator=context_aggregator,
+                                        daily_reviewer=daily_reviewer,
+                                        evolution_optimizer=evolution_optimizer,
+                                    )
                             except Exception as exc:
                                 logger.warning("Market close notification failed: %s", exc)
                             _market_states[market_code] = False

src/strategy/pre_market_planner.py

@@ -8,7 +8,7 @@ from __future__ import annotations
 
 import json
 import logging
-from datetime import date
+from datetime import date, timedelta
 from typing import Any
 
 from src.analysis.smart_scanner import ScanCandidate
@@ -95,10 +95,17 @@ class PreMarketPlanner:
         try:
             # 1. Gather context
             context_data = self._gather_context()
+            self_market_scorecard = self.build_self_market_scorecard(market, today)
             cross_market = self.build_cross_market_context(market, today)
 
             # 2. Build prompt
-            prompt = self._build_prompt(market, candidates, context_data, cross_market)
+            prompt = self._build_prompt(
+                market,
+                candidates,
+                context_data,
+                self_market_scorecard,
+                cross_market,
+            )
 
             # 3. Call Gemini
             market_data = {
@@ -145,7 +152,8 @@ class PreMarketPlanner:
         other_market = "US" if target_market == "KR" else "KR"
         if today is None:
             today = date.today()
-        timeframe = today.isoformat()
+        timeframe_date = today - timedelta(days=1) if target_market == "KR" else today
+        timeframe = timeframe_date.isoformat()
 
         scorecard_key = f"scorecard_{other_market}"
         scorecard_data = self._context_store.get_context(
@@ -175,6 +183,37 @@ class PreMarketPlanner:
             lessons=scorecard_data.get("lessons", []),
         )
 
+    def build_self_market_scorecard(
+        self, market: str, today: date | None = None,
+    ) -> dict[str, Any] | None:
+        """Build previous-day scorecard for the same market."""
+        if today is None:
+            today = date.today()
+        timeframe = (today - timedelta(days=1)).isoformat()
+        scorecard_key = f"scorecard_{market}"
+        scorecard_data = self._context_store.get_context(
+            ContextLayer.L6_DAILY, timeframe, scorecard_key
+        )
+
+        if scorecard_data is None:
+            return None
+
+        if isinstance(scorecard_data, str):
+            try:
+                scorecard_data = json.loads(scorecard_data)
+            except (json.JSONDecodeError, TypeError):
+                return None
+
+        if not isinstance(scorecard_data, dict):
+            return None
+
+        return {
+            "date": timeframe,
+            "total_pnl": float(scorecard_data.get("total_pnl", 0.0)),
+            "win_rate": float(scorecard_data.get("win_rate", 0.0)),
+            "lessons": scorecard_data.get("lessons", []),
+        }
+
     def _gather_context(self) -> dict[str, Any]:
         """Gather strategic context using ContextSelector."""
         layers = self._context_selector.select_layers(
@@ -188,6 +227,7 @@ class PreMarketPlanner:
         market: str,
         candidates: list[ScanCandidate],
         context_data: dict[str, Any],
+        self_market_scorecard: dict[str, Any] | None,
         cross_market: CrossMarketContext | None,
     ) -> str:
         """Build a structured prompt for Gemini to generate scenario JSON."""
@@ -211,6 +251,18 @@ class PreMarketPlanner:
             if cross_market.lessons:
                 cross_market_text += f"- Lessons: {'; '.join(cross_market.lessons[:3])}\n"
 
+        self_market_text = ""
+        if self_market_scorecard:
+            self_market_text = (
+                f"\n## My Market Previous Day ({market})\n"
+                f"- Date: {self_market_scorecard['date']}\n"
+                f"- P&L: {self_market_scorecard['total_pnl']:+.2f}%\n"
+                f"- Win Rate: {self_market_scorecard['win_rate']:.0f}%\n"
+            )
+            lessons = self_market_scorecard.get("lessons", [])
+            if lessons:
+                self_market_text += f"- Lessons: {'; '.join(lessons[:3])}\n"
+
         context_text = ""
         if context_data:
             context_text = "\n## Strategic Context\n"
@@ -224,6 +276,7 @@ class PreMarketPlanner:
             f"You are a pre-market trading strategist for the {market} market.\n"
             f"Generate structured trading scenarios for today.\n\n"
             f"## Candidates (from volatility scanner)\n{candidates_text}\n"
+            f"{self_market_text}"
             f"{cross_market_text}"
             f"{context_text}\n"
             f"## Instructions\n"

tests/test_context.py

@@ -161,7 +161,7 @@ class TestContextAggregator:
         self, aggregator: ContextAggregator, db_conn: sqlite3.Connection
     ) -> None:
         """Test aggregating daily metrics from trades."""
-        date = "2026-02-04"
+        date = datetime.now(UTC).date().isoformat()
 
         # Create sample trades
         log_trade(db_conn, "005930", "BUY", 85, "Good signal", quantity=10, price=70000, pnl=500)
@@ -175,36 +175,44 @@ class TestContextAggregator:
         db_conn.commit()
 
         # Aggregate
-        aggregator.aggregate_daily_from_trades(date)
+        aggregator.aggregate_daily_from_trades(date, market="KR")
 
         # Verify L6 contexts
         store = aggregator.store
-        assert store.get_context(ContextLayer.L6_DAILY, date, "trade_count") == 3
-        assert store.get_context(ContextLayer.L6_DAILY, date, "buys") == 1
-        assert store.get_context(ContextLayer.L6_DAILY, date, "sells") == 1
-        assert store.get_context(ContextLayer.L6_DAILY, date, "holds") == 1
-        assert store.get_context(ContextLayer.L6_DAILY, date, "total_pnl") == 2000.0
-        assert store.get_context(ContextLayer.L6_DAILY, date, "unique_stocks") == 3
+        assert store.get_context(ContextLayer.L6_DAILY, date, "trade_count_KR") == 3
+        assert store.get_context(ContextLayer.L6_DAILY, date, "buys_KR") == 1
+        assert store.get_context(ContextLayer.L6_DAILY, date, "sells_KR") == 1
+        assert store.get_context(ContextLayer.L6_DAILY, date, "holds_KR") == 1
+        assert store.get_context(ContextLayer.L6_DAILY, date, "total_pnl_KR") == 2000.0
+        assert store.get_context(ContextLayer.L6_DAILY, date, "unique_stocks_KR") == 3
         # 2 wins, 0 losses
-        assert store.get_context(ContextLayer.L6_DAILY, date, "win_rate") == 100.0
+        assert store.get_context(ContextLayer.L6_DAILY, date, "win_rate_KR") == 100.0
 
     def test_aggregate_weekly_from_daily(self, aggregator: ContextAggregator) -> None:
         """Test aggregating weekly metrics from daily."""
         week = "2026-W06"
 
         # Set daily contexts
-        aggregator.store.set_context(ContextLayer.L6_DAILY, "2026-02-02", "total_pnl", 100.0)
-        aggregator.store.set_context(ContextLayer.L6_DAILY, "2026-02-03", "total_pnl", 200.0)
-        aggregator.store.set_context(ContextLayer.L6_DAILY, "2026-02-02", "avg_confidence", 80.0)
-        aggregator.store.set_context(ContextLayer.L6_DAILY, "2026-02-03", "avg_confidence", 85.0)
+        aggregator.store.set_context(
+            ContextLayer.L6_DAILY, "2026-02-02", "total_pnl_KR", 100.0
+        )
+        aggregator.store.set_context(
+            ContextLayer.L6_DAILY, "2026-02-03", "total_pnl_KR", 200.0
+        )
+        aggregator.store.set_context(
+            ContextLayer.L6_DAILY, "2026-02-02", "avg_confidence_KR", 80.0
+        )
+        aggregator.store.set_context(
+            ContextLayer.L6_DAILY, "2026-02-03", "avg_confidence_KR", 85.0
+        )
 
         # Aggregate
         aggregator.aggregate_weekly_from_daily(week)
 
         # Verify L5 contexts
         store = aggregator.store
-        weekly_pnl = store.get_context(ContextLayer.L5_WEEKLY, week, "weekly_pnl")
-        avg_conf = store.get_context(ContextLayer.L5_WEEKLY, week, "avg_confidence")
+        weekly_pnl = store.get_context(ContextLayer.L5_WEEKLY, week, "weekly_pnl_KR")
+        avg_conf = store.get_context(ContextLayer.L5_WEEKLY, week, "avg_confidence_KR")
 
         assert weekly_pnl == 300.0
         assert avg_conf == 82.5
@@ -214,9 +222,15 @@ class TestContextAggregator:
         month = "2026-02"
 
         # Set weekly contexts
-        aggregator.store.set_context(ContextLayer.L5_WEEKLY, "2026-W05", "weekly_pnl", 100.0)
-        aggregator.store.set_context(ContextLayer.L5_WEEKLY, "2026-W06", "weekly_pnl", 200.0)
-        aggregator.store.set_context(ContextLayer.L5_WEEKLY, "2026-W07", "weekly_pnl", 150.0)
+        aggregator.store.set_context(
+            ContextLayer.L5_WEEKLY, "2026-W05", "weekly_pnl_KR", 100.0
+        )
+        aggregator.store.set_context(
+            ContextLayer.L5_WEEKLY, "2026-W06", "weekly_pnl_KR", 200.0
+        )
+        aggregator.store.set_context(
+            ContextLayer.L5_WEEKLY, "2026-W07", "weekly_pnl_KR", 150.0
+        )
 
         # Aggregate
         aggregator.aggregate_monthly_from_weekly(month)
@@ -285,7 +299,7 @@ class TestContextAggregator:
         self, aggregator: ContextAggregator, db_conn: sqlite3.Connection
     ) -> None:
         """Test running all aggregations from L7 to L1."""
-        date = "2026-02-04"
+        date = datetime.now(UTC).date().isoformat()
 
         # Create sample trades
         log_trade(db_conn, "005930", "BUY", 85, "Good signal", quantity=10, price=70000, pnl=1000)
@@ -299,12 +313,12 @@ class TestContextAggregator:
 
         # Verify data exists in each layer
         store = aggregator.store
-        assert store.get_context(ContextLayer.L6_DAILY, date, "total_pnl") == 1000.0
+        assert store.get_context(ContextLayer.L6_DAILY, date, "total_pnl_KR") == 1000.0
         from datetime import date as date_cls
         trade_date = date_cls.fromisoformat(date)
         iso_year, iso_week, _ = trade_date.isocalendar()
         trade_week = f"{iso_year}-W{iso_week:02d}"
-        assert store.get_context(ContextLayer.L5_WEEKLY, trade_week, "weekly_pnl") is not None
+        assert store.get_context(ContextLayer.L5_WEEKLY, trade_week, "weekly_pnl_KR") is not None
         trade_month = f"{trade_date.year}-{trade_date.month:02d}"
         trade_quarter = f"{trade_date.year}-Q{(trade_date.month - 1) // 3 + 1}"
         trade_year = str(trade_date.year)

tests/test_context_scheduler.py

@@ -0,0 +1,104 @@
+"""Tests for ContextScheduler."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import UTC, datetime
+
+from src.context.scheduler import ContextScheduler
+
+
+@dataclass
+class StubAggregator:
+    """Stub aggregator that records calls."""
+
+    weekly_calls: list[str]
+    monthly_calls: list[str]
+    quarterly_calls: list[str]
+    annual_calls: list[str]
+    legacy_calls: int
+
+    def aggregate_weekly_from_daily(self, week: str) -> None:
+        self.weekly_calls.append(week)
+
+    def aggregate_monthly_from_weekly(self, month: str) -> None:
+        self.monthly_calls.append(month)
+
+    def aggregate_quarterly_from_monthly(self, quarter: str) -> None:
+        self.quarterly_calls.append(quarter)
+
+    def aggregate_annual_from_quarterly(self, year: str) -> None:
+        self.annual_calls.append(year)
+
+    def aggregate_legacy_from_annual(self) -> None:
+        self.legacy_calls += 1
+
+
+@dataclass
+class StubStore:
+    """Stub store that records cleanup calls."""
+
+    cleanup_calls: int = 0
+
+    def cleanup_expired_contexts(self) -> None:
+        self.cleanup_calls += 1
+
+
+def make_scheduler() -> tuple[ContextScheduler, StubAggregator, StubStore]:
+    aggregator = StubAggregator([], [], [], [], 0)
+    store = StubStore()
+    scheduler = ContextScheduler(aggregator=aggregator, store=store)
+    return scheduler, aggregator, store
+
+
+def test_run_if_due_weekly() -> None:
+    scheduler, aggregator, store = make_scheduler()
+    now = datetime(2026, 2, 8, 10, 0, tzinfo=UTC)  # Sunday
+
+    result = scheduler.run_if_due(now)
+
+    assert result.weekly is True
+    assert aggregator.weekly_calls == ["2026-W06"]
+    assert store.cleanup_calls == 1
+
+
+def test_run_if_due_monthly() -> None:
+    scheduler, aggregator, _store = make_scheduler()
+    now = datetime(2026, 2, 28, 12, 0, tzinfo=UTC)  # Last day of month
+
+    result = scheduler.run_if_due(now)
+
+    assert result.monthly is True
+    assert aggregator.monthly_calls == ["2026-02"]
+
+
+def test_run_if_due_quarterly() -> None:
+    scheduler, aggregator, _store = make_scheduler()
+    now = datetime(2026, 3, 31, 12, 0, tzinfo=UTC)  # Last day of Q1
+
+    result = scheduler.run_if_due(now)
+
+    assert result.quarterly is True
+    assert aggregator.quarterly_calls == ["2026-Q1"]
+
+
+def test_run_if_due_annual_and_legacy() -> None:
+    scheduler, aggregator, _store = make_scheduler()
+    now = datetime(2026, 12, 31, 12, 0, tzinfo=UTC)
+
+    result = scheduler.run_if_due(now)
+
+    assert result.annual is True
+    assert result.legacy is True
+    assert aggregator.annual_calls == ["2026"]
+    assert aggregator.legacy_calls == 1
+
+
+def test_cleanup_runs_once_per_day() -> None:
+    scheduler, _aggregator, store = make_scheduler()
+    now = datetime(2026, 2, 9, 9, 0, tzinfo=UTC)
+
+    scheduler.run_if_due(now)
+    scheduler.run_if_due(now)
+
+    assert store.cleanup_calls == 1

tests/test_daily_review.py

@@ -0,0 +1,383 @@
+"""Tests for DailyReviewer."""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from src.context.layer import ContextLayer
+from src.context.store import ContextStore
+from src.db import init_db, log_trade
+from src.evolution.daily_review import DailyReviewer
+from src.evolution.scorecard import DailyScorecard
+from src.logging.decision_logger import DecisionLogger
+
+
+@pytest.fixture
+def db_conn() -> sqlite3.Connection:
+    return init_db(":memory:")
+
+
+@pytest.fixture
+def context_store(db_conn: sqlite3.Connection) -> ContextStore:
+    return ContextStore(db_conn)
+
+
+def _log_decision(
+    logger: DecisionLogger,
+    *,
+    stock_code: str,
+    market: str,
+    action: str,
+    confidence: int,
+    scenario_match: dict[str, float] | None = None,
+) -> str:
+    return logger.log_decision(
+        stock_code=stock_code,
+        market=market,
+        exchange_code="KRX" if market == "KR" else "NASDAQ",
+        action=action,
+        confidence=confidence,
+        rationale="test",
+        context_snapshot={"scenario_match": scenario_match or {}},
+        input_data={"stock_code": stock_code},
+    )
+
+
+def test_generate_scorecard_market_scoped(
+    db_conn: sqlite3.Connection, context_store: ContextStore,
+) -> None:
+    reviewer = DailyReviewer(db_conn, context_store)
+    logger = DecisionLogger(db_conn)
+
+    buy_id = _log_decision(
+        logger,
+        stock_code="005930",
+        market="KR",
+        action="BUY",
+        confidence=90,
+        scenario_match={"rsi": 29.0},
+    )
+    _log_decision(
+        logger,
+        stock_code="000660",
+        market="KR",
+        action="HOLD",
+        confidence=60,
+    )
+    _log_decision(
+        logger,
+        stock_code="AAPL",
+        market="US",
+        action="SELL",
+        confidence=80,
+        scenario_match={"volume_ratio": 2.1},
+    )
+
+    log_trade(
+        db_conn,
+        "005930",
+        "BUY",
+        90,
+        "buy",
+        quantity=1,
+        price=100.0,
+        pnl=10.0,
+        market="KR",
+        exchange_code="KRX",
+        decision_id=buy_id,
+    )
+    log_trade(
+        db_conn,
+        "000660",
+        "HOLD",
+        60,
+        "hold",
+        quantity=0,
+        price=0.0,
+        pnl=0.0,
+        market="KR",
+        exchange_code="KRX",
+    )
+    log_trade(
+        db_conn,
+        "AAPL",
+        "SELL",
+        80,
+        "sell",
+        quantity=1,
+        price=200.0,
+        pnl=-5.0,
+        market="US",
+        exchange_code="NASDAQ",
+    )
+
+    scorecard = reviewer.generate_scorecard("2026-02-14", "KR")
+
+    assert scorecard.market == "KR"
+    assert scorecard.total_decisions == 2
+    assert scorecard.buys == 1
+    assert scorecard.sells == 0
+    assert scorecard.holds == 1
+    assert scorecard.total_pnl == 10.0
+    assert scorecard.win_rate == 100.0
+    assert scorecard.avg_confidence == 75.0
+    assert scorecard.scenario_match_rate == 50.0
+
+
+def test_generate_scorecard_top_winners_and_losers(
+    db_conn: sqlite3.Connection, context_store: ContextStore,
+) -> None:
+    reviewer = DailyReviewer(db_conn, context_store)
+    logger = DecisionLogger(db_conn)
+
+    for code, pnl in [("005930", 30.0), ("000660", 10.0), ("035420", -15.0), ("051910", -5.0)]:
+        decision_id = _log_decision(
+            logger,
+            stock_code=code,
+            market="KR",
+            action="BUY" if pnl >= 0 else "SELL",
+            confidence=80,
+            scenario_match={"rsi": 30.0},
+        )
+        log_trade(
+            db_conn,
+            code,
+            "BUY" if pnl >= 0 else "SELL",
+            80,
+            "test",
+            quantity=1,
+            price=100.0,
+            pnl=pnl,
+            market="KR",
+            exchange_code="KRX",
+            decision_id=decision_id,
+        )
+
+    scorecard = reviewer.generate_scorecard("2026-02-14", "KR")
+    assert scorecard.top_winners == ["005930", "000660"]
+    assert scorecard.top_losers == ["035420", "051910"]
+
+
+def test_generate_scorecard_empty_day(
+    db_conn: sqlite3.Connection, context_store: ContextStore,
+) -> None:
+    reviewer = DailyReviewer(db_conn, context_store)
+    scorecard = reviewer.generate_scorecard("2026-02-14", "KR")
+
+    assert scorecard.total_decisions == 0
+    assert scorecard.total_pnl == 0.0
+    assert scorecard.win_rate == 0.0
+    assert scorecard.avg_confidence == 0.0
+    assert scorecard.scenario_match_rate == 0.0
+    assert scorecard.top_winners == []
+    assert scorecard.top_losers == []
+
+
+@pytest.mark.asyncio
+async def test_generate_lessons_without_gemini_returns_empty(
+    db_conn: sqlite3.Connection, context_store: ContextStore,
+) -> None:
+    reviewer = DailyReviewer(db_conn, context_store, gemini_client=None)
+    lessons = await reviewer.generate_lessons(
+        DailyScorecard(
+            date="2026-02-14",
+            market="KR",
+            total_decisions=1,
+            buys=1,
+            sells=0,
+            holds=0,
+            total_pnl=5.0,
+            win_rate=100.0,
+            avg_confidence=90.0,
+            scenario_match_rate=100.0,
+        )
+    )
+    assert lessons == []
+
+
+@pytest.mark.asyncio
+async def test_generate_lessons_parses_json_array(
+    db_conn: sqlite3.Connection, context_store: ContextStore,
+) -> None:
+    mock_gemini = MagicMock()
+    mock_gemini.decide = AsyncMock(
+        return_value=SimpleNamespace(rationale='["Cut losers earlier", "Reduce midday churn"]')
+    )
+    reviewer = DailyReviewer(db_conn, context_store, gemini_client=mock_gemini)
+
+    lessons = await reviewer.generate_lessons(
+        DailyScorecard(
+            date="2026-02-14",
+            market="KR",
+            total_decisions=3,
+            buys=1,
+            sells=1,
+            holds=1,
+            total_pnl=-2.5,
+            win_rate=50.0,
+            avg_confidence=70.0,
+            scenario_match_rate=66.7,
+        )
+    )
+    assert lessons == ["Cut losers earlier", "Reduce midday churn"]
+
+
+@pytest.mark.asyncio
+async def test_generate_lessons_fallback_to_lines(
+    db_conn: sqlite3.Connection, context_store: ContextStore,
+) -> None:
+    mock_gemini = MagicMock()
+    mock_gemini.decide = AsyncMock(
+        return_value=SimpleNamespace(rationale="- Keep risk tighter\n- Increase selectivity")
+    )
+    reviewer = DailyReviewer(db_conn, context_store, gemini_client=mock_gemini)
+
+    lessons = await reviewer.generate_lessons(
+        DailyScorecard(
+            date="2026-02-14",
+            market="US",
+            total_decisions=2,
+            buys=1,
+            sells=1,
+            holds=0,
+            total_pnl=1.0,
+            win_rate=50.0,
+            avg_confidence=75.0,
+            scenario_match_rate=100.0,
+        )
+    )
+    assert lessons == ["Keep risk tighter", "Increase selectivity"]
+
+
+@pytest.mark.asyncio
+async def test_generate_lessons_handles_gemini_error(
+    db_conn: sqlite3.Connection, context_store: ContextStore,
+) -> None:
+    mock_gemini = MagicMock()
+    mock_gemini.decide = AsyncMock(side_effect=RuntimeError("boom"))
+    reviewer = DailyReviewer(db_conn, context_store, gemini_client=mock_gemini)
+
+    lessons = await reviewer.generate_lessons(
+        DailyScorecard(
+            date="2026-02-14",
+            market="US",
+            total_decisions=0,
+            buys=0,
+            sells=0,
+            holds=0,
+            total_pnl=0.0,
+            win_rate=0.0,
+            avg_confidence=0.0,
+            scenario_match_rate=0.0,
+        )
+    )
+    assert lessons == []
+
+
+def test_store_scorecard_in_context(
+    db_conn: sqlite3.Connection, context_store: ContextStore,
+) -> None:
+    reviewer = DailyReviewer(db_conn, context_store)
+    scorecard = DailyScorecard(
+        date="2026-02-14",
+        market="KR",
+        total_decisions=5,
+        buys=2,
+        sells=1,
+        holds=2,
+        total_pnl=15.0,
+        win_rate=66.67,
+        avg_confidence=82.0,
+        scenario_match_rate=80.0,
+        lessons=["Keep position sizing stable"],
+        cross_market_note="US risk-off",
+    )
+
+    reviewer.store_scorecard_in_context(scorecard)
+
+    stored = context_store.get_context(
+        ContextLayer.L6_DAILY,
+        "2026-02-14",
+        "scorecard_KR",
+    )
+    assert stored is not None
+    assert stored["market"] == "KR"
+    assert stored["total_pnl"] == 15.0
+    assert stored["lessons"] == ["Keep position sizing stable"]
+
+
+def test_store_scorecard_key_is_market_scoped(
+    db_conn: sqlite3.Connection, context_store: ContextStore,
+) -> None:
+    reviewer = DailyReviewer(db_conn, context_store)
+    kr = DailyScorecard(
+        date="2026-02-14",
+        market="KR",
+        total_decisions=1,
+        buys=1,
+        sells=0,
+        holds=0,
+        total_pnl=1.0,
+        win_rate=100.0,
+        avg_confidence=90.0,
+        scenario_match_rate=100.0,
+    )
+    us = DailyScorecard(
+        date="2026-02-14",
+        market="US",
+        total_decisions=1,
+        buys=0,
+        sells=1,
+        holds=0,
+        total_pnl=-1.0,
+        win_rate=0.0,
+        avg_confidence=70.0,
+        scenario_match_rate=100.0,
+    )
+
+    reviewer.store_scorecard_in_context(kr)
+    reviewer.store_scorecard_in_context(us)
+
+    kr_ctx = context_store.get_context(ContextLayer.L6_DAILY, "2026-02-14", "scorecard_KR")
+    us_ctx = context_store.get_context(ContextLayer.L6_DAILY, "2026-02-14", "scorecard_US")
+
+    assert kr_ctx["market"] == "KR"
+    assert us_ctx["market"] == "US"
+    assert kr_ctx["total_pnl"] == 1.0
+    assert us_ctx["total_pnl"] == -1.0
+
+
+def test_generate_scorecard_handles_invalid_context_snapshot(
+    db_conn: sqlite3.Connection, context_store: ContextStore,
+) -> None:
+    reviewer = DailyReviewer(db_conn, context_store)
+    db_conn.execute(
+        """
+        INSERT INTO decision_logs (
+            decision_id, timestamp, stock_code, market, exchange_code,
+            action, confidence, rationale, context_snapshot, input_data
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """,
+        (
+            "d1",
+            "2026-02-14T09:00:00+00:00",
+            "005930",
+            "KR",
+            "KRX",
+            "HOLD",
+            50,
+            "test",
+            "{invalid_json",
+            json.dumps({}),
+        ),
+    )
+    db_conn.commit()
+
+    scorecard = reviewer.generate_scorecard("2026-02-14", "KR")
+    assert scorecard.total_decisions == 1
+    assert scorecard.scenario_match_rate == 0.0

tests/test_dashboard.py

@@ -0,0 +1,270 @@
+"""Tests for FastAPI dashboard endpoints."""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+from pathlib import Path
+
+import pytest
+
+pytest.importorskip("fastapi")
+from fastapi.testclient import TestClient
+
+from src.dashboard.app import create_dashboard_app
+from src.db import init_db
+
+
+def _seed_db(conn: sqlite3.Connection) -> None:
+    conn.execute(
+        """
+        INSERT INTO playbooks (
+            date, market, status, playbook_json, generated_at,
+            token_count, scenario_count, match_count
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        """,
+        (
+            "2026-02-14",
+            "KR",
+            "ready",
+            json.dumps({"market": "KR", "stock_playbooks": []}),
+            "2026-02-14T08:30:00+00:00",
+            123,
+            2,
+            1,
+        ),
+    )
+    conn.execute(
+        """
+        INSERT INTO contexts (layer, timeframe, key, value, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?)
+        """,
+        (
+            "L6_DAILY",
+            "2026-02-14",
+            "scorecard_KR",
+            json.dumps({"market": "KR", "total_pnl": 1.5, "win_rate": 60.0}),
+            "2026-02-14T15:30:00+00:00",
+            "2026-02-14T15:30:00+00:00",
+        ),
+    )
+    conn.execute(
+        """
+        INSERT INTO contexts (layer, timeframe, key, value, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?)
+        """,
+        (
+            "L7_REALTIME",
+            "2026-02-14T10:00:00+00:00",
+            "volatility_KR_005930",
+            json.dumps({"momentum_score": 70.0}),
+            "2026-02-14T10:00:00+00:00",
+            "2026-02-14T10:00:00+00:00",
+        ),
+    )
+    conn.execute(
+        """
+        INSERT INTO decision_logs (
+            decision_id, timestamp, stock_code, market, exchange_code,
+            action, confidence, rationale, context_snapshot, input_data
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """,
+        (
+            "d-kr-1",
+            "2026-02-14T09:10:00+00:00",
+            "005930",
+            "KR",
+            "KRX",
+            "BUY",
+            85,
+            "signal matched",
+            json.dumps({"scenario_match": {"rsi": 28.0}}),
+            json.dumps({"current_price": 70000}),
+        ),
+    )
+    conn.execute(
+        """
+        INSERT INTO decision_logs (
+            decision_id, timestamp, stock_code, market, exchange_code,
+            action, confidence, rationale, context_snapshot, input_data
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """,
+        (
+            "d-us-1",
+            "2026-02-14T21:10:00+00:00",
+            "AAPL",
+            "US",
+            "NASDAQ",
+            "SELL",
+            80,
+            "no match",
+            json.dumps({"scenario_match": {}}),
+            json.dumps({"current_price": 200}),
+        ),
+    )
+    conn.execute(
+        """
+        INSERT INTO trades (
+            timestamp, stock_code, action, confidence, rationale,
+            quantity, price, pnl, market, exchange_code, selection_context, decision_id
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """,
+        (
+            "2026-02-14T09:11:00+00:00",
+            "005930",
+            "BUY",
+            85,
+            "buy",
+            1,
+            70000,
+            2.0,
+            "KR",
+            "KRX",
+            None,
+            "d-kr-1",
+        ),
+    )
+    conn.execute(
+        """
+        INSERT INTO trades (
+            timestamp, stock_code, action, confidence, rationale,
+            quantity, price, pnl, market, exchange_code, selection_context, decision_id
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """,
+        (
+            "2026-02-14T21:11:00+00:00",
+            "AAPL",
+            "SELL",
+            80,
+            "sell",
+            1,
+            200,
+            -1.0,
+            "US",
+            "NASDAQ",
+            None,
+            "d-us-1",
+        ),
+    )
+    conn.commit()
+
+
+def _client(tmp_path: Path) -> TestClient:
+    db_path = tmp_path / "dashboard_test.db"
+    conn = init_db(str(db_path))
+    _seed_db(conn)
+    conn.close()
+    app = create_dashboard_app(str(db_path))
+    return TestClient(app)
+
+
+def test_index_serves_html(tmp_path: Path) -> None:
+    client = _client(tmp_path)
+    resp = client.get("/")
+    assert resp.status_code == 200
+    assert "The Ouroboros Dashboard API" in resp.text
+
+
+def test_status_endpoint(tmp_path: Path) -> None:
+    client = _client(tmp_path)
+    resp = client.get("/api/status")
+    assert resp.status_code == 200
+    body = resp.json()
+    assert "KR" in body["markets"]
+    assert "US" in body["markets"]
+    assert "totals" in body
+
+
+def test_playbook_found(tmp_path: Path) -> None:
+    client = _client(tmp_path)
+    resp = client.get("/api/playbook/2026-02-14?market=KR")
+    assert resp.status_code == 200
+    assert resp.json()["market"] == "KR"
+
+
+def test_playbook_not_found(tmp_path: Path) -> None:
+    client = _client(tmp_path)
+    resp = client.get("/api/playbook/2026-02-15?market=KR")
+    assert resp.status_code == 404
+
+
+def test_scorecard_found(tmp_path: Path) -> None:
+    client = _client(tmp_path)
+    resp = client.get("/api/scorecard/2026-02-14?market=KR")
+    assert resp.status_code == 200
+    assert resp.json()["scorecard"]["total_pnl"] == 1.5
+
+
+def test_scorecard_not_found(tmp_path: Path) -> None:
+    client = _client(tmp_path)
+    resp = client.get("/api/scorecard/2026-02-15?market=KR")
+    assert resp.status_code == 404
+
+
+def test_performance_all(tmp_path: Path) -> None:
+    client = _client(tmp_path)
+    resp = client.get("/api/performance?market=all")
+    assert resp.status_code == 200
+    body = resp.json()
+    assert body["market"] == "all"
+    assert body["combined"]["total_trades"] == 2
+    assert len(body["by_market"]) == 2
+
+
+def test_performance_market_filter(tmp_path: Path) -> None:
+    client = _client(tmp_path)
+    resp = client.get("/api/performance?market=KR")
+    assert resp.status_code == 200
+    body = resp.json()
+    assert body["market"] == "KR"
+    assert body["metrics"]["total_trades"] == 1
+
+
+def test_performance_empty_market(tmp_path: Path) -> None:
+    client = _client(tmp_path)
+    resp = client.get("/api/performance?market=JP")
+    assert resp.status_code == 200
+    assert resp.json()["metrics"]["total_trades"] == 0
+
+
+def test_context_layer_all(tmp_path: Path) -> None:
+    client = _client(tmp_path)
+    resp = client.get("/api/context/L7_REALTIME")
+    assert resp.status_code == 200
+    body = resp.json()
+    assert body["layer"] == "L7_REALTIME"
+    assert body["count"] == 1
+
+
+def test_context_layer_timeframe_filter(tmp_path: Path) -> None:
+    client = _client(tmp_path)
+    resp = client.get("/api/context/L6_DAILY?timeframe=2026-02-14")
+    assert resp.status_code == 200
+    body = resp.json()
+    assert body["count"] == 1
+    assert body["entries"][0]["key"] == "scorecard_KR"
+
+
+def test_decisions_endpoint(tmp_path: Path) -> None:
+    client = _client(tmp_path)
+    resp = client.get("/api/decisions?market=KR")
+    assert resp.status_code == 200
+    body = resp.json()
+    assert body["count"] == 1
+    assert body["decisions"][0]["decision_id"] == "d-kr-1"
+
+
+def test_scenarios_active_filters_non_matched(tmp_path: Path) -> None:
+    client = _client(tmp_path)
+    resp = client.get("/api/scenarios/active?market=KR&date_str=2026-02-14")
+    assert resp.status_code == 200
+    body = resp.json()
+    assert body["count"] == 1
+    assert body["matches"][0]["stock_code"] == "005930"
+
+
+def test_scenarios_active_empty_when_no_matches(tmp_path: Path) -> None:
+    client = _client(tmp_path)
+    resp = client.get("/api/scenarios/active?market=US&date_str=2026-02-14")
+    assert resp.status_code == 200
+    assert resp.json()["count"] == 0

tests/test_main.py

@@ -1,13 +1,23 @@
 """Tests for main trading loop integration."""
 
-from datetime import date
+from datetime import UTC, date, datetime
 from unittest.mock import ANY, AsyncMock, MagicMock, patch
 
 import pytest
 
-from src.core.risk_manager import CircuitBreakerTripped, FatFingerRejected
 from src.context.layer import ContextLayer
-from src.main import safe_float, trading_cycle
+from src.context.scheduler import ScheduleResult
+from src.core.risk_manager import CircuitBreakerTripped, FatFingerRejected
+from src.db import init_db, log_trade
+from src.evolution.scorecard import DailyScorecard
+from src.logging.decision_logger import DecisionLogger
+from src.main import (
+    _handle_market_close,
+    _run_context_scheduler,
+    _run_evolution_loop,
+    safe_float,
+    trading_cycle,
+)
 from src.strategy.models import (
     DayPlaybook,
     ScenarioAction,
@@ -44,6 +54,17 @@ def _make_hold_match(stock_code: str = "005930") -> ScenarioMatch:
     )
 
 
+def _make_sell_match(stock_code: str = "005930") -> ScenarioMatch:
+    """Create a ScenarioMatch that returns SELL."""
+    return ScenarioMatch(
+        stock_code=stock_code,
+        matched_scenario=None,
+        action=ScenarioAction.SELL,
+        confidence=90,
+        rationale="Test sell",
+    )
+
+
 class TestSafeFloat:
     """Test safe_float() helper function."""
 
@@ -1113,3 +1134,323 @@ class TestScenarioEngineIntegration:
         # REDUCE_ALL is not BUY or SELL — no order sent
         mock_broker.send_order.assert_not_called()
         mock_telegram.notify_trade_execution.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_sell_updates_original_buy_decision_outcome() -> None:
+    """SELL should update the original BUY decision outcome in decision_logs."""
+    db_conn = init_db(":memory:")
+    decision_logger = DecisionLogger(db_conn)
+
+    buy_decision_id = decision_logger.log_decision(
+        stock_code="005930",
+        market="KR",
+        exchange_code="KRX",
+        action="BUY",
+        confidence=85,
+        rationale="Initial buy",
+        context_snapshot={},
+        input_data={},
+    )
+    log_trade(
+        conn=db_conn,
+        stock_code="005930",
+        action="BUY",
+        confidence=85,
+        rationale="Initial buy",
+        quantity=1,
+        price=100.0,
+        pnl=0.0,
+        market="KR",
+        exchange_code="KRX",
+        decision_id=buy_decision_id,
+    )
+
+    broker = MagicMock()
+    broker.get_orderbook = AsyncMock(
+        return_value={"output1": {"stck_prpr": "120", "frgn_ntby_qty": "0"}}
+    )
+    broker.get_balance = AsyncMock(
+        return_value={
+            "output2": [
+                {
+                    "tot_evlu_amt": "100000",
+                    "dnca_tot_amt": "10000",
+                    "pchs_amt_smtl_amt": "90000",
+                }
+            ]
+        }
+    )
+    broker.send_order = AsyncMock(return_value={"msg1": "OK"})
+
+    overseas_broker = MagicMock()
+    engine = MagicMock(spec=ScenarioEngine)
+    engine.evaluate = MagicMock(return_value=_make_sell_match())
+    risk = MagicMock()
+    context_store = MagicMock(
+        get_latest_timeframe=MagicMock(return_value=None),
+        set_context=MagicMock(),
+    )
+    criticality_assessor = MagicMock(
+        assess_market_conditions=MagicMock(return_value=MagicMock(value="NORMAL")),
+        get_timeout=MagicMock(return_value=5.0),
+    )
+    telegram = MagicMock()
+    telegram.notify_trade_execution = AsyncMock()
+    telegram.notify_fat_finger = AsyncMock()
+    telegram.notify_circuit_breaker = AsyncMock()
+    telegram.notify_scenario_matched = AsyncMock()
+
+    market = MagicMock()
+    market.name = "Korea"
+    market.code = "KR"
+    market.exchange_code = "KRX"
+    market.is_domestic = True
+
+    await trading_cycle(
+        broker=broker,
+        overseas_broker=overseas_broker,
+        scenario_engine=engine,
+        playbook=_make_playbook(),
+        risk=risk,
+        db_conn=db_conn,
+        decision_logger=decision_logger,
+        context_store=context_store,
+        criticality_assessor=criticality_assessor,
+        telegram=telegram,
+        market=market,
+        stock_code="005930",
+        scan_candidates={},
+    )
+
+    updated_buy = decision_logger.get_decision_by_id(buy_decision_id)
+    assert updated_buy is not None
+    assert updated_buy.outcome_pnl == 20.0
+    assert updated_buy.outcome_accuracy == 1
+
+
+@pytest.mark.asyncio
+async def test_handle_market_close_runs_daily_review_flow() -> None:
+    """Market close should aggregate, create scorecard, lessons, and notify."""
+    telegram = MagicMock()
+    telegram.notify_market_close = AsyncMock()
+    telegram.send_message = AsyncMock()
+
+    context_aggregator = MagicMock()
+    reviewer = MagicMock()
+    reviewer.generate_scorecard.return_value = DailyScorecard(
+        date="2026-02-14",
+        market="KR",
+        total_decisions=3,
+        buys=1,
+        sells=1,
+        holds=1,
+        total_pnl=12.5,
+        win_rate=50.0,
+        avg_confidence=75.0,
+        scenario_match_rate=66.7,
+    )
+    reviewer.generate_lessons = AsyncMock(return_value=["Cut losers faster"])
+
+    await _handle_market_close(
+        market_code="KR",
+        market_name="Korea",
+        market_timezone=UTC,
+        telegram=telegram,
+        context_aggregator=context_aggregator,
+        daily_reviewer=reviewer,
+    )
+
+    telegram.notify_market_close.assert_called_once_with("Korea", 0.0)
+    context_aggregator.aggregate_daily_from_trades.assert_called_once()
+    reviewer.generate_scorecard.assert_called_once()
+    assert reviewer.store_scorecard_in_context.call_count == 2
+    reviewer.generate_lessons.assert_called_once()
+    telegram.send_message.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_handle_market_close_without_lessons_stores_once() -> None:
+    """If no lessons are generated, scorecard should be stored once."""
+    telegram = MagicMock()
+    telegram.notify_market_close = AsyncMock()
+    telegram.send_message = AsyncMock()
+
+    context_aggregator = MagicMock()
+    reviewer = MagicMock()
+    reviewer.generate_scorecard.return_value = DailyScorecard(
+        date="2026-02-14",
+        market="US",
+        total_decisions=1,
+        buys=0,
+        sells=1,
+        holds=0,
+        total_pnl=-3.0,
+        win_rate=0.0,
+        avg_confidence=65.0,
+        scenario_match_rate=100.0,
+    )
+    reviewer.generate_lessons = AsyncMock(return_value=[])
+
+    await _handle_market_close(
+        market_code="US",
+        market_name="United States",
+        market_timezone=UTC,
+        telegram=telegram,
+        context_aggregator=context_aggregator,
+        daily_reviewer=reviewer,
+    )
+
+    assert reviewer.store_scorecard_in_context.call_count == 1
+
+
+@pytest.mark.asyncio
+async def test_handle_market_close_triggers_evolution_for_us() -> None:
+    telegram = MagicMock()
+    telegram.notify_market_close = AsyncMock()
+    telegram.send_message = AsyncMock()
+
+    context_aggregator = MagicMock()
+    reviewer = MagicMock()
+    reviewer.generate_scorecard.return_value = DailyScorecard(
+        date="2026-02-14",
+        market="US",
+        total_decisions=2,
+        buys=1,
+        sells=1,
+        holds=0,
+        total_pnl=3.0,
+        win_rate=50.0,
+        avg_confidence=80.0,
+        scenario_match_rate=100.0,
+    )
+    reviewer.generate_lessons = AsyncMock(return_value=[])
+
+    evolution_optimizer = MagicMock()
+    evolution_optimizer.evolve = AsyncMock(return_value=None)
+
+    await _handle_market_close(
+        market_code="US",
+        market_name="United States",
+        market_timezone=UTC,
+        telegram=telegram,
+        context_aggregator=context_aggregator,
+        daily_reviewer=reviewer,
+        evolution_optimizer=evolution_optimizer,
+    )
+
+    evolution_optimizer.evolve.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_handle_market_close_skips_evolution_for_kr() -> None:
+    telegram = MagicMock()
+    telegram.notify_market_close = AsyncMock()
+    telegram.send_message = AsyncMock()
+
+    context_aggregator = MagicMock()
+    reviewer = MagicMock()
+    reviewer.generate_scorecard.return_value = DailyScorecard(
+        date="2026-02-14",
+        market="KR",
+        total_decisions=1,
+        buys=1,
+        sells=0,
+        holds=0,
+        total_pnl=1.0,
+        win_rate=100.0,
+        avg_confidence=90.0,
+        scenario_match_rate=100.0,
+    )
+    reviewer.generate_lessons = AsyncMock(return_value=[])
+
+    evolution_optimizer = MagicMock()
+    evolution_optimizer.evolve = AsyncMock(return_value=None)
+
+    await _handle_market_close(
+        market_code="KR",
+        market_name="Korea",
+        market_timezone=UTC,
+        telegram=telegram,
+        context_aggregator=context_aggregator,
+        daily_reviewer=reviewer,
+        evolution_optimizer=evolution_optimizer,
+    )
+
+    evolution_optimizer.evolve.assert_not_called()
+
+
+def test_run_context_scheduler_invokes_scheduler() -> None:
+    """Scheduler helper should call run_if_due with provided datetime."""
+    scheduler = MagicMock()
+    scheduler.run_if_due = MagicMock(return_value=ScheduleResult(cleanup=True))
+
+    _run_context_scheduler(scheduler, now=datetime(2026, 2, 14, tzinfo=UTC))
+
+    scheduler.run_if_due.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_run_evolution_loop_skips_non_us_market() -> None:
+    optimizer = MagicMock()
+    optimizer.evolve = AsyncMock()
+    telegram = MagicMock()
+    telegram.send_message = AsyncMock()
+
+    await _run_evolution_loop(
+        evolution_optimizer=optimizer,
+        telegram=telegram,
+        market_code="KR",
+        market_date="2026-02-14",
+    )
+
+    optimizer.evolve.assert_not_called()
+    telegram.send_message.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_run_evolution_loop_notifies_when_pr_generated() -> None:
+    optimizer = MagicMock()
+    optimizer.evolve = AsyncMock(
+        return_value={
+            "title": "[Evolution] New strategy: v20260214_050000",
+            "branch": "evolution/v20260214_050000",
+            "status": "ready_for_review",
+        }
+    )
+    telegram = MagicMock()
+    telegram.send_message = AsyncMock()
+
+    await _run_evolution_loop(
+        evolution_optimizer=optimizer,
+        telegram=telegram,
+        market_code="US",
+        market_date="2026-02-14",
+    )
+
+    optimizer.evolve.assert_called_once()
+    telegram.send_message.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_run_evolution_loop_notification_error_is_ignored() -> None:
+    optimizer = MagicMock()
+    optimizer.evolve = AsyncMock(
+        return_value={
+            "title": "[Evolution] New strategy: v20260214_050000",
+            "branch": "evolution/v20260214_050000",
+            "status": "ready_for_review",
+        }
+    )
+    telegram = MagicMock()
+    telegram.send_message = AsyncMock(side_effect=RuntimeError("telegram down"))
+
+    await _run_evolution_loop(
+        evolution_optimizer=optimizer,
+        telegram=telegram,
+        market_code="US",
+        market_date="2026-02-14",
+    )
+
+    optimizer.evolve.assert_called_once()
+    telegram.send_message.assert_called_once()

tests/test_pre_market_planner.py

@@ -9,6 +9,7 @@ from unittest.mock import AsyncMock, MagicMock
 import pytest
 
 from src.analysis.smart_scanner import ScanCandidate
+from src.brain.context_selector import DecisionType
 from src.brain.gemini_client import TradeDecision
 from src.config import Settings
 from src.context.store import ContextLayer
@@ -16,12 +17,10 @@ from src.strategy.models import (
     CrossMarketContext,
     DayPlaybook,
     MarketOutlook,
-    PlaybookStatus,
     ScenarioAction,
 )
 from src.strategy.pre_market_planner import PreMarketPlanner
 
-
 # ---------------------------------------------------------------------------
 # Fixtures
 # ---------------------------------------------------------------------------
@@ -89,6 +88,7 @@ def _make_planner(
     token_count: int = 200,
     context_data: dict | None = None,
     scorecard_data: dict | None = None,
+    scorecard_map: dict[tuple[str, str, str], dict | None] | None = None,
 ) -> PreMarketPlanner:
     """Create a PreMarketPlanner with mocked dependencies."""
     if not gemini_response:
@@ -107,11 +107,20 @@ def _make_planner(
 
     # Mock ContextStore
     store = MagicMock()
-    store.get_context = MagicMock(return_value=scorecard_data)
+    if scorecard_map is not None:
+        store.get_context = MagicMock(
+            side_effect=lambda layer, timeframe, key: scorecard_map.get(
+                (layer.value if hasattr(layer, "value") else layer, timeframe, key)
+            )
+        )
+    else:
+        store.get_context = MagicMock(return_value=scorecard_data)
 
     # Mock ContextSelector
     selector = MagicMock()
-    selector.select_layers = MagicMock(return_value=[ContextLayer.L7_REALTIME, ContextLayer.L6_DAILY])
+    selector.select_layers = MagicMock(
+        return_value=[ContextLayer.L7_REALTIME, ContextLayer.L6_DAILY]
+    )
     selector.get_context_data = MagicMock(return_value=context_data or {})
 
     settings = Settings(
@@ -220,11 +229,25 @@ class TestGeneratePlaybook:
         stocks = [
             {
                 "stock_code": "005930",
-                "scenarios": [{"condition": {"rsi_below": 30}, "action": "BUY", "confidence": 85, "rationale": "ok"}],
+                "scenarios": [
+                    {
+                        "condition": {"rsi_below": 30},
+                        "action": "BUY",
+                        "confidence": 85,
+                        "rationale": "ok",
+                    }
+                ],
             },
             {
                 "stock_code": "UNKNOWN",
-                "scenarios": [{"condition": {"rsi_below": 20}, "action": "BUY", "confidence": 90, "rationale": "bad"}],
+                "scenarios": [
+                    {
+                        "condition": {"rsi_below": 20},
+                        "action": "BUY",
+                        "confidence": 90,
+                        "rationale": "bad",
+                    }
+                ],
             },
         ]
         planner = _make_planner(gemini_response=_gemini_response_json(stocks=stocks))
@@ -254,6 +277,43 @@ class TestGeneratePlaybook:
 
         assert pb.token_count == 450
 
+    @pytest.mark.asyncio
+    async def test_generate_playbook_uses_strategic_context_selector(self) -> None:
+        planner = _make_planner()
+        candidates = [_candidate()]
+
+        await planner.generate_playbook("KR", candidates, today=date(2026, 2, 8))
+
+        planner._context_selector.select_layers.assert_called_once_with(
+            decision_type=DecisionType.STRATEGIC,
+            include_realtime=True,
+        )
+        planner._context_selector.get_context_data.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_generate_playbook_injects_self_and_cross_scorecards(self) -> None:
+        scorecard_map = {
+            (ContextLayer.L6_DAILY.value, "2026-02-07", "scorecard_KR"): {
+                "total_pnl": -1.0,
+                "win_rate": 40,
+                "lessons": ["Tighten entries"],
+            },
+            (ContextLayer.L6_DAILY.value, "2026-02-07", "scorecard_US"): {
+                "total_pnl": 1.5,
+                "win_rate": 62,
+                "index_change_pct": 0.9,
+                "lessons": ["Follow momentum"],
+            },
+        }
+        planner = _make_planner(scorecard_map=scorecard_map)
+
+        await planner.generate_playbook("KR", [_candidate()], today=date(2026, 2, 8))
+
+        call_market_data = planner._gemini.decide.call_args.args[0]
+        prompt = call_market_data["prompt_override"]
+        assert "My Market Previous Day (KR)" in prompt
+        assert "Other Market (US)" in prompt
+
 
 # ---------------------------------------------------------------------------
 # _parse_response
@@ -402,7 +462,12 @@ class TestParseResponse:
 
 class TestBuildCrossMarketContext:
     def test_kr_reads_us_scorecard(self) -> None:
-        scorecard = {"total_pnl": 2.5, "win_rate": 65, "index_change_pct": 0.8, "lessons": ["Stay patient"]}
+        scorecard = {
+            "total_pnl": 2.5,
+            "win_rate": 65,
+            "index_change_pct": 0.8,
+            "lessons": ["Stay patient"],
+        }
         planner = _make_planner(scorecard_data=scorecard)
 
         ctx = planner.build_cross_market_context("KR", today=date(2026, 2, 8))
@@ -415,8 +480,9 @@ class TestBuildCrossMarketContext:
 
         # Verify it queried scorecard_US
         planner._context_store.get_context.assert_called_once_with(
-            ContextLayer.L6_DAILY, "2026-02-08", "scorecard_US"
+            ContextLayer.L6_DAILY, "2026-02-07", "scorecard_US"
         )
+        assert ctx.date == "2026-02-07"
 
     def test_us_reads_kr_scorecard(self) -> None:
         scorecard = {"total_pnl": -1.0, "win_rate": 40, "index_change_pct": -0.5}
@@ -447,6 +513,32 @@ class TestBuildCrossMarketContext:
         assert ctx is None
 
 
+# ---------------------------------------------------------------------------
+# build_self_market_scorecard
+# ---------------------------------------------------------------------------
+
+
+class TestBuildSelfMarketScorecard:
+    def test_reads_previous_day_scorecard(self) -> None:
+        scorecard = {"total_pnl": -1.2, "win_rate": 45, "lessons": ["Reduce overtrading"]}
+        planner = _make_planner(scorecard_data=scorecard)
+
+        data = planner.build_self_market_scorecard("KR", today=date(2026, 2, 8))
+
+        assert data is not None
+        assert data["date"] == "2026-02-07"
+        assert data["total_pnl"] == -1.2
+        assert data["win_rate"] == 45
+        assert "Reduce overtrading" in data["lessons"]
+        planner._context_store.get_context.assert_called_once_with(
+            ContextLayer.L6_DAILY, "2026-02-07", "scorecard_KR"
+        )
+
+    def test_missing_scorecard_returns_none(self) -> None:
+        planner = _make_planner(scorecard_data=None)
+        assert planner.build_self_market_scorecard("US", today=date(2026, 2, 8)) is None
+
+
 # ---------------------------------------------------------------------------
 # _build_prompt
 # ---------------------------------------------------------------------------
@@ -457,7 +549,7 @@ class TestBuildPrompt:
         planner = _make_planner()
         candidates = [_candidate(code="005930", name="Samsung")]
 
-        prompt = planner._build_prompt("KR", candidates, {}, None)
+        prompt = planner._build_prompt("KR", candidates, {}, None, None)
 
         assert "005930" in prompt
         assert "Samsung" in prompt
@@ -471,7 +563,7 @@ class TestBuildPrompt:
             win_rate=60, index_change_pct=0.8, lessons=["Cut losses early"],
         )
 
-        prompt = planner._build_prompt("KR", [_candidate()], {}, cross)
+        prompt = planner._build_prompt("KR", [_candidate()], {}, None, cross)
 
         assert "Other Market (US)" in prompt
         assert "+1.50%" in prompt
@@ -481,7 +573,7 @@ class TestBuildPrompt:
         planner = _make_planner()
         context = {"L6_DAILY": {"win_rate": 0.65, "total_pnl": 2.5}}
 
-        prompt = planner._build_prompt("KR", [_candidate()], context, None)
+        prompt = planner._build_prompt("KR", [_candidate()], context, None, None)
 
         assert "Strategic Context" in prompt
         assert "L6_DAILY" in prompt
@@ -489,15 +581,30 @@ class TestBuildPrompt:
 
     def test_prompt_contains_max_scenarios(self) -> None:
         planner = _make_planner()
-        prompt = planner._build_prompt("KR", [_candidate()], {}, None)
+        prompt = planner._build_prompt("KR", [_candidate()], {}, None, None)
 
         assert f"Max {planner._settings.MAX_SCENARIOS_PER_STOCK} scenarios" in prompt
 
     def test_prompt_market_name(self) -> None:
         planner = _make_planner()
-        prompt = planner._build_prompt("US", [_candidate()], {}, None)
+        prompt = planner._build_prompt("US", [_candidate()], {}, None, None)
         assert "US market" in prompt
 
+    def test_prompt_contains_self_market_scorecard(self) -> None:
+        planner = _make_planner()
+        self_scorecard = {
+            "date": "2026-02-07",
+            "total_pnl": -0.8,
+            "win_rate": 45.0,
+            "lessons": ["Avoid midday entries"],
+        }
+        prompt = planner._build_prompt("KR", [_candidate()], {}, self_scorecard, None)
+
+        assert "My Market Previous Day (KR)" in prompt
+        assert "2026-02-07" in prompt
+        assert "-0.80%" in prompt
+        assert "Avoid midday entries" in prompt
+
 
 # ---------------------------------------------------------------------------
 # _extract_json

tests/test_scorecard.py

@@ -0,0 +1,81 @@
+"""Tests for DailyScorecard model."""
+
+from __future__ import annotations
+
+from src.evolution.scorecard import DailyScorecard
+
+
+def test_scorecard_initialization() -> None:
+    scorecard = DailyScorecard(
+        date="2026-02-08",
+        market="KR",
+        total_decisions=10,
+        buys=3,
+        sells=2,
+        holds=5,
+        total_pnl=1234.5,
+        win_rate=60.0,
+        avg_confidence=78.5,
+        scenario_match_rate=70.0,
+        top_winners=["005930", "000660"],
+        top_losers=["035420"],
+        lessons=["Avoid chasing breakouts"],
+        cross_market_note="US volatility spillover",
+    )
+
+    assert scorecard.market == "KR"
+    assert scorecard.total_decisions == 10
+    assert scorecard.total_pnl == 1234.5
+    assert scorecard.top_winners == ["005930", "000660"]
+    assert scorecard.lessons == ["Avoid chasing breakouts"]
+    assert scorecard.cross_market_note == "US volatility spillover"
+
+
+def test_scorecard_defaults() -> None:
+    scorecard = DailyScorecard(
+        date="2026-02-08",
+        market="US",
+        total_decisions=0,
+        buys=0,
+        sells=0,
+        holds=0,
+        total_pnl=0.0,
+        win_rate=0.0,
+        avg_confidence=0.0,
+        scenario_match_rate=0.0,
+    )
+
+    assert scorecard.top_winners == []
+    assert scorecard.top_losers == []
+    assert scorecard.lessons == []
+    assert scorecard.cross_market_note == ""
+
+
+def test_scorecard_list_isolation() -> None:
+    a = DailyScorecard(
+        date="2026-02-08",
+        market="KR",
+        total_decisions=1,
+        buys=1,
+        sells=0,
+        holds=0,
+        total_pnl=10.0,
+        win_rate=100.0,
+        avg_confidence=90.0,
+        scenario_match_rate=100.0,
+    )
+    b = DailyScorecard(
+        date="2026-02-08",
+        market="US",
+        total_decisions=1,
+        buys=0,
+        sells=1,
+        holds=0,
+        total_pnl=-5.0,
+        win_rate=0.0,
+        avg_confidence=60.0,
+        scenario_match_rate=50.0,
+    )
+
+    a.top_winners.append("005930")
+    assert b.top_winners == []