feat: wire evolution loop into market close flow (issue #95)

Run EvolutionOptimizer.evolve() at US market close, skip for other
markets, and notify via Telegram when a strategy PR is generated.

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

src/main.py

@@ -22,12 +22,14 @@ 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 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
@@ -744,6 +746,7 @@ async def _handle_market_close(
     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)
@@ -771,6 +774,72 @@ async def _handle_market_close(
         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
+
+    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')}"
+    )
+
 
 async def run(settings: Settings) -> None:
     """Main async loop — iterate over open markets on a timer."""
@@ -782,6 +851,11 @@ async def run(settings: Settings) -> None:
     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)
@@ -1015,6 +1089,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(
@@ -1053,6 +1128,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)
@@ -1073,6 +1149,7 @@ async def run(settings: Settings) -> None:
                                         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)

src/strategy/pre_market_planner.py

@@ -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 = {
@@ -176,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(
@@ -189,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."""
@@ -212,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"
@@ -225,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_main.py

@@ -1,16 +1,23 @@
 """Tests for main trading loop integration."""
 
-from datetime import UTC, date
+from datetime import UTC, date, datetime
 from unittest.mock import ANY, AsyncMock, MagicMock, patch
 
 import pytest
 
 from src.context.layer import ContextLayer
+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, safe_float, trading_cycle
+from src.main import (
+    _handle_market_close,
+    _run_context_scheduler,
+    _run_evolution_loop,
+    safe_float,
+    trading_cycle,
+)
 from src.strategy.models import (
     DayPlaybook,
     ScenarioAction,
@@ -1295,3 +1302,55 @@ async def test_handle_market_close_without_lessons_stores_once() -> None:
     )
 
     assert reviewer.store_scorecard_in_context.call_count == 1
+
+
+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()

tests/test_pre_market_planner.py

@@ -88,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:
@@ -106,6 +107,13 @@ def _make_planner(
 
     # Mock ContextStore
     store = MagicMock()
+    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
@@ -282,6 +290,30 @@ class TestGeneratePlaybook:
         )
         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
@@ -481,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
 # ---------------------------------------------------------------------------
@@ -491,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
@@ -505,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
@@ -515,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
@@ -523,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