Add Phase 8 — Multiplayer (Human vs Human + AI)

- run_n() accepts 2-4 decks; run() wraps for backward compat
- _select_attack_target() heuristic for multiplayer combat targeting
- N-player elimination order tracking with finish positions
- Removal scans all opponents for scariest creature
- ML snapshot captures all N players
- Log entries use per-seat boards dict with legacy boardA/boardB for 2-player

COMMANDER_GUI_ROADMAP.md

@@ -0,0 +1,145 @@
+# Commander-AI-Lab GUI + LLM Opponents Roadmap
+
+## Project Summary
+
+Build a playable Magic: The Gathering Commander interface where human players face AI opponents powered by a local LLM. The existing Python rules engine handles game legality and state management, while the LLM acts as the decision-making and narration brain for each AI opponent. A Pygame (or web-based) GUI renders the battlefield, zones, and card interactions. Each AI opponent gets a unique personality prompt to simulate different playstyles (aggro, control, combo, politics).
+
+**Local LLM:** GPT-OSS 20B (Q4_K_M) via Ollama or LM Studio
+
+---
+
+## GUI Strategy: Two-Phase Frontend Plan
+
+### Phase A (Prototype) — Pygame
+Use **Pygame** for Phases 1–3 of development. Pure Python means the rules engine and AI opponent code plug in directly with zero bridging. Fast to iterate — a working battlefield renderer can be built in a day. Handles game loop, input events, and card rendering naturally. Ideal for testing AI decisions visually before investing in a polished UI.
+
+### Phase B (Production) — Flask/FastAPI + Web Frontend
+Once the core AI gameplay is working, migrate the UI to a **Flask or FastAPI backend + HTML/JS frontend** (vanilla JS or React). Benefits:
+- Far more polished look for a Commander game
+- Card art from Scryfall API renders natively in browser
+- Easier to add multiplayer later via WebSockets
+- Python backend stays pure — frontend calls it via REST API
+- No Python/JS bridge complexity; clean separation of concerns
+
+### GUI Framework Comparison
+
+| Option | Language | Curve | Best For | Weakness |
+|---|---|---|---|---|
+| **Pygame** ✅ Phase A | Python | Low | Quick prototype, game loops | Dated UI, manual widgets |
+| **Flask + HTML/JS** ✅ Phase B | Python + JS | Medium | Polished UI, browser-based | JS context switch |
+| PyQt6 / PySide6 | Python | Medium | Desktop app widgets | Verbose, overkill for a game |
+| Godot | GDScript | Medium | Full game engine, animations | Separate codebase from engine |
+| Electron + Python | JS + Python | High | Desktop with web UI | Heavy, complex bridge |
+| Tkinter | Python | Low | Simple UI | Very dated look |
+
+---
+
+## Architecture Overview
+
+```
+Game State (Python dict/dataclass)
+        ↓
+Legal Moves Generator (rules engine)
+        ↓
+LLM Prompt: "Given this state and these legal moves, what do you do?"
+        ↓ (GPT-OSS 20B Q4_K_M)
+LLM Response → parsed action
+        ↓
+Rules Engine executes + validates
+        ↓
+GUI updates board state (Pygame → Web)
+```
+
+---
+
+## Task List
+
+### Phase 1 — Game State Serialization
+- [ ] Define a compressed game state schema (Python dataclass or dict) covering: hand, battlefield, graveyard, exile, stack, life totals, commander zone, mana pool
+- [ ] Write a `state_to_prompt()` function that converts game state to a compact LLM-readable string
+- [ ] Write a `legal_moves_to_prompt()` function that lists valid actions in numbered format for LLM selection
+- [ ] Add a state snapshot logger for debugging AI decisions
+
+### Phase 2 — LLM AI Opponent Integration
+- [ ] Load GPT-OSS 20B (Q4_K_M) in Ollama or LM Studio; verify inference speed on RTX 5070 Ti
+- [ ] Benchmark VRAM usage for GPT-OSS 20B Q4_K_M (expected ~12–14 GB VRAM at Q4_K_M quantization)
+- [ ] Build `AIOpponent` class with fields: name, personality_prompt, model_endpoint, deck
+- [ ] Implement `decide_action(game_state, legal_moves)` method — sends prompt to GPT-OSS 20B, parses LLM response, returns validated action index
+- [ ] Add fallback logic: if LLM returns invalid/unparseable action, default to highest-priority heuristic move
+- [ ] Write personality prompt templates (Aggro Timmy, Control Spike, Combo Johnny, Political Negotiator)
+- [ ] Add narration method: `narrate_play(action)` — GPT-OSS 20B generates in-character flavor text for each play
+- [ ] Tune system prompt length to stay within GPT-OSS 20B context window limits
+
+### Phase 3 — Multi-Player Turn Management
+- [ ] Implement turn queue: Player → AI1 → AI2 → AI3 → repeat
+- [ ] Run AI decisions asynchronously (threading or asyncio) so GUI stays responsive during LLM inference
+- [ ] Add priority-passing logic for instants/triggers during other players' turns
+- [ ] Implement basic AI threat assessment: each AI scores opponents by board state danger level
+
+### Phase 4 — Pygame Prototype GUI
+- [ ] Design zone layout: hand, battlefield (creature/non-creature split), graveyard, exile, command zone, stack
+- [ ] Build card rendering: card art placeholder, name, P/T or loyalty, tapped/untapped state
+- [ ] Add click-to-play card interaction for human player
+- [ ] Display AI narration/flavor text in a side panel
+- [ ] Add life total trackers and commander damage matrix (4-player)
+- [ ] Build phase/step indicator (Main 1, Combat, Main 2, etc.)
+- [ ] Add end-of-game screen with win condition display
+
+### Phase 5 — Web Frontend Migration *(Flask/FastAPI + HTML/JS)*
+- [ ] Set up Flask or FastAPI backend exposing game state as REST API
+- [ ] Build HTML/JS board layout mirroring Pygame zone design
+- [ ] Integrate Scryfall API for card art rendering
+- [ ] Add WebSocket support for real-time game state updates
+- [ ] Add drag-and-drop card interaction
+- [ ] Port AI narration panel to web chat-style UI
+- [ ] Test full game loop end-to-end on web frontend
+
+### Phase 6 — Politics & Table Talk *(Stretch Goal)*
+- [ ] Implement inter-AI negotiation: before attacking, AI queries GPT-OSS 20B "should I propose a deal?"
+- [ ] Build deal proposal UI: AI proposes, human can accept/decline, other AIs respond
+- [ ] Add threat-based targeting memory: AIs remember who attacked them last turn
+
+### Phase 7 — Testing & Tuning
+- [ ] Run 10 full simulated games (4 AI vs AI) and log decision quality
+- [ ] Benchmark GPT-OSS 20B Q4_K_M inference time per decision on RTX 5070 Ti
+- [ ] Tune context window compression to stay within model token limits
+- [ ] Profile Pygame and web render loops for stability during AI thinking phases
+- [ ] Add unit tests for `state_to_prompt()` and `decide_action()` parsing
+
+### Phase 8 — Multiplayer (Human vs Human + AI)
+- [ ] **Lobby system** — create/join game rooms with configurable seat count (2–4 players); assign each seat as Human or AI
+- [ ] **WebSocket game server** — upgrade Flask/FastAPI backend to handle persistent connections for real-time state sync across multiple browser clients
+- [ ] **Player session management** — unique session tokens per human player; reconnect support if connection drops mid-game
+- [ ] **Private hand views** — each human player sees only their own hand; other hands shown as face-down card backs
+- [ ] **Turn notification system** — alert active player when it's their turn (browser notification or in-page indicator)
+- [ ] **Action broadcast** — all players see each action played in real-time (card played, attack declared, ability activated) via WebSocket push
+- [ ] **Mixed lobby support** — allow any combination of human and AI seats (e.g., 2 humans + 2 AIs, or 1 human + 3 AIs)
+- [ ] **Spectator mode** — allow observers to watch a game without participating; full board visible, no hand info
+- [ ] **Local LAN play** — host game server on local network so friends can connect via browser on the same Wi-Fi (no internet required)
+- [ ] **Optional: Remote play** — expose server via ngrok or Tailscale for play over the internet without full deployment
+- [ ] **Multiplayer AI pacing** — add configurable AI decision delay (e.g., 1–3 sec) so human players can follow AI turns without them resolving instantly
+- [ ] **Chat panel** — in-game text chat between human players; AI opponents can optionally post narration lines into the same channel
+- [ ] **End-of-game summary** — show full game recap (turns played, damage dealt, commanders cast count) visible to all players after win condition met
+
+---
+
+## Tech Stack
+
+| Component | Choice | Notes |
+|---|---|---|
+| GUI (Prototype) | **Pygame** | Pure Python, fast iteration |
+| GUI (Production) | **Flask/FastAPI + HTML/JS** | Polished, browser-based |
+| Multiplayer | **WebSockets (Flask-SocketIO)** | Real-time state sync across clients |
+| LLM Backend | Ollama or LM Studio | Serves GPT-OSS 20B locally |
+| Model | **GPT-OSS 20B (Q4_K_M)** | ~12–14 GB VRAM, strong reasoning |
+| Game State | Python dataclass | Structured, easy to serialize |
+| Async | asyncio / threading | Keep GUI responsive during inference |
+| Card Data | Scryfall API | Free MTG card data + art |
+| LAN Hosting | Local network / ngrok | No deployment needed for local play |
+
+### GPT-OSS 20B Q4_K_M Notes
+- Q4_K_M quantization balances quality and speed well for a 20B model
+- Expected VRAM: ~12–14 GB on RTX 5070 Ti (16 GB VRAM) — fits comfortably
+- Stronger reasoning than 7B models — better for multi-step MTG decision making
+- Slower inference than smaller models — async handling is essential so GUI doesn't block
+- System prompt + game state should be kept under ~3000 tokens to maintain fast response times

coach/clients/perplexity_client.py

@@ -268,7 +268,92 @@ class PerplexityClient:
                         return json.loads(text[start:i+1])
                     except (json.JSONDecodeError, TypeError):
                         return None
-        return None
+
+        # If we get here, JSON was truncated (depth > 0). Try to repair.
+        return PerplexityClient._repair_truncated_json(text[start:])
+
+    @staticmethod
+    def _repair_truncated_json(text: str) -> Optional[dict]:
+        """
+        Attempt to repair truncated JSON from max_tokens cutoff.
+        Strategy: find the last complete array element in "cards",
+        then close all open brackets/braces.
+        """
+        logger.info("Attempting truncated JSON repair (%d chars)...", len(text))
+
+        # Find the last complete card object (ends with }) in the cards array
+        # Walk backwards to find the last closing brace that ends a valid card
+        last_good = -1
+        depth = 0
+        in_string = False
+        escape_next = False
+
+        for i in range(len(text)):
+            ch = text[i]
+            if escape_next:
+                escape_next = False
+                continue
+            if ch == '\\' and in_string:
+                escape_next = True
+                continue
+            if ch == '"':
+                in_string = not in_string
+                continue
+            if in_string:
+                continue
+            if ch == '{':
+                depth += 1
+            elif ch == '}':
+                depth -= 1
+                if depth >= 1:
+                    # This closes a nested object (like a card) — mark as potential cutoff
+                    last_good = i
+
+        if last_good == -1:
+            return None
+
+        # Take text up to the last complete nested object
+        truncated = text[:last_good + 1]
+
+        # Now figure out what we need to close.
+        # Re-scan to get the closing sequence.
+        close_depth = 0
+        in_arr = 0
+        in_str = False
+        esc = False
+        for ch in truncated:
+            if esc:
+                esc = False
+                continue
+            if ch == '\\' and in_str:
+                esc = True
+                continue
+            if ch == '"':
+                in_str = not in_str
+                continue
+            if in_str:
+                continue
+            if ch == '{':
+                close_depth += 1
+            elif ch == '}':
+                close_depth -= 1
+            elif ch == '[':
+                in_arr += 1
+            elif ch == ']':
+                in_arr -= 1
+
+        # Build closing sequence
+        suffix = ']' * in_arr + '}' * close_depth
+        repaired = truncated + suffix
+
+        try:
+            result = json.loads(repaired)
+            card_count = len(result.get('cards', []))
+            logger.info("JSON repair succeeded: recovered %d cards", card_count)
+            return result
+        except (json.JSONDecodeError, TypeError) as e:
+            logger.warning("JSON repair failed: %s", e)
+            return None
 
     def check_status(self) -> dict:
         """Quick health check — try a minimal API call."""

coach/coach_service.py

@@ -126,11 +126,12 @@ class CoachService:
     # ── Main Coaching Pipeline ─────────────────────────────────
 
     async def run_coaching_session(self, deck_id: str,
-                                    goals: Optional[CoachGoals] = None
+                                    goals: Optional[CoachGoals] = None,
+                                    fallback_report: Optional[DeckReport] = None,
                                     ) -> CoachSession:
         """
         Full coaching pipeline:
-        1. Load deck report
+        1. Load deck report (or use fallback from DB card list)
         2. Identify underperformers
         3. Find replacement candidates via embeddings
         4. Build prompt
@@ -150,8 +151,11 @@ class CoachService:
             except Exception as e:
                 logger.warning("Embeddings auto-load failed: %s", e)
 
-        # 1. Load deck report
+        # 1. Load deck report — try simulation report first, then fallback
         report = self.load_deck_report(deck_id)
+        if report is None and fallback_report is not None:
+            report = fallback_report
+            logger.info("Using DB-built fallback report for '%s' (no simulation data)", deck_id)
         if report is None:
             raise ValueError(f"Deck report not found for: {deck_id}")
 

coach/config.py

@@ -45,7 +45,7 @@ DECK_GEN_PROVIDER = os.environ.get("DECK_GEN_PROVIDER", "perplexity")
 # Model for deck generation (sonar = fast/$0.004, sonar-pro = deep/$0.04)
 DECK_GEN_MODEL = os.environ.get("DECK_GEN_MODEL", "sonar")
 DECK_GEN_TEMPERATURE = float(os.environ.get("DECK_GEN_TEMPERATURE", "0.2"))
-DECK_GEN_MAX_TOKENS = int(os.environ.get("DECK_GEN_MAX_TOKENS", "8192"))
+DECK_GEN_MAX_TOKENS = int(os.environ.get("DECK_GEN_MAX_TOKENS", "16384"))
 
 # ── Smart Substitution Settings ───────────────────────────────
 # Minimum embedding similarity to accept a substitute without Perplexity fallback

coach/prompts/deck_gen_system.py

@@ -31,4 +31,10 @@ IMPORTANT:
 - Provide realistic USD price estimates
 - The commander MUST be included in the cards list with its real category (Creature, Planeswalker, etc.)
 - Assign the correct bracket level based on the cards chosen and combos present
-- List Game Changer cards explicitly in the bracket section"""
+- List Game Changer cards explicitly in the bracket section
+
+OUTPUT EFFICIENCY (critical):
+- Keep each card's "reason" under 15 words — brief is better
+- Keep "synergy_with" to at most 2-3 card names per card
+- Do not repeat the card's own name in synergy_with
+- Omit estimated_price_usd if you are unsure — 0 is fine"""

coach/services/deck_generator.py

@@ -243,13 +243,19 @@ class DeckGeneratorV3:
             )
 
         raw_deck = response.parsed_json
-        logger.info("Deck generated: %d cards, bracket %d",
-                     len(raw_deck.get("cards", [])),
-                     raw_deck.get("bracket", {}).get("level", 0))
+        card_count = len(raw_deck.get("cards", []))
+        truncated = card_count < 90  # Commander decks should have ~100 cards
+        logger.info("Deck generated: %d cards, bracket %d%s",
+                     card_count,
+                     raw_deck.get("bracket", {}).get("level", 0),
+                     " (TRUNCATED — response may have hit token limit)" if truncated else "")
 
         # Step 5: Check ownership and build enriched card list
         cards_with_status = self._check_ownership(raw_deck.get("cards", []))
 
+        # Step 5b: Fill basic lands to hit exactly 100 cards
+        cards_with_status = self._fill_basic_lands(cards_with_status, color_identity)
+
         # Step 6: Compute stats
         stats = self._compute_stats(cards_with_status)
 
@@ -270,6 +276,7 @@ class DeckGeneratorV3:
             },
             "model": response.model,
             "citations": response.citations,
+            "truncated": truncated,
         }
 
     # ── Step 5: Ownership Check ──────────────────────────────
@@ -315,6 +322,57 @@ class DeckGeneratorV3:
 
         return enriched
 
+    # ── Step 5b: Basic Land Fill ──────────────────────────────
+    _COLOR_TO_BASIC = {
+        'W': 'Plains', 'U': 'Island', 'B': 'Swamp',
+        'R': 'Mountain', 'G': 'Forest',
+    }
+    _BASIC_NAMES = set(_COLOR_TO_BASIC.values()) | {'Wastes'}
+
+    def _fill_basic_lands(
+        self,
+        cards: List[DeckCardWithStatus],
+        color_identity: List[str],
+        target_total: int = 100,
+    ) -> List[DeckCardWithStatus]:
+        """
+        Strip LLM-provided basics, then add the right number evenly
+        across the commander's colors to reach exactly target_total.
+        """
+        non_basics = [c for c in cards if c.name not in self._BASIC_NAMES]
+        current_total = sum(c.count for c in non_basics)
+        basics_needed = max(0, target_total - current_total)
+
+        if basics_needed == 0:
+            return non_basics
+
+        ci = [c.upper() for c in color_identity]
+        basic_names = [self._COLOR_TO_BASIC[c] for c in ci if c in self._COLOR_TO_BASIC]
+        if not basic_names:
+            basic_names = ['Wastes']
+
+        per_color = basics_needed // len(basic_names)
+        remainder = basics_needed % len(basic_names)
+
+        for i, bname in enumerate(basic_names):
+            qty = per_color + (1 if i < remainder else 0)
+            if qty > 0:
+                non_basics.append(DeckCardWithStatus(
+                    name=bname,
+                    count=qty,
+                    category='Land',
+                    role_tags=[],
+                    reason='Basic land for mana fixing',
+                    estimated_price_usd=0.10,
+                    owned=True,
+                    owned_qty=qty,
+                    status='owned',
+                ))
+
+        logger.info("Basic land fill: %d basics added across %d color(s)",
+                     basics_needed, len(basic_names))
+        return non_basics
+
     # ── Step 6: Smart Substitution ───────────────────────────
     def run_substitution(
         self,

deck_sources/archidekt_adapter.py

@@ -7,6 +7,10 @@ Currently returns a hardcoded sample for end-to-end wiring.
 Real implementation will call the Archidekt API.
 """
 from .models import TemplateDeck, TemplateDeckCard
+import logging
+
+log = logging.getLogger("commander_ai_lab.deckgen.archidekt")
+
 
 
 def fetch_template_decks(commander_name: str, color_identity: list, config: dict = None) -> list:
