feat: integrate DailyReviewer into market close flow (issue #93)

Extract _handle_market_close() helper that runs EOD aggregation,
generates scorecard with optional AI lessons, and sends Telegram summary.

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

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,6 +1,7 @@
 """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,
@@ -18,4 +19,5 @@ __all__ = [
     "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/main.py

@@ -26,7 +26,8 @@ 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.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
@@ -279,7 +280,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,
@@ -291,6 +292,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
@@ -346,6 +350,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:
@@ -363,9 +379,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
@@ -600,7 +620,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,
@@ -612,6 +632,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
@@ -684,6 +707,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,
@@ -691,13 +726,52 @@ 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,
+) -> 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'}"
+    )
+
+
 async def run(settings: Settings) -> None:
     """Main async loop — iterate over open markets on a timer."""
     broker = KISBroker(settings)
@@ -713,6 +787,7 @@ async def run(settings: Settings) -> None:
     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,
@@ -991,13 +1066,13 @@ 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)
-                                    market_date = datetime.now(
-                                        market_info.timezone
-                                    ).date().isoformat()
-                                    context_aggregator.aggregate_daily_from_trades(
-                                        date=market_date,
-                                        market=market_code,
+                                    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,
                                     )
                             except Exception as exc:
                                 logger.warning("Market close notification failed: %s", exc)

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_main.py

@@ -1,13 +1,16 @@
 """Tests for main trading loop integration."""
 
-from datetime import date
+from datetime import UTC, date
 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.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, safe_float, trading_cycle
 from src.strategy.models import (
     DayPlaybook,
     ScenarioAction,
@@ -44,6 +47,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 +1127,171 @@ 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