@@ -26,5 +30,5 @@ def fetch_template_decks(commander_name: str, color_identity: list, config: dict
     # 1. Search Archidekt for popular decks with this commander
     # 2. Fetch the top 3-5 decklists
     # 3. Normalize card names and return as TemplateDeck
-    print(f"    [ARCHIDEKT] Stub: No template decks for '{commander_name}' (not yet implemented)")
+    log.info(f"    Stub: No template decks for '{commander_name}' (not yet implemented)")
     return []

deck_sources/edhrec_adapter.py

@@ -7,6 +7,10 @@ Currently returns a hardcoded sample for end-to-end wiring.
 Real implementation will parse EDHREC commander pages.
 """
 from .models import TemplateDeck, TemplateDeckCard
+import logging
+
+log = logging.getLogger("commander_ai_lab.deckgen.edhrec")
+
 
 
 def fetch_template_decks(commander_name: str, color_identity: list, config: dict = None) -> list:
@@ -27,5 +31,5 @@ def fetch_template_decks(commander_name: str, color_identity: list, config: dict
     # 2. Fetch the "Average Deck" or "Top Cards" list
     # 3. Parse card names and inclusion percentages
     # 4. Return as a single TemplateDeck with weighted cards
-    print(f"    [EDHREC] Stub: No recommendations for '{commander_name}' (not yet implemented)")
+    log.info(f"    Stub: No recommendations for '{commander_name}' (not yet implemented)")
     return []

deck_sources/moxfield_adapter.py

@@ -6,6 +6,10 @@ Fetches template decklists from Moxfield for a given commander.
 Currently returns empty (experimental — not yet implemented).
 """
 from .models import TemplateDeck, TemplateDeckCard
+import logging
+
+log = logging.getLogger("commander_ai_lab.deckgen.moxfield")
+
 
 
 def fetch_template_decks(commander_name: str, color_identity: list, config: dict = None) -> list:
@@ -13,5 +17,5 @@ def fetch_template_decks(commander_name: str, color_identity: list, config: dict
     Fetch template decks from Moxfield for the given commander.
     Experimental — not yet implemented.
     """
-    print(f"    [MOXFIELD] Stub: Not yet implemented for '{commander_name}'")
+    log.info(f"    Stub: Not yet implemented for '{commander_name}'")
     return []

deck_sources/mtggoldfish_adapter.py

@@ -6,6 +6,10 @@ Fetches template decklists from MTGGoldfish for a given commander.
 Currently returns empty (experimental — not yet implemented).
 """
 from .models import TemplateDeck, TemplateDeckCard
+import logging
+
+log = logging.getLogger("commander_ai_lab.deckgen.mtggoldfish")
+
 
 
 def fetch_template_decks(commander_name: str, color_identity: list, config: dict = None) -> list:
@@ -13,5 +17,5 @@ def fetch_template_decks(commander_name: str, color_identity: list, config: dict
     Fetch template decks from MTGGoldfish for the given commander.
     Experimental — not yet implemented.
     """
-    print(f"    [MTGGOLDFISH] Stub: Not yet implemented for '{commander_name}'")
+    log.info(f"    Stub: Not yet implemented for '{commander_name}'")
     return []

install-commander-ai-lab.ps1

@@ -56,25 +56,27 @@ Install-B64 -R 'coach\__init__.py' -B $b
 $b = 'IyBDb2FjaCBjbGllbnRzIOKAlCBQZXJwbGV4aXR5LCBMTSBTdHVkaW8K'
 Install-B64 -R 'coach\clients\__init__.py' -B $b
 
-# coach/clients/perplexity_client.py (9,727 bytes)
+# coach/clients/perplexity_client.py (12,494 bytes)
 $b = 'IiIiCkNvbW1hbmRlciBBSSBMYWIg4oCUIFBlcnBsZXhpdHkgU29uYXIgU3RydWN0dXJlZCBPdXRwdXQgQ2xpZW50CuKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkOKVkApVc2VzIHRoZSBvcGVuYWkgU0RLIHRvIGNhbGwgUGVycGxleGl0eSdzIGNoYXQvY29tcGxldGlvbnMgZW5kcG9pbnQKd2l0aCByZXNwb25zZV9mb3JtYXQ6IGpzb25fc2NoZW1hIGZvciBndWFyYW50ZWVkIHN0cnVjdHVyZWQgb3V0cHV0LgoKU3VwcG9ydHMgYm90aCBzb25hciAoZmFzdCwgY2hlYXApIGFuZCBzb25hci1wcm8gKGRlZXAsIHRob3JvdWdoKS4KIiIiCgppbXBvcnQganNvbgppbXBvcnQgbG9nZ2luZwppbXBvcnQgYXN5bmNpbwpmcm9tIHR5cGluZyBpbXBvcnQgT3B0aW9uYWwKCmZyb20gb3BlbmFpIGltcG9ydCBPcGVuQUkKCmxvZ2dlciA9IGxvZ2dpbmcuZ2V0TG9nZ2VyKCJjb2FjaC5wcGx4IikKCiMg4pSA4pSAIFBlcnBsZXhpdHkgTW9kZWxzIOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgApTT05BUiA9ICJzb25hciIKU09OQVJfUFJPID0gInNvbmFyLXBybyIKU09OQVJfREVFUF9SRVNFQVJDSCA9ICJzb25hci1kZWVwLXJlc2VhcmNoIgoKCmNsYXNzIFBlcnBsZXhpdHlSZXNwb25zZToKICAgICIiIlBhcnNlZCByZXNwb25zZSBjb250YWluZXIgZnJvbSBQZXJwbGV4aXR5IEFQSS4iIiIKICAgIGRlZiBfX2luaXRfXyhzZWxmLCBjb250ZW50OiBzdHIsIHBhcnNlZF9qc29uOiBPcHRpb25hbFtkaWN0XSwKICAgICAgICAgICAgICAgICBwcm9tcHRfdG9rZW5zOiBpbnQsIGNvbXBsZXRpb25fdG9rZW5zOiBpbnQsCiAgICAgICAgICAgICAgICAgbW9kZWw6IHN0ciwgY2l0YXRpb25zOiBsaXN0W3N0cl0gPSBOb25lKToKICAgICAgICBzZWxmLmNvbnRlbnQgPSBjb250ZW50CiAgICAgICAgc2VsZi5wYXJzZWRfanNvbiA9IHBhcnNlZF9qc29uCiAgICAgICAgc2VsZi5wcm9tcHRfdG9rZW5zID0gcHJvbXB0X3Rva2VucwogICAgICAgIHNlbGYuY29tcGxldGlvbl90b2tlbnMgPSBjb21wbGV0aW9uX3Rva2VucwogICAgICAgIHNlbGYubW9kZWwgPSBtb2RlbAogICAgICAgIHNlbGYuY2l0YXRpb25zID0gY2l0YXRpb25zIG9yIFtdCgogICAgQHByb3BlcnR5CiAgICBkZWYgb2soc2VsZikgLT4gYm9vbDoKICAgICAgICByZXR1cm4gc2VsZi5wYXJzZWRfanNvbiBpcyBub3QgTm9uZQoKCmNsYXNzIFBlcnBsZXhpdHlDbGllbnQ6CiAgICAiIiIKICAgIFBlcnBsZXhpdHkgU29uYXIgQVBJIGNsaWVudCB1c2luZyB0aGUgb3BlbmFpIFNESy4KCiAgICBVc2FnZToKICAgICAgICBjbGllbnQgPSBQZXJwbGV4aXR5Q2xpZW50KGFwaV9rZXk9InBwbHgtLi4uIikKICAgICAgICByZXNwID0gY2xpZW50LmNoYXRfc3RydWN0dXJlZCgKICAgICAgICAgICAgc3lzdGVtX3Byb21wdD0iWW91IGFyZSBhIGRlY2sgYnVpbGRlci4iLAogICAgICAgICAgICB1c2VyX3Byb21wdD0iQnVpbGQgYSBkZWNrIGZvci4uLiIsCiAgICAgICAgICAgIGpzb25fc2NoZW1hPWRlY2tfc2NoZW1hLAogICAgICAgICAgICBzY2hlbWFfbmFtZT0iRGVja0xpc3QiLAogICAgICAgICkKICAgICAgICBpZiByZXNwLm9rOgogICAgICAgICAgICBkZWNrID0gcmVzcC5wYXJzZWRfanNvbgogICAgIiIiCgogICAgZGVmIF9faW5pdF9fKHNlbGYsIGFwaV9rZXk6IHN0ciwgbW9kZWw6IHN0ciA9IFNPTkFSLAogICAgICAgICAgICAgICAgIHRpbWVvdXQ6IGludCA9IDEyMCk6CiAgICAgICAgaWYgbm90IGFwaV9rZXk6CiAgICAgICAgICAgIHJhaXNlIFZhbHVlRXJyb3IoIlBlcnBsZXhpdHkgQVBJIGtleSBpcyByZXF1aXJlZCIpCiAgICAgICAgc2VsZi5hcGlfa2V5ID0gYXBpX2tleQogICAgICAgIHNlbGYubW9kZWwgPSBtb2RlbAogICAgICAgIHNlbGYudGltZW91dCA9IHRpbWVvdXQKICAgICAgICBzZWxmLl9jbGllbnQgPSBPcGVuQUkoCiAgICAgICAgICAgIGFwaV9rZXk9YXBpX2tleSwKICAgICAgICAgICAgYmFzZV91cmw9Imh0dHBzOi8vYXBpLnBlcnBsZXhpdHkuYWkiLAogICAgICAg' +
 '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' +
 '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' +
-'dGlvbiBhcyBlOgogICAgICAgICAgICBsb2dnZXIuZXJyb3IoIltwcGx4XSBQbGFpbiBjaGF0IGZhaWxlZDogJXMiLCBlKQogICAgICAgICAgICByYWlzZQoKICAgIGFzeW5jIGRlZiBhY2hhdF9zdHJ1Y3R1cmVkKHNlbGYsICphcmdzLCAqKmt3YXJncykgLT4gUGVycGxleGl0eVJlc3BvbnNlOgogICAgICAgICIiIkFzeW5jIHdyYXBwZXIg4oCUIHJ1bnMgc3RydWN0dXJlZCBjaGF0IGluIHRocmVhZCBleGVjdXRvci4iIiIKICAgICAgICBsb29wID0gYXN5bmNpby5nZXRfZXZlbnRfbG9vcCgpCiAgICAgICAgcmV0dXJuIGF3YWl0IGxvb3AucnVuX2luX2V4ZWN1dG9yKAogICAgICAgICAgICBOb25lLCBsYW1iZGE6IHNlbGYuY2hhdF9zdHJ1Y3R1cmVkKCphcmdzLCAqKmt3YXJncykKICAgICAgICApCgogICAgYXN5bmMgZGVmIGFjaGF0X3BsYWluKHNlbGYsICphcmdzLCAqKmt3YXJncykgLT4gUGVycGxleGl0eVJlc3BvbnNlOgogICAgICAgICIiIkFzeW5jIHdyYXBwZXIg4oCUIHJ1bnMgcGxhaW4gY2hhdCBpbiB0aHJlYWQgZXhlY3V0b3IuIiIiCiAgICAgICAgbG9vcCA9IGFzeW5jaW8uZ2V0X2V2ZW50X2xvb3AoKQogICAgICAgIHJldHVybiBhd2FpdCBsb29wLnJ1bl9pbl9leGVjdXRvcigKICAgICAgICAgICAgTm9uZSwgbGFtYmRhOiBzZWxmLmNoYXRfcGxhaW4oKmFyZ3MsICoqa3dhcmdzKQogICAgICAgICkKCiAgICBAc3RhdGljbWV0aG9kCiAgICBkZWYgX2V4dHJhY3RfanNvbih0ZXh0OiBzdHIpIC0+IE9wdGlvbmFsW2RpY3RdOgogICAgICAgICIiIkJlc3QtZWZmb3J0IEpTT04gZXh0cmFjdGlvbiBmcm9tIHBvc3NpYmx5IG5vaXN5IHRleHQuIiIiCiAgICAgICAgIyBEaXJlY3QgcGFyc2UKICAgICAgICB0cnk6CiAgICAgICAgICAgIHJldHVybiBqc29uLmxvYWRzKHRleHQuc3RyaXAoKSkKICAgICAgICBleGNlcHQgKGpzb24uSlNPTkRlY29kZUVycm9yLCBUeXBlRXJyb3IpOgogICAgICAgICAgICBwYXNzCgogICAgICAgICMgTWFya2Rvd24gZmVuY2VzCiAgICAgICAgaW1wb3J0IHJlCiAgICAgICAgZmVuY2VfbWF0Y2ggPSByZS5zZWFyY2gocidgYGAoPzpqc29uKT9ccyooW1xzXFNdKj8pYGBgJywgdGV4dCkKICAgICAgICBpZiBmZW5jZV9tYXRjaDoKICAgICAgICAgICAgdHJ5OgogICAgICAgICAgICAgICAgcmV0dXJuIGpzb24ubG9hZHMoZmVuY2VfbWF0Y2guZ3JvdXAoMSkuc3RyaXAoKSkKICAgICAgICAgICAgZXhjZXB0IChqc29uLkpTT05EZWNvZGVFcnJvciwgVHlwZUVycm9yKToKICAgICAgICAgICAgICAgIHBhc3MKCiAgICAgICAgIyBCcmFjZSBjb3VudGluZwogICAgICAgIHN0YXJ0ID0gdGV4dC5maW5kKCd7JykKICAgICAgICBpZiBzdGFydCA9PSAtMToKICAgICAgICAgICAgcmV0dXJuIE5vbmUKCiAgICAgICAgZGVwdGggPSAwCiAgICAgICAgaW5fc3RyaW5nID0gRmFsc2UKICAgICAgICBlc2NhcGVfbmV4dCA9IEZhbHNlCiAgICAgICAgZm9yIGkgaW4gcmFuZ2Uoc3RhcnQsIGxlbih0ZXh0KSk6CiAgICAgICAgICAgIGNoID0gdGV4dFtpXQogICAgICAgICAgICBpZiBlc2NhcGVfbmV4dDoKICAgICAgICAgICAgICAgIGVzY2FwZV9uZXh0ID0gRmFsc2UKICAgICAgICAgICAgICAgIGNvbnRpbnVlCiAgICAgICAgICAgIGlmIGNoID09ICdcXCcgYW5kIGluX3N0cmluZzoKICAgICAgICAgICAgICAgIGVzY2FwZV9uZXh0ID0gVHJ1ZQogICAgICAgICAgICAgICAgY29udGludWUKICAgICAgICAgICAgaWYgY2ggPT0gJyInOgogICAgICAgICAgICAgICAgaW5fc3RyaW5nID0gbm90IGluX3N0cmluZwogICAgICAgICAgICAgICAgY29udGludWUKICAgICAgICAgICAgaWYgaW5fc3RyaW5nOgogICAgICAgICAgICAgICAgY29udGludWUKICAgICAgICAgICAgaWYgY2ggPT0gJ3snOgogICAgICAgICAgICAgICAgZGVwdGggKz0gMQogICAgICAgICAgICBlbGlmIGNoID09ICd9JzoKICAgICAgICAgICAgICAgIGRlcHRoIC09IDEKICAgICAgICAgICAgICAgIGlmIGRlcHRoID09IDA6CiAgICAgICAgICAgICAgICAgICAgdHJ5OgogICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4ganNvbi5sb2Fkcyh0ZXh0W3N0YXJ0OmkrMV0pCiAgICAgICAgICAgICAgICAgICAgZXhjZXB0IChqc29uLkpTT05EZWNvZGVFcnJvciwgVHlwZUVycm9yKToKICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIE5vbmUKICAgICAgICByZXR1cm4gTm9uZQoKICAgIGRlZiBjaGVja19zdGF0dXMoc2VsZikgLT4gZGljdDoKICAgICAgICAiIiJRdWljayBoZWFs' +
-'dGggY2hlY2sg4oCUIHRyeSBhIG1pbmltYWwgQVBJIGNhbGwuIiIiCiAgICAgICAgdHJ5OgogICAgICAgICAgICByZXNwb25zZSA9IHNlbGYuX2NsaWVudC5jaGF0LmNvbXBsZXRpb25zLmNyZWF0ZSgKICAgICAgICAgICAgICAgIG1vZGVsPXNlbGYubW9kZWwsCiAgICAgICAgICAgICAgICBtZXNzYWdlcz1bCiAgICAgICAgICAgICAgICAgICAgeyJyb2xlIjogInN5c3RlbSIsICJjb250ZW50IjogIlJlcGx5IHdpdGggdGhlIHdvcmQgT0suIn0sCiAgICAgICAgICAgICAgICAgICAgeyJyb2xlIjogInVzZXIiLCAiY29udGVudCI6ICJTdGF0dXMgY2hlY2suIn0sCiAgICAgICAgICAgICAgICBdLAogICAgICAgICAgICAgICAgbWF4X3Rva2Vucz0xMCwKICAgICAgICAgICAgKQogICAgICAgICAgICByZXR1cm4gewogICAgICAgICAgICAgICAgImNvbm5lY3RlZCI6IFRydWUsCiAgICAgICAgICAgICAgICAibW9kZWwiOiBzZWxmLm1vZGVsLAogICAgICAgICAgICAgICAgInJlc3BvbnNlIjogcmVzcG9uc2UuY2hvaWNlc1swXS5tZXNzYWdlLmNvbnRlbnQsCiAgICAgICAgICAgIH0KICAgICAgICBleGNlcHQgRXhjZXB0aW9uIGFzIGU6CiAgICAgICAgICAgIHJldHVybiB7CiAgICAgICAgICAgICAgICAiY29ubmVjdGVkIjogRmFsc2UsCiAgICAgICAgICAgICAgICAibW9kZWwiOiBzZWxmLm1vZGVsLAogICAgICAgICAgICAgICAgImVycm9yIjogc3RyKGUpLAogICAgICAgICAgICB9Cg=='
+'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' +
+'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' +
+'ZCBjbG9zaW5nIHNlcXVlbmNlCiAgICAgICAgc3VmZml4ID0gJ10nICogaW5fYXJyICsgJ30nICogY2xvc2VfZGVwdGgKICAgICAgICByZXBhaXJlZCA9IHRydW5jYXRlZCArIHN1ZmZpeAoKICAgICAgICB0cnk6CiAgICAgICAgICAgIHJlc3VsdCA9IGpzb24ubG9hZHMocmVwYWlyZWQpCiAgICAgICAgICAgIGNhcmRfY291bnQgPSBsZW4ocmVzdWx0LmdldCgnY2FyZHMnLCBbXSkpCiAgICAgICAgICAgIGxvZ2dlci5pbmZvKCJKU09OIHJlcGFpciBzdWNjZWVkZWQ6IHJlY292ZXJlZCAlZCBjYXJkcyIsIGNhcmRfY291bnQpCiAgICAgICAgICAgIHJldHVybiByZXN1bHQKICAgICAgICBleGNlcHQgKGpzb24uSlNPTkRlY29kZUVycm9yLCBUeXBlRXJyb3IpIGFzIGU6CiAgICAgICAgICAgIGxvZ2dlci53YXJuaW5nKCJKU09OIHJlcGFpciBmYWlsZWQ6ICVzIiwgZSkKICAgICAgICAgICAgcmV0dXJuIE5vbmUKCiAgICBkZWYgY2hlY2tfc3RhdHVzKHNlbGYpIC0+IGRpY3Q6CiAgICAgICAgIiIiUXVpY2sgaGVhbHRoIGNoZWNrIOKAlCB0cnkgYSBtaW5pbWFsIEFQSSBjYWxsLiIiIgogICAgICAgIHRyeToKICAgICAgICAgICAgcmVzcG9uc2UgPSBzZWxmLl9jbGllbnQuY2hhdC5jb21wbGV0aW9ucy5jcmVhdGUoCiAgICAgICAgICAgICAgICBtb2RlbD1zZWxmLm1vZGVsLAogICAgICAgICAgICAgICAgbWVzc2FnZXM9WwogICAgICAgICAgICAgICAgICAgIHsicm9sZSI6ICJzeXN0ZW0iLCAiY29udGVudCI6ICJSZXBseSB3aXRoIHRoZSB3b3JkIE9LLiJ9LAogICAgICAgICAgICAgICAgICAgIHsicm9sZSI6ICJ1c2VyIiwgImNvbnRlbnQiOiAiU3RhdHVzIGNoZWNrLiJ9LAogICAgICAgICAgICAgICAgXSwKICAgICAgICAgICAgICAgIG1heF90b2tlbnM9MTAsCiAgICAgICAgICAgICkKICAgICAgICAgICAgcmV0dXJuIHsKICAgICAgICAgICAgICAgICJjb25uZWN0ZWQiOiBUcnVlLAogICAgICAgICAgICAgICAgIm1vZGVsIjogc2VsZi5tb2RlbCwKICAgICAgICAgICAgICAgICJyZXNwb25zZSI6IHJlc3BvbnNlLmNob2ljZXNbMF0ubWVzc2FnZS5jb250ZW50LAogICAgICAgICAgICB9CiAgICAgICAgZXhjZXB0IEV4Y2VwdGlvbiBhcyBlOgogICAgICAgICAgICByZXR1cm4gewogICAgICAgICAgICAgICAgImNvbm5lY3RlZCI6IEZhbHNlLAogICAgICAgICAgICAgICAgIm1vZGVsIjogc2VsZi5tb2RlbCwKICAgICAgICAgICAgICAgICJlcnJvciI6IHN0cihlKSwKICAgICAgICAgICAgfQo='
 Install-B64 -R 'coach\clients\perplexity_client.py' -B $b
 
-# coach/coach_service.py (11,183 bytes)
+# coach/coach_service.py (11,542 bytes)
 $b = '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' +
 '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' +
-'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' +
-'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' +
-'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'
+'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' +
+'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' +
+'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' +
+'IkxNIFN0dWRpbyBub3QgcmVhY2hhYmxlIikKCiAgICAgICAgIyBDaGVjayBlbWJlZGRpbmdzCiAgICAgICAgc3RhdHVzLmVtYmVkZGluZ3NMb2FkZWQgPSBzZWxmLmVtYmVkZGluZ3MubG9hZGVkCiAgICAgICAgc3RhdHVzLmVtYmVkZGluZ0NhcmRzID0gc2VsZi5lbWJlZGRpbmdzLmNhcmRfY291bnQKCiAgICAgICAgIyBDaGVjayBkZWNrIHJlcG9ydHMKICAgICAgICBzdGF0dXMuZGVja1JlcG9ydHNBdmFpbGFibGUgPSBsZW4oc2VsZi5saXN0X2RlY2tfcmVwb3J0cygpKQoKICAgICAgICByZXR1cm4gc3RhdHVzCg=='
 Install-B64 -R 'coach\coach_service.py' -B $b
 
-# coach/config.py (3,839 bytes)
+# coach/config.py (3,840 bytes)
 $b = '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' +
-'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'
+'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'
 Install-B64 -R 'coach\config.py' -B $b
 
 # coach/embeddings.py (12,853 bytes)
@@ -112,8 +114,9 @@ Install-B64 -R 'coach\prompt_template.py' -B $b
 $b = 'IyBDb2FjaCBwcm9tcHRzIOKAlCBEZWNrIGdlbmVyYXRpb24gYW5kIHN1YnN0aXR1dGlvbiB0ZW1wbGF0ZXMK'
 Install-B64 -R 'coach\prompts\__init__.py' -B $b
 
-# coach/prompts/deck_gen_system.py (2,248 bytes)
-$b = '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'
+# coach/prompts/deck_gen_system.py (2,510 bytes)
+$b = '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' +
+'VVQgRUZGSUNJRU5DWSAoY3JpdGljYWwpOgotIEtlZXAgZWFjaCBjYXJkJ3MgInJlYXNvbiIgdW5kZXIgMTUgd29yZHMg4oCUIGJyaWVmIGlzIGJldHRlcgotIEtlZXAgInN5bmVyZ3lfd2l0aCIgdG8gYXQgbW9zdCAyLTMgY2FyZCBuYW1lcyBwZXIgY2FyZAotIERvIG5vdCByZXBlYXQgdGhlIGNhcmQncyBvd24gbmFtZSBpbiBzeW5lcmd5X3dpdGgKLSBPbWl0IGVzdGltYXRlZF9wcmljZV91c2QgaWYgeW91IGFyZSB1bnN1cmUg4oCUIDAgaXMgZmluZSIiIgo='
 Install-B64 -R 'coach\prompts\deck_gen_system.py' -B $b
 
 # coach/prompts/deck_gen_user.py (2,661 bytes)
@@ -160,17 +163,17 @@ Install-B64 -R 'coach\schemas\substitution_schema.py' -B $b
 $b = 'IyBDb2FjaCBzZXJ2aWNlcyDigJQgRGVjayBnZW5lcmF0b3IgVjMK'
 Install-B64 -R 'coach\services\__init__.py' -B $b
 
-# coach/services/deck_generator.py (21,925 bytes)
+# coach/services/deck_generator.py (22,169 bytes)
 $b = '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' +
 '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' +
 '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' +
 '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' +
-'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' +
-'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' +
-'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' +
-'ICBzZWxmLAogICAgICAgIGNhcmQ6IERlY2tDYXJkV2l0aFN0YXR1cywKICAgICAgICBjb2xvcl9pZGVudGl0eTogTGlzdFtzdHJdLAogICAgICAgIGF2YWlsYWJsZV9wb29sOiBMaXN0W3N0cl0sCiAgICApIC0+IExpc3RbQ2FyZEFsdGVybmF0aXZlXToKICAgICAgICAiIiJGaW5kIGVtYmVkZGluZy1zaW1pbGFyIG93bmVkIGNhcmRzIGFzIHN1YnN0aXR1dGVzLiIiIgogICAgICAgIGlmIG5vdCBzZWxmLmVtYmVkZGluZ19pbmRleCBvciBub3Qgc2VsZi5lbWJlZGRpbmdfaW5kZXgubG9hZGVkOgogICAgICAgICAgICByZXR1cm4gW10KCiAgICAgICAgIyBVc2UgdGhlIGVtYmVkZGluZ3Mgc2VhcmNoIHRvIGZpbmQgc2ltaWxhciBjYXJkcwogICAgICAgIG1hdGNoZXMgPSBzZWxmLmVtYmVkZGluZ19pbmRleC5zZWFyY2hfc2ltaWxhcigKICAgICAgICAgICAgcXVlcnlfY2FyZD1jYXJkLm5hbWUsCiAgICAgICAgICAgIGNvbG9yX2ZpbHRlcj1jb2xvcl9pZGVudGl0eSBpZiBjb2xvcl9pZGVudGl0eSBlbHNlIE5vbmUsCiAgICAgICAgICAgIHR5cGVfZmlsdGVyPWNhcmQuY2F0ZWdvcnkgaWYgY2FyZC5jYXRlZ29yeSBlbHNlIE5vbmUsCiAgICAgICAgICAgIGV4Y2x1ZGVfY2FyZHM9W2NhcmQubmFtZV0sCiAgICAgICAgICAgIHRvcF9uPVNVQlNUSVRVVElPTl9NQVhfQUxURVJOQVRJVkVTICogMywgICMgT3Zlci1mZXRjaCwgdGhlbiBmaWx0ZXIgdG8gb3duZWQKICAgICAgICApCgogICAgICAgICMgRmlsdGVyIHRvIG9ubHkgY2FyZHMgaW4gdGhlIGF2YWlsYWJsZSBwb29sCiAgICAgICAgcG9vbF9sb3dlciA9IHNldChuLmxvd2VyKCkgZm9yIG4gaW4gYXZhaWxhYmxlX3Bvb2wpCiAgICAgICAgYWx0ZXJuYXRpdmVzID0gW10KICAgICAgICBmb3IgbWF0Y2ggaW4gbWF0Y2hlczoKICAgICAgICAgICAgaWYgbWF0Y2gubmFtZS5sb3dlcigpIGluIHBvb2xfbG93ZXI6CiAgICAgICAgICAgICAgICAjIENvbXB1dGUgcm9sZSBvdmVybGFwCiAgICAgICAgICAgICAgICBtYXRjaF9yb2xlcyA9IFtdICAjIFdvdWxkIG5lZWQgY2FyZCdzIHJvbGVfdGFncyBmcm9tIERCCiAgICAgICAgICAgICAgICByb2xlX292ZXJsYXAgPSBsaXN0KHNldChjYXJkLnJvbGVfdGFncykgJiBzZXQobWF0Y2hfcm9sZXMpKSBpZiBtYXRjaF9yb2xlcyBlbHNlIFtdCgogICAgICAgICAgICAgICAgYWx0ZXJuYXRpdmVzLmFwcGVuZChDYXJkQWx0ZXJuYXRpdmUoCiAgICAgICAgICAgICAgICAgICAgbmFtZT1tYXRjaC5uYW1lLAogICAgICAgICAgICAgICAgICAgIHNpbWlsYXJpdHlfc2NvcmU9bWF0Y2guc2ltaWxhcml0eSwKICAgICAgICAgICAgICAgICAgICByZWFzb249ZiJTaW1pbGFyIHRvIHtjYXJkLm5hbWV9IChjb3NpbmUgc2ltOiB7bWF0Y2guc2ltaWxhcml0eTouM2Z9KSIsCiAgICAgICAgICAgICAgICAgICAgc291cmNlPSJlbWJlZGRpbmciLAogICAgICAgICAgICAgICAgICAgIHJvbGVfb3ZlcmxhcD1yb2xlX292ZXJsYXAsCiAgICAgICAgICAgICAgICAgICAgY21jX2RlbHRhPW1hdGNoLm1hbmFfdmFsdWUgLSAoY2FyZC5lc3RpbWF0ZWRfcHJpY2VfdXNkIG9yIDApLAogICAgICAgICAgICAgICAgKSkKCiAgICAgICAgICAgICAgICBpZiBsZW4oYWx0ZXJuYXRpdmVzKSA+PSBTVUJTVElUVVRJT05fTUFYX0FMVEVSTkFUSVZFUzoKICAgICAgICAgICAgICAgICAgICBicmVhawoKICAgICAgICByZXR1cm4gYWx0ZXJuYXRpdmVzCgogICAgZGVmIF9wcGx4X3N1YnN0aXR1dGlvbigKICAgICAgICBzZWxmLAogICAgICAgIG1pc3NpbmdfY2FyZHM6IExpc3RbRGVja0NhcmRXaXRoU3RhdHVzXSwKICAgICAgICBhdmFpbGFibGVfcG9vbDogTGlzdFtzdHJdLAogICAgICAgIGNvbW1hbmRlcjogZGljdCwKICAgICAgICBzdHJhdGVneTogc3RyLAogICAgKToKICAgICAgICAiIiIKICAgICAgICBCYXRjaCBQZXJwbGV4aXR5IGZhbGxiYWNrIGZvciBjYXJkcyB3aXRoIGxvdyBlbWJlZGRpbmcgY29uZmlkZW5jZS4KICAgICAgICBNdXRhdGVzIHRoZSBjYXJkcyBpbi1wbGFjZSB3aXRoIHN1YnN0aXR1dGlvbiBkYXRhLgogICAgICAgICIiIgogICAgICAgIGlmIG5vdCBhdmFpbGFibGVfcG9vbDoKICAgICAgICAgICAgcmV0dXJuCgogICAgICAgICMgQnVpbGQgdGhlIHJlcXVlc3QKICAgICAgICBtaXNzaW5nX2RpY3RzID0gWwogICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAibmFtZSI6IGMubmFtZSwKICAgICAgICAgICAgICAgICJyb2xlX3RhZ3MiOiBjLnJvbGVfdGFncywKICAgICAgICAgICAg' +
-'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' +
-'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'
+'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' +
+'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' +
+'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' +
+'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' +
+'Y2Ugd2l0aCBzdWJzdGl0dXRpb24gZGF0YS4KICAgICAgICAiIiIKICAgICAgICBpZiBub3QgYXZhaWxhYmxlX3Bvb2w6CiAgICAgICAgICAgIHJldHVybgoKICAgICAgICAjIEJ1aWxkIHRoZSByZXF1ZXN0CiAgICAgICAgbWlzc2luZ19kaWN0cyA9IFsKICAgICAgICAgICAgewogICAgICAgICAgICAgICAgIm5hbWUiOiBjLm5hbWUsCiAgICAgICAgICAgICAgICAicm9sZV90YWdzIjogYy5yb2xlX3RhZ3MsCiAgICAgICAgICAgICAgICAiY2F0ZWdvcnkiOiBjLmNhdGVnb3J5LAogICAgICAgICAgICAgICAgInJlYXNvbiI6IGMucmVhc29uLAogICAgICAgICAgICB9CiAgICAgICAgICAgIGZvciBjIGluIG1pc3NpbmdfY2FyZHMKICAgICAgICBdCgogICAgICAgIHVzZXJfcHJvbXB0ID0gYnVpbGRfc3Vic3RpdHV0aW9uX3Byb21wdCgKICAgICAgICAgICAgbWlzc2luZ19jYXJkcz1taXNzaW5nX2RpY3RzLAogICAgICAgICAgICBhbGxvd2VkX2NhcmRzPWF2YWlsYWJsZV9wb29sWzoyMDBdLCAgIyBMaW1pdCB0byBhdm9pZCB0b2tlbiBvdmVyZmxvdwogICAgICAgICAgICBjb21tYW5kZXI9Y29tbWFuZGVyLmdldCgibmFtZSIsICIiKSwKICAgICAgICAgICAgY29sb3JfaWRlbnRpdHk9Y29tbWFuZGVyLmdldCgiY29sb3JfaWRlbnRpdHkiLCBbXSksCiAgICAgICAgICAgIHN0cmF0ZWd5PXN0cmF0ZWd5LAogICAgICAgICkKCiAgICAgICAgdHJ5OgogICAgICAgICAgICBmcm9tIC4uc2NoZW1hcy5zdWJzdGl0dXRpb25fc2NoZW1hIGltcG9ydCBTVUJTVElUVVRJT05fUkVTUE9OU0VfU0NIRU1BCiAgICAgICAgICAgIHJlc3BvbnNlID0gc2VsZi5wcGx4LmNoYXRfc3RydWN0dXJlZCgKICAgICAgICAgICAgICAgIHN5c3RlbV9wcm9tcHQ9U1VCU1RJVFVUSU9OX1NZU1RFTSwKICAgICAgICAgICAgICAgIHVzZXJfcHJvbXB0PXVzZXJfcHJvbXB0LAogICAgICAgICAgICAgICAganNvbl9zY2hlbWE9U1VCU1RJVFVUSU9OX1JFU1BPTlNFX1NDSEVNQSwKICAgICAgICAgICAgICAgIHNjaGVtYV9uYW1lPSJTdWJzdGl0dXRpb25SZXNwb25zZSIsCiAgICAgICAgICAgICAgICBtb2RlbD1TVUJTVElUVVRJT05fTU9ERUwsCiAgICAgICAgICAgICAgICB0ZW1wZXJhdHVyZT0wLjEsCiAgICAgICAgICAgICAgICBtYXhfdG9rZW5zPTQwOTYsCiAgICAgICAgICAgICkKCiAgICAgICAgICAgIGlmIG5vdCByZXNwb25zZS5vazoKICAgICAgICAgICAgICAgIGxvZ2dlci53YXJuaW5nKCJQZXJwbGV4aXR5IHN1YnN0aXR1dGlvbiBmYWxsYmFjayBmYWlsZWQg4oCUIG5vbi1KU09OIHJlc3BvbnNlIikKICAgICAgICAgICAgICAgIHJldHVybgoKICAgICAgICAgICAgc3VicyA9IHJlc3BvbnNlLnBhcnNlZF9qc29uLmdldCgic3Vic3RpdHV0aW9ucyIsIFtdKQogICAgICAgICAgICBsb2dnZXIuaW5mbygiUGVycGxleGl0eSBzdWdnZXN0ZWQgJWQgc3Vic3RpdHV0aW9ucyIsIGxlbihzdWJzKSkKCiAgICAgICAgICAgICMgQXBwbHkgc3Vic3RpdHV0aW9ucwogICAgICAgICAgICBjYXJkX2J5X25hbWUgPSB7Yy5uYW1lLmxvd2VyKCk6IGMgZm9yIGMgaW4gbWlzc2luZ19jYXJkc30KICAgICAgICAgICAgZm9yIHN1YiBpbiBzdWJzOgogICAgICAgICAgICAgICAgb3JpZyA9IHN1Yi5nZXQoIm9yaWdpbmFsIiwgIiIpLmxvd2VyKCkKICAgICAgICAgICAgICAgIHN1YnN0aXR1dGUgPSBzdWIuZ2V0KCJzdWJzdGl0dXRlIiwgIiIpCiAgICAgICAgICAgICAgICByZWFzb24gPSBzdWIuZ2V0KCJyZWFzb24iLCAiIikKCiAgICAgICAgICAgICAgICBpZiBvcmlnIGluIGNhcmRfYnlfbmFtZSBhbmQgc3Vic3RpdHV0ZToKICAgICAgICAgICAgICAgICAgICBjYXJkID0gY2FyZF9ieV9uYW1lW29yaWddCiAgICAgICAgICAgICAgICAgICAgIyBBZGQgYXMgdG9wIGFsdGVybmF0aXZlCiAgICAgICAgICAgICAgICAgICAgcHBseF9hbHQgPSBDYXJkQWx0ZXJuYXRpdmUoCiAgICAgICAgICAgICAgICAgICAgICAgIG5hbWU9c3Vic3RpdHV0ZSwKICAgICAgICAgICAgICAgICAgICAgICAgc2ltaWxhcml0eV9zY29yZT0wLjgwLCAgIyBOb21pbmFsIHNjb3JlIGZvciBQZXJwbGV4aXR5IHN1Z2dlc3Rpb25zCiAgICAgICAgICAgICAgICAgICAgICAgIHJlYXNvbj1yZWFzb24sCiAgICAgICAgICAgICAgICAgICAgICAgIHNvdXJjZT0icGVycGxleGl0eSIsCiAgICAgICAgICAgICAgICAgICAgICAgIHJvbGVfb3ZlcmxhcD1zdWIuZ2V0KCJyb2xlX292ZXJsYXAiLCBbXSksCiAgICAgICAgICAgICAgICAgICAgKQog' +
+'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'
 Install-B64 -R 'coach\services\deck_generator.py' -B $b
 
 # deck_sources/__init__.py (236 bytes)
@@ -536,7 +539,7 @@ Install-B64 -R 'frontend\commander-ai-lab-ui\tsconfig.node.json' -B $b
 $b = 'aW1wb3J0IHsgZGVmaW5lQ29uZmlnIH0gZnJvbSAndml0ZScKaW1wb3J0IHJlYWN0IGZyb20gJ0B2aXRlanMvcGx1Z2luLXJlYWN0JwppbXBvcnQgdGFpbHdpbmRjc3MgZnJvbSAnQHRhaWx3aW5kY3NzL3ZpdGUnCgpleHBvcnQgZGVmYXVsdCBkZWZpbmVDb25maWcoewogIHBsdWdpbnM6IFtyZWFjdCgpLCB0YWlsd2luZGNzcygpXSwKICBzZXJ2ZXI6IHsKICAgIHBvcnQ6IDUxNzMsCiAgICBwcm94eTogewogICAgICAnL2FwaSc6IHsKICAgICAgICB0YXJnZXQ6ICdodHRwOi8vbG9jYWxob3N0OjgwODAnLAogICAgICAgIGNoYW5nZU9yaWdpbjogdHJ1ZSwKICAgICAgfSwKICAgIH0sCiAgfSwKICBidWlsZDogewogICAgb3V0RGlyOiAnZGlzdCcsCiAgICBzb3VyY2VtYXA6IGZhbHNlLAogICAgcm9sbHVwT3B0aW9uczogewogICAgICBvdXRwdXQ6IHsKICAgICAgICBtYW51YWxDaHVua3M6IHsKICAgICAgICAgIHJlY2hhcnRzOiBbJ3JlY2hhcnRzJ10sCiAgICAgICAgICByZWFjdDogWydyZWFjdCcsICdyZWFjdC1kb20nLCAncmVhY3Qtcm91dGVyLWRvbSddLAogICAgICAgIH0sCiAgICAgIH0sCiAgICB9LAogIH0sCn0pCg=='
 Install-B64 -R 'frontend\commander-ai-lab-ui\vite.config.ts' -B $b
 
-# lab_api.py (322,143 bytes)
+# lab_api.py (326,001 bytes)
 $b = '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' +
 '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' +
 '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' +
@@ -658,29 +661,30 @@ $b = 'IyEvdXNyL2Jpbi9lbnYgcHl0aG9uMwoiIiIKQ29tbWFuZGVyIEFJIExhYiDigJQgRmFzdEFQSS
 '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' +
 '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' +
 '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' +
-'dWlsZGVyIERCKS4iIiIKICAgIGNvbm4gPSBfZ2V0X2RiX2Nvbm4oKQogICAgcm93cyA9IGNvbm4uZXhlY3V0ZSgKICAgICAgICAiIiJTRUxFQ1QgZC5pZCBhcyBkZWNrX2lkLCBkLm5hbWUgYXMgZGVja19uYW1lLCBkLmNvbW1hbmRlciwKICAgICAgICAgICAgICAgICAgQ09VTlQoZGMuaWQpIGFzIGNhcmRfY291bnQKICAgICAgICAgICBGUk9NIGRlY2tzIGQKICAgICAgICAgICBMRUZUIEpPSU4gZGVja19jYXJkcyBkYyBPTiBkYy5kZWNrX2lkID0gZC5pZAogICAgICAgICAgIEdST1VQIEJZIGQuaWQKICAgICAgICAgICBPUkRFUiBCWSBkLm5hbWUiIiIKICAgICkuZmV0Y2hhbGwoKQoKICAgICMgQWxzbyBnZXQgcmVwb3J0IGF2YWlsYWJpbGl0eSBmcm9tIGNvYWNoIHNlcnZpY2UKICAgIHJlcG9ydF9pZHMgPSBzZXQoKQogICAgaWYgX2NvYWNoX3NlcnZpY2U6CiAgICAgICAgcmVwb3J0X2lkcyA9IHNldChfY29hY2hfc2VydmljZS5saXN0X2RlY2tfcmVwb3J0cygpKQoKICAgIGRlY2tzID0gW10KICAgIGZvciByIGluIHJvd3M6CiAgICAgICAgZGVja19uYW1lID0gclsiZGVja19uYW1lIl0KICAgICAgICAjIENoZWNrIGlmIGEgcmVwb3J0IGV4aXN0cyAoYnkgZGVjayBuYW1lIHNsdWcgbWF0Y2gpCiAgICAgICAgaGFzX3JlcG9ydCA9IGFueSgKICAgICAgICAgICAgZGVja19uYW1lLmxvd2VyKCkucmVwbGFjZSgiICIsICItIikgPT0gcmlkLmxvd2VyKCkgb3IKICAgICAgICAgICAgZGVja19uYW1lLmxvd2VyKCkgPT0gcmlkLmxvd2VyKCkKICAgICAgICAgICAgZm9yIHJpZCBpbiByZXBvcnRfaWRzCiAgICAgICAgKQogICAgICAgIGRlY2tzLmFwcGVuZCh7CiAgICAgICAgICAgICJkZWNrX2lkIjogclsiZGVja19pZCJdLAogICAgICAgICAgICAiZGVja19uYW1lIjogclsiZGVja19uYW1lIl0sCiAgICAgICAgICAgICJjb21tYW5kZXIiOiByWyJjb21tYW5kZXIiXSBvciAiIiwKICAgICAgICAgICAgImNhcmRfY291bnQiOiByWyJjYXJkX2NvdW50Il0sCiAgICAgICAgICAgICJoYXNfcmVwb3J0IjogaGFzX3JlcG9ydCwKICAgICAgICAgICAgInJlcG9ydF9jb3VudCI6IDEgaWYgaGFzX3JlcG9ydCBlbHNlIDAsCiAgICAgICAgICAgICJsYXN0X3JlcG9ydF9kYXRlIjogTm9uZSwKICAgICAgICB9KQogICAgcmV0dXJuIGRlY2tzCgoKQGFwcC5nZXQoIi9hcGkvY29hY2gvZGVja3Mve2RlY2tfaWR9L3JlcG9ydCIpCmFzeW5jIGRlZiBjb2FjaF9nZXRfcmVwb3J0KGRlY2tfaWQ6IHN0cik6CiAgICAiIiJHZXQgdGhlIGxhdGVzdCBEZWNrUmVwb3J0IGZvciBhIGRlY2suIiIiCiAgICBpZiBfY29hY2hfc2VydmljZSBpcyBOb25lOgogICAgICAgIHJhaXNlIEhUVFBFeGNlcHRpb24oNTAwLCAiQ29hY2ggc2VydmljZSBub3QgaW5pdGlhbGl6ZWQiKQogICAgcmVwb3J0ID0gX2NvYWNoX3NlcnZpY2UubG9hZF9kZWNrX3JlcG9ydChkZWNrX2lkKQogICAgaWYgcmVwb3J0IGlzIE5vbmU6CiAgICAgICAgcmFpc2UgSFRUUEV4Y2VwdGlvbig0MDQsIGYiRGVjayByZXBvcnQgbm90IGZvdW5kOiB7ZGVja19pZH0iKQogICAgcmV0dXJuIHJlcG9ydC5tb2RlbF9kdW1wKCkKCgpjbGFzcyBDb2FjaFJlcXVlc3RCb2R5KEJhc2VNb2RlbCk6CiAgICBnb2FsczogT3B0aW9uYWxbZGljdF0gPSBOb25lCgoKY2xhc3MgQ29hY2hDaGF0TWVzc2FnZShCYXNlTW9kZWwpOgogICAgcm9sZTogc3RyICAjICJ1c2VyIiBvciAiYXNzaXN0YW50IgogICAgY29udGVudDogc3RyCgpjbGFzcyBDb2FjaENoYXRSZXF1ZXN0KEJhc2VNb2RlbCk6CiAgICBkZWNrX2lkOiBzdHIKICAgIG1lc3NhZ2VzOiBsaXN0W2RpY3RdICAjIGNvbnZlcnNhdGlvbiBoaXN0b3J5IFt7cm9sZSwgY29udGVudH1dCiAgICBnb2FsczogT3B0aW9uYWxbZGljdF0gPSBOb25lCiAgICBzdHJlYW06IE9wdGlvbmFsW2Jvb2xdID0gRmFsc2UKCmNsYXNzIENvYWNoQXBwbHlSZXF1ZXN0KEJhc2VNb2RlbCk6CiAgICBzZXNzaW9uX2lkOiBzdHIKICAgIGRlY2tfaWQ6IGludCAgIyBudW1lcmljIGRlY2sgSUQgaW4gdGhlIERCCiAgICBhY2NlcHRlZF9jdXRzOiBsaXN0W3N0cl0gPSBbXSAgIyBjYXJkIG5hbWVzIHRvIHJlbW92ZQogICAgYWNjZXB0ZWRfYWRkczogbGlzdFtzdHJdID0gW10gICMgY2FyZCBuYW1lcyB0byBhZGQKCmNsYXNzIENvYWNoR29hbHNSZXF1ZXN0KEJhc2VNb2RlbCk6CiAgICB0YXJnZXRfcG93ZXJfbGV2ZWw6IE9wdGlvbmFsW2ludF0gPSBOb25lICAjIDEtMTAKICAgIG1ldGFfZm9jdXM6IE9wdGlvbmFsW3N0' +
-'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' +
-'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' +
-'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' +
-'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' +
-'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' +
-'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' +
-'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' +
-'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' +
-'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' +
-'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' +
-'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' +
-'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' +
-'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' +
-'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' +
-'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' +
-'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' +
-'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' +
-'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' +
-'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' +
-'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' +
-'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' +
-'ICBXZWIgVUk6ICAgICAgIGh0dHA6Ly9sb2NhbGhvc3Q6e0NGRy5wb3J0fS9pbmRleC5odG1sICAobGVnYWN5IEhUTUwpIikKICAgICAgICBwcmludChmIiAgTk9URTogUmVhY3QgU1BBIG5vdCBidWlsdC4gUnVuOiBjZCBmcm9udGVuZC9jb21tYW5kZXItYWktbGFiLXVpICYmIG5wbSBpbnN0YWxsICYmIG5wbSBydW4gYnVpbGQiKQogICAgcHJpbnQoZiIgIEFQSSBkb2NzOiAgICAgaHR0cDovL2xvY2FsaG9zdDp7Q0ZHLnBvcnR9L2RvY3MiKQogICAgcHJpbnQoKQoKICAgIGltcG9ydCB1dmljb3JuCiAgICB1dmljb3JuLnJ1bihhcHAsIGhvc3Q9IjAuMC4wLjAiLCBwb3J0PUNGRy5wb3J0LCBsb2dfbGV2ZWw9ImluZm8iKQoKCmlmIF9fbmFtZV9fID09ICJfX21haW5fXyI6CiAgICBtYWluKCkK'
+'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' +
+'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' +
+'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' +
+'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' +
+'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' +
+'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' +
+'Y2hhdC9jb21wbGV0aW9ucyIsCiAgICAgICAgICAgICAgICBkYXRhPWpzb24uZHVtcHMobGxtX2JvZHkpLmVuY29kZSgidXRmLTgiKSwKICAgICAgICAgICAgICAgIGhlYWRlcnM9eyJDb250ZW50LVR5cGUiOiAiYXBwbGljYXRpb24vanNvbiJ9LAogICAgICAgICAgICAgICAgbWV0aG9kPSJQT1NUIiwKICAgICAgICAgICAgKQoKICAgICAgICAgICAgaW1wb3J0IGFzeW5jaW8KICAgICAgICAgICAgbG9vcCA9IGFzeW5jaW8uZ2V0X2V2ZW50X2xvb3AoKQogICAgICAgICAgICBkZWYgX2NhbGwoKToKICAgICAgICAgICAgICAgIHdpdGggdXJsb3BlbihyZXEsIHRpbWVvdXQ9TE1fU1RVRElPX1RJTUVPVVQpIGFzIHJlc3A6CiAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGpzb24ubG9hZHMocmVzcC5yZWFkKCkuZGVjb2RlKCJ1dGYtOCIpKQoKICAgICAgICAgICAgcmF3ID0gYXdhaXQgbG9vcC5ydW5faW5fZXhlY3V0b3IoTm9uZSwgX2NhbGwpCgogICAgICAgICAgICBjb250ZW50ID0gcmF3LmdldCgiY2hvaWNlcyIsIFt7fV0pWzBdLmdldCgibWVzc2FnZSIsIHt9KS5nZXQoImNvbnRlbnQiLCAiIikKICAgICAgICAgICAgIyBTdHJpcCB0aGluayB0YWdzCiAgICAgICAgICAgIGNvbnRlbnQgPSBfY29hY2hfbGxtLl9zdHJpcF90aGlua190YWdzKGNvbnRlbnQpCiAgICAgICAgICAgIHVzYWdlID0gcmF3LmdldCgidXNhZ2UiLCB7fSkKCiAgICAgICAgICAgIHJldHVybiB7CiAgICAgICAgICAgICAgICAiY29udGVudCI6IGNvbnRlbnQsCiAgICAgICAgICAgICAgICAibW9kZWwiOiByYXcuZ2V0KCJtb2RlbCIsICIiKSwKICAgICAgICAgICAgICAgICJwcm9tcHRfdG9rZW5zIjogdXNhZ2UuZ2V0KCJwcm9tcHRfdG9rZW5zIiwgMCksCiAgICAgICAgICAgICAgICAiY29tcGxldGlvbl90b2tlbnMiOiB1c2FnZS5nZXQoImNvbXBsZXRpb25fdG9rZW5zIiwgMCksCiAgICAgICAgICAgIH0KCiAgICBleGNlcHQgRXhjZXB0aW9uIGFzIGU6CiAgICAgICAgcmFpc2UgSFRUUEV4Y2VwdGlvbig1MDAsIGYiQ2hhdCBmYWlsZWQ6IHtlfSIpCgoKQGFwcC5wb3N0KCIvYXBpL2NvYWNoL2FwcGx5IikKYXN5bmMgZGVmIGNvYWNoX2FwcGx5X3N1Z2dlc3Rpb25zKGJvZHk6IENvYWNoQXBwbHlSZXF1ZXN0KToKICAgICIiIkFwcGx5IGFjY2VwdGVkIGNvYWNoaW5nIHN1Z2dlc3Rpb25zIHRvIGEgZGVjayDigJQgcmVtb3ZlIGN1dHMsIGFkZCBhZGRzLiIiIgogICAgY29ubiA9IF9nZXRfZGJfY29ubigpCgogICAgIyBWZXJpZnkgZGVjayBleGlzdHMKICAgIGRlY2sgPSBjb25uLmV4ZWN1dGUoIlNFTEVDVCAqIEZST00gZGVja3MgV0hFUkUgaWQgPSA/IiwgKGJvZHkuZGVja19pZCwpKS5mZXRjaG9uZSgpCiAgICBpZiBub3QgZGVjazoKICAgICAgICByYWlzZSBIVFRQRXhjZXB0aW9uKDQwNCwgZiJEZWNrIHtib2R5LmRlY2tfaWR9IG5vdCBmb3VuZCIpCgogICAgcmVzdWx0cyA9IHsiY3V0cyI6IFtdLCAiYWRkcyI6IFtdLCAiZXJyb3JzIjogW119CgogICAgIyBQcm9jZXNzIGN1dHM6IHJlbW92ZSBjYXJkcyBieSBuYW1lCiAgICBmb3IgY2FyZF9uYW1lIGluIGJvZHkuYWNjZXB0ZWRfY3V0czoKICAgICAgICByb3cgPSBjb25uLmV4ZWN1dGUoCiAgICAgICAgICAgICJTRUxFQ1QgaWQgRlJPTSBkZWNrX2NhcmRzIFdIRVJFIGRlY2tfaWQgPSA/IEFORCBjYXJkX25hbWUgPSA/IExJTUlUIDEiLAogICAgICAgICAgICAoYm9keS5kZWNrX2lkLCBjYXJkX25hbWUpCiAgICAgICAgKS5mZXRjaG9uZSgpCiAgICAgICAgaWYgcm93OgogICAgICAgICAgICBjb25uLmV4ZWN1dGUoIkRFTEVURSBGUk9NIGRlY2tfY2FyZHMgV0hFUkUgaWQgPSA/IiwgKHJvd1siaWQiXSwpKQogICAgICAgICAgICByZXN1bHRzWyJjdXRzIl0uYXBwZW5kKHsibmFtZSI6IGNhcmRfbmFtZSwgInN0YXR1cyI6ICJyZW1vdmVkIn0pCiAgICAgICAgZWxzZToKICAgICAgICAgICAgIyBUcnkgY2FzZS1pbnNlbnNpdGl2ZQogICAgICAgICAgICByb3cgPSBjb25uLmV4ZWN1dGUoCiAgICAgICAgICAgICAgICAiU0VMRUNUIGlkLCBjYXJkX25hbWUgRlJPTSBkZWNrX2NhcmRzIFdIRVJFIGRlY2tfaWQgPSA/IEFORCBMT1dFUihjYXJkX25hbWUpID0gTE9XRVIoPykgTElNSVQgMSIsCiAgICAgICAgICAgICAgICAoYm9keS5kZWNrX2lkLCBjYXJkX25hbWUpCiAgICAgICAgICAgICkuZmV0Y2hvbmUoKQogICAgICAgICAgICBpZiByb3c6CiAgICAgICAgICAgICAgICBjb25uLmV4ZWN1dGUoIkRFTEVURSBGUk9NIGRlY2tfY2FyZHMg' +
+'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' +
+'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' +
+'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' +
+'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' +
+'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' +
+'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' +
+'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' +
+'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' +
+'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' +
+'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' +
+'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' +
+'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' +
+'ICAgIHRyeToKICAgICAgICBpbXBvcnQgc3lzCiAgICAgICAgcHJvamVjdF9yb290ID0gc3RyKFBhdGgoX19maWxlX18pLnBhcmVudCkKICAgICAgICBpZiBwcm9qZWN0X3Jvb3Qgbm90IGluIHN5cy5wYXRoOgogICAgICAgICAgICBzeXMucGF0aC5pbnNlcnQoMCwgcHJvamVjdF9yb290KQoKICAgICAgICBfdG91cm5hbWVudF9zdGF0ZVsicnVubmluZyJdID0gVHJ1ZQogICAgICAgIF90b3VybmFtZW50X3N0YXRlWyJlcnJvciJdID0gTm9uZQogICAgICAgIF90b3VybmFtZW50X3N0YXRlWyJyZXN1bHQiXSA9IE5vbmUKICAgICAgICBfdG91cm5hbWVudF9zdGF0ZVsicGhhc2UiXSA9ICJydW5uaW5nIgogICAgICAgIF90b3VybmFtZW50X3N0YXRlWyJtZXNzYWdlIl0gPSAiUnVubmluZyB0b3VybmFtZW50Li4uIgoKICAgICAgICBmcm9tIG1sLmV2YWwudG91cm5hbWVudCBpbXBvcnQgKAogICAgICAgICAgICBydW5fdG91cm5hbWVudCwgSGV1cmlzdGljUG9saWN5LCBSYW5kb21Qb2xpY3ksIExlYXJuZWRQb2xpY3ksCiAgICAgICAgKQoKICAgICAgICBja3B0X2RpciA9IG9zLnBhdGguam9pbihwcm9qZWN0X3Jvb3QsICJtbCIsICJtb2RlbHMiLCAiY2hlY2twb2ludHMiKQogICAgICAgIHBvbGljaWVzID0gewogICAgICAgICAgICAiaGV1cmlzdGljIjogSGV1cmlzdGljUG9saWN5KCksCiAgICAgICAgICAgICJyYW5kb20iOiBSYW5kb21Qb2xpY3koKSwKICAgICAgICB9CgogICAgICAgIHN1cF9wYXRoID0gb3MucGF0aC5qb2luKGNrcHRfZGlyLCAiYmVzdF9wb2xpY3kucHQiKQogICAgICAgIGlmIG9zLnBhdGguZXhpc3RzKHN1cF9wYXRoKToKICAgICAgICAgICAgcG9saWNpZXNbInN1cGVydmlzZWQiXSA9IExlYXJuZWRQb2xpY3koc3VwX3BhdGgpCgogICAgICAgIHBwb19wYXRoID0gb3MucGF0aC5qb2luKGNrcHRfZGlyLCAiYmVzdF9wcG8ucHQiKQogICAgICAgIGlmIG9zLnBhdGguZXhpc3RzKHBwb19wYXRoKToKICAgICAgICAgICAgcG9saWNpZXNbInBwbyJdID0gTGVhcm5lZFBvbGljeShwcG9fcGF0aCkKCiAgICAgICAgcmVzdWx0ID0gcnVuX3RvdXJuYW1lbnQoCiAgICAgICAgICAgIHBvbGljaWVzPXBvbGljaWVzLAogICAgICAgICAgICBlcGlzb2Rlc19wZXJfbWF0Y2h1cD1lcGlzb2RlcywKICAgICAgICAgICAgcGxheXN0eWxlPXBsYXlzdHlsZSwKICAgICAgICApCgogICAgICAgICMgU2F2ZSByZXN1bHRzCiAgICAgICAgb3V0cHV0X3BhdGggPSBvcy5wYXRoLmpvaW4oY2twdF9kaXIsICJ0b3VybmFtZW50X3Jlc3VsdHMuanNvbiIpCiAgICAgICAgd2l0aCBvcGVuKG91dHB1dF9wYXRoLCAidyIpIGFzIGY6CiAgICAgICAgICAgIGpzb24uZHVtcChyZXN1bHQudG9fZGljdCgpLCBmLCBpbmRlbnQ9MikKCiAgICAgICAgX3RvdXJuYW1lbnRfc3RhdGVbInBoYXNlIl0gPSAiZG9uZSIKICAgICAgICBfdG91cm5hbWVudF9zdGF0ZVsicnVubmluZyJdID0gRmFsc2UKICAgICAgICBfdG91cm5hbWVudF9zdGF0ZVsicmVzdWx0Il0gPSByZXN1bHQudG9fZGljdCgpCiAgICAgICAgX3RvdXJuYW1lbnRfc3RhdGVbIm1lc3NhZ2UiXSA9IGYiVG91cm5hbWVudCBjb21wbGV0ZSEge3Jlc3VsdC50b3RhbF9tYXRjaGVzfSBtYXRjaGVzIgoKICAgIGV4Y2VwdCBFeGNlcHRpb24gYXMgZToKICAgICAgICBpbXBvcnQgdHJhY2ViYWNrCiAgICAgICAgX3RvdXJuYW1lbnRfc3RhdGVbInBoYXNlIl0gPSAiZXJyb3IiCiAgICAgICAgX3RvdXJuYW1lbnRfc3RhdGVbInJ1bm5pbmciXSA9IEZhbHNlCiAgICAgICAgX3RvdXJuYW1lbnRfc3RhdGVbImVycm9yIl0gPSBzdHIoZSkKICAgICAgICBfdG91cm5hbWVudF9zdGF0ZVsibWVzc2FnZSJdID0gZiJUb3VybmFtZW50IGZhaWxlZDoge2V9IgogICAgICAgIHRyYWNlYmFjay5wcmludF9leGMoKQoKCkBhcHAucG9zdCgiL2FwaS9tbC90b3VybmFtZW50IikKYXN5bmMgZGVmIG1sX3N0YXJ0X3RvdXJuYW1lbnQocmVxdWVzdDogRmFzdEFQSVJlcXVlc3QpOgogICAgIiIiU3RhcnQgYSB0b3VybmFtZW50IGV2YWx1YXRpb24uIiIiCiAgICBpZiBfdG91cm5hbWVudF9zdGF0ZVsicnVubmluZyJdOgogICAgICAgIHJhaXNlIEhUVFBFeGNlcHRpb24oNDA5LCAiVG91cm5hbWVudCBhbHJlYWR5IGluIHByb2dyZXNzIikKCiAgICBib2R5ID0gYXdhaXQgcmVxdWVzdC5qc29uKCkgaWYgYXdhaXQgcmVxdWVzdC5ib2R5KCkgZWxzZSB7fQogICAgZXBpc29kZXMgPSBib2R5LmdldCgiZXBpc29kZXMiLCA1MCkKICAgIHBsYXlzdHlsZSA9IGJv' +
+'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' +
+'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' +
+'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' +
+'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'
 Install-B64 -R 'lab_api.py' -B $b
 
 # ml/__init__.py (0 bytes)
@@ -1370,25 +1374,25 @@ $b = 'PCFET0NUWVBFIGh0bWw+CjxodG1sIGxhbmc9ImVuIj4KPGhlYWQ+CiAgICA8bWV0YSBjaGFyc2
 'IiBzdHlsZT0iZGlzcGxheTpub25lOyI+CiAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSJwYW5lbC1oZWFkZXIiPgogICAgICAgICAgICAgICAgICAgIDxoMj5NYW5hIEJhc2UgQWR2aWNlPC9oMj4KICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPHAgaWQ9ImNvYWNoLW1hbmEtdGV4dCIgY2xhc3M9ImNvYWNoLW1hbmEtdGV4dCI+PC9wPgogICAgICAgICAgICA8L2Rpdj4KCiAgICAgICAgICAgIDwhLS0gUmF3IEV4cGxhbmF0aW9uIChjb2xsYXBzaWJsZSkgLS0+CiAgICAgICAgICAgIDxkZXRhaWxzIGNsYXNzPSJwYW5lbCBjb2FjaC1yYXctZGV0YWlscyI+CiAgICAgICAgICAgICAgICA8c3VtbWFyeT5GdWxsIExMTSBSZXNwb25zZTwvc3VtbWFyeT4KICAgICAgICAgICAgICAgIDxwcmUgaWQ9ImNvYWNoLXJhdy10ZXh0IiBjbGFzcz0iY29hY2gtcmF3LXRleHQiPjwvcHJlPgogICAgICAgICAgICA8L2RldGFpbHM+CiAgICAgICAgPC9zZWN0aW9uPgoKICAgICAgICA8IS0tIFBhc3QgU2Vzc2lvbnMgLS0+CiAgICAgICAgPHNlY3Rpb24gY2xhc3M9InBhbmVsIGNvYWNoLXNlc3Npb25zLXNlY3Rpb24iPgogICAgICAgICAgICA8ZGl2IGNsYXNzPSJwYW5lbC1oZWFkZXIiPgogICAgICAgICAgICAgICAgPGgyPlBhc3QgU2Vzc2lvbnM8L2gyPgogICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgPGRpdiBpZD0iY29hY2gtc2Vzc2lvbnMtbGlzdCIgY2xhc3M9ImNvYWNoLXNlc3Npb25zLWxpc3QiPgogICAgICAgICAgICAgICAgPHAgY2xhc3M9ImNvYWNoLWVtcHR5Ij5ObyBjb2FjaGluZyBzZXNzaW9ucyB5ZXQuIFJ1biB0aGUgY29hY2ggdG8gZ2V0IHN0YXJ0ZWQuPC9wPgogICAgICAgICAgICA8L2Rpdj4KICAgICAgICA8L3NlY3Rpb24+CgogICAgICAgIDwhLS0gVG9hc3QgQ29udGFpbmVyIC0tPgogICAgICAgIDxkaXYgY2xhc3M9ImNvYWNoLXRvYXN0LWNvbnRhaW5lciIgaWQ9ImNvYWNoLXRvYXN0LWNvbnRhaW5lciI+PC9kaXY+CiAgICA8L2Rpdj4KCiAgICA8c2NyaXB0IHNyYz0iY29hY2guanMiPjwvc2NyaXB0Pgo8L2JvZHk+CjwvaHRtbD4K'
 Install-B64 -R 'ui\coach.html' -B $b
 
-# ui/coach.js (39,376 bytes)
+# ui/coach.js (40,252 bytes)
 $b = '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' +
 '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' +
 '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' +
 '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' +
-'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' +
-'ICAgICAgIGNvbnN0IG9wdCA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoJ29wdGlvbicpOwogICAgICAgICAgICAgICAgb3B0LnZhbHVlID0gZGVjay5pZDsKICAgICAgICAgICAgICAgIG9wdC50ZXh0Q29udGVudCA9IGRlY2submFtZSArIChkZWNrLmNvbW1hbmRlciA/ICcgKCcgKyBkZWNrLmNvbW1hbmRlciArICcpJyA6ICcnKTsKICAgICAgICAgICAgICAgIGFwcGx5RGVja1NlbGVjdC5hcHBlbmRDaGlsZChvcHQpOwogICAgICAgICAgICB9CiAgICAgICAgfSBjYXRjaCAoZSkgewogICAgICAgICAgICBjb25zb2xlLmVycm9yKCdGYWlsZWQgdG8gbG9hZCBEQiBkZWNrczonLCBlKTsKICAgICAgICB9CiAgICB9CgogICAgLy8g4pSA4pSAIExvYWQgUGFzdCBTZXNzaW9ucyDilIDilIDilIDilIDilIDilIDilIDilIDilIDilIDilIDilIDilIDilIDilIDilIDilIDilIDilIDilIDilIDilIDilIDilIDilIDilIDilIDilIDilIDilIDilIDilIDilIDilIAKCiAgICBhc3luYyBmdW5jdGlvbiBsb2FkU2Vzc2lvbnMoKSB7CiAgICAgICAgdHJ5IHsKICAgICAgICAgICAgY29uc3QgcmVzID0gYXdhaXQgZmV0Y2goQVBJICsgJy9hcGkvY29hY2gvc2Vzc2lvbnMnKTsKICAgICAgICAgICAgY29uc3QgZGF0YSA9IGF3YWl0IHJlcy5qc29uKCk7CiAgICAgICAgICAgIGNvbnN0IHNlc3Npb25zID0gZGF0YS5zZXNzaW9ucyB8fCBbXTsKCiAgICAgICAgICAgIGlmIChzZXNzaW9ucy5sZW5ndGggPT09IDApIHsKICAgICAgICAgICAgICAgIHNlc3Npb25zTGlzdC5pbm5lckhUTUwgPSAnPHAgY2xhc3M9ImNvYWNoLWVtcHR5Ij5ObyBjb2FjaGluZyBzZXNzaW9ucyB5ZXQuIFJ1biB0aGUgY29hY2ggdG8gZ2V0IHN0YXJ0ZWQuPC9wPic7CiAgICAgICAgICAgICAgICByZXR1cm47CiAgICAgICAgICAgIH0KCiAgICAgICAgICAgIHNlc3Npb25zTGlzdC5pbm5lckhUTUwgPSAnJzsKICAgICAgICAgICAgZm9yIChjb25zdCBzIG9mIHNlc3Npb25zKSB7CiAgICAgICAgICAgICAgICBjb25zdCBpdGVtID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgnZGl2Jyk7CiAgICAgICAgICAgICAgICBpdGVtLmNsYXNzTmFtZSA9ICdjb2FjaC1zZXNzaW9uLWl0ZW0nOwogICAgICAgICAgICAgICAgaXRlbS5kYXRhc2V0LnNlc3Npb25JZCA9IHMuc2Vzc2lvbklkOwoKICAgICAgICAgICAgICAgIGNvbnN0IHRpbWVTdHIgPSBzLnRpbWVzdGFtcCA/IGZvcm1hdFRpbWUocy50aW1lc3RhbXApIDogJyc7CiAgICAgICAgICAgICAgICBjb25zdCBpc0V4cGFuZGVkID0gZXhwYW5kZWRTZXNzaW9uc1tzLnNlc3Npb25JZF07CgogICAgICAgICAgICAgICAgaXRlbS5pbm5lckhUTUwgPQogICAgICAgICAgICAgICAgICAgICc8ZGl2IGNsYXNzPSJjb2FjaC1zZXNzaW9uLWhlYWRlciIgZGF0YS1zaWQ9IicgKyBlc2NIdG1sKHMuc2Vzc2lvbklkKSArICciPicgKwogICAgICAgICAgICAgICAgICAgICAgICAnPHNwYW4gY2xhc3M9ImNvYWNoLXNlc3Npb24tZXhwYW5kLWFycm93Ij4nICsgKGlzRXhwYW5kZWQgPyAnXHUyNUJDJyA6ICdcdTI1QjYnKSArICc8L3NwYW4+JyArCiAgICAgICAgICAgICAgICAgICAgICAgICc8c3BhbiBjbGFzcz0iY29hY2gtc2Vzc2lvbi1kZWNrIj4nICsgZXNjSHRtbChzLmRlY2tJZCkgKyAnPC9zcGFuPicgKwogICAgICAgICAgICAgICAgICAgICAgICAnPHNwYW4gY2xhc3M9ImNvYWNoLXNlc3Npb24tc3VtbWFyeSI+JyArIGVzY0h0bWwocy5zdW1tYXJ5IHx8ICcobm8gc3VtbWFyeSknKSArICc8L3NwYW4+JyArCiAgICAgICAgICAgICAgICAgICAgICAgICc8c3BhbiBjbGFzcz0iY29hY2gtc2Vzc2lvbi1tZXRhIj4nICsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICc8c3BhbiBjbGFzcz0iY29hY2gtc2Vzc2lvbi1jdXRzIj4tJyArIChzLmN1dHNDb3VudCB8fCAwKSArICc8L3NwYW4+JyArCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAnPHNwYW4gY2xhc3M9ImNvYWNoLXNlc3Npb24tYWRkcyI+KycgKyAocy5hZGRzQ291bnQgfHwgMCkgKyAnPC9zcGFuPicgKwogICAgICAgICAgICAgICAgICAgICAgICAgICAgJzxzcGFuIGNsYXNzPSJjb2FjaC1zZXNzaW9uLXRpbWUiPicgKyBlc2NIdG1sKHRpbWVTdHIpICsgJzwvc3Bhbj4nICsKICAgICAgICAgICAgICAgICAgICAgICAgJzwvc3Bhbj4nICsKICAgICAgICAgICAgICAgICAgICAnPC9kaXY+JyArCiAgICAgICAgICAgICAgICAgICAgJzxkaXYgY2xhc3M9ImNvYWNoLXNlc3Npb24tZGV0YWlsIiBpZD0ic2Vzc2lv' +
-'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' +
-'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' +
-'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' +
-'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' +
-'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' +
-'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' +
-'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' +
-'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' +
-'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' +
-'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' +
-'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' +
-'ZW5kQ2hpbGQoY2hpcCk7CiAgICB9CgogICAgZnVuY3Rpb24gZm9ybWF0SW1wYWN0KHNjb3JlKSB7CiAgICAgICAgaWYgKHNjb3JlID09PSB1bmRlZmluZWQgfHwgc2NvcmUgPT09IG51bGwpIHsKICAgICAgICAgICAgcmV0dXJuICc8c3BhbiBjbGFzcz0iY29hY2gtaW1wYWN0IGNvYWNoLWltcGFjdC1uZXV0cmFsIj5cdTIwMTQ8L3NwYW4+JzsKICAgICAgICB9CiAgICAgICAgY29uc3QgZml4ZWQgPSBzY29yZS50b0ZpeGVkKDMpOwogICAgICAgIGlmIChzY29yZSA8IC0wLjAxKSB7CiAgICAgICAgICAgIHJldHVybiAnPHNwYW4gY2xhc3M9ImNvYWNoLWltcGFjdCBjb2FjaC1pbXBhY3QtbmVnYXRpdmUiPicgKyBmaXhlZCArICc8L3NwYW4+JzsKICAgICAgICB9IGVsc2UgaWYgKHNjb3JlID4gMC4wMSkgewogICAgICAgICAgICByZXR1cm4gJzxzcGFuIGNsYXNzPSJjb2FjaC1pbXBhY3QgY29hY2gtaW1wYWN0LXBvc2l0aXZlIj4rJyArIGZpeGVkICsgJzwvc3Bhbj4nOwogICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgIHJldHVybiAnPHNwYW4gY2xhc3M9ImNvYWNoLWltcGFjdCBjb2FjaC1pbXBhY3QtbmV1dHJhbCI+JyArIGZpeGVkICsgJzwvc3Bhbj4nOwogICAgICAgIH0KICAgIH0KCiAgICBmdW5jdGlvbiBmb3JtYXRUaW1lKGlzb1N0cikgewogICAgICAgIHRyeSB7CiAgICAgICAgICAgIGNvbnN0IGQgPSBuZXcgRGF0ZShpc29TdHIpOwogICAgICAgICAgICByZXR1cm4gZC50b0xvY2FsZURhdGVTdHJpbmcoKSArICcgJyArIGQudG9Mb2NhbGVUaW1lU3RyaW5nKFtdLCB7IGhvdXI6ICcyLWRpZ2l0JywgbWludXRlOiAnMi1kaWdpdCcgfSk7CiAgICAgICAgfSBjYXRjaCB7CiAgICAgICAgICAgIHJldHVybiBpc29TdHI7CiAgICAgICAgfQogICAgfQoKICAgIGZ1bmN0aW9uIGVzY0h0bWwoc3RyKSB7CiAgICAgICAgaWYgKCFzdHIpIHJldHVybiAnJzsKICAgICAgICByZXR1cm4gU3RyaW5nKHN0cikKICAgICAgICAgICAgLnJlcGxhY2UoLyYvZywgJyZhbXA7JykKICAgICAgICAgICAgLnJlcGxhY2UoLzwvZywgJyZsdDsnKQogICAgICAgICAgICAucmVwbGFjZSgvPi9nLCAnJmd0OycpCiAgICAgICAgICAgIC5yZXBsYWNlKC8iL2csICcmcXVvdDsnKTsKICAgIH0KCn0pKCk7Cg=='
+'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' +
+'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' +
+'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' +
+'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' +
+'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' +
+'gOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgAoKICAgIGFzeW5jIGZ1bmN0aW9uIGdlbmVyYXRlUmVwb3J0cygpIHsKICAgICAgICBnZW5SZXBvcnRzQnRuLmRpc2FibGVkID0gdHJ1ZTsKICAgICAgICBnZW5SZXBvcnRzQnRuLnRleHRDb250ZW50ID0gJ0dlbmVyYXRpbmcuLi4nOwoKICAgICAgICB0cnkgewogICAgICAgICAgICBjb25zdCByZXMgPSBhd2FpdCBmZXRjaChBUEkgKyAnL2FwaS9jb2FjaC9yZXBvcnRzL2dlbmVyYXRlJywgeyBtZXRob2Q6ICdQT1NUJyB9KTsKICAgICAgICAgICAgY29uc3QgZGF0YSA9IGF3YWl0IHJlcy5qc29uKCk7CgogICAgICAgICAgICBpZiAoZGF0YS5jb3VudCA+IDApIHsKICAgICAgICAgICAgICAgIGdlblJlcG9ydHNCdG4udGV4dENvbnRlbnQgPSBkYXRhLmNvdW50ICsgJyByZXBvcnRzIGdlbmVyYXRlZCc7CiAgICAgICAgICAgICAgICBhd2FpdCBjaGVja1N0YXR1cygpOwogICAgICAgICAgICAgICAgYXdhaXQgbG9hZERlY2tzKCk7CiAgICAgICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgICAgICBnZW5SZXBvcnRzQnRuLnRleHRDb250ZW50ID0gJ05vIHJlc3VsdHMgZm91bmQnOwogICAgICAgICAgICB9CiAgICAgICAgfSBjYXRjaCAoZSkgewogICAgICAgICAgICBnZW5SZXBvcnRzQnRuLnRleHRDb250ZW50ID0gJ0Vycm9yOiAnICsgZS5tZXNzYWdlOwogICAgICAgIH0gZmluYWxseSB7CiAgICAgICAgICAgIHNldFRpbWVvdXQoKCkgPT4gewogICAgICAgICAgICAgICAgZ2VuUmVwb3J0c0J0bi5kaXNhYmxlZCA9IGZhbHNlOwogICAgICAgICAgICAgICAgZ2VuUmVwb3J0c0J0bi50ZXh0Q29udGVudCA9ICdSZWJ1aWxkIFJlcG9ydHMnOwogICAgICAgICAgICB9LCAzMDAwKTsKICAgICAgICB9CiAgICB9CgogICAgLy8g4pSA4pSAIFJ1biBDb2FjaCAob25lLXNob3QpIOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgOKUgAoKICAgIGFzeW5jIGZ1bmN0aW9uIHJ1bkNvYWNoKCkgewogICAgICAgIGNvbnN0IGRlY2tJZCA9IGRlY2tTZWxlY3QudmFsdWU7CiAgICAgICAgaWYgKCFkZWNrSWQpIHJldHVybjsKCiAgICAgICAgY29uc3QgZ29hbHMgPSBnZXRHb2FscygpOwoKICAgICAgICBydW5CdG4uZGlzYWJsZWQgPSB0cnVlOwogICAgICAgIHByb2dyZXNzRWwuc3R5bGUuZGlzcGxheSA9ICdmbGV4JzsKICAgICAgICBwcm9ncmVzc1RleHQudGV4dENvbnRlbnQgPSAnQW5hbHl6aW5nIGRlY2sgYW5kIGNvbnN1bHRpbmcgTExNLi4uIFRoaXMgbWF5IHRha2UgMzAtNjAgc2Vjb25kcy4nOwogICAgICAgIHJlc3VsdHNFbC5zdHlsZS5kaXNwbGF5ID0gJ25vbmUnOwoKICAgICAgICBjb25zdCBwcmV2RXJyb3IgPSBkb2N1bWVudC5xdWVyeVNlbGVjdG9yKCcuY29hY2gtZXJyb3InKTsKICAgICAgICBpZiAocHJldkVycm9yKSBwcmV2RXJyb3IucmVtb3ZlKCk7CgogICAgICAgIHRyeSB7CiAgICAgICAgICAgIGNvbnN0IHJlcyA9IGF3YWl0IGZldGNoKEFQSSArICcvYXBpL2NvYWNoL2RlY2tzLycgKyBlbmNvZGVVUklDb21wb25lbnQoZGVja0lkKSwgewogICAgICAgICAgICAgICAgbWV0aG9kOiAnUE9TVCcsCiAgICAgICAgICAgICAgICBoZWFkZXJzOiB7ICdDb250ZW50LVR5cGUnOiAnYXBwbGljYXRpb24vanNvbicgfSwKICAgICAgICAgICAgICAgIGJvZHk6IEpTT04uc3RyaW5naWZ5KHsgZ29hbHM6IGdvYWxzIH0pLAogICAgICAgICAgICB9KTsKCiAgICAgICAgICAgIGlmICghcmVzLm9rKSB7CiAgICAgICAgICAgICAgICBjb25zdCBlcnIgPSBhd2FpdCByZXMuanNvbigpLmNhdGNoKCgpID0+ICh7IGRldGFpbDogJ1Vua25vd24gZXJyb3InIH0pKTsKICAgICAgICAgICAgICAgIHRocm93IG5ldyBFcnJvcihlcnIuZGV0YWlsIHx8ICdDb2FjaCByZXF1ZXN0IGZhaWxlZCAoJyArIHJlcy5zdGF0dXMgKyAnKScpOwogICAgICAgICAgICB9CgogICAgICAgICAgICBjb25zdCBzZXNzaW9uID0gYXdhaXQgcmVzLmpzb24oKTsKICAgICAgICAgICAgY3VycmVudFNlc3Npb25JZCA9IHNlc3Npb24uc2Vzc2lvbklkIHx8IG51bGw7CiAgICAgICAgICAgIGRpc3BsYXlTZXNzaW9uKHNlc3Npb24pOwogICAgICAgICAgICBsb2FkU2Vzc2lvbnMoKTsKICAgICAgICB9IGNhdGNoIChlKSB7CiAgICAgICAgICAgIGNvbnN0IGVyckRpdiA9IGRvY3VtZW50' +
+'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' +
+'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' +
+'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' +
+'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' +
+'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' +
+'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' +
+'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' +
+'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'
 Install-B64 -R 'ui\coach.js' -B $b
 
 # ui/collection.css (56,542 bytes)

ml/actions/labeler.py

@@ -240,12 +240,12 @@ def print_label_distribution(labels: np.ndarray) -> Dict[str, int]:
         dist[action.value] = count
 
     total = len(labels)
-    print(f"\n{'Action':<25} {'Count':>8} {'Pct':>8}")
-    print("─" * 43)
+    log.info(f"\n{'Action':<25} {'Count':>8} {'Pct':>8}")
+    log.info("─" * 43)
     for action_name, count in sorted(dist.items(), key=lambda x: -x[1]):
         pct = (count / total * 100) if total > 0 else 0
-        print(f"  {action_name:<23} {count:>8} {pct:>7.1f}%")
-    print(f"{'─' * 43}")
-    print(f"  {'TOTAL':<23} {total:>8}")
+        log.info(f"  {action_name:<23} {count:>8} {pct:>7.1f}%")
+    log.info(f"{'─' * 43}")
+    log.info(f"  {'TOTAL':<23} {total:>8}")
 
     return dist

ml/data/dataset_builder.py

@@ -154,17 +154,17 @@ def build_dataset(
 
     # Print game outcome distribution
     unique_outcomes, outcome_counts = np.unique(outcomes, return_counts=True)
-    print(f"\n{'Outcome':<25} {'Count':>8}")
-    print("─" * 35)
+    log.info(f"\n{'Outcome':<25} {'Count':>8}")
+    log.info("─" * 35)
     for o, c in sorted(zip(unique_outcomes, outcome_counts), key=lambda x: -x[1]):
-        print(f"  {str(o):<23} {c:>8}")
+        log.info(f"  {str(o):<23} {c:>8}")
 
     # Print playstyle distribution
     unique_styles, style_counts = np.unique(playstyles, return_counts=True)
-    print(f"\n{'Playstyle':<25} {'Count':>8}")
-    print("─" * 35)
+    log.info(f"\n{'Playstyle':<25} {'Count':>8}")
+    log.info("─" * 35)
     for s, c in sorted(zip(unique_styles, style_counts), key=lambda x: -x[1]):
-        print(f"  {str(s):<23} {c:>8}")
+        log.info(f"  {str(s):<23} {c:>8}")
 
     return {
         "states": states,
@@ -288,7 +288,7 @@ def main():
         max_samples=args.max_samples,
     )
     if not dataset:
-        print("\nNo data to save. Run simulations with --ml-log first.")
+        log.info("\nNo data to save. Run simulations with --ml-log first.")
         sys.exit(1)
 
     if args.no_split:
@@ -300,7 +300,7 @@ def main():
         save_dataset(val, f"{base}-val.npz")
         save_dataset(test, f"{base}-test.npz")
 
-    print("\nDataset build complete.")
+    log.info("\nDataset build complete.")
 
 
 if __name__ == "__main__":

ml/training/policy_network.py

@@ -16,6 +16,10 @@ The network is designed for:
 import os
 import sys
 from pathlib import Path
+import logging
+
+log = logging.getLogger("commander_ai_lab.ml.training")
+
 
 # Conditional torch import — graceful failure if not installed
 try:
@@ -25,7 +29,7 @@ try:
     TORCH_AVAILABLE = True
 except ImportError:
     TORCH_AVAILABLE = False
-    print("[ML] PyTorch not installed. Install with: pip install torch")
+    log.warning("PyTorch not installed. Install with: pip install torch")
 
 import numpy as np
 
@@ -204,7 +208,7 @@ def save_checkpoint(
             "dropout": TRAINING_CONFIG.dropout,
         },
     }, path)
-    print(f"[ML] Checkpoint saved: {path}")
+    log.info(f"Checkpoint saved: {path}")
 
 
 def load_checkpoint(path: str, device: str = "cpu"):

ml/training/trainer.py

@@ -49,8 +49,7 @@ from ml.training.policy_network import (
     PolicyNetwork, save_checkpoint, load_checkpoint,
 )
 
-logging.basicConfig(level=logging.INFO, format="[%(name)s] %(message)s")
-logger = logging.getLogger("ml.trainer")
+logger = logging.getLogger("commander_ai_lab.ml.training")
 
 
 # ══════════════════════════════════════════════════════════
@@ -502,40 +501,40 @@ def evaluate_model(
 
 def print_evaluation(results: Dict):
     """Pretty-print evaluation results."""
-    print()
-    print("=" * 65)
-    print("  Test Set Evaluation")
-    print("=" * 65)
-    print(f"  Overall Accuracy: {results['overall_accuracy']:.1%}")
-    print(f"  Total Samples:    {results['total_samples']:,}")
-    print()
-    print(f"  {'Action':<20} {'Support':>8} {'Prec':>7} {'Recall':>7} {'F1':>7}")
-    print("  " + "-" * 55)
+    logger.info("")
+    logger.info("=" * 65)
+    logger.info("  Test Set Evaluation")
+    logger.info("=" * 65)
+    logger.info(f"  Overall Accuracy: {results['overall_accuracy']:.1%}")
+    logger.info(f"  Total Samples:    {results['total_samples']:,}")
+    logger.info("")
+    logger.info(f"  {'Action':<20} {'Support':>8} {'Prec':>7} {'Recall':>7} {'F1':>7}")
+    logger.info("  " + "-" * 55)
 
     for action_name, m in results["per_class"].items():
-        print(
+        logger.info(
             f"  {action_name:<20} {m['support']:>8} "
             f"{m['precision']:>7.3f} {m['recall']:>7.3f} {m['f1']:>7.3f}"
         )
 
-    print("  " + "-" * 55)
+    logger.info("  " + "-" * 55)
 
     # Confusion matrix
-    print()
-    print("  Confusion Matrix (rows=true, cols=predicted):")
+    logger.info("")
+    logger.info("  Confusion Matrix (rows=true, cols=predicted):")
     header = "  " + " " * 18
     for c in range(NUM_ACTIONS):
         short_name = IDX_TO_ACTION[c].value[:6]
         header += f" {short_name:>6}"
-    print(header)
+    logger.info(header)
 
     for r in range(NUM_ACTIONS):
         row_name = IDX_TO_ACTION[r].value[:16]
         row_str = f"  {row_name:<18}"
         for c in range(NUM_ACTIONS):
             row_str += f" {results['confusion_matrix'][r][c]:>6}"
-        print(row_str)
-    print()
+        logger.info(row_str)
+    logger.info("")
 
 
 # ══════════════════════════════════════════════════════════
@@ -605,8 +604,8 @@ def main():
     args = parser.parse_args()
 
     if not TORCH_AVAILABLE:
-        print("PyTorch not installed. Install with:")
-        print("  pip install torch torchvision --index-url https://download.pytorch.org/whl/cu121")
+        logger.info("PyTorch not installed. Install with:")
+        logger.info("  pip install torch torchvision --index-url https://download.pytorch.org/whl/cu121")
         sys.exit(1)
 
     device = args.device or get_best_device()
@@ -621,13 +620,13 @@ def main():
     if args.eval_only:
         # Evaluation only
         if not os.path.exists(test_path):
-            print(f"Test data not found: {test_path}")
-            print("Run: python -m ml.scripts.ml_cli build")
+            logger.info(f"Test data not found: {test_path}")
+            logger.info("Run: python -m ml.scripts.ml_cli build")
             sys.exit(1)
 
         ckpt_path = args.checkpoint or os.path.join(ckpt_dir, "best_policy.pt")
         if not os.path.exists(ckpt_path):
-            print(f"Checkpoint not found: {ckpt_path}")
+            logger.info(f"Checkpoint not found: {ckpt_path}")
             sys.exit(1)
 
         test_states, test_labels = load_npz_split(test_path)
@@ -641,15 +640,15 @@ def main():
         eval_path = os.path.join(ckpt_dir, "eval_results.json")
         with open(eval_path, "w") as f:
             json.dump(results, f, indent=2)
-        print(f"  Results saved: {eval_path}")
+        logger.info(f"  Results saved: {eval_path}")
         return
 
     # Training mode
     for path, label in [(train_path, "train"), (val_path, "val")]:
         if not os.path.exists(path):
-            print(f"{label} data not found: {path}")
-            print("Build the dataset first:")
-            print("  python -m ml.scripts.ml_cli build --results-dir results/")
+            logger.info(f"{label} data not found: {path}")
+            logger.info("Build the dataset first:")
+            logger.info("  python -m ml.scripts.ml_cli build --results-dir results/")
             sys.exit(1)
 
     train_states, train_labels = load_npz_split(train_path)

overnight-run.py

@@ -22,11 +22,15 @@ Configuration:
 
 import argparse
 import json
+import logging
+import logging.handlers
+import os
 import sys
 import time
 import urllib.request
 import urllib.error
 from datetime import datetime, timedelta
+from pathlib import Path
 
 
 # ── Default Config ──────────────────────────────────────────────
@@ -51,10 +55,48 @@ DEFAULT_CONFIG = {
 }
 
 
-def log(msg):
-    ts = datetime.now().strftime("%H:%M:%S")
-    print(f"[{ts}] {msg}")
-    sys.stdout.flush()
+# ── Logging ──────────────────────────────────────────────────
+_LOG_DIR = Path(os.environ.get("CAL_LOG_DIR", "logs"))
+
+
+def setup_overnight_logging() -> logging.Logger:
+    """Configure logging for the overnight runner.
+
+    Outputs to both console and a rotating log file so that
+    unattended runs always have a persistent record.
+    """
+    _LOG_DIR.mkdir(parents=True, exist_ok=True)
+
+    logger = logging.getLogger("commander_ai_lab.overnight")
+    logger.setLevel(logging.INFO)
+
+    if logger.handlers:
+        return logger
+
+    fmt = logging.Formatter(
+        "%(asctime)s %(levelname)-5s [%(name)s] %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+
+    console = logging.StreamHandler(sys.stdout)
+    console.setLevel(logging.INFO)
+    console.setFormatter(fmt)
+    logger.addHandler(console)
+
+    file_handler = logging.handlers.RotatingFileHandler(
+        _LOG_DIR / "overnight-run.log",
+        maxBytes=10 * 1024 * 1024,  # 10 MB
+        backupCount=5,
+        encoding="utf-8",
+    )
+    file_handler.setLevel(logging.INFO)
+    file_handler.setFormatter(fmt)
+    logger.addHandler(file_handler)
+
+    return logger
+
+
+log = setup_overnight_logging()
 
 
 def api_get(base_url, path):
@@ -129,8 +171,8 @@ def wait_for_batch(base_url, batch_id, engine="deepseek", deadline=None):
     while True:
         # Hard deadline check — stop waiting if we've run out of time
         if deadline and time.time() >= deadline:
-            log(f"  Time limit reached while batch {batch_id} was running.")
-            log(f"  The batch will continue on the server but we're moving on.")
+            log.info(f"  Time limit reached while batch {batch_id} was running.")
+            log.info(f"  The batch will continue on the server but we're moving on.")
             return {"completed": 0, "timed_out": True}
 
         try:
@@ -144,12 +186,12 @@ def wait_for_batch(base_url, batch_id, engine="deepseek", deadline=None):
             elapsed = status.get("elapsedMs", 0)
 
             if error:
-                log(f"  Batch {batch_id} ERROR: {error}")
+                log.error(f"  Batch {batch_id} ERROR: {error}")
                 return None
 
             if not running and completed > 0:
                 elapsed_s = elapsed / 1000 if elapsed else 0
-                log(f"  Batch {batch_id} complete: {completed} games in {elapsed_s:.0f}s")
+                log.info(f"  Batch {batch_id} complete: {completed} games in {elapsed_s:.0f}s")
                 try:
                     result = api_get(base_url, f"/api/lab/result?batchId={batch_id}")
                     return result
@@ -160,15 +202,15 @@ def wait_for_batch(base_url, batch_id, engine="deepseek", deadline=None):
             if not running and completed == 0:
                 stall_checks += 1
                 if stall_checks > 20:  # 5 min with no progress
-                    log(f"  Batch {batch_id} never started. Aborting.")
+                    log.info(f"  Batch {batch_id} never started. Aborting.")
                     return None
 
             # Progress log with ETA
             if deadline:
                 mins_left = (deadline - time.time()) / 60
-                log(f"  Progress: {completed}/{total} games ({elapsed / 1000:.0f}s) — {mins_left:.0f}min left in run")
+                log.info(f"  Progress: {completed}/{total} games ({elapsed / 1000:.0f}s) — {mins_left:.0f}min left in run")
             else:
-                log(f"  Progress: {completed}/{total} games ({elapsed / 1000:.0f}s)")
+                log.info(f"  Progress: {completed}/{total} games ({elapsed / 1000:.0f}s)")
 
             # Track stall
             if completed == last_completed:
@@ -180,9 +222,9 @@ def wait_for_batch(base_url, batch_id, engine="deepseek", deadline=None):
         except Exception as e:
             consecutive_errors += 1
             if consecutive_errors > 10:
-                log(f"  Lost connection to server after 10 retries. Aborting batch.")
+                log.info(f"  Lost connection to server after 10 retries. Aborting batch.")
                 return None
-            log(f"  Connection error (retry {consecutive_errors}/10): {e}")
+            log.info(f"  Connection error (retry {consecutive_errors}/10): {e}")
 
         time.sleep(poll_interval)
 
@@ -214,26 +256,26 @@ def wait_for_training(base_url):
             error = status.get("error")
 
             if error:
-                log(f"  Training ERROR: {error}")
+                log.error(f"  Training ERROR: {error}")
                 return False
 
             if not running and phase in ("done", "idle") and epoch > 0:
                 result = status.get("result", {})
-                log(f"  Training complete!")
+                log.info(f"  Training complete!")
                 if result:
-                    log(f"  Final accuracy: {result.get('best_val_accuracy', '?')}")
-                    log(f"  Model saved: {result.get('model_path', '?')}")
+                    log.info(f"  Final accuracy: {result.get('best_val_accuracy', '?')}")
+                    log.info(f"  Model saved: {result.get('model_path', '?')}")
                 return True
 
             if phase == "training" and total > 0:
                 metrics = status.get("metrics", {})
                 val_acc = metrics.get("val_accuracy", "?") if metrics else "?"
-                log(f"  Training: epoch {epoch}/{total} — {message} (val_acc: {val_acc})")
+                log.info(f"  Training: epoch {epoch}/{total} — {message} (val_acc: {val_acc})")
             else:
-                log(f"  [{phase}] {message}")
+                log.info(f"  [{phase}] {message}")
 
         except Exception as e:
-            log(f"  Connection error: {e}")
+            log.info(f"  Connection error: {e}")
 
         time.sleep(poll_interval)
 
@@ -253,46 +295,46 @@ def run_overnight(cfg):
     """Main overnight pipeline."""
     base_url = cfg["lab_url"]
 
-    log("=" * 60)
-    log("  Commander AI Lab — Overnight AFK Runner")
-    log("=" * 60)
+    log.info("=" * 60)
+    log.info("  Commander AI Lab — Overnight AFK Runner")
+    log.info("=" * 60)
 
     # ── Verify server ────────────────────────────────────────
-    log("Checking lab server...")
+    log.info("Checking lab server...")
     if not check_server(base_url):
-        log(f"ERROR: Cannot reach lab server at {base_url}")
-        log("Start the lab first: start-lab.bat")
+        log.error(f"ERROR: Cannot reach lab server at {base_url}")
+        log.info("Start the lab first: start-lab.bat")
         return False
 
-    log(f"Server OK at {base_url}")
+    log.info(f"Server OK at {base_url}")
 
     # ── Get decks ─────────────────────────────────────────────
     available_decks = get_available_decks(base_url)
-    log(f"Found {len(available_decks)} decks: {', '.join(available_decks[:5])}{'...' if len(available_decks) > 5 else ''}")
+    log.info(f"Found {len(available_decks)} decks: {', '.join(available_decks[:5])}{'...' if len(available_decks) > 5 else ''}")
 
     engine = cfg["engine"]
     if engine == "deepseek":
         decks = cfg["ds_decks"] if cfg["ds_decks"] else available_decks
         if not decks:
-            log("ERROR: No decks available. Create decks in the Deck Builder first.")
+            log.error("ERROR: No decks available. Create decks in the Deck Builder first.")
             return False
-        log(f"Using DeepSeek engine with {len(decks)} deck(s)")
+        log.info(f"Using DeepSeek engine with {len(decks)} deck(s)")
     else:
         decks = cfg["java_decks"]
         if len(decks) != 3:
-            log("ERROR: Java engine requires exactly 3 deck names.")
-            log("Set java_decks in the config or use --decks deck1 deck2 deck3")
+            log.error("ERROR: Java engine requires exactly 3 deck names.")
+            log.info("Set java_decks in the config or use --decks deck1 deck2 deck3")
             return False
-        log(f"Using Java/Forge engine with decks: {decks}")
+        log.info(f"Using Java/Forge engine with decks: {decks}")
 
     # ── ML logging ────────────────────────────────────────────
-    log("Enabling ML logging...")
+    log.info("Enabling ML logging...")
     try:
         api_post(base_url, "/api/ml/toggle?enable=true", {})
-        log("ML logging enabled")
+        log.info("ML logging enabled")
     except Exception as e:
-        log(f"WARNING: Could not enable ML logging: {e}")
-        log("(DeepSeek batches always log ML data regardless)")
+        log.warning(f"WARNING: Could not enable ML logging: {e}")
+        log.info("(DeepSeek batches always log ML data regardless)")
         # Try alternate form
         try:
             api_get(base_url, "/api/ml/toggle?enable=true")
@@ -301,7 +343,7 @@ def run_overnight(cfg):
 
     # ── Initial data stats ────────────────────────────────────
     decisions_before, files_before = get_ml_data_summary(base_url)
-    log(f"Current ML data: {decisions_before} decisions in {files_before} files")
+    log.info(f"Current ML data: {decisions_before} decisions in {files_before} files")
 
     # ── Run batches ───────────────────────────────────────────
     games_per_batch = cfg["games_per_batch"]
@@ -315,32 +357,32 @@ def run_overnight(cfg):
     total_games = 0
     total_decisions = 0
 
-    log("")
-    log(f"Starting batch loop:")
+    log.info("")
+    log.info(f"Starting batch loop:")
     if num_batches > 0:
-        log(f"  Mode: {num_batches} batches × {games_per_batch} games")
+        log.info(f"  Mode: {num_batches} batches × {games_per_batch} games")
     else:
-        log(f"  Mode: Run for {cfg['time_limit_hours']}h, {games_per_batch} games/batch")
-    log(f"  Engine: {engine}")
-    log(f"  Auto-train after: {'Yes' if cfg['auto_train'] else 'No'}")
-    log("")
+        log.info(f"  Mode: Run for {cfg['time_limit_hours']}h, {games_per_batch} games/batch")
+    log.info(f"  Engine: {engine}")
+    log.info(f"  Auto-train after: {'Yes' if cfg['auto_train'] else 'No'}")
+    log.info("")
 
     while True:
         # Check stopping conditions
         if num_batches > 0 and batch_num >= num_batches:
-            log(f"Reached target of {num_batches} batches. Stopping.")
+            log.info(f"Reached target of {num_batches} batches. Stopping.")
             break
 
         elapsed = time.time() - start_time
         remaining = deadline - time.time()
         if remaining < 120:  # need at least 2 min for a batch
-            log(f"Time limit approaching ({remaining:.0f}s left). Stopping sim loop.")
+            log.info(f"Time limit approaching ({remaining:.0f}s left). Stopping sim loop.")
             break
 
         batch_num += 1
         elapsed_str = str(timedelta(seconds=int(elapsed)))
         remaining_str = str(timedelta(seconds=int(remaining)))
-        log(f"── Batch {batch_num} ── (elapsed: {elapsed_str}, remaining: {remaining_str})")
+        log.info(f"── Batch {batch_num} ── (elapsed: {elapsed_str}, remaining: {remaining_str})")
 
         try:
             if engine == "deepseek":
@@ -352,12 +394,12 @@ def run_overnight(cfg):
                 )
 
             if not batch_id:
-                log("  ERROR: Failed to start batch (no batchId returned)")
-                log("  Waiting 60s before retry...")
+                log.error("  ERROR: Failed to start batch (no batchId returned)")
+                log.info("  Waiting 60s before retry...")
                 time.sleep(60)
                 continue
 
-            log(f"  Started batch {batch_id}")
+            log.info(f"  Started batch {batch_id}")
             result = wait_for_batch(base_url, batch_id, engine, deadline=deadline)
 
             if result:
@@ -366,19 +408,19 @@ def run_overnight(cfg):
                 for deck in result.get("decks", []):
                     wr = deck.get("winRate", "?")
                     name = deck.get("deckName", "?")
-                    log(f"    {name}: {wr}% WR")
+                    log.info(f"    {name}: {wr}% WR")
             else:
-                log("  Batch failed, continuing to next...")
+                log.info("  Batch failed, continuing to next...")
 
         except Exception as e:
-            log(f"  ERROR starting batch: {e}")
-            log("  Waiting 60s before retry...")
+            log.error(f"  ERROR starting batch: {e}")
+            log.info("  Waiting 60s before retry...")
             time.sleep(60)
             continue
 
         # Pause between batches
         if pause_sec > 0:
-            log(f"  Cooling down {pause_sec}s...")
+            log.info(f"  Cooling down {pause_sec}s...")
             time.sleep(pause_sec)
 
     # ── Summary ───────────────────────────────────────────────
@@ -387,26 +429,26 @@ def run_overnight(cfg):
     new_decisions = decisions_after - decisions_before
     new_files = files_after - files_before
 
-    log("")
-    log("=" * 60)
-    log("  BATCH SIMULATION COMPLETE")
-    log("=" * 60)
-    log(f"  Batches run:       {batch_num}")
-    log(f"  Total games:       ~{total_games}")
-    log(f"  New ML decisions:  {new_decisions} (in {new_files} new files)")
-    log(f"  Total ML data:     {decisions_after} decisions")
-    log(f"  Elapsed time:      {str(timedelta(seconds=int(total_elapsed)))}")
-    log("")
+    log.info("")
+    log.info("=" * 60)
+    log.info("  BATCH SIMULATION COMPLETE")
+    log.info("=" * 60)
+    log.info(f"  Batches run:       {batch_num}")
+    log.info(f"  Total games:       ~{total_games}")
+    log.info(f"  New ML decisions:  {new_decisions} (in {new_files} new files)")
+    log.info(f"  Total ML data:     {decisions_after} decisions")
+    log.info(f"  Elapsed time:      {str(timedelta(seconds=int(total_elapsed)))}")
+    log.info("")
 
     # ── Auto-train ────────────────────────────────────────────
     if cfg["auto_train"]:
         if decisions_after < 100:
-            log("Skipping training — too few decisions (need at least 100)")
+            log.info("Skipping training — too few decisions (need at least 100)")
             return True
 
-        log("Starting ML training pipeline...")
-        log(f"  Epochs: {cfg['train_epochs']}, LR: {cfg['train_lr']}, "
-            f"Batch: {cfg['train_batch_size']}, Patience: {cfg['train_patience']}")
+        log.info("Starting ML training pipeline...")
+        log.info(f"  Epochs: {cfg['train_epochs']}, LR: {cfg['train_lr']}, "
+                 f"Batch: {cfg['train_batch_size']}, Patience: {cfg['train_patience']}")
 
         try:
             start_training(
@@ -416,21 +458,21 @@ def run_overnight(cfg):
                 batch_size=cfg["train_batch_size"],
                 patience=cfg["train_patience"],
             )
-            log("Training started, monitoring progress...")
+            log.info("Training started, monitoring progress...")
             success = wait_for_training(base_url)
             if success:
-                log("")
-                log("=" * 60)
-                log("  TRAINING COMPLETE — model updated!")
-                log("=" * 60)
+                log.info("")
+                log.info("=" * 60)
+                log.info("  TRAINING COMPLETE — model updated!")
+                log.info("=" * 60)
             else:
-                log("Training finished with errors. Check the Training tab for details.")
+                log.info("Training finished with errors. Check the Training tab for details.")
         except Exception as e:
-            log(f"ERROR starting training: {e}")
+            log.error(f"ERROR starting training: {e}")
             return False
 
-    log("")
-    log("Overnight run finished. You can close this window.")
+    log.info("")
+    log.info("Overnight run finished. You can close this window.")
     return True
 
 

pyproject.toml

@@ -10,8 +10,30 @@ readme = "README.md"
 requires-python = ">=3.10"
 license = {text = "MIT"}
 
+dependencies = [
+    "fastapi>=0.100.0",
+    "uvicorn[standard]>=0.23.0",
+    "pydantic>=2.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-asyncio>=0.21",
+    "httpx>=0.24.0",
+    "ruff>=0.1.0",
+]
+
 [tool.setuptools.packages.find]
 where = ["src"]
 
 [project.scripts]
 commander-sim = "commander_ai_lab.lab.experiments:_cli_main"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = [".", "src"]
+
+[tool.ruff]
+line-length = 120
+target-version = "py310"

requirements.txt

@@ -0,0 +1,7 @@
+# Core runtime dependencies
+# Install with: pip install -r requirements.txt
+# Or for dev tools: pip install -e ".[dev]"
+
+fastapi>=0.100.0
+uvicorn[standard]>=0.23.0
+pydantic>=2.0.0

scanner/pipeline.py

@@ -13,6 +13,10 @@ No local OCR or OpenCV needed — all recognition is done by the
 Ximilar cloud API using visual AI.
 """
 from typing import Callable, Optional
+import logging
+
+log = logging.getLogger("commander_ai_lab.scanner")
+
 
 from .ximilar_client import identify_cards, XimilarResult
 
@@ -160,7 +164,7 @@ def _ximilar_to_scan_result(xr: XimilarResult,
         try:
             scryfall_data = scryfall_lookup(xr.name)
         except Exception as e:
-            print(f"    [SCAN] Scryfall lookup failed for '{xr.name}': {e}")
+            log.error(f"    Scryfall lookup failed for '{xr.name}': {e}")
 
     if scryfall_data and scryfall_data.get("object") != "error":
         result.scryfall_id = scryfall_data.get("id", "")
@@ -181,6 +185,6 @@ def _ximilar_to_scan_result(xr: XimilarResult,
             # Extract image from scryfall URL pattern
             # e.g., https://scryfall.com/card/m11/149/lightning-bolt
             result.image_uri = ""  # Will be fetched by frontend via scryfall_id
-        print(f"    [SCAN] No Scryfall match for '{xr.name}' — using Ximilar data only")
+        log.info(f"    No Scryfall match for '{xr.name}' — using Ximilar data only")
 
     return result

scanner/ximilar_client.py

@@ -13,6 +13,10 @@ import json
 from typing import Optional, List
 from urllib.request import Request, urlopen
 from urllib.error import URLError, HTTPError
+import logging
+
+log = logging.getLogger("commander_ai_lab.scanner.ximilar")
+
 
 XIMILAR_ENDPOINT = "https://api.ximilar.com/collectibles/v2/tcg_id"
 
@@ -82,7 +86,7 @@ def identify_cards(image_bytes: bytes, api_key: str,
     )
 
     try:
-        print(f"    [XIMILAR] Sending {len(image_bytes):,} bytes to API (analyze_all={analyze_all})")
+        log.info(f"    Sending {len(image_bytes):,} bytes to API (analyze_all={analyze_all})")
         with urlopen(req, timeout=60) as resp:
             resp_data = json.loads(resp.read().decode("utf-8"))
     except HTTPError as e:
@@ -168,12 +172,12 @@ def _parse_response(resp_data: dict) -> List[XimilarResult]:
     if not results:
         results.append(XimilarResult(error="Ximilar could not identify any cards"))
 
-    print(f"    [XIMILAR] Identified {len(results)} card(s)")
+    log.info(f"    Identified {len(results)} card(s)")
     for r in results:
         if r.name:
-            print(f"    [XIMILAR]   - {r.name} ({r.set_code}) conf={r.confidence:.2f}")
+            log.info(f"    - {r.name} ({r.set_code}) conf={r.confidence:.2f}")
         elif r.error:
-            print(f"    [XIMILAR]   - ERROR: {r.error}")
+            log.error(f"    - ERROR: {r.error}")
 
     return results
 

src/commander_ai_lab/lab/experiments.py

@@ -13,6 +13,10 @@ Functions:
 """
 
 from __future__ import annotations
+import logging
+
+log = logging.getLogger("commander_ai_lab.lab.experiments")
+
 
 import time
 from typing import Optional
@@ -238,27 +242,27 @@ def _generate_training_deck() -> list[Card]:
 
 def _print_stats(stats: dict) -> None:
     """Pretty-print simulation stats."""
-    print()
-    print("=" * 60)
-    print(f"  SIMULATION RESULTS: {stats['deck_name']} vs {stats['opponent_name']}")
-    print("=" * 60)
-    print(f"  Games played:      {stats['total_games']}")
-    print(f"  Wins / Losses:     {stats['wins']} / {stats['losses']}")
-    print(f"  Win Rate:          {stats['win_rate']}%")
-    print(f"  Avg Turns:         {stats['avg_turns']}")
-    print("-" * 60)
-    print(f"  Avg Damage Dealt:     {stats['avg_damage_dealt']}")
-    print(f"  Avg Damage Received:  {stats['avg_damage_received']}")
-    print(f"  Avg Spells Cast:      {stats['avg_spells_cast']}")
-    print(f"  Avg Creatures Played: {stats['avg_creatures_played']}")
-    print(f"  Avg Removal Used:     {stats['avg_removal_used']}")
-    print(f"  Avg Ramp Played:      {stats['avg_ramp_played']}")
-    print(f"  Avg Cards Drawn:      {stats['avg_cards_drawn']}")
-    print(f"  Avg Max Board Size:   {stats['avg_max_board_size']}")
-    print("-" * 60)
-    print(f"  Elapsed:           {stats['elapsed_seconds']}s")
-    print("=" * 60)
-    print()
+    log.info("")
+    log.info("=" * 60)
+    log.info(f"  SIMULATION RESULTS: {stats['deck_name']} vs {stats['opponent_name']}")
+    log.info("=" * 60)
+    log.info(f"  Games played:      {stats['total_games']}")
+    log.info(f"  Wins / Losses:     {stats['wins']} / {stats['losses']}")
+    log.info(f"  Win Rate:          {stats['win_rate']}%")
+    log.info(f"  Avg Turns:         {stats['avg_turns']}")
+    log.info("-" * 60)
+    log.info(f"  Avg Damage Dealt:     {stats['avg_damage_dealt']}")
+    log.info(f"  Avg Damage Received:  {stats['avg_damage_received']}")
+    log.info(f"  Avg Spells Cast:      {stats['avg_spells_cast']}")
+    log.info(f"  Avg Creatures Played: {stats['avg_creatures_played']}")
+    log.info(f"  Avg Removal Used:     {stats['avg_removal_used']}")
+    log.info(f"  Avg Ramp Played:      {stats['avg_ramp_played']}")
+    log.info(f"  Avg Cards Drawn:      {stats['avg_cards_drawn']}")
+    log.info(f"  Avg Max Board Size:   {stats['avg_max_board_size']}")
+    log.info("-" * 60)
+    log.info(f"  Elapsed:           {stats['elapsed_seconds']}s")
+    log.info("=" * 60)
+    log.info("")
 
 
 def _cli_main() -> None:
@@ -294,15 +298,15 @@ def _run_smoke_test() -> None:
         "Harmonize", "Read the Bones", "Phyrexian Arena",
     ]
 
-    print("Building test deck (Korvold Aristocrats)...")
+    log.info("Building test deck (Korvold Aristocrats)...")
     test_deck = build_deck(test_decklist)
-    print(f"  Deck size: {len(test_deck)} cards")
+    log.info(f"  Deck size: {len(test_deck)} cards")
 
-    print("\nRunning single game...")
+    log.info("\nRunning single game...")
     single = run_single_game(test_deck, name_a="Korvold")
-    print(f"  Winner: {single['winner_name']} in {single['turns']} turns")
+    log.info(f"  Winner: {single['winner_name']} in {single['turns']} turns")
 
-    print("\nRunning Monte Carlo simulation (10 games)...")
+    log.info("\nRunning Monte Carlo simulation (10 games)...")
     stats = run_simulation(test_deck, num_games=10, name_a="Korvold")
     _print_stats(stats)
 

src/commander_ai_lab/sim/deepseek_brain.py

@@ -18,6 +18,8 @@ Performance features:
   - Response caching for identical game states
   - Structured JSON output with validation
   - Decision logging (JSONL) for future RL training data
+    Each JSONL entry includes game_result (winner_seat, winner_name,
+    player_lives, reward) once flush_log() is called with a GameResult.
 """
 
 from __future__ import annotations
@@ -115,17 +117,18 @@ def build_game_state_snapshot(
     opp = sim_state.players[1 - player_index]
     ctx = deck_context or {}
 
-    # ── Mana by Color (Enhancement #8) ──────────────────────────
+    # ── Mana by Color (Enhancement #8) ────────────────────────────
     mana_total = 0
     mana_by_color = {"W": 0, "U": 0, "B": 0, "R": 0, "G": 0, "C": 0}
-    for c in sim_state.battlefield:
-        if c.owner_id == player_index and not c.tapped and c.is_land():
+    my_bf = sim_state.get_battlefield(player_index)
+    opp_bf = sim_state.get_battlefield(1 - player_index)
+    for c in my_bf:
+        if not c.tapped and c.is_land():
             mana_total += 1
             land_name = c.name.lower().strip()
             if land_name in _LAND_COLOR_MAP:
                 mana_by_color[_LAND_COLOR_MAP[land_name]] += 1
             elif c.oracle_text:
-                # Parse oracle text for mana production
                 oracle_lower = c.oracle_text.lower()
                 if "any color" in oracle_lower:
                     for clr in "WUBRG":
@@ -136,14 +139,13 @@ def build_game_state_snapshot(
                         if sym in oracle_lower or f"add {clr.lower()}" in oracle_lower:
                             mana_by_color[clr] += 1
                     if not any(mana_by_color[k] for k in "WUBRG"):
-                        mana_by_color["C"] += 1  # colorless
+                        mana_by_color["C"] += 1
             else:
                 mana_by_color["C"] += 1
 
-    # Only include colors that have sources
     mana_colors = {k: v for k, v in mana_by_color.items() if v > 0}
 
-    # ── My Hand — Full Oracle Text (Enhancement #5) ────────────
+    # ── My Hand — Full Oracle Text (Enhancement #5) ────────────────
     my_hand = []
     for c in me.hand:
         card_info = {
@@ -155,7 +157,6 @@ def build_game_state_snapshot(
             card_info["pt"] = c.pt
         if c.keywords:
             card_info["keywords"] = c.keywords[:5]
-        # Role detection
         roles = []
         if c.is_removal:
             roles.append("removal")
@@ -167,24 +168,17 @@ def build_game_state_snapshot(
             roles.append("commander")
         if roles:
             card_info["roles"] = roles
-        # Full oracle text — no truncation (Enhancement #5)
         if c.oracle_text:
             card_info["oracle"] = c.oracle_text
-        # Castability check against available mana
         card_info["castable"] = (c.cmc or 0) <= mana_total and not c.is_land()
         my_hand.append(card_info)
 
-    # ── My Board — with keywords and oracle for synergy ───────
+    # ── My Board ──
     my_board = []
-    for c in sim_state.battlefield:
-        if c.owner_id != player_index:
-            continue
+    for c in my_bf:
         if c.is_land():
             continue
-        entry = {
-            "name": c.name,
-            "type": _short_type(c.type_line),
-        }
+        entry = {"name": c.name, "type": _short_type(c.type_line)}
         if c.pt:
             entry["pt"] = c.pt
         if c.tapped:
@@ -195,20 +189,15 @@ def build_game_state_snapshot(
             entry["is_commander"] = True
         my_board.append(entry)
 
-    # ── Opponent's Board — with Threat Assessment (Enhancement #9)
+    # ── Opponent's Board — with Threat Assessment (Enhancement #9) ──
     opp_board = []
     opp_total_power = 0
     opp_evasion_count = 0
     opp_protected_count = 0
-    for c in sim_state.battlefield:
-        if c.owner_id != (1 - player_index):
-            continue
+    for c in opp_bf:
         if c.is_land():
             continue
-        entry = {
-            "name": c.name,
-            "type": _short_type(c.type_line),
-        }
+        entry = {"name": c.name, "type": _short_type(c.type_line)}
         if c.pt:
             entry["pt"] = c.pt
             opp_total_power += c.get_power()
@@ -223,7 +212,6 @@ def build_game_state_snapshot(
                 opp_protected_count += 1
         opp_board.append(entry)
 
-    # Threat level summary
     if opp_total_power >= me.life:
         threat_level = "LETHAL"
     elif opp_total_power >= me.life * 0.5:
@@ -235,19 +223,16 @@ def build_game_state_snapshot(
     else:
         threat_level = "NONE"
 
-    # ── Graveyard Contents (Enhancement #6) ────────────────────
+    # ── Graveyard Contents (Enhancement #6) ──────────────────────
     my_gy = [{"name": c.name, "type": _short_type(c.type_line)} for c in me.graveyard[:15]]
     opp_gy = [{"name": c.name, "type": _short_type(c.type_line)} for c in opp.graveyard[:10]]
 
     # ── Draw Tracking (Enhancement #7) ─────────────────────────
     total_deck_size = ctx.get("deck_size", 100)
-    cards_seen = len(me.hand) + len(me.graveyard) + sum(
-        1 for c in sim_state.battlefield if c.owner_id == player_index
-    )
+    cards_seen = len(me.hand) + len(me.graveyard) + len(my_bf)
     cards_remaining = len(me.library)
     pct_drawn = round(cards_seen / max(total_deck_size, 1) * 100)
 
-    # Key cards still in library (if we know the decklist)
     key_cards_in_library = []
     if ctx.get("key_cards"):
         library_names = {c.name.lower() for c in me.library}
@@ -255,7 +240,7 @@ def build_game_state_snapshot(
             if kc.lower() in library_names:
                 key_cards_in_library.append(kc)
 
-    # ── Build the snapshot ─────────────────────────────────────
+    # ── Build the snapshot ────────────────────────────────────
     snapshot = {
         "turn": turn + 1,
         "my_life": me.life,
@@ -278,43 +263,33 @@ def build_game_state_snapshot(
         "deck_drawn_pct": pct_drawn,
     }
 
-    # ── Commander Identity (Enhancement #2) ────────────────────
     if ctx.get("commander_name"):
-        # Determine commander zone
         cmd_name_lower = ctx["commander_name"].lower()
-        cmd_zone = "library"  # default
+        cmd_zone = "library"
         for c in me.hand:
             if c.name.lower() == cmd_name_lower:
                 cmd_zone = "hand"
                 break
-        for c in sim_state.battlefield:
-            if c.owner_id == player_index and c.name.lower() == cmd_name_lower:
+        for c in my_bf:
+            if c.name.lower() == cmd_name_lower:
                 cmd_zone = "battlefield"
                 break
         for c in me.graveyard:
             if c.name.lower() == cmd_name_lower:
                 cmd_zone = "graveyard"
                 break
-
         snapshot["commander"] = {
             "name": ctx["commander_name"],
             "zone": cmd_zone,
             "color_identity": ctx.get("color_identity", []),
         }
 
-    # ── Full Decklist Awareness (Enhancement #1) ───────────────
     if ctx.get("deck_summary"):
         snapshot["deck_summary"] = ctx["deck_summary"]
-
-    # ── Win Conditions & Combos (Enhancement #3) ───────────────
     if ctx.get("combo_pieces"):
         snapshot["combo_pieces"] = ctx["combo_pieces"]
-
-    # ── Key Cards in Library (Enhancement #7) ──────────────────
     if key_cards_in_library:
         snapshot["key_cards_in_library"] = key_cards_in_library[:10]
-
-    # ── Historical Win Rate (Enhancement #10) ──────────────────
     if ctx.get("win_rate") is not None:
         snapshot["historical_win_rate"] = ctx["win_rate"]
 
@@ -344,7 +319,7 @@ def _short_type(type_line: str) -> str:
 
 
 def build_deck_context(
-    full_deck: list,          # list[Card] — the full original deck
+    full_deck: list,
     commander_name: str = "",
     color_identity: list[str] | None = None,
     archetype: str = "midrange",
@@ -364,7 +339,6 @@ def build_deck_context(
     if win_rate is not None:
         ctx["win_rate"] = win_rate
 
-    # ── Deck Composition Summary (Enhancement #1) ──────────────
     type_counts: dict[str, int] = {}
     roles: dict[str, list[str]] = {"removal": [], "ramp": [], "board_wipe": [], "draw": []}
     key_cards: list[str] = []
@@ -375,32 +349,25 @@ def build_deck_context(
     for card in full_deck:
         ctype = _short_type(card.type_line) if card.type_line else "?"
         type_counts[ctype] = type_counts.get(ctype, 0) + 1
-
         if not card.is_land():
             total_cmc += card.cmc or 0
             non_land_count += 1
-
-        # Track roles
         if card.is_removal:
             roles["removal"].append(card.name)
         if card.is_board_wipe:
             roles["board_wipe"].append(card.name)
         if card.is_ramp:
             roles["ramp"].append(card.name)
-        # Detect draw engines
         oracle = (card.oracle_text or "").lower()
         if re.search(r"draw .* cards?", oracle):
             roles["draw"].append(card.name)
-
-        # ── Win Conditions & Combos (Enhancement #3) ──────────
         for pattern, label in _COMBO_PATTERNS:
             if re.search(pattern, oracle):
                 combo_pieces.append({"name": card.name, "role": label})
                 key_cards.append(card.name)
-                break  # one label per card
+                break
 
     avg_cmc = round(total_cmc / max(non_land_count, 1), 1)
-
     ctx["deck_summary"] = {
         "card_types": type_counts,
         "avg_cmc": avg_cmc,
@@ -410,10 +377,8 @@ def build_deck_context(
         "draw_count": len(roles["draw"]),
         "archetype": archetype,
     }
-
-    ctx["combo_pieces"] = combo_pieces[:15]  # cap to save tokens
+    ctx["combo_pieces"] = combo_pieces[:15]
     ctx["key_cards"] = list(set(key_cards))[:15]
-
     return ctx
 
 
@@ -421,20 +386,18 @@ def build_deck_context(
 # Action Schema  (Step 3)
 # ══════════════════════════════════════════════════════════════
 
-# Valid actions the LLM can return
 VALID_ACTIONS = [
-    "play_land",       # Play a land from hand
-    "cast_creature",   # Cast a creature spell
-    "cast_removal",    # Cast targeted removal
-    "cast_board_wipe", # Cast a board wipe
-    "cast_ramp",       # Cast a ramp spell
-    "cast_spell",      # Cast any other non-creature spell
-    "attack_all",      # Attack with all eligible creatures
-    "attack_safe",     # Attack only with evasive/large creatures
-    "hold",            # Pass / don't act (save mana, bluff)
+    "play_land",
+    "cast_creature",
+    "cast_removal",
+    "cast_board_wipe",
+    "cast_ramp",
+    "cast_spell",
+    "attack_all",
+    "attack_safe",
+    "hold",
 ]
 
-# Action schema for the LLM's JSON response
 ACTION_SCHEMA = {
     "action": "one of: " + ", ".join(VALID_ACTIONS),
     "target_card": "(optional) name of card to cast or target",
@@ -533,14 +496,19 @@ class DeepSeekBrain:
     """
     LLM-powered decision engine for the AI opponent.
 
-    Sends game state to a local DeepSeek model and parses the action response.
+    Sends game state to a local DeepSeek/GPT-OSS model and parses the action response.
     Falls back to heuristic on timeout/error.
+
+    Decision log entries include game outcome once flush_log() is called
+    with a GameResult, enabling downstream RL weight learning.
     """
 
     def __init__(self, config: DeepSeekConfig | None = None):
         self.config = config or DeepSeekConfig()
         self._cache: OrderedDict[str, dict] = OrderedDict()
         self._decision_log: list[dict] = []
+        self._current_game_id: str = self._new_game_id()
+        self._ai_player_index: int | None = None  # set by caller if known
         self._total_calls = 0
         self._total_fallbacks = 0
         self._total_cache_hits = 0
@@ -548,6 +516,21 @@ class DeepSeekBrain:
         self._connected = False
         self._log_file = None
 
+    @staticmethod
+    def _new_game_id() -> str:
+        """Generate a short unique game ID for grouping decisions in the log."""
+        return hashlib.md5(str(time.time()).encode()).hexdigest()[:12]
+
+    def new_game(self, ai_player_index: int | None = None) -> None:
+        """
+        Signal the start of a new game.
+
+        Call this before each game so that log entries are grouped by game_id
+        and the ai_player_index is recorded for reward calculation.
+        """
+        self._current_game_id = self._new_game_id()
+        self._ai_player_index = ai_player_index
+
     def check_connection(self) -> bool:
         """Test if the LLM endpoint is reachable."""
         try:
@@ -559,7 +542,6 @@ class DeepSeekBrain:
                 self._connected = True
                 models = data.get("data", [])
                 if models:
-                    # Auto-detect model name from LM Studio
                     model_id = models[0].get("id", self.config.model)
                     if model_id:
                         self.config.model = model_id
@@ -573,20 +555,20 @@ class DeepSeekBrain:
 
     def choose_action(
         self,
-        sim_state,          # SimState
-        player_index: int,  # Which player is the AI
+        sim_state,
+        player_index: int,
         turn: int,
         available_mana: int | None = None,
-        deck_context: dict | None = None,  # Full deck intelligence from build_deck_context()
+        deck_context: dict | None = None,
     ) -> dict:
         """
         Choose an action for the AI player.
 
         Returns:
             {
-                "action": str,          # One of VALID_ACTIONS
-                "target_card": str,     # Optional card name
-                "reasoning": str,       # Brief explanation
+                "action": str,
+                "target_card": str,
+                "reasoning": str,
                 "source": "deepseek" | "heuristic" | "cache",
                 "latency_ms": float,
             }
@@ -594,12 +576,10 @@ class DeepSeekBrain:
         self._total_calls += 1
         t_start = time.time()
 
-        # Build game state snapshot with deck intelligence
         snapshot = build_game_state_snapshot(sim_state, player_index, turn, deck_context=deck_context)
         if available_mana is not None:
             snapshot["my_mana_available"] = available_mana
 
-        # Check cache
         if self.config.cache_enabled:
             cache_key = self._cache_key(snapshot)
             if cache_key in self._cache:
@@ -609,7 +589,6 @@ class DeepSeekBrain:
                 cached["latency_ms"] = round((time.time() - t_start) * 1000, 1)
                 return cached
 
-        # Try LLM
         if not self._connected:
             return self._fallback_action(snapshot, t_start, "not_connected")
 
@@ -618,13 +597,11 @@ class DeepSeekBrain:
             result["source"] = "deepseek"
             result["latency_ms"] = round((time.time() - t_start) * 1000, 1)
 
-            # Cache the result
             if self.config.cache_enabled:
                 self._put_cache(cache_key, result)
 
-            # Log decision
             if self.config.log_decisions:
-                self._log_decision(snapshot, result)
+                self._log_decision(snapshot, result, player_index)
 
             self._total_latency_ms += result["latency_ms"]
             return result
@@ -637,11 +614,9 @@ class DeepSeekBrain:
 
     def _call_llm(self, snapshot: dict) -> dict:
         """Send game state to LLM and parse response."""
-        # Build the prompt
         game_state_json = json.dumps(snapshot, indent=2)
         user_prompt = USER_PROMPT_TEMPLATE.format(game_state_json=game_state_json)
 
-        # Build OpenAI-compatible request
         payload = {
             "model": self.config.model,
             "messages": [
@@ -662,7 +637,6 @@ class DeepSeekBrain:
         with urlopen(req, timeout=self.config.request_timeout) as resp:
             resp_data = json.loads(resp.read())
 
-        # Extract the response text
         choices = resp_data.get("choices", [])
         if not choices:
             raise ValueError("Empty response from LLM")
@@ -676,18 +650,12 @@ class DeepSeekBrain:
         Handles common LLM quirks (markdown fences, extra text, etc.)
         """
         text = raw_text.strip()
-
-        # Strip <think>...</think> tags (DeepSeek-R1 reasoning)
-        # Handle both closed tags and unclosed tags (truncated by max_tokens)
         text = re.sub(r'<think>.*?</think>', '', text, flags=re.DOTALL).strip()
         text = re.sub(r'<think>.*', '', text, flags=re.DOTALL).strip()
-
-        # Strip markdown code fences
         text = re.sub(r'^```(?:json)?\s*', '', text)
         text = re.sub(r'\s*```$', '', text)
         text = text.strip()
 
-        # Try to find a JSON object in the text
         json_match = re.search(r'\{[^{}]*\}', text, re.DOTALL)
         if json_match:
             text = json_match.group(0)
@@ -695,7 +663,6 @@ class DeepSeekBrain:
         try:
             parsed = json.loads(text)
         except json.JSONDecodeError:
-            # Last resort: try to extract action keyword
             for action in VALID_ACTIONS:
                 if action in raw_text.lower():
                     return {
@@ -705,16 +672,14 @@ class DeepSeekBrain:
                     }
             raise ValueError(f"Could not parse LLM response as JSON: {raw_text[:200]}")
 
-        # Validate action
         action = parsed.get("action", "hold")
         if action not in VALID_ACTIONS:
-            # Fuzzy match
             for valid in VALID_ACTIONS:
                 if valid in action.lower() or action.lower() in valid:
                     action = valid
                     break
             else:
-                action = "hold"  # safe default
+                action = "hold"
 
         return {
             "action": action,
@@ -732,18 +697,15 @@ class DeepSeekBrain:
         opp_board = snapshot.get("opp_board", [])
         turn = snapshot.get("turn", 1)
 
-        # Priority: land > ramp (early) > removal (if outnumbered) > creature > attack > hold
         action = "hold"
         target = ""
         reasoning = f"Fallback ({reason})"
 
-        # 1. Play a land if available
         lands_in_hand = [c for c in hand if c.get("type") == "land"]
         if lands_in_hand:
             action = "play_land"
             target = lands_in_hand[0]["name"]
             reasoning = "Play land first"
-        # 2. Early game: prioritize ramp
         elif turn <= 4:
             ramp_cards = [c for c in hand if c.get("role") == "ramp" and c.get("cmc", 99) <= mana]
             if ramp_cards:
@@ -752,38 +714,31 @@ class DeepSeekBrain:
                 target = ramp_cards[0]["name"]
                 reasoning = "Early ramp"
             else:
-                # Play cheapest creature
                 creatures = [c for c in hand if c.get("type") == "creature" and c.get("cmc", 99) <= mana]
                 if creatures:
                     creatures.sort(key=lambda c: c.get("cmc", 0))
                     action = "cast_creature"
                     target = creatures[0]["name"]
                     reasoning = "Cheap creature development"
-        # 3. If opponent has many creatures and we have board wipe
         elif len(opp_board) >= 3 and len(my_board) <= 1:
             wipes = [c for c in hand if c.get("role") == "board_wipe" and c.get("cmc", 99) <= mana]
             if wipes:
                 action = "cast_board_wipe"
                 target = wipes[0]["name"]
                 reasoning = "Opponent has board advantage, wiping"
-        # 4. If opponent has a big threat, use removal
         elif opp_board:
             removal = [c for c in hand if c.get("role") == "removal" and c.get("cmc", 99) <= mana]
             if removal:
                 action = "cast_removal"
                 target = removal[0]["name"]
                 reasoning = "Remove opponent threat"
-        # 5. Play best creature
         if action == "hold":
             castable = [c for c in hand if c.get("type") == "creature" and c.get("cmc", 99) <= mana]
             if castable:
-                # Pick the one with highest power
                 castable.sort(key=lambda c: -int(c.get("pt", "0/0").split("/")[0]) if c.get("pt") else 0)
                 action = "cast_creature"
                 target = castable[0]["name"]
                 reasoning = "Play threat"
-
-        # 6. Attack if we have creatures on board
         if action == "hold" and my_board:
             creatures_on_board = [c for c in my_board if c.get("type") == "creature" and not c.get("tapped")]
             if creatures_on_board:
@@ -806,13 +761,10 @@ class DeepSeekBrain:
     # ── Cache helpers ──
 
     def _cache_key(self, snapshot: dict) -> str:
-        """Create a deterministic cache key from game state."""
-        # Normalize — exclude things that don't affect decisions
         key_data = json.dumps(snapshot, sort_keys=True)
         return hashlib.md5(key_data.encode()).hexdigest()
 
     def _put_cache(self, key: str, value: dict):
-        """LRU cache insert."""
         if key in self._cache:
             self._cache.move_to_end(key)
         self._cache[key] = value
@@ -821,10 +773,17 @@ class DeepSeekBrain:
 
     # ── Decision logging ──
 
-    def _log_decision(self, snapshot: dict, result: dict):
-        """Log decision for future training data."""
+    def _log_decision(self, snapshot: dict, result: dict, player_index: int | None = None) -> None:
+        """
+        Append a decision entry to the in-memory log.
+
+        The entry is tagged with game_id so flush_log() can backfill
+        game_result fields once the game is complete.
+        """
         entry = {
             "timestamp": time.time(),
+            "game_id": self._current_game_id,
+            "player_index": player_index if player_index is not None else self._ai_player_index,
             "game_state": snapshot,
             "decision": {
                 "action": result.get("action"),
@@ -833,14 +792,96 @@ class DeepSeekBrain:
                 "source": result.get("source"),
                 "latency_ms": result.get("latency_ms"),
             },
+            # game_result is None until flush_log() is called with a GameResult
+            "game_result": None,
         }
         self._decision_log.append(entry)
 
-    def flush_log(self, filepath: str | None = None):
-        """Write accumulated decision log to JSONL file."""
-        if not self._decision_log:
-            return
+    def flush_log(
+        self,
+        filepath: str | None = None,
+        game_result=None,  # Optional[GameResult] from engine.py
+    ) -> str | None:
+        """
+        Write accumulated decision log to a JSONL file.
 
+        Parameters
+        ----------
+        filepath : str, optional
+            Destination file path.  Defaults to logs/decisions/<timestamp>.jsonl
+            next to the package root.
+        game_result : GameResult, optional
+            Result from GameEngine.run() / run_n().  When provided, every
+            buffered entry is backfilled with:
+
+            ``game_result`` dict containing:
+              - ``winner_seat``  : int   — seat index of the winner
+              - ``winner_name``  : str   — display name of the winning player
+              - ``turns``        : int   — total game length in turns
+              - ``player_lives`` : dict  — {seat_index: final_life} for all seats
+              - ``reward``       : float — normalised reward in [-1.0, 1.0]
+                                          for the AI player recorded in each entry
+                                          (winner_life - loser_life) / 40.0
+
+        Returns the absolute path written, or None if the log was empty.
+        """
+        if not self._decision_log:
+            return None
+
+        # ── Build game_result payload from GameResult dataclass ──
+        result_payload: dict | None = None
+        if game_result is not None:
+            try:
+                winner_seat: int = game_result.winner_seat
+                winner_name: str = game_result.players[winner_seat].name
+                turns: int = game_result.turns
+
+                # Per-seat final life totals
+                player_lives: dict[int, int] = {
+                    pr.seat_index: pr.life
+                    for pr in game_result.players
+                }
+
+                result_payload = {
+                    "winner_seat": winner_seat,
+                    "winner_name": winner_name,
+                    "turns": turns,
+                    "player_lives": player_lives,
+                }
+            except Exception as exc:
+                logger.warning("Could not extract game_result fields: %s", exc)
+
+        # ── Backfill each entry with game_result + per-entry reward ──
+        for entry in self._decision_log:
+            if result_payload is None:
+                entry["game_result"] = None
+                continue
+
+            # Determine reward for the player who made this decision
+            pi = entry.get("player_index")
+            winner_seat = result_payload["winner_seat"]
+            player_lives = result_payload["player_lives"]
+
+            if pi is not None and len(player_lives) >= 2:
+                my_life = player_lives.get(pi, 0)
+                # Sum of all opponents' final life totals
+                opp_life_sum = sum(
+                    v for k, v in player_lives.items() if k != pi
+                )
+                opp_count = max(len(player_lives) - 1, 1)
+                avg_opp_life = opp_life_sum / opp_count
+                raw_reward = (my_life - avg_opp_life) / 40.0
+                reward = round(max(-1.0, min(1.0, raw_reward)), 4)
+            else:
+                # Fallback: binary win/loss
+                reward = 1.0 if (pi is not None and pi == winner_seat) else -1.0
+
+            entry["game_result"] = {
+                **result_payload,
+                "reward": reward,
+            }
+
+        # ── Write to JSONL ──
         if filepath is None:
             log_dir = self.config.log_dir or os.path.join(
                 os.path.dirname(__file__), "..", "..", "..", "logs", "decisions"
@@ -863,7 +904,9 @@ class DeepSeekBrain:
     def get_stats(self) -> dict:
         """Return performance statistics."""
         avg_latency = (
-            self._total_latency_ms / max(self._total_calls - self._total_fallbacks - self._total_cache_hits, 1)
+            self._total_latency_ms / max(
+                self._total_calls - self._total_fallbacks - self._total_cache_hits, 1
+            )
         )
         return {
             "total_calls": self._total_calls,
@@ -875,4 +918,5 @@ class DeepSeekBrain:
             "model": self.config.model,
             "api_base": self.config.api_base,
             "pending_log_entries": len(self._decision_log),
+            "current_game_id": self._current_game_id,
         }

src/commander_ai_lab/sim/deepseek_engine.py

@@ -5,11 +5,16 @@ Extends the headless GameEngine so that one player (the AI opponent)
 uses the DeepSeek LLM brain for decision-making instead of the static
 heuristic scorer.
 
+N-player ready: accepts 2–4 decks. The AI-controlled seat uses DeepSeek;
+all other seats use the heuristic.
+
 The LLM decides:
   1. Whether to play a land (and which one)
   2. Which spell(s) to cast (up to 2 per turn, same as base engine)
   3. Combat stance: attack_all, attack_safe, or hold
 
+Multiplayer attack targeting uses the weakest-opponent heuristic.
+
 If the LLM is unreachable or times out, falls back to the base-engine
 heuristic transparently.
 
@@ -31,7 +36,7 @@ import random
 import uuid
 from typing import Optional
 
-from commander_ai_lab.sim.models import Card, GameResult, Player, PlayerStats, SimState
+from commander_ai_lab.sim.models import Card, GameResult, Player, PlayerResult, PlayerStats, SimState
 from commander_ai_lab.sim.rules import AI_DEFAULT_WEIGHTS, enrich_card, score_card
 from commander_ai_lab.sim.deepseek_brain import DeepSeekBrain, DeepSeekConfig, build_deck_context
 
@@ -77,14 +82,40 @@ class DeepSeekGameEngine:
         color_identity: list[str] | None = None,
         win_rate: float | None = None,
     ) -> GameResult:
-        """Run a single game. The AI player uses DeepSeek for decisions."""
-        sim = self._create_state(deck_a, deck_b, name_a, name_b)
+        """Backward-compatible 2-player entry point."""
+        return self.run_n(
+            decks=[deck_a, deck_b],
+            names=[name_a, name_b],
+            game_id=game_id,
+            archetype=archetype,
+            commander_name=commander_name,
+            color_identity=color_identity,
+            win_rate=win_rate,
+        )
+
+    def run_n(
+        self,
+        decks: list[list[Card]],
+        names: list[str] | None = None,
+        game_id: str | None = None,
+        archetype: str = "midrange",
+        commander_name: str = "",
+        color_identity: list[str] | None = None,
+        win_rate: float | None = None,
+    ) -> GameResult:
+        """Run a single N-player game. The AI player uses DeepSeek for decisions."""
+        n = len(decks)
+        if names is None:
+            names = [f"Player {chr(65 + i)}" for i in range(n)]
+        sim = self._create_state(decks, names)
         game_log: list[dict] = []
+        elimination_order: list[int] = []
         gid = game_id or str(uuid.uuid4())[:12]
-        turn_decisions: list[dict] = []  # raw (snapshot, action_type) pairs
+        turn_decisions: list[dict] = []
 
         # Build deck intelligence context once at game start
-        ai_deck = deck_b if self.ai_player_index == 1 else deck_a
+        ai_idx = min(self.ai_player_index, n - 1)
+        ai_deck = decks[ai_idx]
         self._deck_context = build_deck_context(
             full_deck=ai_deck,
             commander_name=commander_name,
@@ -97,7 +128,7 @@ class DeepSeekGameEngine:
         for turn in range(sim.max_turns):
             turn_entry = {"turn": turn + 1, "phases": []}
 
-            for pi in range(2):
+            for pi in range(len(sim.players)):
                 p = sim.players[pi]
                 if p.eliminated:
                     continue
@@ -118,7 +149,7 @@ class DeepSeekGameEngine:
                     pre_snapshot = self._capture_ml_snapshot(sim, pi, turn)
 
                 # ── Decide: LLM or Heuristic? ──
-                action_type = "pass"  # default
+                action_type = "pass"
                 if pi == self.ai_player_index and self.brain._connected:
                     action_type = self._play_turn_deepseek(sim, pi, turn, phase_events, getattr(self, '_deck_context', None))
                 else:
@@ -132,27 +163,38 @@ class DeepSeekGameEngine:
                     turn_decisions.append(pre_snapshot)
 
                 # ── Track board size ──
-                board_size = sum(1 for c in sim.battlefield if c.owner_id == pi)
+                board_size = len(sim.get_battlefield(pi))
                 if board_size > p.stats.max_board_size:
                     p.stats.max_board_size = board_size
 
                 # ── Untap ──
-                for c in sim.battlefield:
-                    if c.owner_id == pi:
-                        c.tapped = False
+                for c in sim.get_battlefield(pi):
+                    c.tapped = False
 
                 if self.record_log:
-                    turn_entry["phases"].append({
+                    life_dict = {sp.name: sp.life for sp in sim.players}
+                    boards_dict = {
+                        f"board_{si}": [c.name for c in sim.get_battlefield(si) if c.is_creature()]
+                        for si in range(len(sim.players))
+                    }
+                    phase_entry: dict = {
                         "player": p.name,
                         "playerId": pi,
                         "events": phase_events,
-                        "lifeAfter": {
-                            sim.players[0].name: sim.players[0].life,
-                            sim.players[1].name: sim.players[1].life,
-                        },
-                        "boardA": [c.name for c in sim.battlefield if c.owner_id == 0 and c.is_creature()],
-                        "boardB": [c.name for c in sim.battlefield if c.owner_id == 1 and c.is_creature()],
-                    })
+                        "lifeAfter": life_dict,
+                        **boards_dict,
+                    }
+                    if len(sim.players) == 2:
+                        phase_entry["boardA"] = boards_dict.get("board_0", [])
+                        phase_entry["boardB"] = boards_dict.get("board_1", [])
+                    turn_entry["phases"].append(phase_entry)
+
+                # ── Check for new eliminations ──
+                for si, sp in enumerate(sim.players):
+                    if sp.eliminated and si not in elimination_order:
+                        elimination_order.append(si)
+                        if self.record_log:
+                            phase_events.append(f"{sp.name} eliminated!")
 
             # Check game over
             alive = [p for p in sim.players if not p.eliminated]
@@ -160,21 +202,16 @@ class DeepSeekGameEngine:
             if self.record_log:
                 game_log.append(turn_entry)
             if len(alive) <= 1:
-                if self.record_log:
-                    elim_name = next((p.name for p in sim.players if p.eliminated), None)
-                    if elim_name:
-                        game_log[-1]["event"] = f"{elim_name} eliminated!"
                 break
-            if self.record_log:
-                game_log.append(turn_entry) if turn_entry not in game_log else None
 
-        result = self._build_result(sim, final_turn, name_a, name_b)
+        result = self._build_result(sim, final_turn, elimination_order)
         if self.record_log:
             result.game_log = game_log
 
         # Stamp game outcome on all ML decisions and add to engine collection
         if self.ml_log and turn_decisions:
-            outcome = "win" if result.winner == 0 else "loss" if result.winner == 1 else "draw"
+            ai_won = result.winner_seat == self.ai_player_index
+            outcome = "win" if ai_won else "loss"
             for td in turn_decisions:
                 td["game_outcome"] = outcome
             self.ml_decisions.extend(turn_decisions)
@@ -217,7 +254,7 @@ class DeepSeekGameEngine:
 
         if self.record_log:
             events.append(f"[AI Brain: {source}] Action: {action} "
-                         f"{'→ ' + target_card_name if target_card_name else ''} "
+                         f"{'\u2192 ' + target_card_name if target_card_name else ''} "
                          f"({reasoning})")
 
         # ── Phase 1: Land drop ──
@@ -243,7 +280,7 @@ class DeepSeekGameEngine:
         elif action == "hold":
             # LLM chose to hold — no combat
             if self.record_log:
-                events.append("Holds — no attack")
+                events.append("Holds \u2014 no attack")
         else:
             # Default: still attack if we have creatures and it makes sense
             self._resolve_combat_heuristic(sim, pi, turn, events)
@@ -315,7 +352,7 @@ class DeepSeekGameEngine:
         land_card.tapped = False
         land_card.id = sim.next_card_id
         sim.next_card_id += 1
-        sim.battlefield.append(land_card)
+        sim.add_to_battlefield(pi, land_card)
         p.stats.lands_played += 1
 
         if events is not None and self.record_log:
@@ -426,30 +463,33 @@ class DeepSeekGameEngine:
 
         # Pay mana
         mana_needed = card.cmc or 0
-        for bf_card in sim.battlefield:
+        for bf_card in sim.get_battlefield(pi):
             if mana_needed <= 0:
                 break
-            if bf_card.owner_id == pi and not bf_card.tapped and bf_card.is_land():
+            if not bf_card.tapped and bf_card.is_land():
                 bf_card.tapped = True
                 mana_needed -= 1
 
         p.stats.mana_spent += card.cmc or 0
         p.stats.spells_cast += 1
 
-        # Handle removal
+        # Handle removal — target the scariest creature across all opponents
         if card.is_removal:
             p.stats.removal_used += 1
-            opp_creatures = [
-                c for c in sim.battlefield
-                if c.owner_id != pi and c.is_creature()
-            ]
-            if opp_creatures:
-                opp_creatures.sort(key=lambda c: -score_card(c, w))
-                killed = opp_creatures[0]
-                sim.battlefield = [c for c in sim.battlefield if c.id != killed.id]
+            all_opp_creatures = []
+            for oi in range(len(sim.players)):
+                if oi == pi or sim.players[oi].eliminated:
+                    continue
+                for c in sim.get_battlefield(oi):
+                    if c.is_creature():
+                        all_opp_creatures.append(c)
+            if all_opp_creatures:
+                all_opp_creatures.sort(key=lambda c: -score_card(c, w))
+                killed = all_opp_creatures[0]
+                sim.remove_from_battlefield(killed.id)
                 sim.players[killed.owner_id].graveyard.append(killed)
                 if events is not None:
-                    events.append(f"Cast {card.name} (removal) — destroyed {killed.name}")
+                    events.append(f"Cast {card.name} (removal) \u2014 destroyed {killed.name}")
             else:
                 if events is not None:
                     events.append(f"Cast {card.name} (removal, no targets)")
@@ -457,20 +497,23 @@ class DeepSeekGameEngine:
 
         elif card.is_board_wipe:
             p.stats.board_wipes_used += 1
-            wiped = [c.name for c in sim.battlefield if c.is_creature()]
-            surviving = []
-            for c in sim.battlefield:
-                if c.is_creature():
-                    sim.players[c.owner_id].graveyard.append(c)
-                else:
-                    surviving.append(c)
-            sim.battlefield = surviving
+            wiped_names = []
+            for seat_idx in range(len(sim.players)):
+                bf = sim.get_battlefield(seat_idx)
+                keep = []
+                for c in bf:
+                    if c.is_creature():
+                        wiped_names.append(c.name)
+                        sim.players[c.owner_id].graveyard.append(c)
+                    else:
+                        keep.append(c)
+                sim.battlefields[seat_idx] = keep
             p.graveyard.append(card)
             if events is not None:
-                events.append(f"Cast {card.name} (board wipe) — destroyed {len(wiped)} creatures")
+                events.append(f"Cast {card.name} (board wipe) \u2014 destroyed {len(wiped_names)} creatures")
 
         else:
-            sim.battlefield.append(card)
+            sim.add_to_battlefield(pi, card)
             if card.is_creature():
                 p.stats.creatures_played += 1
                 if events is not None:
@@ -485,6 +528,23 @@ class DeepSeekGameEngine:
 
         return self._count_untapped_lands(sim, pi)
 
+    # ──────────────────────────────────────────────────────────
+    # Attack target selection (N-player)
+    # ──────────────────────────────────────────────────────────
+
+    @staticmethod
+    def _select_attack_target(sim: SimState, pi: int) -> int:
+        """Select the weakest non-eliminated opponent (lowest life). Returns seat or -1."""
+        best_seat = -1
+        best_life = float('inf')
+        for si, sp in enumerate(sim.players):
+            if si == pi or sp.eliminated:
+                continue
+            if sp.life < best_life:
+                best_life = sp.life
+                best_seat = si
+        return best_seat
+
     # ──────────────────────────────────────────────────────────
     # Combat — DeepSeek directed
     # ──────────────────────────────────────────────────────────
@@ -499,23 +559,22 @@ class DeepSeekGameEngine:
         attack_safe: only evasive/large creatures
         """
         p = sim.players[pi]
-        opp_idx = 1 - pi
+        opp_idx = self._select_attack_target(sim, pi)
+        if opp_idx == -1:
+            return
         opp = sim.players[opp_idx]
 
-        if opp.eliminated:
-            return
-
         my_creatures = [
-            c for c in sim.battlefield
-            if c.owner_id == pi and c.is_creature() and not c.tapped
+            c for c in sim.get_battlefield(pi)
+            if c.is_creature() and not c.tapped
             and (turn > 0 or c.turn_played != turn)
         ]
         if not my_creatures:
             return
 
         opp_blockers = [
-            c for c in sim.battlefield
-            if c.owner_id == opp_idx and c.is_creature() and not c.tapped
+            c for c in sim.get_battlefield(opp_idx)
+            if c.is_creature() and not c.tapped
         ]
 
         # Select attackers based on LLM's preference
@@ -523,7 +582,6 @@ class DeepSeekGameEngine:
         if attack_mode == "attack_all":
             attackers = my_creatures[:]
         elif attack_mode == "attack_safe":
-            # Only evasive (flying, trample, menace) or large (power >= 4)
             for atk in my_creatures:
                 if (atk.has_keyword("flying") or atk.has_keyword("trample")
                         or atk.has_keyword("menace") or atk.get_power() >= 4):
@@ -535,7 +593,7 @@ class DeepSeekGameEngine:
         if events is not None and attackers:
             mode_label = "all-in" if attack_mode == "attack_all" else "safe"
             atk_names = [f"{a.name} ({a.pt})" for a in attackers]
-            events.append(f"Attacks ({mode_label}): {', '.join(atk_names)}")
+            events.append(f"Attacks {opp.name} ({mode_label}): {', '.join(atk_names)}")
 
         # Resolve blocking and damage (same logic as base engine)
         self._resolve_damage(sim, pi, attackers, opp_blockers, turn, events)
@@ -543,25 +601,24 @@ class DeepSeekGameEngine:
     def _resolve_combat_heuristic(
         self, sim: SimState, pi: int, turn: int, events: list[str] | None
     ) -> bool:
-        """Heuristic combat (same as base GameEngine._resolve_combat). Returns True if attacked."""
+        """Heuristic combat (N-player ready). Returns True if attacked."""
         p = sim.players[pi]
-        opp_idx = 1 - pi
+        opp_idx = self._select_attack_target(sim, pi)
+        if opp_idx == -1:
+            return False
         opp = sim.players[opp_idx]
 
-        if opp.eliminated:
-            return False
-
         my_creatures = [
-            c for c in sim.battlefield
-            if c.owner_id == pi and c.is_creature() and not c.tapped
+            c for c in sim.get_battlefield(pi)
+            if c.is_creature() and not c.tapped
             and (turn > 0 or c.turn_played != turn)
         ]
         if not my_creatures:
             return False
 
         opp_blockers = [
-            c for c in sim.battlefield
-            if c.owner_id == opp_idx and c.is_creature() and not c.tapped
+            c for c in sim.get_battlefield(opp_idx)
+            if c.is_creature() and not c.tapped
         ]
 
         # Same attacker selection as base engine
@@ -593,7 +650,7 @@ class DeepSeekGameEngine:
 
         if events is not None and attackers:
             atk_names = [f"{a.name} ({a.pt})" for a in attackers]
-            events.append(f"Attacks with: {', '.join(atk_names)}")
+            events.append(f"Attacks {opp.name} with: {', '.join(atk_names)}")
 
         self._resolve_damage(sim, pi, attackers, opp_blockers, turn, events)
         return len(attackers) > 0
@@ -609,7 +666,9 @@ class DeepSeekGameEngine:
     ):
         """Resolve blocking and combat damage."""
         p = sim.players[pi]
-        opp_idx = 1 - pi
+        opp_idx = self._select_attack_target(sim, pi)
+        if opp_idx == -1:
+            return
         opp = sim.players[opp_idx]
         w = self.weights
 
@@ -646,13 +705,13 @@ class DeepSeekGameEngine:
                         combat_details.append(f"{atk.name} blocked by {blocker.name}")
 
                     if a_pow >= blocker.get_toughness() or atk.has_keyword("deathtouch"):
-                        sim.battlefield = [c for c in sim.battlefield if c.id != blocker.id]
+                        sim.remove_from_battlefield(blocker.id)
                         sim.players[opp_idx].graveyard.append(blocker)
                         if events is not None:
                             combat_details.append(f"  {blocker.name} dies")
 
                     if b_pow >= a_tou or blocker.has_keyword("deathtouch"):
-                        sim.battlefield = [c for c in sim.battlefield if c.id != atk.id]
+                        sim.remove_from_battlefield(atk.id)
                         sim.players[pi].graveyard.append(atk)
                         if events is not None:
                             combat_details.append(f"  {atk.name} dies")
@@ -690,35 +749,36 @@ class DeepSeekGameEngine:
     def _capture_ml_snapshot(self, sim: SimState, pi: int, turn: int) -> dict:
         """
         Capture the current game state in the format expected by the ML
-        training pipeline (dataset_builder → state_encoder → labeler).
+        training pipeline (dataset_builder \u2192 state_encoder \u2192 labeler).
 
         Returns a dict compatible with ml-decisions-*.jsonl format.
         """
         players_data = []
-        for seat in range(2):
+        for seat in range(len(sim.players)):
             p = sim.players[seat]
             # Count creatures and lands on battlefield
+            seat_bf = sim.get_battlefield(seat)
             my_creatures = sum(
-                1 for c in sim.battlefield
-                if c.owner_id == seat and c.is_creature()
+                1 for c in seat_bf
+                if c.is_creature()
             )
             my_lands = sum(
-                1 for c in sim.battlefield
-                if c.owner_id == seat and c.is_land()
+                1 for c in seat_bf
+                if c.is_land()
             )
             available_mana = sum(
-                1 for c in sim.battlefield
-                if c.owner_id == seat and not c.tapped and c.is_land()
+                1 for c in seat_bf
+                if not c.tapped and c.is_land()
             )
 
             # Card name lists for zones (for embedding lookup)
             hand_names = [c.name for c in p.hand]
             graveyard_names = [c.name for c in p.graveyard]
             battlefield_names = [
-                c.name for c in sim.battlefield
-                if c.owner_id == seat and not c.is_land()
+                c.name for c in seat_bf
+                if not c.is_land()
             ]
-            # Command zone — not explicitly tracked in Python sim, use empty
+            # Command zone \u2014 not explicitly tracked in Python sim, use empty
             command_zone_names = []
 
             players_data.append({
@@ -735,7 +795,7 @@ class DeepSeekGameEngine:
                 "command_zone": command_zone_names,
             })
 
-        # Determine game phase — Python sim is simplified, treat as main_1
+        # Determine game phase \u2014 Python sim is simplified, treat as main_1
         phase = "main_1"
 
         return {
@@ -779,16 +839,17 @@ class DeepSeekGameEngine:
 
     def _count_untapped_lands(self, sim: SimState, pi: int) -> int:
         return sum(
-            1 for c in sim.battlefield
-            if c.owner_id == pi and not c.tapped and c.is_land()
+            1 for c in sim.get_battlefield(pi)
+            if not c.tapped and c.is_land()
         )
 
     def _create_state(
-        self, deck_a: list[Card], deck_b: list[Card],
-        name_a: str, name_b: str,
+        self, decks: list[list[Card]],
+        names: list[str],
     ) -> SimState:
+        """Create initial simulation state with shuffled decks and opening hands (N players)."""
         sim = SimState(max_turns=self.max_turns)
-        for idx, (deck, name) in enumerate([(deck_a, name_a), (deck_b, name_b)]):
+        for idx, (deck, name) in enumerate(zip(decks, names)):
             cards = [enrich_card(c.clone()) for c in deck]
             random.shuffle(cards)
             hand = cards[:7]
@@ -802,31 +863,54 @@ class DeepSeekGameEngine:
                 stats=PlayerStats(cards_drawn=7),
             )
             sim.players.append(player)
+        sim.init_battlefields(len(sim.players))
         return sim
 
     def _build_result(
         self, sim: SimState, final_turn: int,
-        name_a: str, name_b: str,
+        elimination_order: list[int] | None = None,
     ) -> GameResult:
-        pa = sim.players[0]
-        pb = sim.players[1]
+        """Determine winner and build result object (N-player)."""
+        if elimination_order is None:
+            elimination_order = []
+        n = len(sim.players)
 
-        if pa.eliminated and not pb.eliminated:
-            winner = 1
-        elif not pa.eliminated and pb.eliminated:
-            winner = 0
+        alive = [i for i, p in enumerate(sim.players) if not p.eliminated]
+        if len(alive) == 1:
+            winner = alive[0]
+        elif len(alive) == 0:
+            winner = max(range(n), key=lambda i: sim.players[i].life)
         else:
-            winner = 0 if pa.life >= pb.life else 1
+            winner = max(alive, key=lambda i: sim.players[i].life)
+
+        finish: dict[int, int] = {winner: 1}
+        position = 2
+        for seat in reversed(elimination_order):
+            if seat != winner:
+                finish[seat] = position
+                position += 1
+        remaining_alive = sorted(
+            [i for i in alive if i != winner],
+            key=lambda i: -sim.players[i].life,
+        )
+        for seat in remaining_alive:
+            if seat not in finish:
+                finish[seat] = position
+                position += 1
+
+        player_results = []
+        for seat, p in enumerate(sim.players):
+            player_results.append(PlayerResult(
+                seat_index=seat,
+                name=p.name,
+                life=p.life,
+                eliminated=p.eliminated,
+                finish_position=finish.get(seat, n),
+                stats=p.stats,
+            ))
 
         return GameResult(
-            winner=winner,
+            winner_seat=winner,
             turns=min(final_turn, sim.max_turns),
-            player_a_name=name_a,
-            player_a_life=pa.life,
-            player_a_eliminated=pa.eliminated,
-            player_a_stats=pa.stats,
-            player_b_name=name_b,
-            player_b_life=pb.life,
-            player_b_eliminated=pb.eliminated,
-            player_b_stats=pb.stats,
+            players=player_results,
         )

src/commander_ai_lab/sim/engine.py

@@ -4,12 +4,15 @@ Commander AI Lab — Headless Game Engine
 A headless Commander game simulator for Monte Carlo analysis.
 Faithful port of dtSimGame() / dtCreatePlayer() from mtg-commander-lan.
 
-Simulates simplified 1v1 Commander games:
+N-player ready: accepts 2–4 decks and runs a full multiplayer game.
+Simulates simplified Commander games:
   - Draw, land drop, spell casting (up to 2 per turn)
   - AI card scoring for play priority
   - Simplified combat with flying, trample, deathtouch, lifelink, menace, reach
+  - Multiplayer attack targeting: weakest non-eliminated opponent heuristic
   - Creature removal and board wipe handling
   - Win by elimination (life <= 0) or life comparison at max turns
+  - Elimination order tracking for N-player finish positions
 """
 
 from __future__ import annotations
@@ -21,6 +24,7 @@ from commander_ai_lab.sim.models import (
     Card,
     GameResult,
     Player,
+    PlayerResult,
     PlayerStats,
     SimState,
 )
@@ -33,12 +37,15 @@ from commander_ai_lab.sim.rules import (
 
 class GameEngine:
     """
-    Headless Commander game engine.
+    Headless Commander game engine (N-player ready).
 
     Usage::
 
         engine = GameEngine(max_turns=25)
+        # 2-player (backward-compatible)
         result = engine.run(deck_a, deck_b, name_a="Deck A", name_b="Deck B")
+        # 4-player
+        result = engine.run_n(decks=[d1, d2, d3, d4], names=["A","B","C","D"])
     """
 
     def __init__(
@@ -64,15 +71,30 @@ class GameEngine:
         name_a: str = "Player A",
         name_b: str = "Player B",
     ) -> GameResult:
-        """Run a single headless game and return the result."""
-        sim = self._create_state(deck_a, deck_b, name_a, name_b)
-        game_log: list[dict] = []  # turn-by-turn log
+        """Backward-compatible 2-player entry point."""
+        return self.run_n(
+            decks=[deck_a, deck_b],
+            names=[name_a, name_b],
+        )
+
+    def run_n(
+        self,
+        decks: list[list[Card]],
+        names: list[str] | None = None,
+    ) -> GameResult:
+        """Run a single headless N-player game and return the result."""
+        n = len(decks)
+        if names is None:
+            names = [f"Player {chr(65 + i)}" for i in range(n)]
+        sim = self._create_state(decks, names)
+        game_log: list[dict] = []
+        elimination_order: list[int] = []  # seats in order of elimination
 
         final_turn = 0
         for turn in range(sim.max_turns):
             turn_entry = {"turn": turn + 1, "phases": []}
 
-            for pi in range(2):
+            for pi in range(len(sim.players)):
                 p = sim.players[pi]
                 if p.eliminated:
                     continue
@@ -91,10 +113,9 @@ class GameEngine:
                 land_before = p.stats.lands_played
                 self._play_land(sim, pi)
                 if self.record_log and p.stats.lands_played > land_before:
-                    # Find what land was just played
                     last_land = next(
-                        (c for c in reversed(sim.battlefield)
-                         if c.owner_id == pi and c.is_land()),
+                        (c for c in reversed(sim.get_battlefield(pi))
+                         if c.is_land()),
                         None,
                     )
                     if last_land:
@@ -104,36 +125,46 @@ class GameEngine:
                 available_mana = self._count_untapped_lands(sim, pi)
 
                 # ── Play spells (up to 2) ──
-                spells_before = p.stats.spells_cast
                 self._play_spells(sim, pi, available_mana, phase_events if self.record_log else None)
 
                 # ── Track board size ──
-                board_size = sum(
-                    1 for c in sim.battlefield if c.owner_id == pi
-                )
+                board_size = len(sim.get_battlefield(pi))
                 if board_size > p.stats.max_board_size:
                     p.stats.max_board_size = board_size
 
                 # ── Combat ──
-                combat_before_life_a = sim.players[0].life
-                combat_before_life_b = sim.players[1].life
                 self._resolve_combat(sim, pi, turn, phase_events if self.record_log else None)
 
                 # ── Untap ──
-                for c in sim.battlefield:
-                    if c.owner_id == pi:
-                        c.tapped = False
+                for c in sim.get_battlefield(pi):
+                    c.tapped = False
 
                 if self.record_log:
-                    turn_entry["phases"].append({
+                    # N-player log: life dict + per-seat boards dict
+                    life_dict = {sp.name: sp.life for sp in sim.players}
+                    boards_dict = {
+                        f"board_{si}": [c.name for c in sim.get_battlefield(si) if c.is_creature()]
+                        for si in range(len(sim.players))
+                    }
+                    phase_entry: dict = {
                         "player": p.name,
                         "playerId": pi,
                         "events": phase_events,
-                        "lifeAfter": {sim.players[0].name: sim.players[0].life,
-                                      sim.players[1].name: sim.players[1].life},
-                        "boardA": [c.name for c in sim.battlefield if c.owner_id == 0 and c.is_creature()],
-                        "boardB": [c.name for c in sim.battlefield if c.owner_id == 1 and c.is_creature()],
-                    })
+                        "lifeAfter": life_dict,
+                        **boards_dict,
+                    }
+                    # Legacy keys for 2-player UI compatibility
+                    if len(sim.players) == 2:
+                        phase_entry["boardA"] = boards_dict.get("board_0", [])
+                        phase_entry["boardB"] = boards_dict.get("board_1", [])
+                    turn_entry["phases"].append(phase_entry)
+
+                # ── Check for new eliminations after this player's turn ──
+                for si, sp in enumerate(sim.players):
+                    if sp.eliminated and si not in elimination_order:
+                        elimination_order.append(si)
+                        if self.record_log:
+                            phase_events.append(f"{sp.name} eliminated!")
 
             # Check game over
             alive = [p for p in sim.players if not p.eliminated]
@@ -141,15 +172,9 @@ class GameEngine:
             if self.record_log:
                 game_log.append(turn_entry)
             if len(alive) <= 1:
-                if self.record_log:
-                    elim_name = next((p.name for p in sim.players if p.eliminated), None)
-                    if elim_name:
-                        game_log[-1]["event"] = f"{elim_name} eliminated!"
                 break
-            if self.record_log:
-                game_log.append(turn_entry) if turn_entry not in game_log else None
 
-        result = self._build_result(sim, final_turn, name_a, name_b)
+        result = self._build_result(sim, final_turn, elimination_order)
         if self.record_log:
             result.game_log = game_log
         return result
@@ -160,15 +185,13 @@ class GameEngine:
 
     def _create_state(
         self,
-        deck_a: list[Card],
-        deck_b: list[Card],
-        name_a: str,
-        name_b: str,
+        decks: list[list[Card]],
+        names: list[str],
     ) -> SimState:
-        """Create initial simulation state with shuffled decks and opening hands."""
+        """Create initial simulation state with shuffled decks and opening hands (N players)."""
         sim = SimState(max_turns=self.max_turns)
 
-        for idx, (deck, name) in enumerate([(deck_a, name_a), (deck_b, name_b)]):
+        for idx, (deck, name) in enumerate(zip(decks, names)):
             # Enrich + deep copy cards
             cards = [enrich_card(c.clone()) for c in deck]
             random.shuffle(cards)
@@ -186,6 +209,7 @@ class GameEngine:
             )
             sim.players.append(player)
 
+        sim.init_battlefields(len(sim.players))
         return sim
 
     def _play_land(self, sim: SimState, pi: int) -> None:
@@ -204,15 +228,15 @@ class GameEngine:
         land_card.tapped = False
         land_card.id = sim.next_card_id
         sim.next_card_id += 1
-        sim.battlefield.append(land_card)
+        sim.add_to_battlefield(pi, land_card)
         p.stats.lands_played += 1
 
     def _count_untapped_lands(self, sim: SimState, pi: int) -> int:
         """Count untapped lands for a player."""
         return sum(
             1
-            for c in sim.battlefield
-            if c.owner_id == pi and not c.tapped and c.is_land()
+            for c in sim.get_battlefield(pi)
+            if not c.tapped and c.is_land()
         )
 
     def _play_spells(self, sim: SimState, pi: int, available_mana: int, events: list | None = None) -> None:
@@ -251,34 +275,30 @@ class GameEngine:
 
             # Pay mana
             mana_needed = card.cmc or 0
-            for bf_card in sim.battlefield:
+            for bf_card in sim.get_battlefield(pi):
                 if mana_needed <= 0:
                     break
-                if (
-                    bf_card.owner_id == pi
-                    and not bf_card.tapped
-                    and bf_card.is_land()
-                ):
+                if not bf_card.tapped and bf_card.is_land():
                     bf_card.tapped = True
                     mana_needed -= 1
 
             p.stats.mana_spent += card.cmc or 0
             p.stats.spells_cast += 1
 
-            # Handle removal
+            # Handle removal — target the scariest creature across all opponents
             if card.is_removal:
                 p.stats.removal_used += 1
-                opp_creatures = [
-                    c
-                    for c in sim.battlefield
-                    if c.owner_id != pi and c.is_creature()
-                ]
-                if opp_creatures:
-                    opp_creatures.sort(key=lambda c: -score_card(c, w))
-                    killed = opp_creatures[0]
-                    sim.battlefield = [
-                        c for c in sim.battlefield if c.id != killed.id
-                    ]
+                all_opp_creatures = []
+                for oi in range(len(sim.players)):
+                    if oi == pi or sim.players[oi].eliminated:
+                        continue
+                    for c in sim.get_battlefield(oi):
+                        if c.is_creature():
+                            all_opp_creatures.append(c)
+                if all_opp_creatures:
+                    all_opp_creatures.sort(key=lambda c: -score_card(c, w))
+                    killed = all_opp_creatures[0]
+                    sim.remove_from_battlefield(killed.id)
                     sim.players[killed.owner_id].graveyard.append(killed)
                     if events is not None:
                         events.append(f"Cast {card.name} (removal) — destroyed {killed.name}")
@@ -289,20 +309,23 @@ class GameEngine:
 
             elif card.is_board_wipe:
                 p.stats.board_wipes_used += 1
-                wiped = [c.name for c in sim.battlefield if c.is_creature()]
-                surviving = []
-                for c in sim.battlefield:
-                    if c.is_creature():
-                        sim.players[c.owner_id].graveyard.append(c)
-                    else:
-                        surviving.append(c)
-                sim.battlefield = surviving
+                wiped_names = []
+                for seat_idx in range(len(sim.players)):
+                    bf = sim.get_battlefield(seat_idx)
+                    keep = []
+                    for c in bf:
+                        if c.is_creature():
+                            wiped_names.append(c.name)
+                            sim.players[c.owner_id].graveyard.append(c)
+                        else:
+                            keep.append(c)
+                    sim.battlefields[seat_idx] = keep
                 p.graveyard.append(card)
                 if events is not None:
-                    events.append(f"Cast {card.name} (board wipe) — destroyed {len(wiped)} creatures")
+                    events.append(f"Cast {card.name} (board wipe) — destroyed {len(wiped_names)} creatures")
 
             else:
-                sim.battlefield.append(card)
+                sim.add_to_battlefield(pi, card)
                 if card.is_creature():
                     p.stats.creatures_played += 1
                     if events is not None:
@@ -320,23 +343,41 @@ class GameEngine:
             # Recalculate available mana for next spell
             available_mana = self._count_untapped_lands(sim, pi)
 
+    @staticmethod
+    def _select_attack_target(sim: SimState, pi: int) -> int:
+        """Select the best opponent to attack.
+
+        Multiplayer heuristic: attack the weakest non-eliminated opponent
+        (lowest life total). Ties broken by highest seat index (arbitrary
+        but deterministic).
+
+        Returns the seat index of the chosen target, or -1 if no valid target.
+        """
+        best_seat = -1
+        best_life = float('inf')
+        for si, sp in enumerate(sim.players):
+            if si == pi or sp.eliminated:
+                continue
+            if sp.life < best_life:
+                best_life = sp.life
+                best_seat = si
+        return best_seat
+
     def _resolve_combat(self, sim: SimState, pi: int, turn: int, events: list | None = None) -> None:
-        """Resolve combat phase for a player."""
+        """Resolve combat phase for a player (N-player ready)."""
         p = sim.players[pi]
-        opp_idx = 1 - pi
+        opp_idx = self._select_attack_target(sim, pi)
+        if opp_idx == -1:
+            return  # no valid targets
         opp = sim.players[opp_idx]
         w = self.weights
 
-        if opp.eliminated:
-            return
-
         # My creatures that can attack (not tapped, not summoning sick)
         my_creatures = [
             c
-            for c in sim.battlefield
+            for c in sim.get_battlefield(pi)
             if (
-                c.owner_id == pi
-                and c.is_creature()
+                c.is_creature()
                 and not c.tapped
                 and (turn > 0 or c.turn_played != turn)
             )
@@ -346,18 +387,14 @@ class GameEngine:
 
         opp_blockers = [
             c
-            for c in sim.battlefield
+            for c in sim.get_battlefield(opp_idx)
             if (
-                c.owner_id == opp_idx
-                and c.is_creature()
+                c.is_creature()
                 and not c.tapped
             )
         ]
 
         # ── Decide attackers ──
-        # Aggressive strategy: attack with most creatures.
-        # Only hold back small creatures (power < 3) when opponent has
-        # blockers that would profitably trade AND we have plenty of life.
         attackers = []
         total_my_power = sum(c.get_power() for c in my_creatures)
         for atk in my_creatures:
@@ -367,29 +404,26 @@ class GameEngine:
             has_trample = atk.has_keyword("trample")
             has_haste = atk.has_keyword("haste")
 
-            # Always attack with evasion, big creatures, or if opponent is low
             if has_flying or has_trample or has_haste or a_pow >= 3 or opp.life <= total_my_power:
                 attackers.append(atk)
                 atk.tapped = True
                 continue
 
-            # For small creatures, check if a profitable block exists
             can_die_profitably = any(
                 (
                     (not has_flying or b.has_keyword("flying") or b.has_keyword("reach"))
                     and (b.get_power() >= a_tou or b.has_keyword("deathtouch"))
-                    and b.get_toughness() > a_pow  # blocker survives = bad trade
+                    and b.get_toughness() > a_pow
                 )
                 for b in opp_blockers
             )
-            # Attack unless we'd lose the creature for nothing AND we're healthy
             if not can_die_profitably or p.life > 25:
                 attackers.append(atk)
                 atk.tapped = True
 
         if events is not None and attackers:
             atk_names = [f"{a.name} ({a.pt})" for a in attackers]
-            events.append(f"Attacks with: {', '.join(atk_names)}")
+            events.append(f"Attacks {opp.name} with: {', '.join(atk_names)}")
 
         # ── Blocking and damage ──
         total_damage = 0
@@ -412,12 +446,10 @@ class GameEngine:
 
             blocked = False
             if valid_blockers and not atk.has_keyword("menace"):
-                # Try to find a blocker that survives
                 blocker = next(
                     (b for b in valid_blockers if b.get_toughness() > a_pow),
                     None,
                 )
-                # If life is critical, chump block
                 if blocker is None and opp.life <= a_pow * 2 and valid_blockers:
                     blocker = valid_blockers[0]
 
@@ -429,29 +461,21 @@ class GameEngine:
                     if events is not None:
                         combat_details.append(f"{atk.name} blocked by {blocker.name}")
 
-                    # Attacker kills blocker?
                     if a_pow >= blocker.get_toughness() or atk.has_keyword("deathtouch"):
-                        sim.battlefield = [
-                            c for c in sim.battlefield if c.id != blocker.id
-                        ]
+                        sim.remove_from_battlefield(blocker.id)
                         sim.players[opp_idx].graveyard.append(blocker)
                         if events is not None:
                             combat_details.append(f"  {blocker.name} dies")
 
-                    # Blocker kills attacker?
                     if b_pow >= a_tou or blocker.has_keyword("deathtouch"):
-                        sim.battlefield = [
-                            c for c in sim.battlefield if c.id != atk.id
-                        ]
+                        sim.remove_from_battlefield(atk.id)
                         sim.players[pi].graveyard.append(atk)
                         if events is not None:
                             combat_details.append(f"  {atk.name} dies")
 
-                    # Trample overflow
                     if atk.has_keyword("trample") and a_pow > blocker.get_toughness():
                         total_damage += a_pow - blocker.get_toughness()
 
-                    # Lifelink
                     if atk.has_keyword("lifelink"):
                         p.life += min(a_pow, blocker.get_toughness())
 
@@ -475,30 +499,60 @@ class GameEngine:
         self,
         sim: SimState,
         final_turn: int,
-        name_a: str,
-        name_b: str,
+        elimination_order: list[int] | None = None,
     ) -> GameResult:
-        """Determine winner and build result object."""
-        pa = sim.players[0]
-        pb = sim.players[1]
+        """Determine winner and build result object (N-player).
 
-        if pa.eliminated and not pb.eliminated:
-            winner = 1
-        elif not pa.eliminated and pb.eliminated:
-            winner = 0
+        Finish positions:
+          1 = winner (last player standing, or highest life if timeout)
+          2..N = elimination order (last eliminated = 2nd place, etc.)
+        """
+        if elimination_order is None:
+            elimination_order = []
+        n = len(sim.players)
+
+        # Determine winner: last player standing, or highest life among alive
+        alive = [i for i, p in enumerate(sim.players) if not p.eliminated]
+        if len(alive) == 1:
+            winner = alive[0]
+        elif len(alive) == 0:
+            # Everyone dead — shouldn't happen but pick highest life
+            winner = max(range(n), key=lambda i: sim.players[i].life)
         else:
-            # Both alive or both dead: compare life
-            winner = 0 if pa.life >= pb.life else 1
+            # Timeout — alive player with highest life wins
+            winner = max(alive, key=lambda i: sim.players[i].life)
+
+        # Build finish positions
+        # Winner = 1, then reverse elimination order (last eliminated = 2nd, etc.)
+        finish: dict[int, int] = {winner: 1}
+        position = 2
+        for seat in reversed(elimination_order):
+            if seat != winner:
+                finish[seat] = position
+                position += 1
+        # Any alive non-winner seats get next positions (by life descending)
+        remaining_alive = sorted(
+            [i for i in alive if i != winner],
+            key=lambda i: -sim.players[i].life,
+        )
+        for seat in remaining_alive:
+            if seat not in finish:
+                finish[seat] = position
+                position += 1
+
+        player_results = []
+        for seat, p in enumerate(sim.players):
+            player_results.append(PlayerResult(
+                seat_index=seat,
+                name=p.name,
+                life=p.life,
+                eliminated=p.eliminated,
+                finish_position=finish.get(seat, n),
+                stats=p.stats,
+            ))
 
         return GameResult(
-            winner=winner,
+            winner_seat=winner,
             turns=min(final_turn, sim.max_turns),
-            player_a_name=name_a,
-            player_a_life=pa.life,
-            player_a_eliminated=pa.eliminated,
-            player_a_stats=pa.stats,
-            player_b_name=name_b,
-            player_b_life=pb.life,
-            player_b_eliminated=pb.eliminated,
-            player_b_stats=pb.stats,
+            players=player_results,
         )

src/commander_ai_lab/sim/models.py

@@ -1,8 +1,11 @@
 """
 Commander AI Lab — Simulator Models
 ====================================
-Data classes for Card, Player, PlayerStats, and SimState.
+Data classes for Card, Player, PlayerResult, PlayerStats, SimState, and GameResult.
 Ported from mtg-commander-lan JavaScript (dtCreatePlayer, dtSimGame structs).
+
+N-player ready: GameResult.players is a list[PlayerResult] (no hardcoded seat count).
+SimState.battlefields is per-player: battlefields[seat_index] holds that player's permanents.
 """
 
 from __future__ import annotations
@@ -142,48 +145,198 @@ class Player:
 
 @dataclass
 class SimState:
-    """Full simulation state for a headless game."""
+    """Full simulation state for a headless game.
+
+    battlefields is a list-of-lists: battlefields[seat_index] holds
+    the permanents controlled by that player. Legacy single-list code
+    should use the helpers get_battlefield() / all_battlefield_cards().
+    """
 
     players: list[Player] = field(default_factory=list)
-    battlefield: list[Card] = field(default_factory=list)
+    battlefields: list[list[Card]] = field(default_factory=list)
     turn: int = 0
     max_turns: int = 25
     next_card_id: int = 90000
 
+    # ── Battlefield helpers ──────────────────────────────────
+
+    def get_battlefield(self, seat: int) -> list[Card]:
+        """Return the battlefield list for a given seat index."""
+        while len(self.battlefields) <= seat:
+            self.battlefields.append([])
+        return self.battlefields[seat]
+
+    def all_battlefield_cards(self) -> list[Card]:
+        """Return a flat list of every card on every player's battlefield."""
+        cards: list[Card] = []
+        for bf in self.battlefields:
+            cards.extend(bf)
+        return cards
+
+    def add_to_battlefield(self, seat: int, card: Card) -> None:
+        """Place a card onto the given player's battlefield."""
+        while len(self.battlefields) <= seat:
+            self.battlefields.append([])
+        self.battlefields[seat].append(card)
+
+    def remove_from_battlefield(self, card_id: int) -> Optional[Card]:
+        """Remove a card by id from any player's battlefield. Returns the card or None."""
+        for bf in self.battlefields:
+            for i, c in enumerate(bf):
+                if c.id == card_id:
+                    return bf.pop(i)
+        return None
+
+    def filter_battlefield(self, seat: int, predicate) -> list[Card]:
+        """Remove cards from seat's battlefield that don't match predicate, return removed."""
+        bf = self.get_battlefield(seat)
+        keep = []
+        removed = []
+        for c in bf:
+            if predicate(c):
+                keep.append(c)
+            else:
+                removed.append(c)
+        self.battlefields[seat] = keep
+        return removed
+
+    def init_battlefields(self, num_players: int) -> None:
+        """Ensure battlefields list has one empty list per player."""
+        while len(self.battlefields) < num_players:
+            self.battlefields.append([])
+
+
+# ══════════════════════════════════════════════════════════════
+# Game Results — N-player ready
+# ══════════════════════════════════════════════════════════════
+
+@dataclass
+class PlayerResult:
+    """Post-game result snapshot for one player.
+
+    Matches the Java BatchResult.PlayerResult schema structure.
+    """
+
+    seat_index: int = 0
+    name: str = ""
+    life: int = 0
+    eliminated: bool = False
+    finish_position: int = 0  # 1 = winner, 2+ = elimination order
+    stats: Optional[PlayerStats] = None
+
+    def to_dict(self) -> dict:
+        return {
+            "seatIndex": self.seat_index,
+            "name": self.name,
+            "finalLife": self.life,
+            "eliminated": self.eliminated,
+            "finishPosition": self.finish_position,
+            "isWinner": self.finish_position == 1,
+            "stats": self.stats.to_dict() if self.stats else {},
+        }
+
 
 @dataclass
 class GameResult:
-    """Result of a single simulated game."""
+    """Result of a single simulated game (N-player ready).
 
-    winner: int = -1  # 0 or 1 (player index), -1 = draw
+    - players: list of PlayerResult, one per seat
+    - winner_seat: index of the winning player (-1 = draw)
+    - Backward-compat properties player_a_stats / player_b_stats delegate to players[0] / players[1]
+    """
+
+    winner_seat: int = -1
     turns: int = 0
-    player_a_name: str = ""
-    player_a_life: int = 0
-    player_a_eliminated: bool = False
-    player_a_stats: Optional[PlayerStats] = None
-    player_b_name: str = ""
-    player_b_life: int = 0
-    player_b_eliminated: bool = False
-    player_b_stats: Optional[PlayerStats] = None
-    game_log: list = field(default_factory=list)  # turn-by-turn log (populated when record_log=True)
+    players: list[PlayerResult] = field(default_factory=list)
+    game_log: list = field(default_factory=list)
+
+    # ── Convenience accessors ────────────────────────────────
+
+    def player(self, seat: int) -> Optional[PlayerResult]:
+        """Safe accessor for a seat's result."""
+        if 0 <= seat < len(self.players):
+            return self.players[seat]
+        return None
+
+    # Backward-compat properties so existing code referencing
+    # result.player_a_stats or result.winner keeps working.
+
+    @property
+    def winner(self) -> int:
+        return self.winner_seat
+
+    @property
+    def player_a_stats(self) -> Optional[PlayerStats]:
+        p = self.player(0)
+        return p.stats if p else None
+
+    @property
+    def player_b_stats(self) -> Optional[PlayerStats]:
+        p = self.player(1)
+        return p.stats if p else None
+
+    @property
+    def player_a_name(self) -> str:
+        p = self.player(0)
+        return p.name if p else ""
+
+    @property
+    def player_b_name(self) -> str:
+        p = self.player(1)
+        return p.name if p else ""
+
+    @property
+    def player_a_life(self) -> int:
+        p = self.player(0)
+        return p.life if p else 0
+
+    @property
+    def player_b_life(self) -> int:
+        p = self.player(1)
+        return p.life if p else 0
+
+    @property
+    def player_a_eliminated(self) -> bool:
+        p = self.player(0)
+        return p.eliminated if p else False
+
+    @property
+    def player_b_eliminated(self) -> bool:
+        p = self.player(1)
+        return p.eliminated if p else False
 
     def to_dict(self) -> dict:
-        d = {
-            "winner": self.winner,
+        """Serialize to dict.
+
+        Returns both the legacy 2-player keys (winner, playerA, playerB)
+        that the existing UI and lab_api consumers expect AND the new
+        N-player 'playerResults' array for the Java BatchResult schema.
+        """
+        d: dict = {
+            # Legacy keys (UI expects these)
+            "winner": self.winner_seat,
             "turns": self.turns,
-            "playerA": {
-                "name": self.player_a_name,
-                "life": self.player_a_life,
-                "eliminated": self.player_a_eliminated,
-                "stats": self.player_a_stats.to_dict() if self.player_a_stats else {},
-            },
-            "playerB": {
-                "name": self.player_b_name,
-                "life": self.player_b_life,
-                "eliminated": self.player_b_eliminated,
-                "stats": self.player_b_stats.to_dict() if self.player_b_stats else {},
-            },
+            # New N-player keys (Java BatchResult schema)
+            "winningSeat": self.winner_seat,
+            "playerResults": [p.to_dict() for p in self.players],
         }
+
+        # Legacy playerA / playerB dicts for the UI
+        pa = self.player(0)
+        pb = self.player(1)
+        d["playerA"] = {
+            "name": pa.name if pa else "",
+            "life": pa.life if pa else 0,
+            "eliminated": pa.eliminated if pa else False,
+            "stats": pa.stats.to_dict() if pa and pa.stats else {},
+        }
+        d["playerB"] = {
+            "name": pb.name if pb else "",
+            "life": pb.life if pb else 0,
+            "eliminated": pb.eliminated if pb else False,
+            "stats": pb.stats.to_dict() if pb and pb.stats else {},
+        }
+
         if self.game_log:
             d["gameLog"] = self.game_log
         return d

src/commander_ai_lab/sim/rules.py

@@ -4,16 +4,23 @@ Commander AI Lab — Simulator Rules & Helpers
 AI weights, card enrichment heuristics, and scoring functions.
 Ported from mtg-commander-lan JavaScript (AI_DEFAULT_WEIGHTS,
 enrichCardForSim, headlessScoreCard, headlessGetPower/Toughness/HasKw).
+
+N-player ready: score_card() accepts num_opponents so keyword weights
+scale with pod size (e.g. Propaganda is worth more vs 3 opponents).
 """
 
 from __future__ import annotations
 
+import hashlib
+import json
+import logging
+import os
 import re
-import random
 from typing import Optional
 
 from commander_ai_lab.sim.models import Card
 
+logger = logging.getLogger("rules")
 
 # ══════════════════════════════════════════════════════════════
 # AI Weights (ported from AI_DEFAULT_WEIGHTS in app.js)
@@ -67,6 +74,9 @@ AI_DEFAULT_WEIGHTS: dict[str, float] = {
     "spell_cascade": 3.0,
 }
 
+# Default path for persisted learned weights (sibling to this file)
+_DEFAULT_WEIGHTS_PATH = os.path.join(os.path.dirname(__file__), "learned_weights.json")
+
 
 # ══════════════════════════════════════════════════════════════
 # Card Enrichment — guess type/cost for cards without Scryfall data
@@ -130,9 +140,12 @@ def enrich_card(card: Card) -> Card:
                 _apply_oracle_flags(card)
                 return card
 
-        # Default: treat as creature with random CMC
+        # Default: treat as creature with deterministic CMC based on
+        # card name hash (fixes #32 — no more random.randint jitter
+        # between games for the same card).
         if not card.type_line or len(card.type_line) < 3:
-            estimated_cmc = random.randint(2, 6)
+            name_hash = int(hashlib.md5(name_lower.encode()).hexdigest(), 16)
+            estimated_cmc = (name_hash % 5) + 2          # 2-6 inclusive
             estimated_pow = max(1, estimated_cmc - 1)
             card.type_line = "Creature"
             card.cmc = estimated_cmc
@@ -181,15 +194,46 @@ def _apply_oracle_flags(card: Card) -> None:
             card.is_ramp = True
 
 
-def score_card(card: Card, weights: Optional[dict] = None) -> float:
+# ── Multi-opponent scaling factors ────────────────────────────
+# Keywords / effects that become more valuable in larger pods.
+# Each entry maps a weight key → the extra bonus *per additional
+# opponent* beyond 1.  1v1 uses base weights; 4-player FFA adds
+# 3× the bonus for each matching keyword.
+_MULTI_OPP_SCALING: dict[str, float] = {
+    # Group-slug / pillowfort effects punish each opponent
+    "kw_menace":       0.5,     # harder to block with more players
+    "kw_flying":       0.3,     # evasion matters more in FFA
+    "kw_hexproof":     0.5,     # more removal flying around
+    "kw_indestructible": 0.5,
+    "kw_ward":         0.4,
+    # Multiplayer-relevant triggered abilities
+    "trig_etb":        0.3,
+    "trig_dies":       0.5,     # more creatures dying in FFA
+    # Spells that scale with opponents
+    "spell_destroy":   0.5,     # removal more precious
+    "spell_draw":      0.3,     # card advantage matters more
+    "spell_counter":   0.5,     # counters protect from more threats
+}
+
+
+def score_card(
+    card: Card,
+    weights: Optional[dict] = None,
+    num_opponents: int = 1,
+) -> float:
     """
     Score a card for AI play priority.
-    Ported from headlessScoreCard() in app.js.
+
+    Ported from headlessScoreCard() in app.js.  The optional
+    *num_opponents* parameter (default 1 for 1v1) scales keywords
+    that become more valuable in larger pods.
     """
     w = weights or AI_DEFAULT_WEIGHTS
+    extra_opps = max(0, num_opponents - 1)   # 0 for 1v1
     cmc = card.cmc or 0
     score = 10.0 - cmc * w.get("card_baseCmcPenalty", 1.0)
 
+    # ── Power / toughness bonus ──
     if card.pt:
         parts = card.pt.split("/")
         try:
@@ -202,22 +246,83 @@ def score_card(card: Card, weights: Optional[dict] = None) -> float:
             t = 0
         score += (p + t) * w.get("card_ptBonus", 1.0)
 
+    # ── Keyword / oracle-text scoring ──
     text = (card.oracle_text or "").lower()
-    if "flying" in text:
-        score += w.get("kw_flying", 2.5)
-    if "deathtouch" in text:
-        score += w.get("kw_deathtouch", 2.5)
-    if "haste" in text:
-        score += w.get("kw_haste", 2.5)
-    if "trample" in text:
-        score += w.get("kw_trample", 1.5)
-    if "lifelink" in text:
-        score += w.get("kw_lifelink", 1.5)
+    kw_list = [k.lower() for k in (card.keywords or [])]
 
+    def _kw_bonus(keyword: str, weight_key: str, default: float) -> float:
+        """Return base weight + per-extra-opponent scaling."""
+        base = w.get(weight_key, default)
+        multi = _MULTI_OPP_SCALING.get(weight_key, 0.0) * extra_opps
+        return base + multi
+
+    if "flying" in text or "flying" in kw_list:
+        score += _kw_bonus("flying", "kw_flying", 2.5)
+    if "deathtouch" in text or "deathtouch" in kw_list:
+        score += _kw_bonus("deathtouch", "kw_deathtouch", 2.5)
+    if "haste" in text or "haste" in kw_list:
+        score += _kw_bonus("haste", "kw_haste", 2.5)
+    if "trample" in text or "trample" in kw_list:
+        score += _kw_bonus("trample", "kw_trample", 1.5)
+    if "lifelink" in text or "lifelink" in kw_list:
+        score += _kw_bonus("lifelink", "kw_lifelink", 1.5)
+    if "double strike" in text or "double strike" in kw_list:
+        score += _kw_bonus("double strike", "kw_doubleStrike", 3.0)
+    if "first strike" in text or "first strike" in kw_list:
+        score += _kw_bonus("first strike", "kw_firstStrike", 1.5)
+    if "hexproof" in text or "hexproof" in kw_list:
+        score += _kw_bonus("hexproof", "kw_hexproof", 2.0)
+    if "indestructible" in text or "indestructible" in kw_list:
+        score += _kw_bonus("indestructible", "kw_indestructible", 3.0)
+    if "menace" in text or "menace" in kw_list:
+        score += _kw_bonus("menace", "kw_menace", 1.5)
+    if "vigilance" in text or "vigilance" in kw_list:
+        score += w.get("kw_vigilance", 1.0)
+    if "ward" in text or "ward" in kw_list:
+        score += _kw_bonus("ward", "kw_ward", 1.5)
+    if "infect" in text or "infect" in kw_list:
+        score += w.get("kw_infect", 3.0)
+    if "annihilator" in text:
+        score += w.get("kw_annihilator", 4.0)
+    if "cascade" in text or "cascade" in kw_list:
+        score += w.get("kw_cascade", 3.0)
+    if "defender" in text or "defender" in kw_list:
+        score += w.get("kw_defender", -2.0)
+
+    # ── Triggered ability bonuses ──
+    if "when" in text and "enters" in text:
+        score += w.get("trig_etb", 2.0) + _MULTI_OPP_SCALING.get("trig_etb", 0.0) * extra_opps
+    if "whenever" in text and "attack" in text:
+        score += w.get("trig_attack", 1.5)
+    if "when" in text and "dies" in text:
+        score += w.get("trig_dies", 1.0) + _MULTI_OPP_SCALING.get("trig_dies", 0.0) * extra_opps
+
+    # ── Multiplayer-specific oracle patterns ──
+    if extra_opps > 0:
+        # "each opponent" effects scale linearly with opponent count
+        if "each opponent" in text:
+            score += 2.0 * extra_opps
+        # Pillowfort (Propaganda, Ghostly Prison, etc.)
+        if "attack you" in text and ("pay" in text or "tax" in text or "can't" in text):
+            score += 1.5 * extra_opps
+        # "each player" draw/damage effects
+        if "each player" in text:
+            score += 1.0 * extra_opps
+
+    # ── Spell-type bonuses ──
     if card.is_ramp:
         score += w.get("spell_ramp", 6.0)
     if card.is_removal:
-        score += w.get("spell_destroy", 5.0)
+        score += _kw_bonus("removal", "spell_destroy", 5.0)
+    if card.is_board_wipe:
+        # Board wipes get better in multiplayer — more creatures to hit
+        score += 1.0 * extra_opps
+    if "draw" in text and ("card" in text or "cards" in text):
+        score += w.get("spell_draw", 3.0) + _MULTI_OPP_SCALING.get("spell_draw", 0.0) * extra_opps
+    if "counter target" in text:
+        score += w.get("spell_counter", 4.0) + _MULTI_OPP_SCALING.get("spell_counter", 0.0) * extra_opps
+    if "search your library" in text:
+        score += w.get("spell_search", 2.0)
 
     return score
 
@@ -242,3 +347,73 @@ def parse_decklist(text: str) -> list[Card]:
         for _ in range(qty):
             cards.append(Card(name=name))
     return cards
+
+
+# ══════════════════════════════════════════════════════════════
+# Learned Weights — persist & load simulation-derived weights
+# ══════════════════════════════════════════════════════════════
+
+def load_weights(path: str = _DEFAULT_WEIGHTS_PATH) -> dict[str, float]:
+    """
+    Load AI weights from a JSON file, falling back to AI_DEFAULT_WEIGHTS.
+
+    Merges loaded values on top of defaults so any new weight keys added
+    to AI_DEFAULT_WEIGHTS are always present even in older saved files.
+
+    Usage::
+
+        from commander_ai_lab.sim.rules import load_weights
+        weights = load_weights()                       # uses learned_weights.json if present
+        weights = load_weights("path/to/custom.json")  # custom path
+    """
+    if os.path.exists(path):
+        try:
+            with open(path, encoding="utf-8") as f:
+                loaded: dict = json.load(f)
+            # Only accept numeric values; ignore stale / corrupted keys
+            valid = {k: float(v) for k, v in loaded.items() if isinstance(v, (int, float))}
+            merged = {**AI_DEFAULT_WEIGHTS, **valid}
+            logger.info("Loaded %d learned weights from %s", len(valid), path)
+            return merged
+        except Exception as exc:
+            logger.warning("Failed to load weights from %s: %s — using defaults", path, exc)
+    return dict(AI_DEFAULT_WEIGHTS)
+
+
+def save_weights(weights: dict[str, float], path: str = _DEFAULT_WEIGHTS_PATH) -> str:
+    """
+    Persist AI weights to a JSON file.
+
+    Clamps each value to [-20.0, 20.0] before saving to prevent runaway
+    drift from repeated simulation updates.
+
+    Returns the absolute path that was written.
+
+    Usage::
+
+        from commander_ai_lab.sim.rules import save_weights
+        save_weights(updated_weights)                       # default path
+        save_weights(updated_weights, "path/to/custom.json")
+    """
+    _CLAMP_MIN, _CLAMP_MAX = -20.0, 20.0
+    clamped = {
+        k: round(max(_CLAMP_MIN, min(_CLAMP_MAX, float(v))), 6)
+        for k, v in weights.items()
+    }
+    os.makedirs(os.path.dirname(os.path.abspath(path)), exist_ok=True)
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(clamped, f, indent=2)
+    logger.info("Saved %d weights to %s", len(clamped), path)
+    return os.path.abspath(path)
+
+
+def reset_weights(path: str = _DEFAULT_WEIGHTS_PATH) -> dict[str, float]:
+    """
+    Delete any persisted learned weights and return AI_DEFAULT_WEIGHTS.
+
+    Useful for starting a fresh learning run without stale drift.
+    """
+    if os.path.exists(path):
+        os.remove(path)
+        logger.info("Deleted learned weights file: %s", path)
+    return dict(AI_DEFAULT_WEIGHTS)

tests/conftest.py

@@ -0,0 +1,75 @@
+"""Shared pytest fixtures for Commander AI Lab tests."""
+import pytest
+from commander_ai_lab.sim.models import Card, Player, PlayerStats, SimState
+
+
+@pytest.fixture
+def basic_creature():
+    return Card(name="Grizzly Bears", type_line="Creature — Bear", cmc=2, pt="2/2", power="2", toughness="2")
+
+
+@pytest.fixture
+def flying_creature():
+    return Card(
+        name="Serra Angel",
+        type_line="Creature — Angel",
+        cmc=5,
+        pt="4/4",
+        power="4",
+        toughness="4",
+        oracle_text="Flying, vigilance",
+        keywords=["Flying", "Vigilance"],
+    )
+
+
+@pytest.fixture
+def basic_land():
+    return Card(name="Forest", type_line="Basic Land — Forest", cmc=0)
+
+
+@pytest.fixture
+def sol_ring():
+    return Card(name="Sol Ring", type_line="Artifact", cmc=1, oracle_text="{T}: Add {C}{C}", is_ramp=True)
+
+
+@pytest.fixture
+def removal_spell():
+    return Card(name="Murder", type_line="Instant", cmc=3, oracle_text="Destroy target creature.", is_removal=True)
+
+
+@pytest.fixture
+def board_wipe():
+    return Card(name="Wrath of God", type_line="Sorcery", cmc=4, oracle_text="Destroy all creatures.", is_board_wipe=True)
+
+
+@pytest.fixture
+def commander_card():
+    return Card(
+        name="Korvold, Fae-Cursed King",
+        type_line="Legendary Creature — Dragon Noble",
+        cmc=5,
+        pt="4/4",
+        power="4",
+        toughness="4",
+        is_commander=True,
+        oracle_text="Flying, haste\nWhenever Korvold, Fae-Cursed King enters the battlefield or attacks, sacrifice another permanent.",
+        keywords=["Flying", "Haste"],
+    )
+
+
+@pytest.fixture
+def sample_player(basic_creature, basic_land, sol_ring):
+    p = Player(name="Alice", life=40, owner_id=0)
+    p.library = [basic_creature.clone(), basic_land.clone(), sol_ring.clone()] * 20
+    return p
+
+
+@pytest.fixture
+def two_player_state(sample_player):
+    import copy
+    p2 = copy.deepcopy(sample_player)
+    p2.name = "Bob"
+    p2.owner_id = 1
+    state = SimState(players=[sample_player, p2])
+    state.init_battlefields(2)
+    return state

tests/sim/test_engine.py

@@ -0,0 +1,97 @@
+"""Seeded simulation tests for the game engine."""
+import random
+import pytest
+from commander_ai_lab.sim.models import Card, Player, PlayerStats
+from commander_ai_lab.sim.rules import enrich_card
+from commander_ai_lab.sim.engine import GameEngine
+
+
+def _make_deck(seed: int, size: int = 60) -> list[Card]:
+    """Build a deterministic test deck using a seeded RNG."""
+    rng = random.Random(seed)
+    card_pool = [
+        Card(name="Forest"),
+        Card(name="Sol Ring"),
+        Card(name="Cultivate"),
+        Card(name="Murder"),
+        Card(name="Wrath of God"),
+        Card(name="Grizzly Bears"),
+        Card(name="Serra Angel"),
+    ]
+    for c in card_pool:
+        enrich_card(c)
+    deck = []
+    for i in range(size):
+        deck.append(card_pool[i % len(card_pool)].clone())
+    rng.shuffle(deck)
+    return deck
+
+
+class TestGameEngineTwoPlayer:
+    def test_game_completes(self):
+        """A 2-player seeded game should finish without error."""
+        engine = GameEngine(seed=42)
+        deck_a = _make_deck(seed=1)
+        deck_b = _make_deck(seed=2)
+        result = engine.run_game(
+            deck_a=[c.clone() for c in deck_a],
+            deck_b=[c.clone() for c in deck_b],
+            player_a_name="Alice",
+            player_b_name="Bob",
+        )
+        assert result is not None
+        assert result.turns > 0
+
+    def test_result_has_winner_or_draw(self):
+        """winner_seat must be 0, 1, or -1 (draw)."""
+        engine = GameEngine(seed=99)
+        deck = _make_deck(seed=5)
+        result = engine.run_game(
+            deck_a=[c.clone() for c in deck],
+            deck_b=[c.clone() for c in deck],
+            player_a_name="P1",
+            player_b_name="P2",
+        )
+        assert result.winner_seat in (-1, 0, 1)
+
+    def test_seeded_game_is_deterministic(self):
+        """Same seed must produce identical results."""
+        deck_a = _make_deck(seed=7)
+        deck_b = _make_deck(seed=8)
+
+        engine1 = GameEngine(seed=42)
+        result1 = engine1.run_game(
+            deck_a=[c.clone() for c in deck_a],
+            deck_b=[c.clone() for c in deck_b],
+            player_a_name="Alice",
+            player_b_name="Bob",
+        )
+
+        engine2 = GameEngine(seed=42)
+        result2 = engine2.run_game(
+            deck_a=[c.clone() for c in deck_a],
+            deck_b=[c.clone() for c in deck_b],
+            player_a_name="Alice",
+            player_b_name="Bob",
+        )
+
+        assert result1.winner_seat == result2.winner_seat
+        assert result1.turns == result2.turns
+
+    def test_to_dict_serializable(self):
+        """Game result must serialize to a dict with expected keys."""
+        import json
+        engine = GameEngine(seed=77)
+        deck = _make_deck(seed=3)
+        result = engine.run_game(
+            deck_a=[c.clone() for c in deck],
+            deck_b=[c.clone() for c in deck],
+            player_a_name="A",
+            player_b_name="B",
+        )
+        d = result.to_dict()
+        assert "winner" in d
+        assert "turns" in d
+        assert "playerResults" in d
+        # Ensure it's JSON-serializable
+        json.dumps(d)

tests/sim/test_models.py

@@ -0,0 +1,214 @@
+"""Tests for commander_ai_lab.sim.models."""
+import pytest
+from commander_ai_lab.sim.models import (
+    Card, Player, PlayerStats, PlayerResult, GameResult, SimState
+)
+
+
+# ── Card ────────────────────────────────────────────────────
+
+class TestCardGetPower:
+    def test_from_power_field(self):
+        c = Card(name="Test", power="3", toughness="2", pt="3/2")
+        assert c.get_power() == 3
+
+    def test_from_pt_field(self):
+        c = Card(name="Test", pt="4/5")
+        assert c.get_power() == 4
+
+    def test_no_pt_returns_zero(self):
+        c = Card(name="Test")
+        assert c.get_power() == 0
+
+    def test_non_numeric_returns_zero(self):
+        c = Card(name="Test", power="*", pt="*/2")
+        assert c.get_power() == 0
+
+
+class TestCardGetToughness:
+    def test_from_toughness_field(self):
+        c = Card(name="Test", power="2", toughness="5", pt="2/5")
+        assert c.get_toughness() == 5
+
+    def test_from_pt_field(self):
+        c = Card(name="Test", pt="2/7")
+        assert c.get_toughness() == 7
+
+    def test_no_pt_returns_zero(self):
+        c = Card(name="Test")
+        assert c.get_toughness() == 0
+
+
+class TestCardHasKeyword:
+    def test_in_keywords_list(self):
+        c = Card(name="Test", keywords=["Flying", "Haste"])
+        assert c.has_keyword("flying") is True
+        assert c.has_keyword("haste") is True
+
+    def test_in_oracle_text(self):
+        c = Card(name="Test", oracle_text="This creature has flying and deathtouch.")
+        assert c.has_keyword("flying") is True
+        assert c.has_keyword("deathtouch") is True
+
+    def test_missing_keyword(self):
+        c = Card(name="Test", oracle_text="Draw a card.", keywords=[])
+        assert c.has_keyword("flying") is False
+
+    def test_case_insensitive(self):
+        c = Card(name="Test", keywords=["FLYING"])
+        assert c.has_keyword("Flying") is True
+
+
+class TestCardIsLand:
+    def test_basic_land(self):
+        c = Card(name="Forest", type_line="Basic Land — Forest")
+        assert c.is_land() is True
+
+    def test_nonbasic_land(self):
+        c = Card(name="Command Tower", type_line="Land")
+        assert c.is_land() is True
+
+    def test_creature_not_land(self):
+        c = Card(name="Grizzly Bears", type_line="Creature — Bear")
+        assert c.is_land() is False
+
+    def test_no_type_line(self):
+        c = Card(name="Unknown")
+        assert c.is_land() is False
+
+
+class TestCardIsCreature:
+    def test_creature(self):
+        c = Card(name="Grizzly Bears", type_line="Creature — Bear")
+        assert c.is_creature() is True
+
+    def test_legendary_creature(self):
+        c = Card(name="Korvold", type_line="Legendary Creature — Dragon Noble")
+        assert c.is_creature() is True
+
+    def test_instant_not_creature(self):
+        c = Card(name="Murder", type_line="Instant")
+        assert c.is_creature() is False
+
+    def test_land_not_creature(self):
+        c = Card(name="Forest", type_line="Basic Land — Forest")
+        assert c.is_creature() is False
+
+
+class TestCardClone:
+    def test_clone_is_equal(self, basic_creature):
+        clone = basic_creature.clone()
+        assert clone.name == basic_creature.name
+        assert clone.cmc == basic_creature.cmc
+
+    def test_clone_is_independent(self, basic_creature):
+        clone = basic_creature.clone()
+        clone.name = "Changed"
+        assert basic_creature.name == "Grizzly Bears"
+
+
+# ── PlayerStats ─────────────────────────────────────────────
+
+class TestPlayerStats:
+    def test_to_dict_keys(self):
+        stats = PlayerStats(cards_drawn=7, damage_dealt=10)
+        d = stats.to_dict()
+        assert "cardsDrawn" in d
+        assert "damageDealt" in d
+        assert d["cardsDrawn"] == 7
+        assert d["damageDealt"] == 10
+
+    def test_default_values(self):
+        stats = PlayerStats()
+        assert stats.cards_drawn == 7
+        assert stats.lands_played == 0
+
+
+# ── PlayerResult & GameResult ────────────────────────────────
+
+class TestPlayerResult:
+    def test_to_dict_winner(self):
+        pr = PlayerResult(seat_index=0, name="Alice", life=40, finish_position=1)
+        d = pr.to_dict()
+        assert d["isWinner"] is True
+        assert d["seatIndex"] == 0
+        assert d["name"] == "Alice"
+
+    def test_to_dict_loser(self):
+        pr = PlayerResult(seat_index=1, name="Bob", life=0, eliminated=True, finish_position=2)
+        d = pr.to_dict()
+        assert d["isWinner"] is False
+        assert d["eliminated"] is True
+
+
+class TestGameResult:
+    def _make_result(self):
+        p0 = PlayerResult(seat_index=0, name="Alice", life=35, finish_position=1, stats=PlayerStats(damage_dealt=20))
+        p1 = PlayerResult(seat_index=1, name="Bob", life=0, eliminated=True, finish_position=2, stats=PlayerStats())
+        return GameResult(winner_seat=0, turns=12, players=[p0, p1])
+
+    def test_winner_property(self):
+        gr = self._make_result()
+        assert gr.winner == 0
+
+    def test_player_a_name(self):
+        gr = self._make_result()
+        assert gr.player_a_name == "Alice"
+
+    def test_player_b_name(self):
+        gr = self._make_result()
+        assert gr.player_b_name == "Bob"
+
+    def test_player_a_eliminated(self):
+        gr = self._make_result()
+        assert gr.player_a_eliminated is False
+
+    def test_player_b_eliminated(self):
+        gr = self._make_result()
+        assert gr.player_b_eliminated is True
+
+    def test_to_dict_has_legacy_keys(self):
+        gr = self._make_result()
+        d = gr.to_dict()
+        assert "winner" in d
+        assert "turns" in d
+        assert "playerResults" in d
+        assert len(d["playerResults"]) == 2
+
+
+# ── SimState ─────────────────────────────────────────────────
+
+class TestSimState:
+    def test_init_battlefields(self):
+        state = SimState()
+        state.init_battlefields(4)
+        assert len(state.battlefields) == 4
+
+    def test_add_and_get_battlefield(self):
+        state = SimState()
+        c = Card(name="Test", id=1)
+        state.add_to_battlefield(0, c)
+        bf = state.get_battlefield(0)
+        assert len(bf) == 1
+        assert bf[0].name == "Test"
+
+    def test_remove_from_battlefield(self):
+        state = SimState()
+        c = Card(name="Test", id=42)
+        state.add_to_battlefield(0, c)
+        removed = state.remove_from_battlefield(42)
+        assert removed is not None
+        assert removed.name == "Test"
+        assert len(state.get_battlefield(0)) == 0
+
+    def test_remove_nonexistent_returns_none(self):
+        state = SimState()
+        assert state.remove_from_battlefield(999) is None
+
+    def test_all_battlefield_cards(self):
+        state = SimState()
+        state.add_to_battlefield(0, Card(name="A", id=1))
+        state.add_to_battlefield(1, Card(name="B", id=2))
+        state.add_to_battlefield(1, Card(name="C", id=3))
+        all_cards = state.all_battlefield_cards()
+        assert len(all_cards) == 3

tests/sim/test_rules.py

@@ -0,0 +1,189 @@
+"""Tests for commander_ai_lab.sim.rules."""
+import pytest
+from commander_ai_lab.sim.models import Card
+from commander_ai_lab.sim.rules import enrich_card, score_card, parse_decklist, AI_DEFAULT_WEIGHTS
+
+
+# ── enrich_card ──────────────────────────────────────────────
+
+class TestEnrichCardBasicLands:
+    @pytest.mark.parametrize("name,expected_color", [
+        ("Forest", "G"),
+        ("Island", "U"),
+        ("Plains", "W"),
+        ("Swamp", "B"),
+        ("Mountain", "R"),
+    ])
+    def test_basic_land_color(self, name, expected_color):
+        c = Card(name=name)
+        enrich_card(c)
+        assert c.is_land() is True
+        assert expected_color in c.oracle_text
+        assert c.cmc == 0
+
+
+class TestEnrichCardKnownCards:
+    def test_sol_ring(self):
+        c = Card(name="Sol Ring")
+        enrich_card(c)
+        assert c.is_ramp is True
+        assert c.cmc == 1
+
+    def test_murder(self):
+        c = Card(name="Murder")
+        enrich_card(c)
+        assert c.is_removal is True
+        assert c.cmc == 3
+
+    def test_wrath_of_god(self):
+        c = Card(name="Wrath of God")
+        enrich_card(c)
+        assert c.is_board_wipe is True
+
+    def test_cultivate(self):
+        c = Card(name="Cultivate")
+        enrich_card(c)
+        assert c.is_ramp is True
+        assert c.cmc == 3
+
+    def test_counterspell(self):
+        c = Card(name="Counterspell")
+        enrich_card(c)
+        assert c.is_removal is True
+
+
+class TestEnrichCardDeterministic:
+    def test_same_unknown_card_same_cmc(self):
+        """Unknown cards must get deterministic CMC (no random jitter)."""
+        c1 = Card(name="Unknown Foobar Card")
+        c2 = Card(name="Unknown Foobar Card")
+        enrich_card(c1)
+        enrich_card(c2)
+        assert c1.cmc == c2.cmc
+        assert c1.pt == c2.pt
+
+    def test_different_unknown_cards_may_differ(self):
+        c1 = Card(name="Aaaaa")
+        c2 = Card(name="Zzzzz")
+        enrich_card(c1)
+        enrich_card(c2)
+        # At minimum they are both valid creatures with cmc in [2,6]
+        assert 2 <= c1.cmc <= 6
+        assert 2 <= c2.cmc <= 6
+
+    def test_unknown_card_cmc_range(self):
+        for name in ["Alpha", "Beta", "Gamma", "Delta", "Epsilon"]:
+            c = Card(name=name)
+            enrich_card(c)
+            assert 2 <= c.cmc <= 6
+
+
+class TestEnrichCardPreservesExistingData:
+    def test_real_data_not_overwritten(self):
+        c = Card(name="Custom Card", type_line="Legendary Creature", cmc=7, pt="6/6")
+        enrich_card(c)
+        assert c.cmc == 7
+        assert c.pt == "6/6"
+
+
+class TestEnrichCardOracleFlags:
+    def test_removal_flag_from_oracle(self):
+        c = Card(name="Custom Removal", type_line="Instant", cmc=2,
+                 oracle_text="Destroy target creature.")
+        enrich_card(c)
+        assert c.is_removal is True
+
+    def test_board_wipe_flag_from_oracle(self):
+        c = Card(name="Custom Wipe", type_line="Sorcery", cmc=5,
+                 oracle_text="Destroy all creatures.")
+        enrich_card(c)
+        assert c.is_board_wipe is True
+
+    def test_ramp_flag_from_oracle(self):
+        c = Card(name="Custom Ramp", type_line="Sorcery", cmc=2,
+                 oracle_text="Search your library for a basic land and put it onto the battlefield.")
+        enrich_card(c)
+        assert c.is_ramp is True
+
+
+# ── score_card ───────────────────────────────────────────────
+
+class TestScoreCard:
+    def test_land_scores_lower_than_creature(self):
+        land = Card(name="Forest", type_line="Basic Land — Forest", cmc=0)
+        creature = Card(name="Grizzly Bears", type_line="Creature — Bear", cmc=2, pt="2/2")
+        enrich_card(land)
+        enrich_card(creature)
+        # Creature with pt bonus should score higher than a plain land
+        assert score_card(creature) > score_card(land)
+
+    def test_flying_bonus(self):
+        base = Card(name="Vanilla", type_line="Creature", cmc=3, pt="3/3")
+        flyer = Card(name="Flyer", type_line="Creature", cmc=3, pt="3/3",
+                     oracle_text="Flying", keywords=["Flying"])
+        assert score_card(flyer) > score_card(base)
+
+    def test_ramp_bonus(self):
+        ramp = Card(name="Sol Ring", type_line="Artifact", cmc=1, is_ramp=True)
+        plain = Card(name="Mox Nothing", type_line="Artifact", cmc=1)
+        assert score_card(ramp) > score_card(plain)
+
+    def test_removal_bonus(self):
+        removal = Card(name="Murder", type_line="Instant", cmc=3, is_removal=True,
+                       oracle_text="Destroy target creature.")
+        plain = Card(name="Shock", type_line="Instant", cmc=1)
+        assert score_card(removal) > score_card(plain)
+
+    def test_multiplayer_scales_flying(self):
+        flyer = Card(name="Flyer", type_line="Creature", cmc=3, pt="3/3",
+                     oracle_text="Flying", keywords=["Flying"])
+        score_1v1 = score_card(flyer, num_opponents=1)
+        score_4p = score_card(flyer, num_opponents=3)
+        assert score_4p > score_1v1
+
+    def test_defender_penalty(self):
+        defender = Card(name="Wall", type_line="Creature", cmc=2, pt="0/5",
+                        oracle_text="Defender", keywords=["Defender"])
+        vanilla = Card(name="Vanilla", type_line="Creature", cmc=2, pt="2/2")
+        assert score_card(defender) < score_card(vanilla)
+
+    def test_high_cmc_penalized(self):
+        cheap = Card(name="Cheap", type_line="Creature", cmc=1, pt="1/1")
+        expensive = Card(name="Expensive", type_line="Creature", cmc=8, pt="1/1")
+        assert score_card(cheap) > score_card(expensive)
+
+
+# ── parse_decklist ───────────────────────────────────────────
+
+class TestParseDecklist:
+    def test_numbered_entries(self):
+        text = "4 Lightning Bolt\n2 Counterspell\n1 Black Lotus"
+        cards = parse_decklist(text)
+        assert len(cards) == 7
+        assert cards[0].name == "Lightning Bolt"
+
+    def test_unnumbered_entries(self):
+        cards = parse_decklist("Lightning Bolt")
+        assert len(cards) == 1
+        assert cards[0].name == "Lightning Bolt"
+
+    def test_skips_comments(self):
+        text = "// This is a comment\n1 Sol Ring\n# Also a comment\n1 Forest"
+        cards = parse_decklist(text)
+        assert len(cards) == 2
+
+    def test_skips_blank_lines(self):
+        cards = parse_decklist("1 Sol Ring\n\n\n1 Forest")
+        assert len(cards) == 2
+
+    def test_returns_card_objects(self):
+        cards = parse_decklist("1 Sol Ring")
+        from commander_ai_lab.sim.models import Card
+        assert isinstance(cards[0], Card)
+
+    def test_empty_input(self):
+        assert parse_decklist("") == []
+
+    def test_multi_word_card_names(self):
+        cards = parse_decklist("1 Kodama's Reach")
+        assert cards[0].name == "Kodama's Reach"

ui/ai-lab.css

@@ -617,7 +617,7 @@
 
 .lab-deck-grid {
     display: grid;
-    grid-template-columns: repeat(3, 1fr);
+    grid-template-columns: repeat(4, 1fr);
     gap: var(--sp-3);
     margin-bottom: var(--sp-5);
 }
@@ -887,7 +887,7 @@
 
 .lab-stats-cards {
     display: grid;
-    grid-template-columns: repeat(3, 1fr);
+    grid-template-columns: repeat(4, 1fr);
     gap: var(--sp-3);
     margin-bottom: var(--sp-4);
 }
@@ -972,6 +972,7 @@
 .seat-0-color { background: var(--accent); }
 .seat-1-color { background: var(--error); }
 .seat-2-color { background: var(--success); }
+.seat-3-color { background: #d29922; }
 
 /* ── Win Condition Breakdown ───────────────────────────── */
 
@@ -1172,7 +1173,7 @@
 
 .lab-combat-grid {
     display: grid;
-    grid-template-columns: repeat(3, 1fr);
+    grid-template-columns: repeat(4, 1fr);
     gap: var(--sp-4);
 }
 
@@ -1456,6 +1457,16 @@
 
 /* ── Responsive ────────────────────────────────────────── */
 
+
+@media (max-width: 900px) {
+    .lab-deck-grid {
+        grid-template-columns: repeat(2, 1fr);
+    }
+    .lab-combat-grid {
+        grid-template-columns: repeat(2, 1fr);
+    }
+}
+
 @media (max-width: 768px) {
     .lab-deck-grid,
     .lab-stats-cards {
@@ -1488,321 +1499,59 @@
         width: 95%;
         padding: var(--sp-4);
     }
-    .lab-combat-grid {
-        grid-template-columns: 1fr;
-    }
     .lab-charts-grid {
         grid-template-columns: 1fr;
     }
+    .lab-combat-grid {
+        grid-template-columns: 1fr;
+    }
+    .lab-h2h-table th,
+    .lab-h2h-table td {
+        padding: var(--sp-2);
+        font-size: 11px;
+    }
 }
 
-/* ═══════════════════════════════════════════════════════════
-   Precon Decks — Grid + Cards
-   ═══════════════════════════════════════════════════════════ */
+/* ── Seat Color Overrides ──────────────────────────────── */
 
-.lab-precon-btn {
-    background: linear-gradient(135deg, var(--surface-0), var(--surface-2)) !important;
-    border-color: var(--border) !important;
+.lab-deck-slot[data-seat="0"] {
+    --seat-accent: var(--accent);
 }
 
-.lab-precon-btn:hover {
-    background: linear-gradient(135deg, var(--surface-2), var(--surface-3)) !important;
-    border-color: var(--error) !important;
-}
-
-.lab-precon-controls {
-    display: flex;
-    gap: var(--sp-3);
-    padding: 0 var(--sp-5) var(--sp-3);
-    align-items: center;
-}
-
-.lab-precon-controls input {
-    flex: 1;
-    background: var(--surface-0);
-    border: 1px solid var(--border);
-    color: var(--text);
-    padding: var(--sp-2) var(--sp-3);
-    border-radius: var(--radius-sm);
-    font-size: 14px;
-}
-
-.lab-precon-controls input:focus {
-    outline: none;
-    border-color: var(--error);
-}
-
-.lab-precon-install-all-btn {
-    background: var(--surface-3);
-    color: var(--text);
-    border: 1px solid var(--border);
-    padding: var(--sp-2) var(--sp-4);
-    border-radius: var(--radius-sm);
-    cursor: pointer;
-    font-size: 13px;
-    white-space: nowrap;
-    transition: all var(--duration) var(--ease);
-}
-
-.lab-precon-install-all-btn:hover {
-    background: var(--surface-hover);
-    border-color: var(--error);
-}
-
-.lab-precon-grid {
-    display: grid;
-    grid-template-columns: repeat(auto-fill, minmax(220px, 1fr));
-    gap: var(--sp-3);
-    padding: 0 var(--sp-5) var(--sp-5);
-    max-height: 55vh;
-    overflow-y: auto;
-}
-
-.lab-precon-card {
-    background: var(--surface-0);
-    border: 1px solid var(--border);
-    border-radius: var(--radius-md);
-    padding: var(--sp-4);
-    cursor: pointer;
-    transition: all 0.2s var(--ease);
-    display: flex;
-    flex-direction: column;
-    gap: 6px;
-    position: relative;
-}
-
-.lab-precon-card:hover {
-    border-color: var(--error);
-    transform: translateY(-2px);
-    box-shadow: 0 4px 16px var(--error-dim);
-}
-
-.lab-precon-card-installed {
-    border-color: var(--success);
-    opacity: 0.8;
-}
-
-.lab-precon-card-installed .lab-precon-install-btn {
-    background: var(--success);
-    border-color: var(--success);
-    cursor: default;
-}
-
-.precon-card-colors {
-    display: flex;
-    gap: 4px;
-    margin-bottom: 2px;
-}
-
-.precon-card-name {
-    font-size: 15px;
-    font-weight: 600;
-    color: var(--text);
-    line-height: 1.2;
-}
-
-.precon-card-commander {
-    font-size: 12px;
-    color: var(--error);
-    font-style: italic;
-}
-
-.precon-card-set {
-    font-size: 11px;
-    color: var(--text-secondary);
-}
-
-.precon-card-theme {
-    font-size: 11px;
-    color: var(--text-tertiary);
-    line-height: 1.3;
-    margin-top: auto;
-}
-
-.lab-precon-install-btn {
-    margin-top: var(--sp-2);
-    width: 100%;
-    background: var(--surface-3);
-    color: var(--text);
-    border: 1px solid var(--border);
-    padding: 6px var(--sp-3);
-    border-radius: var(--radius-sm);
-    cursor: pointer;
-    font-size: 12px;
-    transition: all var(--duration) var(--ease);
-}
-
-.lab-precon-install-btn:hover {
-    background: var(--surface-hover);
-    border-color: var(--error);
-}
-
-.badge-precon {
-    background: var(--surface-3);
-    border-color: var(--border);
-}
-
-/* ══════════════════════════════════════════════════════════════
-   v5: Analytics & Trends Panels
-   ══════════════════════════════════════════════════════════════ */
-
-.lab-empty-hint {
-    color: var(--text-tertiary);
-    font-size: 13px;
-    padding: var(--sp-4) 0;
-    text-align: center;
-}
-
-.lab-loading-hint {
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    gap: var(--sp-3);
-    color: var(--text-secondary);
-    font-size: 13px;
-    padding: var(--sp-6) 0;
-}
-
-/* Analytics Grid */
-.lab-analytics-grid {
-    display: grid;
-    grid-template-columns: repeat(auto-fill, minmax(280px, 1fr));
-    gap: var(--sp-4);
-    padding: var(--sp-2) 0;
-}
-
-.lab-analytics-card {
-    background: var(--surface-0);
-    border: 1px solid var(--border);
-    border-radius: var(--radius-md);
-    padding: var(--sp-4);
-}
-
-.lab-analytics-card:hover {
-    border-color: var(--border-focus);
-}
-
-.lab-analytics-error {
-    opacity: 0.6;
-}
-
-.lab-analytics-name {
-    font-weight: 700;
-    color: #fff;
-    font-size: 15px;
-    margin-bottom: var(--sp-1);
-}
-
-.lab-analytics-commander {
-    font-size: 12px;
-    color: var(--text-secondary);
-    margin-bottom: var(--sp-3);
-}
-
-.lab-analytics-err-msg {
-    color: var(--error);
-    font-size: 12px;
-}
-
-.lab-analytics-stat {
-    display: flex;
-    justify-content: space-between;
-    padding: var(--sp-1) 0;
-    border-bottom: 1px solid var(--border-subtle);
-    font-size: 13px;
-}
-
-.lab-analytics-label {
-    color: var(--text-secondary);
-}
-
-.lab-analytics-value {
-    color: var(--text);
-    font-weight: 600;
-    font-variant-numeric: tabular-nums;
-}
-
-.lab-analytics-sections {
-    display: flex;
-    flex-wrap: wrap;
-    gap: var(--sp-1);
-    margin-top: var(--sp-3);
-}
-
-.lab-analytics-section-pill {
-    background: var(--surface-2);
-    border: 1px solid var(--border);
-    border-radius: var(--radius-xl);
-    padding: 2px var(--sp-2);
-    font-size: 11px;
-    color: var(--text-secondary);
-}
-
-/* Trends */
-.lab-trends-summary {
-    display: grid;
-    grid-template-columns: repeat(auto-fill, minmax(260px, 1fr));
-    gap: var(--sp-4);
-    padding: var(--sp-2) 0;
-}
-
-.lab-trends-card {
-    background: var(--surface-0);
-    border: 1px solid var(--border);
-    border-radius: var(--radius-md);
-    padding: var(--sp-4);
-}
-
-.lab-trends-card:hover {
-    border-color: var(--border-focus);
-}
-
-.lab-trends-deck-name {
-    font-weight: 700;
-    color: #fff;
-    font-size: 14px;
-    margin-bottom: var(--sp-3);
-}
-
-.lab-trends-stats {
-    display: grid;
-    grid-template-columns: 1fr 1fr;
-    gap: var(--sp-2);
-}
-
-.lab-trends-stat {
-    display: flex;
-    flex-direction: column;
-    gap: 2px;
-}
-
-.lab-trends-stat-label {
-    font-size: 11px;
-    color: var(--text-tertiary);
-    text-transform: uppercase;
-    letter-spacing: 0.5px;
-}
-
-.lab-trends-stat-value {
-    font-size: 16px;
-    font-weight: 700;
-    color: var(--text);
-    font-variant-numeric: tabular-nums;
-}
-
-/* Precon Refresh Button */
-.lab-precon-refresh-btn {
-    background: var(--surface-2);
-    border: 1px solid var(--border);
-    color: var(--text-secondary);
-    padding: 6px 14px;
-    border-radius: 6px;
-    cursor: pointer;
-    font-size: 13px;
-    transition: all 180ms ease;
-}
-
-.lab-precon-refresh-btn:hover {
+.lab-deck-slot[data-seat="0"].filled {
     border-color: var(--accent);
-    color: var(--accent);
+    box-shadow: 0 0 8px var(--accent-glow);
 }
+
+.lab-deck-slot[data-seat="1"] {
+    --seat-accent: var(--error);
+}
+
+.lab-deck-slot[data-seat="1"].filled {
+    border-color: var(--error);
+    box-shadow: 0 0 8px var(--error-glow, rgba(248, 81, 73, 0.25));
+}
+
+.lab-deck-slot[data-seat="2"] {
+    --seat-accent: var(--success);
+}
+
+.lab-deck-slot[data-seat="2"].filled {
+    border-color: var(--success);
+    box-shadow: 0 0 8px var(--success-glow, rgba(63, 185, 80, 0.25));
+}
+
+.lab-deck-slot[data-seat="3"] {
+    --seat-accent: #d29922;
+}
+
+.lab-deck-slot[data-seat="3"].filled {
+    border-color: #d29922;
+    box-shadow: 0 0 8px rgba(210, 153, 34, 0.25);
+}
+
+/* Seat label coloring */
+.lab-deck-slot[data-seat="0"] .seat-label { color: var(--accent); }
+.lab-deck-slot[data-seat="1"] .seat-label { color: var(--error); }
+.lab-deck-slot[data-seat="2"] .seat-label { color: var(--success); }
+.lab-deck-slot[data-seat="3"] .seat-label { color: #d29922; }

ui/coach.js

@@ -208,7 +208,8 @@
         try {
             const res = await fetch(API + '/api/coach/decks');
             const data = await res.json();
-            const decks = data.decks || [];
+            // Backend returns a bare array of objects, not {decks: [...]}
+            const decks = Array.isArray(data) ? data : (data.decks || []);
 
             while (deckSelect.options.length > 1) {
                 deckSelect.remove(1);
@@ -217,16 +218,30 @@
             if (decks.length === 0) {
                 const opt = document.createElement('option');
                 opt.disabled = true;
-                opt.textContent = 'No deck reports available \u2014 run simulations first';
+                opt.textContent = 'No decks found \u2014 add decks in Deck Builder first';
                 deckSelect.appendChild(opt);
                 return;
             }
 
-            decks.sort();
-            for (const deckId of decks) {
+            // Sort by deck name
+            decks.sort((a, b) => {
+                const na = (typeof a === 'string' ? a : a.deck_name || '').toLowerCase();
+                const nb = (typeof b === 'string' ? b : b.deck_name || '').toLowerCase();
+                return na.localeCompare(nb);
+            });
+
+            for (const deck of decks) {
                 const opt = document.createElement('option');
-                opt.value = deckId;
-                opt.textContent = deckId;
+                if (typeof deck === 'string') {
+                    // Legacy: bare string ID
+                    opt.value = deck;
+                    opt.textContent = deck;
+                } else {
+                    // Object format: {deck_id, deck_name, commander, has_report, ...}
+                    const slug = deck.deck_name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/(^-|-$)/g, '');
+                    opt.value = slug;
+                    opt.textContent = deck.deck_name + (deck.commander ? ' (' + deck.commander + ')' : '');
+                }
                 deckSelect.appendChild(opt);
             }
         } catch (e) {

ui/collection.css

@@ -746,15 +746,18 @@
 .coll-th-sortable {
     cursor: pointer;
     user-select: none;
-    transition: color 0.15s;
+    transition: color 0.15s, background 0.15s;
+    position: relative;
 }
 
 .coll-th-sortable:hover {
     color: var(--accent);
+    background: rgba(255,255,255,0.06);
 }
 
 .coll-th-active {
     color: var(--accent);
+    background: rgba(255,255,255,0.04);
 }
 
 .coll-table td,
@@ -2738,6 +2741,69 @@
 
 /* ── 15. Animations ──────────────────────────────────────── */
 
+/* ── Sort Bar ─────────────────────────────────────────── */
+
+.coll-sort-bar {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    padding: 8px 14px;
+    margin-bottom: 8px;
+    background: var(--card-bg, #1e1e2e);
+    border: 1px solid var(--border, #2a2a3a);
+    border-radius: 8px;
+    font-size: 13px;
+    color: var(--text-secondary, #999);
+}
+
+.coll-sort-bar-label {
+    font-weight: 600;
+    color: var(--text-secondary, #999);
+    white-space: nowrap;
+}
+
+.coll-sort-select {
+    background: var(--bg, #121220);
+    color: var(--text, #e0e0e0);
+    border: 1px solid var(--border, #2a2a3a);
+    border-radius: 6px;
+    padding: 5px 10px;
+    font-size: 13px;
+    cursor: pointer;
+    transition: border-color 0.15s;
+}
+
+.coll-sort-select:hover,
+.coll-sort-select:focus {
+    border-color: var(--accent, #6c63ff);
+    outline: none;
+}
+
+.coll-sort-dir-btn {
+    background: var(--bg, #121220);
+    color: var(--text, #e0e0e0);
+    border: 1px solid var(--border, #2a2a3a);
+    border-radius: 6px;
+    padding: 5px 12px;
+    font-size: 13px;
+    cursor: pointer;
+    font-weight: 600;
+    transition: border-color 0.15s, background 0.15s;
+    white-space: nowrap;
+}
+
+.coll-sort-dir-btn:hover {
+    border-color: var(--accent, #6c63ff);
+    background: rgba(108, 99, 255, 0.1);
+}
+
+.coll-sort-bar-count {
+    margin-left: auto;
+    font-weight: 500;
+    color: var(--text-secondary, #999);
+    white-space: nowrap;
+}
+
 @keyframes coll-fade-in {
     from { opacity: 0; }
     to   { opacity: 1; }

ui/collection.js

@@ -352,6 +352,7 @@ const Collection = (() => {
             showLoading(false);
         }
         renderTable();
+        renderSortBar();
         renderPagination();
         renderCountBadge();
     }
@@ -450,6 +451,7 @@ const Collection = (() => {
 
                 <!-- Table Area -->
                 <div class="coll-table-wrap">
+                    ${renderSortBarHtml()}
                     <div class="coll-table-container">
                         <table class="coll-table" id="coll-table">
                             ${renderTableHeaderHtml()}
@@ -491,6 +493,59 @@ const Collection = (() => {
         renderPagination();
     }
 
+    // ── Sort Bar HTML ───────────────────────────────────────
+
+    function renderSortBarHtml() {
+        const sortOptions = [
+            { value: 'name',       label: 'Name' },
+            { value: 'tcg_price',  label: 'Price' },
+            { value: 'cmc',        label: 'CMC / Mana Value' },
+            { value: 'quantity',   label: 'Quantity' },
+            { value: 'type_line',  label: 'Type' },
+            { value: 'rarity',     label: 'Rarity' },
+            { value: 'edhrec_rank',label: 'EDHREC Rank' },
+            { value: 'salt_score', label: 'Salt Score' },
+            { value: 'set_code',   label: 'Set' },
+            { value: 'finish',     label: 'Finish' },
+        ];
+        const opts = sortOptions.map(o =>
+            `<option value="${o.value}" ${state.sortField === o.value ? 'selected' : ''}>${o.label}</option>`
+        ).join('');
+        const dirLabel = state.sortDir === 'asc' ? '▲ Asc' : '▼ Desc';
+        return `
+        <div class="coll-sort-bar">
+            <span class="coll-sort-bar-label">Sort by</span>
+            <select class="coll-sort-select" id="coll-sort-select" onchange="Collection.setSortFromBar(this.value)">
+                ${opts}
+            </select>
+            <button class="coll-sort-dir-btn" id="coll-sort-dir-btn" onclick="Collection.toggleSortDir()" title="Toggle sort direction">${dirLabel}</button>
+            <span class="coll-sort-bar-count" id="coll-sort-bar-count">${state.total.toLocaleString()} cards</span>
+        </div>`;
+    }
+
+    function renderSortBar() {
+        const bar = document.querySelector('.coll-sort-bar');
+        if (bar) {
+            bar.outerHTML = renderSortBarHtml();
+        }
+    }
+
+    function setSortFromBar(field) {
+        state.sortField = field;
+        state.page = 1;
+        savePreferences();
+        pushUrlState();
+        fetchCollection();
+    }
+
+    function toggleSortDir() {
+        state.sortDir = state.sortDir === 'asc' ? 'desc' : 'asc';
+        state.page = 1;
+        savePreferences();
+        pushUrlState();
+        fetchCollection();
+    }
+
     // ── Filter Panel HTML ───────────────────────────────────
 
     function renderFiltersHtml() {
@@ -724,7 +779,7 @@ const Collection = (() => {
         { key: 'cmc',           label: 'CMC',       sortable: true },
         { key: 'power_toughness',label: 'P/T',      sortable: false },
         { key: 'rarity',        label: 'Rarity',    sortable: true },
-        { key: 'set_name',      label: 'Set',       sortable: true },
+        { key: 'set_code',      label: 'Set',       sortable: true },
         { key: 'tcg_price',     label: 'Price',     sortable: true },
         { key: 'edhrec_rank',   label: 'EDHREC',    sortable: true },
         { key: 'salt_score',    label: 'Salt',      sortable: true },
@@ -2729,6 +2784,8 @@ const Collection = (() => {
         resetFilters,
         // Sort / page
         setSort,
+        setSortFromBar,
+        toggleSortDir,
         setPage,
         setPageSize,
         // Category inline

ui/deckgenerator.css

@@ -1152,6 +1152,19 @@
     font-size: 0.85rem;
 }
 
+.dg-card-count {
+    display: inline-block;
+    background: var(--accent, #6c63ff);
+    color: #fff;
+    border-radius: 4px;
+    padding: 1px 5px;
+    font-size: 0.7rem;
+    font-weight: 700;
+    margin-right: 2px;
+    min-width: 20px;
+    text-align: center;
+}
+
 .dg-card-row-roles {
     display: flex;
     gap: 3px;

ui/deckgenerator.js

@@ -406,7 +406,7 @@ const DeckGenerator = (() => {
             html += '<div class="dg-card-group">'
                 + '<div class="dg-group-header" data-type="' + type + '">'
                 + '<span class="dg-group-title">' + icon + ' ' + escHtml(type) + '</span>'
-                + '<span class="dg-group-count">' + groupCards.length + '</span>'
+                + '<span class="dg-group-count">' + groupCards.reduce(function(s,c){ return s + (c.count || 1); }, 0) + '</span>'
                 + '</div>'
                 + '<div class="dg-group-body" data-group="' + type + '">';
 
@@ -462,7 +462,7 @@ const DeckGenerator = (() => {
 
         return '<div class="dg-card-row dg-card-status-' + card.status + '">'
             + '<div class="dg-card-row-main">'
-            + '<span class="dg-card-row-name">' + escHtml(card.name) + '</span>'
+            + '<span class="dg-card-row-name">' + ((card.count || 1) > 1 ? '<span class="dg-card-count">' + card.count + 'x</span> ' : '') + escHtml(card.name) + '</span>'
             + '<span class="dg-card-row-roles">' + roleTags + '</span>'
             + statusBadge
             + price

ui/global.css

@@ -727,3 +727,140 @@ table { border-collapse: collapse; width: 100%; }
         grid-template-columns: 1fr;
     }
 }
+
+/* ═══════════════════════════════════════════════════════════
+   PREMIUM UPGRADE LAYER
+   ═══════════════════════════════════════════════════════════ */
+
+/* ── Ambient background glow (body) ─────────────────────── */
+body {
+    background-image:
+        radial-gradient(ellipse 80% 50% at 10% -10%, rgba(91,158,240,0.07) 0%, transparent 60%),
+        radial-gradient(ellipse 60% 40% at 90% 110%, rgba(167,139,250,0.05) 0%, transparent 60%);
+    background-attachment: fixed;
+}
+
+/* ── Page title: subtle gradient text ───────────────────── */
+.page-header h1 {
+    background: linear-gradient(135deg, #fff 60%, rgba(91,158,240,0.85) 100%);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    background-clip: text;
+}
+
+/* ── Nav: stronger glass + accent underline ─────────────── */
+.nav {
+    background: rgba(9,11,16,0.80);
+    backdrop-filter: blur(20px) saturate(1.8);
+    -webkit-backdrop-filter: blur(20px) saturate(1.8);
+    box-shadow: 0 1px 0 rgba(91,158,240,0.08), 0 4px 24px rgba(0,0,0,0.3);
+    border-bottom-color: rgba(255,255,255,0.06);
+}
+.nav-brand svg { filter: drop-shadow(0 0 8px rgba(91,158,240,0.4)); }
+.nav-links a.active { box-shadow: inset 0 0 0 1px rgba(91,158,240,0.2); }
+
+/* ── Panels: gradient border on hover ───────────────────── */
+.panel {
+    position: relative;
+    transition: border-color var(--duration) var(--ease),
+                box-shadow var(--duration) var(--ease);
+}
+.panel::before {
+    content: '';
+    position: absolute;
+    inset: 0;
+    border-radius: var(--radius-lg);
+    padding: 1px;
+    background: linear-gradient(135deg, rgba(91,158,240,0.18), transparent 50%, rgba(167,139,250,0.1));
+    -webkit-mask: linear-gradient(#fff 0 0) content-box, linear-gradient(#fff 0 0);
+    -webkit-mask-composite: xor;
+    mask-composite: exclude;
+    pointer-events: none;
+    opacity: 0;
+    transition: opacity var(--duration) var(--ease);
+}
+.panel:hover::before { opacity: 1; }
+.panel:hover {
+    box-shadow: 0 8px 32px rgba(0,0,0,0.35), 0 0 0 1px rgba(91,158,240,0.08);
+}
+
+/* ── Stat cards: gradient surface + shimmer top edge ─────── */
+.stat-card {
+    position: relative;
+    background: linear-gradient(145deg, var(--surface-2), var(--surface-1));
+    overflow: hidden;
+}
+.stat-card::after {
+    content: '';
+    position: absolute;
+    top: 0; left: 0; right: 0;
+    height: 1px;
+    background: linear-gradient(90deg, transparent, rgba(255,255,255,0.12), transparent);
+    pointer-events: none;
+}
+.stat-card:hover {
+    box-shadow: var(--shadow-md), 0 0 20px rgba(91,158,240,0.08);
+    transform: translateY(-2px);
+}
+
+/* ── Buttons: gradient fills + inner highlight ───────────── */
+.btn { position: relative; overflow: hidden; }
+.btn::after {
+    content: '';
+    position: absolute;
+    top: 0; left: 0; right: 0;
+    height: 50%;
+    background: linear-gradient(to bottom, rgba(255,255,255,0.07), transparent);
+    border-radius: inherit;
+    pointer-events: none;
+}
+.btn-primary {
+    background: linear-gradient(135deg, var(--accent), #4a8de0);
+    box-shadow: 0 2px 8px rgba(91,158,240,0.25);
+}
+.btn-primary:hover {
+    background: linear-gradient(135deg, var(--accent-hover), var(--accent));
+    box-shadow: 0 4px 20px rgba(91,158,240,0.4);
+}
+.btn-success {
+    background: linear-gradient(135deg, var(--success), #38c46c);
+    box-shadow: 0 2px 8px rgba(74,222,128,0.2);
+}
+.btn-success:hover { box-shadow: 0 4px 20px rgba(74,222,128,0.4); transform: translateY(-1px); }
+.btn-purple {
+    background: linear-gradient(135deg, var(--purple), #9171f0);
+    box-shadow: 0 2px 8px rgba(167,139,250,0.2);
+}
+.btn-purple:hover { box-shadow: 0 4px 20px rgba(167,139,250,0.4); transform: translateY(-1px); }
+
+/* ── Tags: subtle colored border ────────────────────────── */
+.tag-blue   { border: 1px solid rgba(91,158,240,0.25); }
+.tag-green  { border: 1px solid rgba(74,222,128,0.25); }
+.tag-yellow { border: 1px solid rgba(251,191,36,0.25); }
+.tag-red    { border: 1px solid rgba(248,113,113,0.25); }
+.tag-purple { border: 1px solid rgba(167,139,250,0.25); }
+
+/* ── Progress fill: glow ─────────────────────────────────── */
+.progress-fill { box-shadow: 0 0 8px rgba(91,158,240,0.5); }
+
+/* ── Badge running: glow dot ─────────────────────────────── */
+.badge-running { box-shadow: 0 0 12px rgba(91,158,240,0.15); }
+.badge-running::before { box-shadow: 0 0 6px var(--accent); }
+
+/* ── Toast: glassmorphism + colored glow ─────────────────── */
+.toast { backdrop-filter: blur(12px); }
+.toast-success { box-shadow: var(--shadow-lg), 0 0 20px rgba(74,222,128,0.1); }
+.toast-error   { box-shadow: var(--shadow-lg), 0 0 20px rgba(248,113,113,0.1); }
+
+/* ── Divider: fade-out gradient ──────────────────────────── */
+.divider {
+    background: linear-gradient(90deg, transparent, var(--border), transparent);
+}
+
+/* ── Inputs: inset shadow for depth ─────────────────────── */
+.form-input, .form-select, .form-textarea {
+    box-shadow: inset 0 1px 3px rgba(0,0,0,0.25);
+}
+.form-input:focus, .form-select:focus, .form-textarea:focus {
+    box-shadow: 0 0 0 3px var(--accent-dim), inset 0 1px 3px rgba(0,0,0,0.1);
+}