coach: accept rules_context in build_user_prompt (every Coach request failed)

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_016Er49soaMyG7Yburq57PeB
farmhouse: sync Forge fixes (display, one deck folder, absolute result path) and phase model-seat safety (pre-validation, circuit-breaker, cost counters)
2026-10-26 23:01:48 -05:00 · 2026-10-26 22:32:14 -05:00 · 2026-10-26 20:20:10 -05:00 · 2026-10-26 19:50:51 -05:00 · 2026-10-26 19:39:01 -05:00 · 2026-10-26 18:48:20 -05:00
59 changed files with 4451 additions and 29 deletions
@@ -0,0 +1,93 @@
+# FarmHouse changes
+
+This branch (`farmhouse`) is `KoalaTrapLord/commander-ai-lab` at commit `54cc5e9` plus the changes below. They were made to run the app
+**Python-only** (no Forge/Java, no PyTorch) in a Kubernetes namespace, with a local LLM behind an OpenAI-compatible gateway instead of
+Anthropic/DeepSeek, and they were each found by actually running the app, not by reading it. Written 2026-10-26.
+
+Every change started life as an anchored text patch (`patch_app.py` in the farmhouse-os repo, which still builds the deployed image from
+the upstream commit); here they are ordinary source edits. Lines carry a `# FARMHOUSE_...` marker where the patch left one.
+
+## What was wrong, and what changed
+
+### The simulator played nothing (the big one)
+| Problem | Change |
+|---|---|
+| Every card reached the simulator with **no type line and no rules text**. The loaders join the user's *collection* and a *card_records* table (both empty on a fresh install) and the Forge card cache that was meant to fill the gap is not installed. A land was indistinguishable from a creature: an 8-game batch cast 0 spells, dealt 0 damage and lost every game. | `services/farmhouse_sim.py` `fill_card_data` fills type, text, mana cost, cmc, P/T, keywords and colour identity from the 113k-card Scryfall bulk database. Wired into `services/forge_runner.py` (batch) and `routes/deepseek.py` (`_fetch_deck_card_data`, which the Monte Carlo and single-deck routes use). |
+| The batch loader **did not repeat cards by quantity**: a 100-card deck loaded as 66-84 cards with *one* Island. | `expand_quantities` (same module). |
+| The LLM engine asked the model **once per turn** and applied the answer as one action. | `src/commander_ai_lab/sim/farmhouse_turns.py`: up to `BRAIN_STEPS` (default 4) questions per turn (land, spell, spell, attack), re-reading the board after each; stops on attack/hold/no change. `BRAIN_STEPS=1` restores the original. |
+| A model that "thinks" spent ~46 s on a one-line move. | `deepseek_brain.py` sends `reasoning_effort` from `LLM_REASONING` (46 s -> 1.8 s per move). |
+| The engine dropdown defaulted to **Forge**, which cannot run without Java. | `ui/ai-lab.js`: only "LLM opponents" is offered. |
+
+After the fixes: a 40-game Monte Carlo takes 0.4 s with real numbers (10 spells and 12.7 damage per game); two LLM-piloted games took
+212 s with 49 model calls and no fallbacks.
+
+### Deck import
+| Problem | Change |
+|---|---|
+| **Moxfield links were accepted nowhere**, and the Deck Builder import took only pasted text. | `services/farmhouse_deck_links.py`: Moxfield (public decks, `api2.moxfield.com`) and Archidekt links in the simulator URL import and in both Deck Builder imports (a lone link in the paste box). A private deck says to use Moxfield's Export > Copy as text. |
+| The Deck Builder import looked **every card up on scryfall.com**; after a few dozen it was rate-limited (HTTP 429) and the app reported the rest as "not found" (250-card deck: 55 matched; even plain `Sol Ring` failed). | `local_card()`: names resolve from the local bulk database first; the website is only the fallback. |
+
+### Deck generation
+- `deck_builder/pipeline/farmhouse_fit.py`: the model's list is **filtered to the commander's colour identity** (from the bulk DB), de-duplicated,
+  fitted to per-category targets and trimmed to 99 + commander. Before this the model returned off-colour cards and 359-card lists.
+- Scryfall bulk format changed (`jsonl_download_uri`, gzip JSONL; no `download_uri`).
+- Scryfall answers **HTTP 400 to the default `python-requests` User-Agent** (every lookup became "Commander not found"): a named UA is sent everywhere.
+- Scryfall 429s: requests back off on `Retry-After` and the pace is 0.25 s.
+- `LLM_REASONING` / `LLM_MAX_TOKENS` are sent by the deck builder and coach.
+
+### Coach / startup
+- The coach was only initialised in `main()`, not when the app starts under uvicorn; `check_connection_sync()` was called but never defined;
+  the coach used the first model the gateway listed rather than the configured one. All fixed.
+- Status label says "Language model" instead of the hardcoded "Claude Opus".
+- `RAG_AUTOBUILD` (default off in our deployment) controls whether the card-search index is built at startup (113k embeddings; about an hour).
+
+### Decision model (Laya / Kev), wired and off
+`src/commander_ai_lab/sim/farmhouse_decide.py` asks a `/v1/systemone` server which of the nine actions to take, in one forward pass.
+`DECISION_MODE=shadow` records whether it agrees with the LLM (the game still uses the LLM); `assist` uses it when `DECISION_MIN_CONF`
+sure; `off` (default) does nothing. `scripts/farmhouse_decision_eval.py` replays recorded decisions through it.
+
+**Measured 2026-10-26 on 149 recorded LLM decisions: zero-shot, both Laya checkpoints agreed with the LLM less often than always
+guessing the commonest action** (English 16.1%, typed-decisions 18.6%, baseline 27.5%), at 2-4 s per answer on a 4-thread CPU. It is only
+worth using after fine-tuning on this game's decisions; the write-up is `LAYA-EVALUATION.md` in the farmhouse-os repo's commander-lab folder.
+
+### Laya connections (all off by default)
+Forge's concrete priority path, extra typed questions in the same call, a capture log, a fine-tuning dataset exporter, and card-role classification:
+`src/commander_ai_lab/sim/farmhouse_laya.py`, `scripts/farmhouse_laya_dataset.py`, `scripts/farmhouse_laya_roles_eval.py`, tests `tests/farmhouse/test_farmhouse_laya*.py`.
+How it fits the strategic-intelligence work, what is measured and how to fine-tune: [docs/LAYA-CONNECTIONS.md](docs/LAYA-CONNECTIONS.md). Reference copies of the Laya
+image, manifests and CI are in `farmhouse/laya/`.
+
+### Forge, and rules-accurate simulation with phase-rs
+- **Forge is installed** in the cluster image (it was left out by mistake): `farmhouse/forge/README.md`. Batches are clamped to one game at a time (`FORGE_MAX_THREADS`).
+- **Rules-accurate simulation** through the phase-rs engine (Rust, headless): `routes/farmhouse_phase.py`, `ui/phase-sim.html` (linked from the home page) and the service in
+  `farmhouse/phase/`. Four saved decks play real Commander games; the page shows wins by seat with a 95% interval and warns about cards the engine did not recognise.
+  Seats can be put on a **model** (twin-turbo through Olla, or Laya): the model chooses among the engine's own legal options only, anything wrong or slow is played by phase's AI,
+  and a call cap bounds the cost (`farmhouse/phase/README.md`). Assessment and plan: `docs/PHASE-AND-PLAYTESTER.md`.
+
+## Settings (environment variables)
+| Variable | Meaning |
+|---|---|
+| `LLM_URL`, `LLM_MODEL` | OpenAI-compatible endpoint (`.../v1`) and model for the coach and deck builder |
+| `LLM_REASONING` (`none`), `LLM_MAX_TOKENS`, `LLM_TIMEOUT` | keep requests lean: reasoning off, cap on answer length |
+| `COACH_PROVIDER`, `DECK_GEN_PROVIDER` = `local`, `DECK_GEN_MODEL` | use the local model, not Anthropic |
+| `OLLAMA_BASE_URL`, `RAG_EMBEDDING_MODEL`, `RAG_AUTOBUILD` | card-search embeddings (one host only: vectors differ between hosts) |
+| `BRAIN_API_BASE` (**no** `/v1`; the client appends it), `BRAIN_MODEL`, `BRAIN_MAX_TOKENS`, `BRAIN_STEPS` | the simulator's LLM opponents |
+| `DECISION_URL`, `DECISION_MODEL`, `DECISION_MODE` (`off`/`shadow`/`assist`), `DECISION_MIN_CONF`, `DECISION_TIMEOUT` | the decision model above |
+| `ollama` Python package | required by the card-search index build (ChromaDB's Ollama embedder imports it) |
+
+## Tests
+`tests/farmhouse/` (standard library only, no network): `python -I -X utf8 tests/farmhouse/test_farmhouse_deck_links.py`, `..._sim.py`, `..._fit.py`.
+Run them with `-I` and from outside the package folders; do not put `services/` on `sys.path` (`services/logging.py` shadows the standard library).
+
+## Things still worth doing
+- **Make the LLM-opponent turns faster** (a piloted move averages ~7.5 s: about 2.2k tokens in, ~30 out, so reading the prompt dominates).
+  These are ideas, not measured; none is implemented:
+  - *Shared prefix:* about 1.2k tokens of every prompt (the system prompt) are identical each time; a llama.cpp server can reuse them
+    if the calls share the prefix, so only the board state is read each move.
+  - *Smaller prompt:* send a compact board state instead of the indented JSON the engine builds now (`json.dumps(snapshot, indent=2)`
+    in `deepseek_brain.py`).
+  - *Parallel games:* run several games at once, which would also fill the GPU while one game waits on a move. Caveat: for long prompts
+    two requests at once gave no extra throughput on a V100 (reading the prompt is compute-bound), so measure before relying on it.
+- Opponents are the engine's heuristics; only the piloted seat uses the model.
+- Build the card-search index and measure it.
+- The upstream `LICENSE` is missing (`pyproject.toml` says MIT). Ask the author to add one before publishing a derivative widely.
+- Forge-based features (the Java simulator, training) remain unavailable by design.
@@ -549,7 +549,7 @@ class CoachService:
                status.llmModels = []
                status.error = "Anthropic API key not configured. Set ANTHROPIC_API_KEY env var."
        else:
-            llm_status = self.llm.check_connection()
+            llm_status = self.llm.check_connection_sync()  # FARMHOUSE_COACH_STATUS_V1 (was an un-awaited coroutine)
            status.llmConnected = llm_status.get("connected", False)
            status.llmModel = llm_status.get("active_model")
            status.llmModels = llm_status.get("models", [])
@@ -74,7 +74,7 @@ class LLMClient:
        try:
            status = await self.check_connection()
            if status.get("connected") and status.get("active_model"):
-                self._resolved_model = status["active_model"]
+                self._resolved_model = self.model if self.model in (status.get("models") or []) else status["active_model"]  # FARMHOUSE_MODEL_PIN_V1
                logger.info("Resolved Ollama model: %s", self._resolved_model)
                return self._resolved_model
        except Exception:
@@ -103,6 +103,14 @@ class LLMClient:
        }
        if force_json:
            body["response_format"] = {"type": "json_object"}
+        # FARMHOUSE_LLM_KNOBS_V1 (see patch_app.py)
+        import os as _fh_os
+        _fh_effort = _fh_os.environ.get("LLM_REASONING", "").strip()
+        if _fh_effort:
+            body["reasoning_effort"] = _fh_effort
+        _fh_cap = int(_fh_os.environ.get("LLM_MAX_TOKENS", "0") or 0)
+        if _fh_cap:
+            body["max_tokens"] = min(body["max_tokens"], _fh_cap)
        return body

    # ── Response parsing ──────────────────────────────────────
@@ -260,6 +268,17 @@ class LLMClient:
            f"LLM call failed after {LLM_MAX_RETRIES} attempts: {last_error}"
        )

+    def check_connection_sync(self) -> dict:  # FARMHOUSE_LLM_SYNC_V1
+        """Blocking version of check_connection (upstream called it and never defined it)."""
+        try:
+            _r = httpx.get(f"{self.base_url}/models", timeout=5.0, headers={"Content-Type": "application/json"})
+            _r.raise_for_status()
+            _ids = [m.get("id", "unknown") for m in _r.json().get("data", [])]
+            return {"connected": True, "models": _ids,
+                    "active_model": self.model if self.model in _ids else (_ids[0] if _ids else self.model)}
+        except Exception as _e:
+            return {"connected": False, "error": str(_e), "models": [], "active_model": None}
+
    async def check_connection(self) -> dict:
        """Check if Ollama is reachable. Returns status dict."""
        try:
@@ -546,6 +546,21 @@ def build_quick_system_prompt(report: DeckReport,


 def build_user_prompt(report: DeckReport,
+                      candidates: Dict[str, List[dict]] = None,
+                      rag_cards: List[dict] = None,
+                      rules_context: List[dict] = None) -> str:  # FARMHOUSE_RULES_CONTEXT
+    text = _farmhouse_build_user_prompt(report, candidates, rag_cards)
+    rules = []
+    for item in (rules_context or [])[:3]:
+        body = (item.get('text') or item.get('document') or item.get('content')) if isinstance(item, dict) else str(item)
+        if body:
+            rules.append('- ' + str(body).strip()[:700])
+    if rules:
+        text += '\n\n## Relevant rules (for grounding; do not quote them back)\n' + '\n'.join(rules)
+    return text
+
+
+def _farmhouse_build_user_prompt(report: DeckReport,
                      candidates: Dict[str, List[dict]] = None,
                      rag_cards: List[dict] = None) -> str:
    """Build the user prompt with full deck report data.
@@ -0,0 +1,67 @@
+# Laya connections
+
+Laya (and Kev: same `POST /v1/systemone` API) is a **decision model**: typed multiple-choice, yes/no and score questions about a text, answered in
+one forward pass, no generated text. This page is where it plugs into the strategic-intelligence work in this repository
+([INTELLIGENCE-HANDOFF.md](INTELLIGENCE-HANDOFF.md)), what is measured, and how to make it worth using. Written 2026-10-26.
+
+**Short version.** Every connection below is built, tested offline and **off by default**. Zero-shot, Laya is a poor action chooser
+(below the always-guess baseline) but a reasonable card classifier (48% against 17% by chance); it is too slow on a CPU for Forge's
+priority path (8 s against a 1.5 s budget). The way forward is fine-tuning on the decisions these connections record.
+
+## What connects where
+
+| Connection | Code | Mode | Notes |
+|---|---|---|---|
+| Farmhouse macro choice: Laya picks among CSIE's candidate macros, reading the CSIE ranking and ITI objective in its text | `farmhouse_decide.py` (called from `deepseek_brain.py`) | `DECISION_MODE=shadow` records agreement with the LLM; `assist` uses a pick it is `DECISION_MIN_CONF` sure of | existing; only offered candidates are accepted |
+| **Forge concrete priority choice**: Laya picks among the same concrete candidate IDs Forge sent to `/api/policy/decide/concrete` | `farmhouse_laya.advise_concrete` / `attach_concrete`, called from `routes/policy.py` | `shadow`: adds `laya` to the response, selection unchanged. `assist`: may replace `selected_id`, never one Forge tagged `stops_immediate_win` / `wins_now`; the original is kept as `csie_selected_id` | candidate described by kind, card, cost, target, tags (never by its opaque id); Forge still executes only an ID it sent |
+| **Extra questions in the same call**: "how dangerous are the opponents' boards?" (none/low/moderate/high/lethal) and "is there a threat that must be answered?" | `farmhouse_laya._extra_questions` | whenever Laya is asked | one forward pass answers all questions, so they cost almost nothing; recorded as weak signals for the learned-threat work, **not used to decide** |
+| **Capture**: every call is appended to `data/decisions/laya-shadow-<date>.jsonl` (`laya-shadow-v1`) | `farmhouse_laya.capture` | shadow / assist | the text Laya read, the offered options, its answer and extras, and the other deciders' picks (`labels`: `llm`, `csie`, `selected`) |
+| **Fine-tuning data**: capture log -> `train.jsonl` / `valid.jsonl` / `manifest.json`, split by game, with the baselines to beat | `scripts/farmhouse_laya_dataset.py` | offline | the manifest reports commonest-action, CSIE-vs-teacher and Laya-zero-shot agreement on the validation side |
+| **Card role evidence**: removal, board wipe, ramp, card draw, counterspell, protection, tutor, creature, other, from Oracle text | `farmhouse_laya.classify_roles` (batched, cached, with `source: laya:<model>` provenance); `scripts/farmhouse_laya_roles_eval.py` measures it | on demand | evidence for ITI / Tagger-style use, never a rules fact |
+
+Not built (still the open items in the handoff, none of which Laya can substitute for): compiling and running the Forge controller, the bounded
+combo executor, the multi-turn planner, the calibrated learned-threat model. Laya's "threat" and "must answer" extras are only raw material for that last one.
+
+## Where the hooks are
+- `src/commander_ai_lab/sim/farmhouse_decide.py` (committed): the macro-choice client gained the extra questions, the state text/options in its
+  answer, and `record()` writes the capture line.
+- `routes/policy.py` (**working tree only, uncommitted**: the route itself is part of the pending strategic-evaluator work, so the hook was
+  left for that commit). It is one block in `decide_concrete`, after the result is computed:
+  `if _L.mode() != "off": advice = await run_in_threadpool(_L.advise_concrete, ...); result = _L.attach_concrete(...)`, guarded by `except ImportError`.
+- Everything else is new files: `farmhouse_laya.py`, the two scripts, `tests/farmhouse/test_farmhouse_laya*.py`, `farmhouse/laya/`.
+
+## Settings
+`DECISION_URL` (e.g. `http://laya.commander-lab.svc.cluster.local:8080`), `DECISION_MODE` (`off` default / `shadow` / `assist`), `DECISION_MODEL`
+(a checkpoint such as `typed-decisions`), `DECISION_MIN_CONF` (0.7), `DECISION_TIMEOUT` (5 s), `DECISION_TIMEOUT_FORGE` (**1.5 s**: Forge waits on this),
+`DECISION_API_KEY`, `LAYA_CAPTURE_DIR` (`data/decisions`), `LAYA_CAPTURE=0` to stop writing capture lines. Three failures in a row pause asking for a minute.
+
+## Rules the code enforces
+1. Text is built from public facts and the acting player's own hand. An opponent's `hand` field is never read, even if a client sends one (tested).
+2. Laya's answer must be one of the options that were offered; anything else is discarded.
+3. In assist, a pick Forge marked `stops_immediate_win` / `wins_now` is never overridden, and the response says what CSIE chose.
+4. A missing, slow or broken server returns "no answer"; nothing raises and the game proceeds as without Laya.
+5. Scores and probabilities are relative signals; Laya's probabilities are not calibrated for this game.
+
+## What was measured (2026-10-26, `typed-decisions` checkpoint, 4-thread CPU)
+- **Macro action vs the LLM, 149 recorded decisions:** 16.1% (English) and 18.6% (typed-decisions); always guessing the commonest action 27.5%.
+- **Forge-shaped priority choice, 3 scenarios, with CSIE's ranking in the text:** agreed with CSIE all three times (expected: the ranking is in the
+  text it reads), 42-48% sure, **7.5-8.4 s per call** with the extra questions. That is five times Forge's 1.5 s budget: on this CPU the Forge path
+  would time out and fall back; it needs a GPU (33 ms quoted) or a smaller text.
+- **Extras:** "threat" said *high* for a lethal stack, a calm board and a behind board alike (useless zero-shot); "must answer" gave 0.48 for the
+  lethal stack against 0.25 and 0.29 for the others (right direction, weak).
+- **Card roles from Oracle text, 150 unambiguous cards:** 48.0% (16.7% by chance among the six roles present); counterspell 76%, board wipe 64%,
+  removal 40%, tutor 40%, ramp 36%, card draw 32%; when 70% sure, 69% right but only 11% of cards reach that. **3.2 s per card** in batches on the CPU:
+  fine for the cards in a hand (cached), not for tagging 30,000 cards (about a day).
+
+## How to make it worth using
+1. Run games with `DECISION_URL` set and `DECISION_MODE=shadow` (Farmhouse LLM games, and Forge games through `/api/policy/decide/concrete`).
+2. `python scripts/farmhouse_laya_dataset.py --teacher llm` (or `csie`, or `selected`). Read `manifest.json`: the **validation baselines** are the bar.
+   A student of CSIE can at best equal CSIE, which is free; a student of the LLM is the useful one. Several thousand rows are needed.
+3. Fine-tune with Laya's own notebook/script (github.com/NandhaKishorM/laya, `notebooks/`; 2xT4 about 4-5 hours, or Apple silicon). Its worked example
+   (browser agent choosing among ~45 concrete candidates) went from 0.10 zero-shot to 0.66, so a concrete-candidate head is the shape that works.
+   Adapt the row field names if its loader differs.
+4. Serve the result (`LAYA_EXTRA_MODELS` / `DECISION_MODEL`), rerun `scripts/farmhouse_decision_eval.py` and the dataset manifest, and only then
+   try `assist`. A GPU host makes the Forge path possible.
+5. Keep game result and decision quality separate (handoff boundary 6 / learned-threat contract): a captured label is a teacher's choice, not proof it was right.
+
+Deployment reference copies are in `farmhouse/laya/` (image, manifests, CI); the source of truth is the farmhouse-os GitOps repo.
@@ -0,0 +1,74 @@
+# phase-rs and commander-playtester: assessment and plan
+
+Researched 2026-10-26 from the public repositories and data files only. **Nothing from either project has been run, vendored or deployed.**
+Facts marked (verified) were read from the source; (unverified) are inferences to check before building on them.
+
+## phase-rs/phase: a rules engine
+
+A Rust rules engine (turns, priority, the stack, combat, layers, triggers, replacement effects) that compiles to native and WebAssembly, with a game
+client, a WebSocket server and its own AI. Dual licensed Apache-2.0 / MIT (`LICENSE-APACHE`, `LICENSE-MIT`; GitHub's licence field shows "none" only
+because there are two files). Card data from MTGJSON (MIT); card images come from Scryfall at runtime; the repo says it bundles no card art or
+Comprehensive Rules text and has a DMCA/fan-content policy. One maintainer, young (weeks to months), fast-moving (latest engine tag v0.100.0).
+
+Why it matters here: our Python simulator has no rules stack (the handoff says so: `stack_supported: false`) and Forge needs a JDK and Maven that
+are not in the image. Phase is a rules-accurate engine that can run headless.
+
+### Coverage of the decks in this app (verified, from phase's published `coverage-data.json`)
+Phase reports 88.9% of 36,037 cards implemented overall and 92.5% for Commander. For the five saved decks, distinct cards supported:
+Empress V8 72/77, Landfall 65/66, God and Anime 69/71, Im not dead yet 82/84, Pew Pew 88/93: **376 of 391 (96.2%)**. The 15 unsupported cards have
+one or two parsing gaps each (e.g. Gale Waterdeep Prodigy, Hall of Echoes, Precursor Golem, Invigorate, Mavinda, Drana and Linvala, Tibalt's Trickery).
+"Supported" means every ability parsed; it is not a guarantee that each card plays correctly. How the engine treats an unsupported card in a game
+(blank, no-op, refused) is **unverified**; test it before trusting a result that involves one.
+
+### The parts that fit
+| Part | What it gives us | Notes |
+|---|---|---|
+| `ai-duel` (crate `phase-ai`) | headless AI-vs-AI games from the command line: seeded, deterministic "measurement mode", batches, JSON reports, a 4-player Commander suite, paired-seed comparison | decks are plain JSON `{"name", "main":[{"name","count"}]}` (verified). **No prebuilt binary is released**: it needs a Rust build (in CI or a container, not on the workstation). How a custom Commander deck and commander are supplied to `--commander-suite` is unverified (that suite reads a feed file) |
+| `phase-server` | a WebSocket game server (lobby, hidden information, spectators) | a prebuilt image is published (`ghcr.io/phase-rs/phase-server`, tags `latest`, `preview`, `sha-...`). A Python client could play seats and record every decision with real rules (protocol documentation not yet read) |
+| `phase-llm` | **model-driven AI seats**: the engine hands the model its legal option list, the model returns an index, the engine re-validates it, and any failure falls back to the heuristic AI | same principle as `farmhouse_laya.py`. Speaks OpenAI-style chat (so Olla / twin-turbo) **and the System One protocol Laya and Kev serve** (verified: `WireProtocol::SystemOneRelay`, question id `pick`, 2 to 255 options) |
+| `POST /jev/systemone` relay in `phase-server` | forwards the System One request to the URL in `TYPESAFE_API_URL` (verified, env var, `http` allowed for local setups) | point it at `http://laya...:8080/v1/systemone` to put Laya or Kev in a seat. The relay sends the key as `Authorization: Bearer` and does not follow redirects |
+
+The attraction for the Laya work: a captured decision from phase is an **engine-issued option list plus the pick**, in rules-accurate games. That
+is a better fine-tuning source than this repository's approximate simulator, and the exporter (`scripts/farmhouse_laya_dataset.py`) could take it with a small adapter.
+
+## RafaelAugustScherer/commander-playtester: a browser app on top of phase
+
+TypeScript/React single-page app, no backend. Runs phase's engine as WebAssembly in a Web Worker. Deck library with Moxfield / Archidekt / plain-text
+import, a goldfishing Monte Carlo (mulligan rate, screw and flood, land drops, ramp by turn 3, curve), real engine matches (watch, or pilot one seat),
+and 1-50 match head-to-head runs with a win rate and 95% confidence interval. Pins the phase engine in `engine-manifest.json` (v0.100.0; its README
+still says v0.57.0) and fetches the WASM and card data with SHA-256 checks. Zero stars, last pushed 2026-10-24.
+
+**It has no LICENSE file** (verified: the repository metadata shows none). Without a licence the code is all rights reserved: it can be read and used
+as a reference, but not copied into this repository or redistributed. Ask the author to add a licence (MIT would do) before reusing any of it. What is
+worth taking as ideas, not code: the goldfishing metrics, the head-to-head confidence-interval report, the name-only deck payload for the engine, and
+the engine-smoke gate that boots the real engine and plays a match to completion after every upgrade.
+
+## Recommended plan, smallest useful step first
+1. **Prove it on one deck.** Build `ai-duel` from the pinned phase tag in CI (Rust, container), convert one saved deck to the JSON format, run a seeded
+   batch against a baseline deck, and read the result. Answers: does it run a Commander game end to end, what does it do with an unsupported card, how
+   long is a game. This replaces the guesswork about the Python simulator's win rates.
+2. **A `phase-sim` service** in the commander-lab namespace (no egress, called only by the app) with an endpoint "run N rules-accurate games for deck X
+   against Y", returning win rate, confidence interval, wins by seat and the game log; the app's results panel reads it. The Python simulator stays for
+   instant, rough Monte Carlo.
+3. **Model seats.** Run `phase-server` with `TYPESAFE_API_URL` at Laya (or at a fine-tuned one later) and the OpenAI-compatible seat at Olla; compare
+   heuristic-only, LLM and Laya seats. Record every decision for the Laya dataset.
+4. **Only then** consider the playtester's UI ideas, after the author adds a licence or as a clean reimplementation.
+
+## What was built from this plan (2026-10-27)
+1. **The headless runner** (`ai-commander`, Commander four-player, batch mode) is built from the v0.118.0 tag with the card database that release was published with, in a
+   container (`farmhouse/phase/Dockerfile`). Not `ai-duel` for the decks: `ai-commander` takes a feed JSON of four decks, which is exactly what the app has.
+2. **The service and the app side**: `farmhouse/phase/phase_sim.py` (HTTP, jobs, parser, warnings) and `routes/farmhouse_phase.py` + `ui/phase-sim.html`. Games that stall, hit the
+   action cap or panic are reported and never counted.
+3. **Model seats**: not a setting. phase's model support lives only in its browser client (`engine-wasm` calls `phase-llm`; the HTTP is done by TypeScript), and
+   `phase-llm` depends on `phase-ai`, so the headless binary cannot use it. `farmhouse/phase/llm-seat/` is a new crate that includes the runner and installs a hook
+   (two anchored edits to phase's source). The server-side Jev relay and the browser client were not needed. Details: `farmhouse/phase/README.md`.
+Not done: the playtester's UI (no licence), a Python client for phase's WebSocket server (a large, fast-moving protocol), feeding the captured model-seat decisions into
+`scripts/farmhouse_laya_dataset.py` (the natural next step: each is an engine-issued option list plus a pick).
+
+## Risks and open questions
+- Phase is a one-person, fast-moving project: pin tags, keep a smoke test that plays a full game, expect breaking changes.
+- Rust builds are heavy; keep them in CI/containers. Resource and image size are unmeasured.
+- Card coverage is parse-level; correctness per card is unmeasured. Unsupported cards must be flagged in any result.
+- The phase server and its AI use CPU; its measured game speed is unknown (the README says a game is thousands of AI decisions).
+- Legal: phase is Apache/MIT with Wizards fan-content wording; the playtester has no licence. The card data is MTGJSON (MIT).
+- Not yet read: phase's WebSocket protocol, how `--commander-suite` accepts custom decks, and whether the server can run unattended self-play.
@@ -0,0 +1,32 @@
+# Forge in the cluster image
+
+The batch simulator on the Simulator page runs on **Forge**, the Java rules engine. The first cluster builds left it out by mistake ("Python-only"
+was read as "no Java"), so the page answered `Forge JAR not found`. It is now built into the image (reference copy of the Dockerfile stage:
+`infrastructure/apps/commander-lab/image/Dockerfile` in the farmhouse-os repo).
+
+What the image build does:
+
+1. **Stage 1** (`maven:3.9-eclipse-temurin-17`): fetch the official `Card-Forge/forge` at commit `edb28158f6d8` (the commit `KoalaTrapLord/Forge-Repo`
+   is on; that fork is 0 commits ahead of upstream, so this is the code the lab's Java was written against; newer Forge may have changed APIs), then
+   `mvn install -pl forge-gui-desktop -am -DskipTests -Drevision=2.0.12-SNAPSHOT`, retried up to three times (Maven Central downloads fail now and then).
+2. **The lab's Java tool** (`LabCli`, from this repository's `pom.xml`) is built against it. Forge's installed poms keep `${revision}` as their parent
+   version, which Maven cannot resolve for a consumer even with `-Drevision`; the placeholder is rewritten in the installed `.pom` files first.
+3. **Runtime**: the full `openjdk-17-jre` (not `-headless`) plus `xvfb`, the two jars, and Forge's `res/` data without `adventure`, `music`, `sound`, `quest` and `skins`
+   (about 190 MB the headless simulator never reads). The environment the app reads: `FORGE_JAR`, `FORGE_DIR`, `LAB_JAR`, `FORGE_DECKS_DIR`, `PRECON_DIR`, `JAVA_HOME`.
+4. `FORGE_MAX_THREADS` (default 1) clamps the batch's thread count: every Forge game is its own JVM with up to a 4 GB heap, and the cluster has two small nodes.
+5. CI starts the app, begins a batch through the app's own `/api/lab/start` and requires a Commander game with turns played and a readable `/api/lab/result` before the image is published.
+
+## Things that only showed up by running it in the cluster (2026-10-27)
+Each of these made a batch fail while every individual piece looked installed. Together they are why the CI test starts a batch through the app's own API.
+- **Forge needs a display, even for `sim`.** `GuiDesktop`'s static initialiser asks AWT for the default screen device; the headless JRE throws `HeadlessException`, and
+  `forge.view.Main` then exits 1 with no output at all (the lab tool records every game as an instant draw: "Forge produced NO output"). Fix: the full `openjdk-17-jre`,
+  `xvfb`, `DISPLAY=:99`, and the entrypoint starts `Xvfb :99`.
+- **Three folders, one deck.** The app writes saved decks to `USER_DECKS_DIR`, the lab's Java tool resolves deck files through `PRECON_DECKS_DIR`, and Forge finds a deck BY
+  NAME in its own commander folder ("Could not load deck"). All three are the Forge folder (`FORGE_DECKS_DIR`), which the entrypoint seeds with the 163 bundled precons.
+- **Writable folders.** The tool writes `results/` beside Forge's data and Forge a debug log beside its jar; both folders are owned by uid 10001 in the image.
+- **Result path.** The app asked for `results/ml-decision-<id>.json` (relative) but ran the tool from Forge's folder, so the file landed there and `/api/lab/result` answered
+  "Result file not found". The path is made absolute (patch `forge-results-abs`) and `/app/results` is linked to `/state/results`.
+- `docker cp` cannot write into a tmpfs and Docker mounts `/tmp` `noexec` (it stops SQLite's native library loading): test-harness traps, not cluster problems.
+
+Speed: about 25 seconds per game, one at a time (the project's own figure is ~0.04 simulations/s single-threaded). For many games with real rules, the
+phase-rs engine (`farmhouse/phase/`) is far faster. Forge is GPL-3.0: private use, do not redistribute the built image.
@@ -0,0 +1,37 @@
+#!/bin/sh
+# Keep the app's state on the persistent volume (/state) while the code stays in the image.
+# The upstream app writes next to its code: collection.db, scryfall_cache.db, data/ (Scryfall bulk DB, ChromaDB index),
+# user-decks/. Point each at /state with a symlink; seed data/ and user-decks/ from the image the first time.
+set -eu
+S="${STATE_DIR:-/state}"
+mkdir -p "$S"
+
+for d in data user-decks results; do
+  if [ ! -e "$S/$d" ]; then
+    if [ -d "/app/$d" ]; then cp -a "/app/$d" "$S/$d"; else mkdir -p "$S/$d"; fi
+  fi
+  rm -rf "/app/$d"
+  ln -s "$S/$d" "/app/$d"
+done
+
+for f in collection.db scryfall_cache.db; do
+  rm -f "/app/$f"
+  ln -s "$S/$f" "/app/$f"       # sqlite creates the target on first open
+done
+
+# Forge looks decks up by name in its user folder; the app exports the decks it simulates there.
+mkdir -p "${FORGE_DECKS_DIR:-/tmp/.forge/decks/commander}"
+# Seed it with the bundled precon decks (163 small files); never overwrite a deck that is already there.
+if [ -d /app/precon-decks ]; then cp -n /app/precon-decks/*.dck "${FORGE_DECKS_DIR:-/tmp/.forge/decks/commander}"/ 2>/dev/null || true; fi
+
+# A virtual display for Forge (it initialises AWT even in command-line mode; see the Dockerfile). Best effort: the app itself does not need it.
+if command -v Xvfb >/dev/null 2>&1; then
+  mkdir -p /tmp/.X11-unix && chmod 1777 /tmp/.X11-unix 2>/dev/null || true
+  Xvfb "${DISPLAY:-:99}" -screen 0 1280x800x24 -nolisten tcp >/tmp/xvfb.log 2>&1 &
+  for _ in 1 2 3 4 5 6 7 8 9 10; do
+    [ -S "/tmp/.X11-unix/X${DISPLAY#:}" ] && break
+    sleep 0.3
+  done
+fi
+
+exec "$@"
@@ -0,0 +1,34 @@
+# Laya (https://github.com/NandhaKishorM/laya, Apache-2.0): a "decision model". It answers typed multiple-choice / yes-no / score
+# questions about a piece of text in ONE forward pass (about 33 ms on a GPU) and never writes text. Here it is staged for the Commander
+# AI Lab simulator, which asks an LLM "which action?" about 25 times per game; a small classifier can answer that class of question
+# far faster, if it is accurate enough (it is measured in shadow mode first, see ../README.md).
+#
+# CPU only. The weights are baked in at a pinned Hugging Face commit and the pod has NO network access (NetworkPolicy), so the
+# running service fetches nothing. Two checkpoints are included so they can be compared: the English base and the fine-tuned
+# "typed-decisions" one (about 840 MB each).
+FROM python:3.12-slim-bookworm
+
+ARG LAYA_VERSION=0.4.15
+ARG LAYA_HF_REVISION=7b928d828b7b0e022f929d9bd2e44165aa270148
+
+ENV PIP_NO_CACHE_DIR=1 PIP_DISABLE_PIP_VERSION_CHECK=1 PYTHONUNBUFFERED=1 HF_HOME=/opt/hf
+
+RUN pip install torch --index-url https://download.pytorch.org/whl/cpu \
+ && pip install "laya[serve]==${LAYA_VERSION}"
+
+# Weights at the pinned commit. HF's offline lookup resolves the "main" ref, which a commit-pinned download does not create, so it is
+# written by hand to the same commit.
+RUN python -c "from huggingface_hub import snapshot_download; snapshot_download('convaiinnovations/laya', revision='${LAYA_HF_REVISION}', ignore_patterns=['multilingual/*','assets/*','eval/*'])" \
+ && mkdir -p /opt/hf/hub/models--convaiinnovations--laya/refs \
+ && printf '%s' "${LAYA_HF_REVISION}" > /opt/hf/hub/models--convaiinnovations--laya/refs/main \
+ && chmod -R a+rX /opt/hf
+
+RUN useradd --uid 10001 --no-create-home --shell /usr/sbin/nologin laya
+USER 10001
+
+ENV HF_HUB_OFFLINE=1 TRANSFORMERS_OFFLINE=1 \
+    LAYA_HOST=0.0.0.0 LAYA_PORT=8080 \
+    LAYA_MODELS=english,typed-decisions LAYA_DEFAULT_MODEL=english LAYA_MAX_LOADED=2 LAYA_PRELOAD=1 LAYA_THREADS=4
+
+EXPOSE 8080
+CMD ["laya-serve"]
@@ -0,0 +1,52 @@
+# Laya as the simulator's "which action?" model: evaluation, 2026-10-26
+
+**Result: not usable as shipped.** Both checkpoints agreed with the LLM less often than a model that always answers the commonest action.
+
+## What was measured
+The simulator's LLM brain ("twin-turbo") picks one of nine actions about 25 times a game. A decision model (Laya, or Kev; both serve
+`POST /v1/systemone`) could answer that kind of question in one forward pass instead of a 7-second generation. To find out whether it
+could stand in, every LLM decision the app had recorded (`/app/logs/decisions/*.jsonl`: the game state and the action the LLM chose)
+was replayed through Laya with the same question, and the answers compared. The LLM is the *teacher*, not the truth: this measures
+whether a fast model can imitate the slow one, not which plays better.
+
+Script: `image/farmhouse_decision_eval.py` (in the app image as `/app/scripts/farmhouse_decision_eval.py`):
+`DECISION_URL=http://laya:8080 python scripts/farmhouse_decision_eval.py /app/logs/decisions english typed-decisions`
+
+## Numbers (149 recorded decisions)
+LLM's choices: play_land 41, hold 31, attack_all 28, cast_creature 20, cast_spell 13, attack_safe 7, cast_removal 5, cast_ramp 4.
+
+| | agrees with the LLM | answers | time per answer | what it picked |
+|---|---|---|---|---|
+| always "play_land" (baseline) | **27.5%** | 149 | 0 | |
+| `english` (ModernBERT-large, base) | 16.1% | 149 | 1.9 s | cast_creature 105, attack_all 26; never hold, almost never play_land |
+| `typed-decisions` (fine-tuned) | 18.6% | 140 (9 timed out at 5 s) | ~4 s (shared CPU) | cast_creature 99, attack_all 26 |
+
+It could say "cast_creature" and "attack_all" and little else; it never recognised "hold" (31 of the LLM's choices) or a removal spell.
+
+## Why, and caveats
+- The shipped checkpoints are trained on generic ticket-triage style decisions. Laya's own README says fine-tuning "on decisions from your
+  own domain is where accuracy jumps" (0.766 against 0.362 for the base on its own benchmark). This game's decisions were never in its training.
+- Speed on this cluster's CPU (4 threads) was 2-4 s per answer, not the ~33 ms quoted for a GPU. Against the LLM's ~7.5 s that is not the
+  speed-up that was hoped for either, without a GPU.
+- The question wording (the nine action descriptions) and the compact text it reads (`farmhouse_decide.compact_state`) are mine; a
+  better prompt might help a little, not from 18% to usable.
+- Part of the recorded data predates the card-data fix (v10), so some states had thinner hands than they would now.
+- The LLM being the "truth" also caps the result: where the LLM is wrong, agreeing with it is not a win.
+
+## Where this leaves it
+- Laya is **staged but scaled to 0 replicas** (`deployment-laya.yaml`: `replicas: 0`; set to 1 to run it). The image
+  (`ghcr.io/fez5587/farmhouse-laya:v1`, offline, weights baked in), the service and the network policy remain.
+- The app is wired to use it (`DECISION_URL`, `DECISION_MODE`) and `DECISION_MODE` is `off`. `shadow` records agreement without
+  affecting games; `assist` uses it when it is `DECISION_MIN_CONF` sure. Kev speaks the same API, so swapping is a URL.
+- To make it worth using: fine-tune on this game's decisions (Laya ships a Kaggle 2xT4 notebook, about 4 hours, and an Apple/CPU
+  script). The labels would be the LLM's recorded decisions; a few thousand are needed, so generate them first (LLM games at ~7 s a
+  decision, or label states with the engine's own heuristic for the cheap, abundant version). Then re-run this evaluation.
+- Node memory: it needed about 2 GB (3.6 GB with both checkpoints, which pushed the control-plane node to 92%; it is pinned to the other node).
+
+## Later the same day: the new connections (see docs/LAYA-CONNECTIONS.md in the fork)
+- **Forge-shaped priority choice** (CSIE's ranking in the text, three scenarios): agreed with CSIE each time, 42-48% sure, 7.5-8.4 s per call on the CPU against Forge's
+  1.5 s budget. Not usable on a CPU; the code falls back silently.
+- **Card roles from Oracle text** (150 unambiguous cards, 6 roles present, 9 offered): 48% against 17% by chance (counterspell 76%, board wipe 64%, removal 40%, tutor 40%,
+  ramp 36%, card draw 32%), 3.2 s per card in batches. Much better than the action choice; useful as on-demand evidence for the cards in a hand, too slow to tag the whole pool.
+- **Extra questions** in the same call: "threat" said *high* for everything; "must answer" gave 0.48 for a lethal stack against 0.25-0.29 otherwise (right direction, weak).
+- Capture, dataset export and the rest are built and off by default; fine-tuning on the captured decisions is the path to making it useful.
@@ -0,0 +1,21 @@
+# Laya in this repository
+
+Laya (https://github.com/NandhaKishorM/laya, Apache-2.0) is a **decision model**: it answers typed multiple-choice, yes/no and score
+questions about a piece of text in one forward pass and never writes text. Here it is a fast second opinion beside the LLM and CSIE.
+Kev (https://github.com/jaredpalmer/kev) serves the same `POST /v1/systemone` API, so swapping is a URL change (Kev needs a GPU).
+
+| File | What |
+|---|---|
+| `Dockerfile` | CPU image: `laya[serve]` 0.4.15 + CPU torch, English and `typed-decisions` checkpoints baked in at Hugging Face commit `7b928d8`; runs offline |
+| `deployment-laya.yaml` | Kubernetes Deployment + Service + NetworkPolicy (no egress; only the app may call it). Currently `replicas: 0` |
+| `build-farmhouse-laya.workflow.yml` | the CI workflow that builds and smoke-tests the image offline (it lives in `.github/workflows/` of the farmhouse-os GitOps repo) |
+| `LAYA-EVALUATION.md` | why it is off: zero-shot both checkpoints agreed with the LLM less often than always guessing the commonest action |
+
+The deployment source of truth is the farmhouse-os repo (`infrastructure/apps/commander-lab/`); these are reference copies so the
+fork is self-contained. Things learned running it:
+
+- A Kubernetes Service named `laya` injects `LAYA_PORT=tcp://...`, which `laya-serve` reads as its own port setting and refuses. Set
+  `enableServiceLinks: false` and `LAYA_PORT=8080` explicitly.
+- Two checkpoints resident use 3.6 GB; one uses about 1.9 GB. Do not place it on a control-plane node.
+- The CPU answers in 2-4 s, not the ~33 ms quoted for a GPU.
+- How the code in this repository connects to it, and how to fine-tune it: `docs/LAYA-CONNECTIONS.md`.
@@ -0,0 +1,96 @@
+name: Build FarmHouse Laya
+
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - main
+    paths:
+      - "infrastructure/apps/commander-lab/laya/**"
+      - ".github/workflows/build-farmhouse-laya.yml"
+
+permissions:
+  contents: read
+  packages: write
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    env:
+      IMAGE_NAME: ghcr.io/${{ github.repository_owner }}/farmhouse-laya
+      # Bump together with the image tag in infrastructure/apps/commander-lab/deployment-laya.yaml.
+      IMAGE_TAG: v1
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set image name lowercase
+        shell: bash
+        run: |
+          echo "IMAGE=$(echo "${IMAGE_NAME}" | tr '[:upper:]' '[:lower:]')" >> "$GITHUB_ENV"
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Build validation image
+        uses: docker/build-push-action@v6
+        with:
+          context: infrastructure/apps/commander-lab/laya
+          load: true
+          push: false
+          tags: laya:test
+
+      # The service must answer with NO network (that is how it runs in the cluster) as the unprivileged user, for both checkpoints.
+      - name: Smoke test (boots offline, answers a game-state question with both checkpoints)
+        shell: bash
+        run: |
+          set -euo pipefail
+          docker run -d --name laya --network none laya:test
+          cat > /tmp/ask.py <<'PY'
+          import json, sys, time, urllib.request
+          model = sys.argv[1]
+          body = {"model": model,
+                  "state": {"body": "Turn 4. You have 4 lands untapped. Hand: Llanowar Elves, Swords to Plowshares, Forest. Opponent has a 6/6 creature attacking you."},
+                  "questions": {"action": {"type": "choice", "instructions": "Which action is best this turn?",
+                                           "criteria": {"cast_creature": "put a creature onto the battlefield",
+                                                        "cast_removal": "destroy or exile an opposing permanent",
+                                                        "play_land": "play a land",
+                                                        "hold": "do nothing this turn"}}}}
+          req = urllib.request.Request("http://127.0.0.1:8080/v1/systemone", data=json.dumps(body).encode(), headers={"content-type": "application/json"})
+          t = time.time()
+          out = json.load(urllib.request.urlopen(req, timeout=120))
+          print(model, "%.0f ms" % ((time.time() - t) * 1000), json.dumps(out)[:600])
+          assert "answers" in out and "action" in out["answers"], out
+          PY
+          docker cp /tmp/ask.py laya:/tmp/ask.py
+          ok=0
+          for i in $(seq 1 120); do
+            if docker exec laya python -c "import socket; socket.create_connection(('127.0.0.1', 8080), 2)" 2>/dev/null; then ok=1; break; fi
+            sleep 3
+          done
+          if [ "$ok" != 1 ]; then echo "laya did not open its port"; docker logs laya | tail -60; exit 1; fi
+          for m in english typed-decisions; do docker exec laya python /tmp/ask.py "$m"; done
+          docker exec laya id
+          docker rm -f laya >/dev/null
+          echo SMOKE OK
+
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Build and publish
+        uses: docker/build-push-action@v6
+        with:
+          context: infrastructure/apps/commander-lab/laya
+          push: true
+          tags: |
+            ${{ env.IMAGE }}:${{ env.IMAGE_TAG }}
+            ${{ env.IMAGE }}:${{ github.sha }}
+          labels: |
+            org.opencontainers.image.source=${{ github.server_url }}/${{ github.repository }}
+            org.opencontainers.image.revision=${{ github.sha }}
@@ -0,0 +1,93 @@
+# Laya, a CPU decision model (laya/Dockerfile), staged for the simulator. Reached only by the app, over the cluster network, on 8080.
+# No internet, no volume (weights are in the image), no service-account token.
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: laya
+  namespace: commander-lab
+  labels: {app: laya}
+spec:
+  # 0 since 2026-10-26: both checkpoints scored BELOW the always-guess baseline against the LLM's recorded decisions (English 16.1%, typed-decisions
+  # 18.6%, baseline 27.5%, 149 states), and ~2 GB of the node's memory was needed for the card-search index build. Set to 1 to bring it back
+  # (image, service and policy stay in place); it is only worth running once it is fine-tuned on this game's decisions (README).
+  replicas: 0
+  selector:
+    matchLabels: {app: laya}
+  template:
+    metadata:
+      labels: {app: laya}
+    spec:
+      automountServiceAccountToken: false
+      # Kubernetes injects LAYA_PORT=tcp://<ip>:8080 for a Service named laya, and laya-serve reads LAYA_PORT as its own port setting
+      # ("invalid LAYA_PORT 'tcp://...'", crash loop). Service-link variables are not wanted here at all.
+      enableServiceLinks: false
+      # NOT on talos-gmw: that node runs the Kubernetes API server, and Laya's first placement there (two checkpoints, 3.6 GB) took it from
+      # 68% to 92% memory on 2026-10-26.
+      nodeSelector: {kubernetes.io/hostname: talos-noy-0r4}
+      imagePullSecrets:
+        - name: ghcr-pull
+      securityContext:
+        runAsNonRoot: true
+        runAsUser: 10001
+        runAsGroup: 10001
+        seccompProfile: {type: RuntimeDefault}
+      containers:
+        - name: laya
+          image: ghcr.io/fez5587/farmhouse-laya:v1
+          ports:
+            - {name: http, containerPort: 8080}
+          env:
+            - {name: LAYA_THREADS, value: "4"}
+            - {name: LAYA_PORT, value: "8080"}
+            # One checkpoint only (about 1.9 GB): the English base scored below the always-guess baseline against the LLM; typed-decisions is the
+            # fine-tuned one still being measured.
+            - {name: LAYA_MODELS, value: "typed-decisions"}
+            - {name: LAYA_DEFAULT_MODEL, value: "typed-decisions"}
+            - {name: LAYA_MAX_LOADED, value: "1"}
+          securityContext:
+            allowPrivilegeEscalation: false
+            capabilities: {drop: [ALL]}
+          resources:
+            requests: {cpu: "500m", memory: 2500Mi}
+            limits: {cpu: "4", memory: 3Gi}
+          # Loading two checkpoints takes a while; the port opens when the server is up.
+          startupProbe:
+            tcpSocket: {port: http}
+            periodSeconds: 5
+            failureThreshold: 90
+          readinessProbe:
+            tcpSocket: {port: http}
+            periodSeconds: 10
+          livenessProbe:
+            tcpSocket: {port: http}
+            periodSeconds: 30
+            failureThreshold: 6
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: laya
+  namespace: commander-lab
+spec:
+  type: ClusterIP
+  selector: {app: laya}
+  ports:
+    - {name: http, port: 8080, targetPort: http}
+---
+# IN: only the app. OUT: nothing at all (the weights are in the image; it needs no DNS and calls no one).
+apiVersion: networking.k8s.io/v1
+kind: NetworkPolicy
+metadata:
+  name: laya
+  namespace: commander-lab
+spec:
+  podSelector:
+    matchLabels: {app: laya}
+  policyTypes: [Ingress, Egress]
+  ingress:
+    - from:
+        - podSelector:
+            matchLabels: {app: commander-lab}
+      ports:
+        - {protocol: TCP, port: 8080}
+  egress: []
@@ -0,0 +1,61 @@
+# phase-sim: rules-accurate four-player Commander games with phase-rs's headless AI (github.com/phase-rs/phase), behind a small HTTP service.
+#
+# phase is a Rust rules engine (stack, priority, combat, layers, triggers, replacement effects), dual licensed Apache-2.0 / MIT, with card
+# data from MTGJSON (MIT). Pinned to release v0.118.0 (commit ad0de6a) and to the card database that release was published with
+# (`card-data-5e541a38c99b97f0.json`, named in data.phase-rs.dev/card-data-meta.json for that commit); the file's SHA-256 is checked, so a
+# changed file fails the build instead of silently changing results. Nothing is fetched at run time, and the pod has no network.
+#
+# Built: the `ai-commander` binary (4-player Commander, batch mode) and `ai-duel` with the repo's `server-release` profile (unwinding
+# panics, so one game's panic cannot kill a batch). The toolchain is whatever rust-toolchain.toml pins (a dated nightly).
+FROM rust:slim-bookworm AS build
+
+ARG PHASE_REPO=https://github.com/phase-rs/phase.git
+ARG PHASE_TAG=v0.118.0
+ARG PHASE_SHA=ad0de6adf00153a6e6eb89604f6670be5b1d5168
+ARG CARD_DATA_URL=https://data.phase-rs.dev/card-data-5e541a38c99b97f0.json
+ARG CARD_DATA_SHA256=5e541a38c99b97f0ef12c81f7b249e7cd253f38b32bd5c156cf19608cb6f1218
+
+RUN apt-get update \
+ && apt-get install -y --no-install-recommends git ca-certificates curl build-essential pkg-config python3 \
+ && rm -rf /var/lib/apt/lists/*
+
+RUN set -eux; \
+    mkdir /phase; cd /phase; \
+    git init -q; \
+    git remote add origin "$PHASE_REPO"; \
+    git fetch -q --depth 1 origin "$PHASE_SHA"; \
+    git checkout -q FETCH_HEAD; \
+    test "$(git rev-parse HEAD)" = "$PHASE_SHA"
+
+WORKDIR /phase
+# phase's server-release profile uses thin LTO and 16 code-generation units; compiling its big engine crate that way ran a 7 GB CI machine
+# out of memory ("cannot allocate memory", 2026-10-27). LTO off and two parallel jobs trade some build time (and a few percent of run
+# speed) for a build that fits; the optimisation level and panic=unwind (which batch isolation needs) are unchanged.
+ENV CARGO_BUILD_JOBS=2 \
+    CARGO_PROFILE_SERVER_RELEASE_LTO=off \
+    CARGO_PROFILE_SERVER_RELEASE_CODEGEN_UNITS=8
+RUN cargo build --profile server-release -p phase-ai --bin ai-commander --bin ai-duel
+
+RUN set -eux; \
+    curl -fsSL --retry 3 -o /card-data.json "$CARD_DATA_URL"; \
+    echo "$CARD_DATA_SHA256  /card-data.json" | sha256sum -c -; \
+    cp /phase/client/public/feeds/mtggoldfish-commander.json /sample-feed.json
+
+FROM python:3.12-slim-bookworm
+ARG PHASE_TAG=v0.118.0
+
+RUN groupadd -g 10001 phase && useradd -u 10001 -g 10001 -d /tmp -s /usr/sbin/nologin phase
+COPY --from=build /phase/target/server-release/ai-commander /opt/phase/ai-commander
+COPY --from=build /phase/target/server-release/ai-duel /opt/phase/ai-duel
+COPY --from=build /card-data.json /opt/phase/data/card-data.json
+COPY --from=build /sample-feed.json /opt/phase/sample-feed.json
+COPY phase_sim.py phase_smoke.py /opt/phase/
+
+ENV PHASE_ENGINE_VERSION="phase-rs ${PHASE_TAG}" \
+    PHASE_AI_COMMANDER=/opt/phase/ai-commander \
+    PHASE_CARD_DATA=/opt/phase/data/card-data.json \
+    PYTHONUNBUFFERED=1 PORT=8090
+USER 10001
+WORKDIR /tmp
+EXPOSE 8090
+CMD ["python", "/opt/phase/phase_sim.py"]
@@ -0,0 +1,72 @@
+# phase-sim: rules-accurate four-player Commander games with phase-rs's headless AI (github.com/phase-rs/phase), behind a small HTTP service.
+#
+# phase is a Rust rules engine (stack, priority, combat, layers, triggers, replacement effects), dual licensed Apache-2.0 / MIT, with card
+# data from MTGJSON (MIT). Pinned to release v0.118.0 (commit ad0de6a) and to the card database that release was published with
+# (`card-data-5e541a38c99b97f0.json`, named in data.phase-rs.dev/card-data-meta.json for that commit); the file's SHA-256 is checked, so a
+# changed file fails the build instead of silently changing results. Nothing is fetched at run time, and the pod has no network.
+#
+# Built: the `ai-commander` binary (4-player Commander, batch mode) and `ai-duel` with the repo's `server-release` profile (unwinding
+# panics, so one game's panic cannot kill a batch). The toolchain is whatever rust-toolchain.toml pins (a dated nightly).
+FROM rust:slim-bookworm AS build
+
+ARG PHASE_REPO=https://github.com/phase-rs/phase.git
+ARG PHASE_TAG=v0.118.0
+ARG PHASE_SHA=ad0de6adf00153a6e6eb89604f6670be5b1d5168
+ARG CARD_DATA_URL=https://data.phase-rs.dev/card-data-5e541a38c99b97f0.json
+ARG CARD_DATA_SHA256=5e541a38c99b97f0ef12c81f7b249e7cd253f38b32bd5c156cf19608cb6f1218
+
+RUN apt-get update \
+ && apt-get install -y --no-install-recommends git ca-certificates curl build-essential pkg-config python3 \
+ && rm -rf /var/lib/apt/lists/*
+
+RUN set -eux; \
+    mkdir /phase; cd /phase; \
+    git init -q; \
+    git remote add origin "$PHASE_REPO"; \
+    git fetch -q --depth 1 origin "$PHASE_SHA"; \
+    git checkout -q FETCH_HEAD; \
+    test "$(git rev-parse HEAD)" = "$PHASE_SHA"
+
+WORKDIR /phase
+# phase's server-release profile uses thin LTO and 16 code-generation units; compiling its big engine crate that way ran a 7 GB CI machine
+# out of memory ("cannot allocate memory", 2026-10-27). LTO off and two parallel jobs trade some build time (and a few percent of run
+# speed) for a build that fits; the optimisation level and panic=unwind (which batch isolation needs) are unchanged.
+ENV CARGO_BUILD_JOBS=2 \
+    CARGO_PROFILE_SERVER_RELEASE_LTO=off \
+    CARGO_PROFILE_SERVER_RELEASE_CODEGEN_UNITS=8
+RUN cargo build --profile server-release -p phase-ai --bin ai-commander --bin ai-duel
+
+# ---- model seats (this Dockerfile only) -------------------------------------------------------------------------------------------
+# Everything above is identical to Dockerfile, so the long compile above comes from the build cache. These steps add `ai-commander-llm`: the
+# same runner with a hook that lets a language model or a decision model (Laya / Kev) choose for named seats among the engine's OWN legal
+# options. Two anchored edits to phase's source (apply_phase_patches.py: the build stops if phase moved either line) and one new crate.
+# phase-llm depends on phase-ai, so the hook cannot live in phase-ai's binary; the new crate depends on both and includes the runner.
+COPY llm-seat /llm-seat
+RUN python3 /llm-seat/apply_phase_patches.py /phase /llm-seat
+RUN cargo build --profile server-release -p farmhouse-llm-seat --bin ai-commander-llm
+
+RUN set -eux; \
+    curl -fsSL --retry 3 -o /card-data.json "$CARD_DATA_URL"; \
+    echo "$CARD_DATA_SHA256  /card-data.json" | sha256sum -c -; \
+    cp /phase/client/public/feeds/mtggoldfish-commander.json /sample-feed.json
+
+FROM python:3.12-slim-bookworm
+ARG PHASE_TAG=v0.118.0
+
+RUN groupadd -g 10001 phase && useradd -u 10001 -g 10001 -d /tmp -s /usr/sbin/nologin phase
+COPY --from=build /phase/target/server-release/ai-commander /opt/phase/ai-commander
+COPY --from=build /phase/target/server-release/ai-duel /opt/phase/ai-duel
+COPY --from=build /phase/target/server-release/ai-commander-llm /opt/phase/ai-commander-llm
+COPY --from=build /card-data.json /opt/phase/data/card-data.json
+COPY --from=build /sample-feed.json /opt/phase/sample-feed.json
+COPY phase_sim.py phase_smoke.py /opt/phase/
+
+ENV PHASE_ENGINE_VERSION="phase-rs ${PHASE_TAG}" \
+    PHASE_AI_COMMANDER=/opt/phase/ai-commander \
+    PHASE_AI_COMMANDER_LLM=/opt/phase/ai-commander-llm \
+    PHASE_CARD_DATA=/opt/phase/data/card-data.json \
+    PYTHONUNBUFFERED=1 PORT=8090
+USER 10001
+WORKDIR /tmp
+EXPOSE 8090
+CMD ["python", "/opt/phase/phase_sim.py"]
@@ -0,0 +1,36 @@
+# phase-sim: rules-accurate Commander games with phase-rs
+
+Reference copies of what runs in the cluster (source of truth: `infrastructure/apps/commander-lab/` in the farmhouse-os repo). Background and the assessment
+that led here: `docs/PHASE-AND-PLAYTESTER.md`.
+
+| File | What |
+|---|---|
+| `phase_sim.py` | the service: stdlib HTTP, one job at a time. `POST /run` four decks -> `GET /job/<id>` per-game results, wins by seat, 95% interval, warnings. Optional model seats and two loopback-only relays (`/llm/v1/chat/completions`, `/jev/systemone`) |
+| `Dockerfile` | builds phase-rs `v0.118.0` (`ai-commander`, `ai-duel`) and takes the card database that release was published with (SHA-256 checked) |
+| `Dockerfile.llm` | the same plus `ai-commander-llm`: model-driven seats |
+| `llm-seat/` | the Rust crate and the two anchored edits to phase's source that make model seats possible |
+| `phase_smoke.py`, `test_phase_sim.py` | CI: real games through the service; 49 offline checks against a stub engine |
+| `deployment-phase.yaml` | Deployment, Service and a NetworkPolicy (in: the app only; out: DNS, Olla and Laya only) |
+
+The app side is `routes/farmhouse_phase.py` (four saved decks -> the service) and `ui/phase-sim.html`; both are real source in this repository, registered by
+`lab_api.py` and linked from the home page.
+
+## Model seats: how they work and why they are safe
+phase's headless runner has no model support; the model seats exist only in phase's browser client. `phase-llm` (the crate) deliberately does no networking:
+it renders the engine's option list into a prompt, builds the HTTP request, and parses the reply, and the host performs the call. `llm-seat/` is that host
+for the headless runner:
+
+1. `apply_phase_patches.py` adds a process-wide `ACTION_OVERRIDE` hook in `phase-ai/src/auto_play.rs` (asked before the built-in AI chooses) and makes the runner's `main` `pub`.
+2. The crate `farmhouse-llm-seat` includes the runner's source as a module (`#[path]`) and installs the hook. `phase-llm` depends on `phase-ai`, so the hook cannot
+   live inside phase-ai's own binary.
+3. For each decision on a model seat: the engine issues its option list (`AiDecisionContract`); phase-llm builds the prompt (a forced move with one option is never asked);
+   this crate makes the HTTP call (blocking, no TLS, 20 s limit); phase-llm turns the reply into one of the engine's options; the choice is checked against the contract
+   here and again by `run_ai_action`. **Any** problem returns "no opinion" and phase's own AI plays the move. A cap on model calls per run (default 300) bounds the cost.
+4. The service supplies the endpoints through its own loopback-only relays: the chat relay switches the model's thinking off (twin-turbo otherwise thinks for tens of
+   seconds a move) and caps the answer; the decision relay unwraps phase's `Jev` envelope and forwards the System One request to Laya or Kev.
+
+The model never authors an action and never sees hidden cards beyond what phase-llm renders for that seat.
+
+## Status
+Written 2026-10-27. The service logic is tested offline; the Rust crate has not compiled outside CI when this was written (no Rust toolchain on the workstation), so
+its first CI run is the first real test. Check `.github/workflows/build-farmhouse-phase-sim.yml` results in the farmhouse-os repo.
@@ -0,0 +1,111 @@
+# phase-sim (phase/Dockerfile): rules-accurate four-player Commander games over a small HTTP API. Only the app may call it; it has no
+# network and no volume (engine and card data are in the image). One game at a time, CPU heavy.
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: phase-sim
+  namespace: commander-lab
+  labels: {app: phase-sim}
+spec:
+  replicas: 1
+  selector:
+    matchLabels: {app: phase-sim}
+  template:
+    metadata:
+      labels: {app: phase-sim}
+    spec:
+      automountServiceAccountToken: false
+      # A Service named like the app injects PHASE_SIM_* variables into the pod; nothing here wants them (the same kind of collision
+      # crash-looped Laya on LAYA_PORT).
+      enableServiceLinks: false
+      imagePullSecrets:
+        - name: ghcr-pull
+      securityContext:
+        runAsNonRoot: true
+        runAsUser: 10001
+        runAsGroup: 10001
+        seccompProfile: {type: RuntimeDefault}
+      containers:
+        - name: phase-sim
+          image: ghcr.io/fez5587/farmhouse-phase-sim:v1-llm      # -llm = the baseline plus ai-commander-llm (model seats)
+          ports:
+            - {name: http, containerPort: 8090}
+          env:
+            - {name: PORT, value: "8090"}
+            - {name: PHASE_SIM_MAX_GAMES, value: "50"}
+            - {name: PHASE_SIM_TIMEOUT, value: "3600"}
+            # Model seats. The engine talks to THIS service's loopback-only relays, which forward to these (see phase_sim.py): chat = an
+            # OpenAI-style endpoint (Olla -> twin-turbo; the relay switches thinking off and caps the answer), decision = a System One server
+            # (Laya / Kev; the deployment is scaled to 0 until it is fine-tuned, so a decision-seat run answers 502 and falls back to phase's AI).
+            - {name: PHASE_LLM_CHAT_URL, value: "http://olla.ai-system.svc.cluster.local:40114/olla/openai/v1"}
+            - {name: PHASE_LLM_DECISION_URL, value: "http://laya.commander-lab.svc.cluster.local:8080/v1/systemone"}
+            - {name: PHASE_LLM_REASONING, value: "none"}
+            - {name: PHASE_LLM_MAX_TOKENS_CAP, value: "256"}
+          securityContext:
+            allowPrivilegeEscalation: false
+            readOnlyRootFilesystem: true
+            capabilities: {drop: [ALL]}
+          volumeMounts:
+            - {name: tmp, mountPath: /tmp}
+          resources:
+            requests: {cpu: "500m", memory: 1Gi}
+            limits: {cpu: "3", memory: 3Gi}
+          readinessProbe:
+            httpGet: {path: /health, port: http}
+            periodSeconds: 10
+          livenessProbe:
+            httpGet: {path: /health, port: http}
+            periodSeconds: 30
+            failureThreshold: 6
+      volumes:
+        - name: tmp
+          emptyDir: {sizeLimit: 512Mi}
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: phase-sim
+  namespace: commander-lab
+spec:
+  type: ClusterIP
+  selector: {app: phase-sim}
+  ports:
+    - {name: http, port: 8090, targetPort: http}
+---
+# IN: only the app. OUT: DNS and the two model endpoints the relays use (Olla for the chat model, Laya for the decision model); nothing else.
+apiVersion: networking.k8s.io/v1
+kind: NetworkPolicy
+metadata:
+  name: phase-sim
+  namespace: commander-lab
+spec:
+  podSelector:
+    matchLabels: {app: phase-sim}
+  policyTypes: [Ingress, Egress]
+  ingress:
+    - from:
+        - podSelector:
+            matchLabels: {app: commander-lab}
+      ports:
+        - {protocol: TCP, port: 8090}
+  egress:
+    - to:
+        - namespaceSelector:
+            matchLabels: {kubernetes.io/metadata.name: kube-system}
+          podSelector:
+            matchLabels: {k8s-app: kube-dns}
+      ports:
+        - {protocol: UDP, port: 53}
+        - {protocol: TCP, port: 53}
+    - to:
+        - namespaceSelector:
+            matchLabels: {kubernetes.io/metadata.name: ai-system}
+          podSelector:
+            matchLabels: {app.kubernetes.io/name: olla}
+      ports:
+        - {protocol: TCP, port: 40114}
+    - to:
+        - podSelector:
+            matchLabels: {app: laya}
+      ports:
+        - {protocol: TCP, port: 8080}
@@ -0,0 +1,26 @@
+[package]
+name = "farmhouse-llm-seat"
+version.workspace = true
+edition = "2021"
+license.workspace = true
+publish = false
+
+# FarmHouse: phase's headless four-player Commander runner (`ai-commander`) with MODEL-DRIVEN SEATS. The runner's own source is included
+# as a module (src/main.rs, #[path]); this crate adds only the network transport phase-llm deliberately leaves to the host. phase-llm
+# depends on phase-ai, so the hook cannot live inside phase-ai's own binary: a new crate that depends on both is the way round that.
+
+[[bin]]
+name = "ai-commander-llm"
+path = "src/main.rs"
+
+[dependencies]
+engine = { path = "../engine", package = "phase-engine" }
+phase-ai = { path = "../phase-ai" }
+phase-llm = { path = "../phase-llm" }
+serde = { workspace = true }
+serde_json = "1"
+rand = "0.9"
+tracing = "0.1"
+mimalloc = "0.1"
+# Blocking HTTP, no TLS: the model endpoints are cluster-internal http:// relays (phase-sim's own /llm and /jev routes).
+ureq = { version = "2", default-features = false }
@@ -0,0 +1,74 @@
+"""Apply the FarmHouse edits to a phase-rs checkout (run in the Docker build, from the repository root).
+
+    python apply_phase_patches.py <phase-checkout> <llm-seat-crate-dir>
+
+1. crates/phase-ai/src/auto_play.rs: a process-wide ACTION_OVERRIDE hook, asked before the built-in AI chooses. It returns Option<GameAction>;
+   None (the default, and what every failure returns) leaves phase's own choice untouched. The chosen action still goes through the same
+   contract check (`contract.permits`) as before.
+2. crates/phase-ai/src/bin/ai_commander.rs: `fn main` becomes `pub fn main` so the new crate can include and call it.
+3. The new crate is copied into crates/farmhouse-llm-seat (the workspace takes every crates/* member).
+
+Every anchor must match exactly once or the build stops, so a phase update that moves a line is reported here, not in a compile error."""
+import os
+import shutil
+import sys
+
+root, crate = sys.argv[1], sys.argv[2]
+
+
+def edit(rel, edits):
+    path = os.path.join(root, rel)
+    text = open(path, encoding="utf-8", newline="").read()
+    for old, new in edits:
+        n = text.count(old)
+        if n != 1:
+            raise SystemExit("%s: anchor found %d times (need 1): %r" % (rel, n, old[:80]))
+        text = text.replace(old, new)
+    open(path, "w", encoding="utf-8", newline="").write(text)
+    print("patched", rel)
+
+
+HOOK = '''use crate::search::choose_action_with_session;
+
+/// FarmHouse: an optional process-wide override, asked BEFORE the built-in AI chooses for a seat. A host (see crates/farmhouse-llm-seat)
+/// installs one to let a model pick among the engine's own options. It returns None to leave the choice to the built-in AI, which is also
+/// what it must return on any failure; whatever it returns still has to pass the same decision-contract check below.
+pub type ActionOverride = Box<
+    dyn Fn(
+            &engine::types::game_state::GameState,
+            &engine::ai_support::AiDecisionContract,
+            engine::types::player::PlayerId,
+            engine::types::player::PlayerId,
+        ) -> Option<engine::types::actions::GameAction>
+        + Send
+        + Sync,
+>;
+static ACTION_OVERRIDE: std::sync::OnceLock<ActionOverride> = std::sync::OnceLock::new();
+
+/// Install the override. Returns false if one is already installed (it can be set once per process).
+pub fn install_action_override(hook: ActionOverride) -> bool {
+    ACTION_OVERRIDE.set(hook).is_ok()
+}
+'''
+
+edit("crates/phase-ai/src/auto_play.rs", [
+    ("use crate::search::choose_action_with_session;\n", HOOK),
+    ("    let action = match choose_action_with_session(state, semantic_owner, config, rng, session) {\n        Some(action) => action,\n        None => {\n            tracing::warn!(player = ?actor, \"choose_action returned None",
+     "    // The override's pick must be one the engine will really APPLY, not only one it lists: a model chose both modes of a modal spell whose\n"
+     "    // entwine cost it could not pay, the contract listed the option, apply refused it, and the whole game stalled (2026-10-27). Try it on a\n"
+     "    // copy of the game first; anything the engine refuses is dropped and the built-in AI plays the move. (Stack-pass rechecks have their\n"
+     "    // own verified path and are left alone.)\n"
+     "    let farmhouse_choice = ACTION_OVERRIDE\n        .get()\n        .and_then(|hook| hook(&*state, &contract, semantic_owner, actor))\n"
+     "        .filter(|candidate| {\n"
+     "            verified_ai_stack_pass_player(&*state, candidate).is_some()\n"
+     "                || apply_interaction(&mut (*state).clone(), actor, semantic_owner, candidate.clone()).is_ok()\n"
+     "        });\n"
+     "    let action = match farmhouse_choice\n        .or_else(|| choose_action_with_session(state, semantic_owner, config, rng, session))\n    {\n        Some(action) => action,\n        None => {\n            tracing::warn!(player = ?actor, \"choose_action returned None"),
+])
+edit("crates/phase-ai/src/bin/ai_commander.rs", [("\nfn main() {\n", "\npub fn main() {\n")])
+
+dest = os.path.join(root, "crates", "farmhouse-llm-seat")
+os.makedirs(os.path.join(dest, "src"), exist_ok=True)
+shutil.copy(os.path.join(crate, "Cargo.toml"), os.path.join(dest, "Cargo.toml"))
+shutil.copy(os.path.join(crate, "src", "main.rs"), os.path.join(dest, "src", "main.rs"))
+print("added crates/farmhouse-llm-seat")
@@ -0,0 +1,237 @@
+//! ai-commander with model-driven seats (FarmHouse).
+//!
+//! phase's headless runner plays four-player Commander games with the built-in AI on every seat. This binary is that same runner (its
+//! source is included below, unchanged but for `fn main` being `pub`) plus a hook, installed before the games start, that asks a
+//! language model or a decision model (Laya / Kev, over the System One protocol) to choose for the seats named in `PHASE_LLM_SEATS`.
+//!
+//! The model never authors an action. For each decision the engine issues its own option list (`AiDecisionContract`), phase-llm renders
+//! it and builds the HTTP request, this file performs the HTTP call (the one thing phase-llm leaves to the host), and phase-llm turns the
+//! reply into one of the engine's options. The pick is then checked against the contract a second time here, and again by
+//! `run_ai_action`. ANY problem (forced move, timeout, an unreadable or stale answer, the call cap) returns `None` and phase's own AI
+//! plays the move, so a model that is down, slow or wrong cannot stall or corrupt a game.
+//!
+//! Settings (environment): PHASE_LLM_SEATS "1,3" (seats 0-3; empty = none, the plain runner), PHASE_LLM_PROVIDER (OpenAiCompatible | Jev),
+//! PHASE_LLM_BASE_URL, PHASE_LLM_MODEL, PHASE_LLM_API_KEY (leave empty for http:// endpoints), PHASE_LLM_MAX_TOKENS (256),
+//! PHASE_LLM_TEMPERATURE (0.2), PHASE_LLM_TIMEOUT_S (20), PHASE_LLM_MAX_CALLS (total model calls for the whole process, default 300),
+//! PHASE_LLM_DIFFICULTY (Medium: the strength hint in the prompt), PHASE_LLM_MAX_FAILS (4: model failures IN A ROW before every model seat
+//! switches itself off for the rest of the process).
+
+use std::collections::HashSet;
+use std::path::PathBuf;
+use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
+use std::sync::OnceLock;
+use std::time::{Duration, Instant};
+
+use engine::ai_support::AiDecisionContract;
+use engine::database::CardDatabase;
+use engine::types::actions::GameAction;
+use engine::types::game_state::GameState;
+use engine::types::player::PlayerId;
+use phase_ai::auto_play::install_action_override;
+use phase_ai::config::AiDifficulty;
+use phase_llm::{LlmEndpointConfig, LlmProvider, LlmReply};
+
+// The unchanged runner, with `fn main` made `pub` by apply_phase_patches.py.
+#[path = "../../phase-ai/src/bin/ai_commander.rs"]
+#[allow(dead_code, unused_imports, unused_variables)]
+mod commander;
+
+struct Seats {
+    seats: HashSet<u8>,
+    endpoint: LlmEndpointConfig,
+    difficulty: AiDifficulty,
+    agent: ureq::Agent,
+    cards_path: PathBuf,
+    db: OnceLock<Option<CardDatabase>>,
+    max_calls: u64,
+    asked: [AtomicU64; 4],
+    used: [AtomicU64; 4],
+    fell_back: [AtomicU64; 4],
+    total: AtomicU64,
+    // Cost visibility and the circuit-breaker. A late-game prompt is thousands of tokens and a big-model server needs longer than the
+    // per-call limit to read it; every such call used to burn the whole limit (a 9-minute game, 25 questions, 1 answer used). After
+    // `max_fails` failures IN A ROW the model seats switch themselves off for the rest of the process and phase's AI plays on.
+    timeouts: AtomicU64,
+    consecutive_fails: AtomicU64,
+    max_fails: u64,
+    disabled: AtomicBool,
+    millis: AtomicU64,
+    answered: AtomicU64,
+    prompt_chars: AtomicU64,
+}
+
+impl Seats {
+    fn database(&self) -> Option<&CardDatabase> {
+        self.db
+            .get_or_init(|| CardDatabase::from_export(&self.cards_path.join("card-data.json")).ok())
+            .as_ref()
+    }
+
+    /// The model's pick for `actor`, or None to let phase's AI play. Never panics on a bad answer.
+    /// One failed model call (timeout, error status, unusable answer). Returns None so callers can `return self.failed(..)`.
+    fn failed(&self, timeout: bool) -> Option<GameAction> {
+        if timeout {
+            self.timeouts.fetch_add(1, Ordering::Relaxed);
+        }
+        let in_a_row = self.consecutive_fails.fetch_add(1, Ordering::Relaxed) + 1;
+        if in_a_row >= self.max_fails && !self.disabled.swap(true, Ordering::Relaxed) {
+            println!(
+                "LLM-SEAT-DISABLED after {in_a_row} consecutive failures ({} timeouts of {} questions): phase's own AI plays the rest",
+                self.timeouts.load(Ordering::Relaxed),
+                self.total.load(Ordering::Relaxed)
+            );
+        }
+        None
+    }
+
+    fn decide(&self, state: &GameState, contract: &AiDecisionContract, actor: PlayerId) -> Option<GameAction> {
+        if self.disabled.load(Ordering::Relaxed) {
+            return None;
+        }
+        let seat = (actor.0 as usize).min(3);
+        // A forced move (one legal option) is never put to a model: build_game_decision_prompt refuses it.
+        let request = phase_llm::build_game_decision_prompt(
+            state,
+            contract,
+            self.difficulty,
+            self.database(),
+            &Vec::new(),
+        )
+        .ok()?;
+        if self.total.fetch_add(1, Ordering::Relaxed) >= self.max_calls {
+            return None; // the call cap: every later decision is phase's AI
+        }
+        self.asked[seat].fetch_add(1, Ordering::Relaxed);
+        self.prompt_chars.fetch_add(request.prompt.char_count() as u64, Ordering::Relaxed);
+        let http = phase_llm::build_chat_request(&self.endpoint, &request.prompt).ok()?;
+        let mut call = self.agent.request(http.method, &http.url);
+        for header in &http.headers {
+            call = call.set(&header.name, &header.value);
+        }
+        let started = Instant::now();
+        let (status, body) = match call.send_string(&http.body) {
+            Ok(response) => {
+                let status = response.status();
+                match response.into_string() {
+                    Ok(text) => (status, text),
+                    Err(_) => return self.failed(true),
+                }
+            }
+            // A 4xx/5xx still carries a body phase-llm knows how to classify.
+            Err(ureq::Error::Status(code, response)) => (code, response.into_string().unwrap_or_default()),
+            Err(_) => return self.failed(true), // transport error: a timeout, or the endpoint is down
+        };
+        self.millis.fetch_add(started.elapsed().as_millis() as u64, Ordering::Relaxed);
+        self.answered.fetch_add(1, Ordering::Relaxed);
+        let selection = match phase_llm::select_action_from_response(
+            state,
+            contract,
+            &request.fingerprint,
+            LlmReply { provider: self.endpoint.provider, status, body: &body },
+        ) {
+            Ok(selection) => selection,
+            Err(_) => return self.failed(false),
+        };
+        if !contract.contains_action(state, &selection.action) {
+            return self.failed(false);
+        }
+        self.consecutive_fails.store(0, Ordering::Relaxed);
+        self.used[seat].fetch_add(1, Ordering::Relaxed);
+        Some(selection.action)
+    }
+
+    fn report(&self, seat: usize) {
+        let asked = self.asked[seat].load(Ordering::Relaxed);
+        if asked > 0 && asked % 25 == 0 {
+            let answered = self.answered.load(Ordering::Relaxed).max(1);
+            let questions = self.total.load(Ordering::Relaxed).max(1);
+            println!(
+                "LLM-SEAT seat={seat} asked={asked} used={} total_calls={} timeouts={} avg_ms={} avg_prompt_chars={}",
+                self.used[seat].load(Ordering::Relaxed),
+                self.total.load(Ordering::Relaxed),
+                self.timeouts.load(Ordering::Relaxed),
+                self.millis.load(Ordering::Relaxed) / answered,
+                self.prompt_chars.load(Ordering::Relaxed) / questions
+            );
+        }
+    }
+}
+
+fn env_or(name: &str, default: &str) -> String {
+    std::env::var(name).ok().filter(|v| !v.trim().is_empty()).unwrap_or_else(|| default.to_string())
+}
+
+fn install_model_seats() {
+    let seats: HashSet<u8> = env_or("PHASE_LLM_SEATS", "")
+        .split(',')
+        .filter_map(|s| s.trim().parse::<u8>().ok())
+        .filter(|s| *s < 4)
+        .collect();
+    if seats.is_empty() {
+        println!("LLM seats: none (plain ai-commander)");
+        return;
+    }
+    let provider = LlmProvider::from_label(&env_or("PHASE_LLM_PROVIDER", "OpenAiCompatible"));
+    let endpoint = LlmEndpointConfig {
+        provider,
+        base_url: std::env::var("PHASE_LLM_BASE_URL").ok().filter(|v| !v.trim().is_empty()),
+        api_key: env_or("PHASE_LLM_API_KEY", ""),
+        model: env_or("PHASE_LLM_MODEL", "model"),
+        max_output_tokens: env_or("PHASE_LLM_MAX_TOKENS", "256").parse().ok(),
+        temperature: env_or("PHASE_LLM_TEMPERATURE", "0.2").parse().ok(),
+    };
+    let timeout = env_or("PHASE_LLM_TIMEOUT_S", "20").parse::<u64>().unwrap_or(20);
+    // The runner's first positional argument is the data folder (card-data.json lives there).
+    let cards_path = PathBuf::from(std::env::args().nth(1).unwrap_or_else(|| ".".to_string()));
+    let state = Seats {
+        seats: seats.clone(),
+        endpoint,
+        difficulty: AiDifficulty::from_label(&env_or("PHASE_LLM_DIFFICULTY", "Medium")),
+        agent: ureq::AgentBuilder::new().timeout(Duration::from_secs(timeout)).redirects(0).build(),
+        cards_path,
+        db: OnceLock::new(),
+        max_calls: env_or("PHASE_LLM_MAX_CALLS", "300").parse().unwrap_or(300),
+        asked: Default::default(),
+        used: Default::default(),
+        fell_back: Default::default(),
+        total: AtomicU64::new(0),
+        timeouts: AtomicU64::new(0),
+        consecutive_fails: AtomicU64::new(0),
+        max_fails: env_or("PHASE_LLM_MAX_FAILS", "4").parse().unwrap_or(4),
+        disabled: AtomicBool::new(false),
+        millis: AtomicU64::new(0),
+        answered: AtomicU64::new(0),
+        prompt_chars: AtomicU64::new(0),
+    };
+    println!(
+        "LLM seats: {:?} provider={} model={} max_calls={}",
+        {
+            let mut v: Vec<u8> = seats.iter().copied().collect();
+            v.sort();
+            v
+        },
+        provider.label(),
+        state.endpoint.model,
+        state.max_calls
+    );
+    let installed = install_action_override(Box::new(move |game, contract, _owner, actor| {
+        if !state.seats.contains(&actor.0) {
+            return None;
+        }
+        let seat = (actor.0 as usize).min(3);
+        let pick = state.decide(game, contract, actor);
+        if pick.is_none() {
+            state.fell_back[seat].fetch_add(1, Ordering::Relaxed);
+        }
+        state.report(seat);
+        pick
+    }));
+    if !installed {
+        eprintln!("LLM seats: an action override was already installed; model seats are off");
+    }
+}
+
+fn main() {
+    install_model_seats();
+    commander::main();
+}
@@ -0,0 +1,501 @@
+"""phase-sim: run rules-accurate four-player Commander games with phase-rs's headless `ai-commander` and report what happened.
+
+Standard library only. One job runs at a time (a game is CPU-heavy); more wait in a queue. The service never touches the network.
+
+  GET  /health            {"ok": true, "engine": ..., "queued": n, "running": id|null}
+  POST /run               {"decks": [4 x {"name", "commander": ["Card"], "main": [{"name","count"}, ...]}],
+                           "games": 1..MAX_GAMES, "seed": int, "difficulty": "Medium", "seat_difficulty": {"2": "Hard"}, "action_cap": int}
+                          -> {"job": id}
+  GET  /job/<id>          status queued|running|done|error, games finished, and when done: per-game rows, wins by seat and by deck,
+                          win rate with a 95% interval, the cards the engine could not resolve, and the tail of the engine's output
+
+Seat i is the i-th deck in the request (P0 = first). The engine treats every seat as AI; difficulty is per seat if given.
+A game that stalls, hits the action cap, or panics is reported as such and is NEVER counted as a win or a draw.
+
+Model seats (optional, needs the image's ai-commander-llm binary): "llm_seats": [1, 3] and "llm": {"kind": "chat" | "decision", "model": "...",
+"max_calls": 300}. Those seats ask a model to pick among the ENGINE'S OWN legal options (phase-llm builds the prompt and checks the answer;
+anything wrong or slow falls back to phase's AI). kind "chat" goes to PHASE_LLM_CHAT_URL (an OpenAI-style endpoint, e.g. Olla) through this
+service's /llm relay, which switches the model's thinking off and caps its answer; kind "decision" goes to PHASE_LLM_DECISION_URL (a System One
+server: Laya or Kev) through /jev/systemone. Both relays accept connections from this machine only.
+"""
+import json
+import math
+import os
+import re
+import subprocess
+import sys
+import tempfile
+import threading
+import time
+import urllib.error
+import urllib.request
+import uuid
+from collections import deque
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+BIN = os.environ.get("PHASE_AI_COMMANDER", "/opt/phase/ai-commander")
+CARD_DATA = os.environ.get("PHASE_CARD_DATA", "/opt/phase/data/card-data.json")
+ENGINE = os.environ.get("PHASE_ENGINE_VERSION", "phase-rs (version unknown)")
+MAX_GAMES = int(os.environ.get("PHASE_SIM_MAX_GAMES", "50"))
+JOB_TIMEOUT = int(os.environ.get("PHASE_SIM_TIMEOUT", "3600"))
+PORT = int(os.environ.get("PORT", "8090"))
+DIFFICULTIES = ("VeryEasy", "Easy", "Medium", "Hard", "VeryHard")
+BIN_LLM = os.environ.get("PHASE_AI_COMMANDER_LLM", "/opt/phase/ai-commander-llm")
+CHAT_URL = os.environ.get("PHASE_LLM_CHAT_URL", "").rstrip("/")          # e.g. http://olla...:40114/olla/openai/v1
+DECISION_URL = os.environ.get("PHASE_LLM_DECISION_URL", "")             # e.g. http://laya...:8080/v1/systemone
+DECISION_KEY = os.environ.get("PHASE_LLM_DECISION_KEY", "")
+CHAT_REASONING = os.environ.get("PHASE_LLM_REASONING", "none")
+CHAT_MAX_TOKENS = int(os.environ.get("PHASE_LLM_MAX_TOKENS_CAP", "256"))
+MAX_LLM_CALLS = int(os.environ.get("PHASE_LLM_MAX_CALLS", "600"))
+LOCAL_ONLY = ("127.0.0.1", "::1")
+# A late-game prompt is thousands of tokens; reading it takes a 27B model on a V100 20-30 s. The engine waits MODEL_TIMEOUT per question and the
+# relay a little less, and the engine switches the model seats off after PHASE_LLM_MAX_FAILS failures in a row, so a dead model costs a few minutes at most.
+RELAY_TIMEOUT = float(os.environ.get("PHASE_LLM_RELAY_TIMEOUT", "55"))
+MODEL_TIMEOUT = os.environ.get("PHASE_LLM_TIMEOUT_S", "60")
+MAX_DECK_ENTRIES = 400
+
+_jobs = {}
+_queue = deque()
+_cv = threading.Condition()
+_running = {"id": None}
+
+
+# ---------- request -> engine inputs ------------------------------------------------------------------------------------------
+
+class BadRequest(ValueError):
+    pass
+
+
+def validate(req):
+    decks = req.get("decks")
+    if not isinstance(decks, list) or len(decks) != 4:
+        raise BadRequest("decks must be a list of exactly 4 decks (one per seat)")
+    feed = []
+    for i, d in enumerate(decks):
+        if not isinstance(d, dict) or not str(d.get("name") or "").strip():
+            raise BadRequest("deck %d needs a name" % i)
+        cmd = d.get("commander")
+        if isinstance(cmd, str):
+            cmd = [cmd]
+        if not isinstance(cmd, list) or not cmd or not all(isinstance(c, str) and c.strip() for c in cmd):
+            raise BadRequest("deck %d needs commander: [\"Card Name\"]" % i)
+        main = d.get("main")
+        if main is None and isinstance(d.get("cards"), list):
+            counts = {}
+            for n in d["cards"]:
+                counts[str(n)] = counts.get(str(n), 0) + 1
+            main = [{"name": k, "count": v} for k, v in counts.items()]
+        if not isinstance(main, list) or not main or len(main) > MAX_DECK_ENTRIES:
+            raise BadRequest("deck %d needs a non-empty main list (at most %d entries)" % (i, MAX_DECK_ENTRIES))
+        rows = []
+        for e in main:
+            try:
+                name, count = str(e["name"]), int(e["count"])
+            except (KeyError, TypeError, ValueError):
+                raise BadRequest("deck %d has a bad main entry: %r" % (i, e))
+            if not name.strip() or not 1 <= count <= 99:
+                raise BadRequest("deck %d has a bad main entry: %r" % (i, e))
+            rows.append({"name": name, "count": count})
+        feed.append({"name": str(d["name"]), "commander": [c.strip() for c in cmd], "main": rows})
+    try:
+        games = int(req.get("games", 1))
+        seed = int(req.get("seed", 1))
+    except (TypeError, ValueError):
+        raise BadRequest("games and seed must be integers")
+    if not 1 <= games <= MAX_GAMES:
+        raise BadRequest("games must be 1 to %d" % MAX_GAMES)
+    difficulty = req.get("difficulty", "Medium")
+    if difficulty not in DIFFICULTIES:
+        raise BadRequest("difficulty must be one of %s" % ", ".join(DIFFICULTIES))
+    seat_diff = {}
+    for k, v in (req.get("seat_difficulty") or {}).items():
+        if str(k) not in ("0", "1", "2", "3") or v not in DIFFICULTIES:
+            raise BadRequest("seat_difficulty keys are seats 0-3, values one of %s" % ", ".join(DIFFICULTIES))
+        seat_diff[int(k)] = v
+    cap = req.get("action_cap")
+    if cap is not None:
+        try:
+            cap = int(cap)
+        except (TypeError, ValueError):
+            raise BadRequest("action_cap must be an integer")
+        if not 100 <= cap <= 200000:
+            raise BadRequest("action_cap must be 100 to 200000")
+    llm = None
+    seats = req.get("llm_seats") or []
+    if seats:
+        if not isinstance(seats, list) or not all(isinstance(x, int) and 0 <= x <= 3 for x in seats):
+            raise BadRequest("llm_seats must be a list of seats 0-3")
+        cfg = req.get("llm") or {}
+        kind = cfg.get("kind", "chat")
+        if kind not in ("chat", "decision"):
+            raise BadRequest("llm.kind must be chat or decision")
+        if (kind == "chat" and not CHAT_URL) or (kind == "decision" and not DECISION_URL):
+            raise BadRequest("this service has no %s model endpoint configured" % kind)
+        if not os.path.isfile(BIN_LLM) and not os.environ.get("PHASE_SIM_ALLOW_MISSING_LLM_BIN"):
+            raise BadRequest("this image has no model-seat engine (ai-commander-llm)")
+        model = str(cfg.get("model") or "").strip()
+        if kind == "chat" and not model:
+            raise BadRequest("llm.model is required for a chat model")
+        try:
+            max_calls = int(cfg.get("max_calls", 300))
+        except (TypeError, ValueError):
+            raise BadRequest("llm.max_calls must be an integer")
+        if not 1 <= max_calls <= MAX_LLM_CALLS:
+            raise BadRequest("llm.max_calls must be 1 to %d" % MAX_LLM_CALLS)
+        llm = {"seats": sorted(set(seats)), "kind": kind, "model": model or "decision-model", "max_calls": max_calls}
+    return {"feed": feed, "games": games, "seed": seed, "difficulty": difficulty, "seat_difficulty": seat_diff, "action_cap": cap, "llm": llm}
+
+
+def engine_env(spec):
+    """The environment for the engine process: model-seat settings, or None (inherit) for the plain runner."""
+    llm = spec.get("llm")
+    if not llm:
+        return None
+    env = dict(os.environ)
+    local = "http://127.0.0.1:%d" % PORT
+    env.update(PHASE_LLM_SEATS=",".join(str(x) for x in llm["seats"]), PHASE_LLM_MODEL=llm["model"], PHASE_LLM_API_KEY="",
+               PHASE_LLM_MAX_CALLS=str(llm["max_calls"]), PHASE_LLM_DIFFICULTY=spec["difficulty"], PHASE_LLM_TIMEOUT_S=MODEL_TIMEOUT)
+    if llm["kind"] == "chat":
+        env.update(PHASE_LLM_PROVIDER="OpenAiCompatible", PHASE_LLM_BASE_URL=local + "/llm/v1")
+    else:
+        env.update(PHASE_LLM_PROVIDER="Jev", PHASE_LLM_BASE_URL=local)
+    return env
+
+
+def command(spec, root):
+    cmd = [BIN_LLM if spec.get("llm") else BIN, root, "--feed", "feed.json", "--games-file", os.path.join(root, "games.txt")]
+    for seat, level in sorted(spec["seat_difficulty"].items()):
+        cmd += ["--difficulty-p%d" % seat, level]
+    if spec["action_cap"]:
+        cmd += ["--action-cap", str(spec["action_cap"])]
+    return cmd
+
+
+# ---------- engine output -> results ------------------------------------------------------------------------------------------
+
+GAME_HEAD = re.compile(r"^--- GAME\b(.*)$")
+WINNER = re.compile(r"Game ended cleanly\. Winner: (draw|P(\d))")
+TURNS = re.compile(r"^Turns played: (\d+)")
+ELIM = re.compile(r"^ELIMINATED: P(\d)\s+turn=(\d+)")
+RESOLVED = re.compile(r"^\s+P(\d)\s+main=\s*(\d+)\s+commander=(\d+)")
+LLM_STAT = re.compile(r"^LLM-SEAT seat=(\d) asked=(\d+) used=(\d+)(?: total_calls=(\d+))?(?: timeouts=(\d+))?(?: avg_ms=(\d+))?(?: avg_prompt_chars=(\d+))?")
+LLM_OFF = re.compile(r"^LLM-SEAT-DISABLED after (\d+) consecutive failures")
+SKIP = re.compile(r"^\s+SKIP (.+?): commander '(.+)' not in card db")
+PRE = re.compile(r"^\s+(.+?)\s+\|\s+commander: (.+?)\s+\|\s+main: (\d+) cards")
+
+
+def parse(output):
+    """Per-game rows and the deck-resolution facts from the engine's stdout. Games that did not finish are kept, labelled, never counted."""
+    lines = output.splitlines()
+    pre, resolved, skipped, games, cur = [], {}, [], [], None
+
+    def finish():
+        if cur is not None:
+            games.append(cur)
+
+    def new_game(label=""):
+        return {"label": label, "status": "unfinished", "winner_seat": None, "turns": None, "eliminated": []}
+
+    result_line = re.compile(r"Game ended cleanly|^Turns played|^ELIMINATED:|^STALL:|ABORT: hit action cap|PANICKED")
+    for ln in lines:
+        if cur is None and not games:                       # the preamble: decks listed, then their resolved sizes
+            m = PRE.match(ln)
+            if m:
+                pre.append({"deck": m.group(1), "commander": m.group(2), "listed": int(m.group(3))})
+                continue
+            m = SKIP.match(ln)
+            if m:
+                skipped.append({"deck": m.group(1), "commander": m.group(2)})
+                continue
+            m = RESOLVED.match(ln)
+            if m and int(m.group(1)) not in resolved:
+                resolved[int(m.group(1))] = {"main": int(m.group(2)), "commanders": int(m.group(3))}
+                continue
+        if GAME_HEAD.match(ln):
+            finish()
+            cur = new_game(GAME_HEAD.match(ln).group(1).strip(" -"))
+            continue
+        if cur is None:
+            if not result_line.search(ln):
+                continue                                    # banner and preamble lines are not a game
+            cur = new_game()                                # a single-game run prints no "--- GAME" header
+        m = WINNER.search(ln)
+        if m:
+            cur["status"] = "draw" if m.group(1) == "draw" else "won"
+            cur["winner_seat"] = None if m.group(2) is None else int(m.group(2))
+            continue
+        m = TURNS.match(ln)
+        if m:
+            cur["turns"] = int(m.group(1))
+            continue
+        m = ELIM.match(ln)
+        if m:
+            cur["eliminated"].append({"seat": int(m.group(1)), "turn": int(m.group(2))})
+            continue
+        if ln.startswith("STALL:"):
+            cur["status"] = "stalled"
+            cur.setdefault("detail", ln)
+        elif "ABORT: hit action cap" in ln:
+            cur["status"] = "action_cap"
+        elif re.search(r"GAME .* PANICKED", ln):
+            cur["status"] = "panicked"
+            cur["detail"] = ln[:300]
+    finish()
+    games = [g for g in games if g["status"] != "unfinished" or g["turns"] is not None or g["eliminated"] or g["label"]]
+    return {"pre": pre, "resolved": resolved, "skipped": skipped, "games": games}
+
+
+def llm_summary(llm, lines):
+    """The model seats' own counters (the engine prints one every 25th question), last value per seat, plus the breaker and the cost."""
+    per_seat, extra, disabled = {}, {}, None
+    for ln in lines:
+        m = LLM_STAT.match(ln)
+        if m:
+            per_seat[int(m.group(1))] = {"asked": int(m.group(2)), "used": int(m.group(3))}
+            for key, grp in (("timeouts", 5), ("avg_ms", 6), ("avg_prompt_chars", 7)):
+                if m.group(grp) is not None:
+                    extra[key] = int(m.group(grp))
+            continue
+        m = LLM_OFF.match(ln)
+        if m:
+            disabled = int(m.group(1))
+    out = {"seats": llm["seats"], "kind": llm["kind"], "model": llm["model"], "max_calls": llm["max_calls"], "per_seat": per_seat,
+           "note": "counters are printed every 25th question, so the last few may be missing"}
+    out.update(extra)
+    if disabled is not None:
+        out["switched_off_after_failures_in_a_row"] = disabled
+    return out
+
+
+def wilson(wins, n, z=1.96):
+    if n == 0:
+        return [0.0, 0.0]
+    p = wins / n
+    d = 1 + z * z / n
+    c = p + z * z / (2 * n)
+    h = z * math.sqrt(p * (1 - p) / n + z * z / (4 * n * n))
+    return [round(max(0.0, (c - h) / d), 4), round(min(1.0, (c + h) / d), 4)]
+
+
+def summarize(spec, parsed, seeds):
+    decks = [d["name"] for d in spec["feed"]]
+    finished = [g for g in parsed["games"] if g["status"] in ("won", "draw")]
+    won = [g for g in finished if g["status"] == "won"]
+    by_seat = [sum(1 for g in won if g["winner_seat"] == i) for i in range(4)]
+    n = len(finished)
+    warnings = []
+    for s in parsed["skipped"]:
+        warnings.append("deck %r was skipped: commander %r is not in the engine's card database" % (s["deck"], s["commander"]))
+    for i, pre in enumerate(parsed["pre"][:4]):
+        got = (parsed["resolved"].get(i) or {}).get("main")
+        if got is not None and got < pre["listed"]:
+            warnings.append("seat %d (%s): %d of %d cards were not recognised by the engine and were left out" % (
+                i, pre["deck"], pre["listed"] - got, pre["listed"]))
+    bad = [g for g in parsed["games"] if g["status"] not in ("won", "draw")]
+    if bad:
+        warnings.append("%d game(s) did not finish (%s): not counted as wins or draws" % (
+            len(bad), ", ".join(sorted({g["status"] for g in bad}))))
+    for i, g in enumerate(parsed["games"]):
+        if i < len(seeds):
+            g["seed"] = seeds[i]
+    return {"games_requested": spec["games"], "games_finished": n, "games_not_finished": len(bad), "draws": n - len(won),
+            "wins_by_seat": by_seat,
+            "decks": [{"seat": i, "name": decks[i], "wins": by_seat[i], "win_rate": round(by_seat[i] / n, 4) if n else None,
+                       "win_rate_95": wilson(by_seat[i], n)} for i in range(4)],
+            "avg_turns": round(sum(g["turns"] or 0 for g in finished) / n, 1) if n else None,
+            "warnings": warnings, "games": parsed["games"]}
+
+
+# ---------- jobs ----------------------------------------------------------------------------------------------------------------
+
+def run_job(job):
+    spec = job["spec"]
+    root = tempfile.mkdtemp(prefix="phase-sim-")
+    out_lines = []
+    try:
+        os.symlink(CARD_DATA, os.path.join(root, "card-data.json"))
+        with open(os.path.join(root, "feed.json"), "w", encoding="utf-8") as f:
+            json.dump({"decks": spec["feed"]}, f)
+        seeds = [spec["seed"] + i for i in range(spec["games"])]
+        with open(os.path.join(root, "games.txt"), "w", encoding="utf-8") as f:
+            f.write("".join("%d,%s\n" % (s, spec["difficulty"]) for s in seeds))
+        job["status"], job["started"] = "running", time.time()
+        proc = subprocess.Popen(command(spec, root), stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, errors="replace", cwd=root,
+                                env=engine_env(spec))
+        timer = threading.Timer(JOB_TIMEOUT, proc.kill)
+        timer.start()
+        try:
+            for ln in proc.stdout:
+                out_lines.append(ln.rstrip("\n"))
+                if GAME_HEAD.match(ln):
+                    job["games_started"] += 1
+                if WINNER.search(ln) or "GAME" in ln and "PANICKED" in ln or ln.startswith("STALL:") or "ABORT: hit action cap" in ln:
+                    job["games_done"] += 1
+            code = proc.wait()
+        finally:
+            timer.cancel()
+        text = "\n".join(out_lines)
+        parsed = parse(text)
+        job["result"] = summarize(spec, parsed, seeds)
+        if spec.get("llm"):
+            job["result"]["llm"] = llm_summary(spec["llm"], out_lines)
+            if "switched_off_after_failures_in_a_row" in job["result"]["llm"]:
+                job["result"]["warnings"].append(
+                    "the model seats switched themselves off after %d failures in a row (usually timeouts: late-game prompts are thousands of tokens "
+                    "and the model server could not read them in time); phase's own AI played the rest of the run, so the later moves are NOT the model's"
+                    % job["result"]["llm"]["switched_off_after_failures_in_a_row"])
+            job["result"]["warnings"].append(
+                "model seats %s: the model is asked about each non-forced decision, up to %d calls for the whole run; an answer the engine "
+                "cannot use, a timeout, or any decision after the cap is played by phase's own AI instead" % (spec["llm"]["seats"], spec["llm"]["max_calls"]))
+        job["engine_exit_code"] = code
+        job["output_tail"] = out_lines[-40:]
+        job["status"] = "done" if parsed["games"] else "error"
+        if not parsed["games"]:
+            job["error"] = "the engine produced no game results (exit code %s); see output_tail" % code
+    except Exception as exc:  # the job fails, the service does not
+        job["status"], job["error"] = "error", "%s: %s" % (type(exc).__name__, exc)
+        job["output_tail"] = out_lines[-40:]
+    finally:
+        job["finished"] = time.time()
+        try:
+            for name in os.listdir(root):
+                os.unlink(os.path.join(root, name))
+            os.rmdir(root)
+        except OSError:
+            pass
+
+
+def worker():
+    while True:
+        with _cv:
+            while not _queue:
+                _cv.wait()
+            job = _queue.popleft()
+            _running["id"] = job["id"]
+        run_job(job)
+        with _cv:
+            _running["id"] = None
+
+
+def submit(req):
+    spec = validate(req)
+    job = {"id": uuid.uuid4().hex[:12], "status": "queued", "created": time.time(), "spec": spec, "games_started": 0, "games_done": 0}
+    with _cv:
+        _jobs[job["id"]] = job
+        _queue.append(job)
+        for old in sorted(_jobs.values(), key=lambda j: j["created"])[:-50]:   # remember the last 50
+            if old["status"] in ("done", "error"):
+                _jobs.pop(old["id"], None)
+        _cv.notify()
+    return job["id"]
+
+
+def public(job):
+    out = {k: job[k] for k in ("id", "status", "games_started", "games_done") if k in job}
+    out["games_requested"] = job["spec"]["games"]
+    for k in ("result", "error", "output_tail", "engine_exit_code"):
+        if k in job:
+            out[k] = job[k]
+    if "started" in job:
+        out["seconds"] = round((job.get("finished") or time.time()) - job["started"], 1)
+    return out
+
+
+def forward(url, data, headers):
+    req = urllib.request.Request(url, data=data, headers=dict({"content-type": "application/json"}, **headers))
+    try:
+        with urllib.request.urlopen(req, timeout=RELAY_TIMEOUT) as r:
+            return r.status, json.loads(r.read() or b"{}")
+    except urllib.error.HTTPError as exc:
+        try:
+            return exc.code, json.loads(exc.read() or b"{}")
+        except ValueError:
+            return exc.code, {"error": "upstream error"}
+    except (urllib.error.URLError, OSError, ValueError):
+        return 502, {"error": "the model endpoint is not reachable"}
+
+
+def relay_chat(body, remote):
+    """POST /llm/v1/chat/completions -> the OpenAI-style endpoint, with the model's thinking off and its answer capped."""
+    if remote not in LOCAL_ONLY or not CHAT_URL:
+        return 403, {"error": "not available"}
+    try:
+        req = json.loads(body)
+        req["max_tokens"] = min(int(req.get("max_tokens") or CHAT_MAX_TOKENS), CHAT_MAX_TOKENS)
+        req["stream"] = False
+        if CHAT_REASONING:
+            req["reasoning_effort"] = CHAT_REASONING
+        data = json.dumps(req).encode()
+    except (ValueError, TypeError):
+        return 400, {"error": "bad chat request"}
+    return forward(CHAT_URL + "/chat/completions", data, {})
+
+
+def relay_decision(body, remote):
+    """POST /jev/systemone: phase's Jev envelope {"apiKey", "request": {...}} -> a System One server (Laya / Kev); the key comes from the environment."""
+    if remote not in LOCAL_ONLY or not DECISION_URL:
+        return 403, {"error": "not available"}
+    try:
+        data = json.dumps(json.loads(body)["request"]).encode()
+    except (ValueError, KeyError, TypeError):
+        return 400, {"error": "bad decision request"}
+    return forward(DECISION_URL, data, {"authorization": "Bearer " + DECISION_KEY} if DECISION_KEY else {})
+
+
+class Handler(BaseHTTPRequestHandler):
+    protocol_version = "HTTP/1.1"
+    server_version = "phase-sim/1"
+
+    def log_message(self, fmt, *args):
+        if os.environ.get("PHASE_SIM_LOG") == "1":
+            sys.stderr.write("%s\n" % (fmt % args))
+
+    def _send(self, code, obj):
+        body = json.dumps(obj).encode()
+        self.send_response(code)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def do_GET(self):
+        if self.path == "/health":
+            with _cv:
+                return self._send(200, {"ok": os.path.isfile(BIN) and os.path.isfile(CARD_DATA), "engine": ENGINE,
+                                        "queued": len(_queue), "running": _running["id"], "max_games": MAX_GAMES})
+        m = re.match(r"^/job/([0-9a-f]+)$", self.path)
+        if m:
+            with _cv:
+                job = _jobs.get(m.group(1))
+                return self._send(200, public(job)) if job else self._send(404, {"error": "no such job"})
+        self._send(404, {"error": "not found"})
+
+    def do_POST(self):
+        if self.path in ("/llm/v1/chat/completions", "/jev/systemone"):
+            n = int(self.headers.get("Content-Length") or 0)
+            if n > 4_000_000:
+                return self._send(413, {"error": "request too large"})
+            fn = relay_chat if self.path.startswith("/llm") else relay_decision
+            code, obj = fn(self.rfile.read(n), self.client_address[0])
+            return self._send(code, obj)
+        if self.path != "/run":
+            return self._send(404, {"error": "not found"})
+        try:
+            n = int(self.headers.get("Content-Length") or 0)
+            if n > 2_000_000:
+                return self._send(413, {"error": "request too large"})
+            req = json.loads(self.rfile.read(n) or b"{}")
+            if not isinstance(req, dict):
+                raise BadRequest("the body must be a JSON object")
+            self._send(202, {"job": submit(req)})
+        except (BadRequest, json.JSONDecodeError) as exc:
+            self._send(400, {"error": str(exc)})
+
+
+def main():
+    threading.Thread(target=worker, daemon=True).start()
+    ThreadingHTTPServer(("0.0.0.0", PORT), Handler).serve_forever()
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,108 @@
+"""Smoke test, run INSIDE the image (CI and by hand): four real decks from phase's own sample feed play real games through the service.
+
+    python /opt/phase/phase_smoke.py [games] [difficulty]            plain engine
+    python /opt/phase/phase_smoke.py --llm                           model seats against a stub model inside this process
+
+Exits non-zero unless at least one game finished with a winner or a draw. Prints what the engine reported, including any cards it did
+not recognise, so a bad data/engine pairing shows up here and not in a result someone trusts.
+
+--llm starts a stub OpenAI-style model on 127.0.0.1:9099 (the service must have been started with PHASE_LLM_CHAT_URL=http://127.0.0.1:9099/v1),
+puts seats 1 and 3 on it, and passes when the engine's own counters show the model was asked AND its answers were used by the engine: that
+proves the Rust hook, the relay and phase's answer check end to end without any outside service. The stub always answers option 0, so the
+game itself may not finish (it can hit the action cap); that is not what is being tested.
+"""
+import json
+import sys
+import threading
+import time
+import urllib.request
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+BASE = "http://127.0.0.1:8090"
+LLM = "--llm" in sys.argv
+args = [a for a in sys.argv[1:] if not a.startswith("--")]
+games = int(args[0]) if args else (1 if LLM else 2)
+difficulty = args[1] if len(args) > 1 else "VeryEasy"
+
+ASKED = []
+
+
+class StubModel(BaseHTTPRequestHandler):
+    def log_message(self, *a):
+        pass
+
+    def do_POST(self):
+        body = json.loads(self.rfile.read(int(self.headers.get("Content-Length") or 0)))
+        ASKED.append(body)
+        out = json.dumps({"choices": [{"index": 0, "message": {"role": "assistant", "content": "{\"choice\": 0, \"reason\": \"stub\"}"}, "finish_reason": "stop"}],
+                          "usage": {"prompt_tokens": 1, "completion_tokens": 1, "total_tokens": 2}}).encode()
+        self.send_response(200)
+        self.send_header("content-type", "application/json")
+        self.send_header("content-length", str(len(out)))
+        self.end_headers()
+        self.wfile.write(out)
+
+
+if LLM:
+    threading.Thread(target=HTTPServer(("127.0.0.1", 9099), StubModel).serve_forever, daemon=True).start()
+
+
+def call(path, body=None):
+    req = urllib.request.Request(BASE + path, data=None if body is None else json.dumps(body).encode(), headers={"content-type": "application/json"})
+    with urllib.request.urlopen(req, timeout=60) as r:
+        return json.load(r)
+
+
+for _ in range(60):
+    try:
+        h = call("/health")
+        break
+    except Exception:
+        time.sleep(1)
+else:
+    sys.exit("the service did not come up")
+print("health:", h)
+assert h["ok"], "binary or card data missing"
+
+feed = json.load(open("/opt/phase/sample-feed.json", encoding="utf-8"))["decks"]
+decks = []
+for d in feed:
+    cmd = d.get("commander") or [d["name"]]
+    decks.append({"name": d["name"], "commander": cmd, "main": d["main"]})
+    if len(decks) == 4:
+        break
+request = {"decks": decks, "games": games, "seed": 7, "difficulty": difficulty, "action_cap": 60000}
+if LLM:
+    request.update(action_cap=6000, llm_seats=[1, 3], llm={"kind": "chat", "model": "stub-model", "max_calls": 60})
+job = call("/run", request)["job"]
+t0 = time.time()
+while True:
+    j = call("/job/" + job)
+    if j["status"] in ("done", "error"):
+        break
+    if time.time() - t0 > 1500:
+        sys.exit("timed out; last: %s" % json.dumps(j)[:300])
+    time.sleep(3)
+print("job: %s in %.0f s" % (j["status"], time.time() - t0))
+res = j.get("result") or {}
+print(json.dumps({k: res.get(k) for k in ("games_requested", "games_finished", "games_not_finished", "draws", "wins_by_seat", "avg_turns", "warnings")}, indent=1))
+for g in res.get("games", []):
+    print("  game seed=%s %s winner=%s turns=%s eliminated=%s" % (g.get("seed"), g["status"], g.get("winner_seat"), g.get("turns"), g.get("eliminated")))
+if LLM:
+    llm = res.get("llm") or {}
+    print("model seats:", json.dumps(llm), "| requests the stub model received:", len(ASKED))
+    print("\n".join((j.get("output_tail") or [])[-15:]))
+    seats = llm.get("per_seat") or {}
+    asked = sum(v["asked"] for v in seats.values())
+    used = sum(v["used"] for v in seats.values())
+    reasoned = [a for a in ASKED if a.get("reasoning_effort") == "none"]
+    if not ASKED or not asked or not used:
+        sys.exit("the model seats were not exercised: stub got %d requests, engine counters asked=%d used=%d" % (len(ASKED), asked, used))
+    if len(reasoned) != len(ASKED):
+        sys.exit("the relay did not switch the model's thinking off on every request")
+    print("PHASE LLM SMOKE OK (asked %d, engine used %d, stub saw %d requests, all with thinking off)" % (asked, used, len(ASKED)))
+    sys.exit(0)
+if j["status"] != "done" or res.get("games_finished", 0) < 1:
+    print("\n".join(j.get("output_tail") or []))
+    sys.exit("no game finished")
+print("PHASE SMOKE OK")
@@ -0,0 +1,272 @@
+"""Run:  python -I -X utf8 test_phase_sim.py   (offline: a stub engine prints output in the format phase's ai-commander prints)"""
+import json
+import os
+import sys
+import tempfile
+import threading
+import time
+import urllib.request
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import phase_sim as P  # noqa: E402
+
+FAILS = 0
+
+
+def ck(name, cond, detail=""):
+    global FAILS
+    print("  %s  %s%s" % ("ok  " if cond else "FAIL", name, ("  -- " + str(detail)[:260]) if detail and not cond else ""))
+    if not cond:
+        FAILS += 1
+
+
+def deck(name, cmd, n=3):
+    return {"name": name, "commander": [cmd], "main": [{"name": "Sol Ring", "count": 1}, {"name": "Forest", "count": n}]}
+
+
+GOOD = {"decks": [deck("A", "Cmd A"), deck("B", "Cmd B"), deck("C", "Cmd C"), deck("D", "Cmd D")], "games": 3, "seed": 10}
+
+# --- validation
+def bad(mut, why):
+    req = json.loads(json.dumps(GOOD))
+    mut(req)
+    try:
+        P.validate(req)
+        ck("rejects " + why, False)
+    except P.BadRequest as exc:
+        ck("rejects " + why, True, exc)
+
+ck("a good request validates", P.validate(GOOD)["games"] == 3)
+bad(lambda r: r["decks"].pop(), "three decks")
+bad(lambda r: r["decks"][0].pop("commander"), "a deck with no commander")
+bad(lambda r: r["decks"][1].update(main=[]), "an empty main list")
+bad(lambda r: r["decks"][2]["main"].append({"name": "X", "count": 0}), "a zero count")
+bad(lambda r: r.update(games=P.MAX_GAMES + 1), "too many games")
+bad(lambda r: r.update(difficulty="Impossible"), "an unknown difficulty")
+bad(lambda r: r.update(seat_difficulty={"7": "Easy"}), "a seat outside 0-3")
+bad(lambda r: r.update(action_cap=5), "a tiny action cap")
+v = P.validate(dict(GOOD, decks=[dict(deck("A", "Cmd A"), commander="Cmd A", main=None, cards=["Forest", "Forest", "Sol Ring"])] + GOOD["decks"][1:]))
+ck("a plain card list becomes counted rows and a commander string becomes a list",
+   v["feed"][0]["commander"] == ["Cmd A"] and {"name": "Forest", "count": 2} in v["feed"][0]["main"], v["feed"][0])
+
+# --- parsing the engine's output
+OUT = """=== 4-player Commander AI test ===
+Feed: feed.json
+Batch mode: 5 games from games.txt
+
+  A  |  commander: Cmd A  |  main: 99 cards
+  B  |  commander: Cmd B  |  main: 99 cards
+  SKIP C: commander 'Cmd C' not in card db
+  D  |  commander: Cmd D  |  main: 99 cards
+Resolved deck sizes (post name-resolution, 0-indexed by seat):
+  P0  main= 99  commander=1
+  P1  main= 97  commander=1
+  P2  main= 99  commander=1
+  P3  main= 99  commander=1
+
+ExecutionMode: measurement
+--- GAME seed=10 difficulty=Medium ---
+Game started. 4 players.
+ELIMINATED: P1  turn=9  actions=  400  elapsed=3.1s
+ELIMINATED: P3  turn=12  actions=  600  elapsed=5.0s
+
+=== RESULT ===
+Elapsed: 8.0s
+Turns played: 14
+
+Game ended cleanly. Winner: P2
+--- GAME seed=11 difficulty=Medium ---
+Game started. 4 players.
+=== RESULT ===
+Turns played: 40
+Game ended cleanly. Winner: draw
+--- GAME seed=12 difficulty=Medium ---
+=== RESULT ===
+Turns played: 7
+STALL: waiting_for=ChooseTarget turn=7 active=P0 priority=P0 pending_cast=none
+Game did NOT reach GameOver. waiting_for = ChooseTarget
+--- GAME seed=13 difficulty=Medium ---
+ABORT: hit action cap=50000
+=== RESULT ===
+Turns played: 31
+Game did NOT reach GameOver. waiting_for = Priority
+--- GAME seed=14 difficulty=Medium ---
+GAME 14 PANICKED: index out of bounds
+"""
+parsed = P.parse(OUT)
+st = [g["status"] for g in parsed["games"]]
+ck("five games found with their outcomes in order", st == ["won", "draw", "stalled", "action_cap", "panicked"], st)
+g0 = parsed["games"][0]
+ck("winner seat, turns and elimination order are read", g0["winner_seat"] == 2 and g0["turns"] == 14
+   and [e["seat"] for e in g0["eliminated"]] == [1, 3], g0)
+ck("a draw has no winner seat", parsed["games"][1]["winner_seat"] is None)
+ck("pre-resolution and resolved deck sizes and the skipped deck are read", len(parsed["pre"]) == 3 and parsed["resolved"][1]["main"] == 97
+   and parsed["skipped"] == [{"deck": "C", "commander": "Cmd C"}], (parsed["pre"], parsed["resolved"], parsed["skipped"]))
+
+spec = P.validate(dict(GOOD, games=5))
+res = P.summarize(spec, parsed, [10, 11, 12, 13, 14])
+ck("only finished games are counted", res["games_finished"] == 2 and res["games_not_finished"] == 3 and res["draws"] == 1, res)
+ck("wins by seat and per-deck win rate", res["wins_by_seat"] == [0, 0, 1, 0] and res["decks"][2]["win_rate"] == 0.5 and res["decks"][0]["win_rate"] == 0.0)
+lo, hi = res["decks"][2]["win_rate_95"]
+ck("a 95% interval wraps the rate and stays in 0..1", 0 <= lo < 0.5 < hi <= 1)
+w = " | ".join(res["warnings"])
+ck("warnings: a skipped deck, unrecognised cards, and unfinished games (never counted)",
+   "was skipped" in w and "2 of 99" in w and "not counted as wins or draws" in w and "stalled" in w, w)
+ck("each game carries its seed", [g["seed"] for g in res["games"]] == [10, 11, 12, 13, 14])
+ck("interval of nothing is zeros, of a sweep is high", P.wilson(0, 0) == [0.0, 0.0] and P.wilson(10, 10)[0] > 0.7)
+
+# --- a whole job through the real worker path with a stub engine
+STUB = os.path.join(tempfile.mkdtemp(), "stub_engine.py")
+with open(STUB, "w", encoding="utf-8") as f:
+    f.write('''import sys, os
+root = sys.argv[1]
+seeds = [l.split(",")[0] for l in open(os.path.join(root, "games.txt")) if l.strip()]
+feed = __import__("json").load(open(os.path.join(root, "feed.json")))
+assert os.path.exists(os.path.join(root, "card-data.json")) and len(feed["decks"]) == 4
+for d in feed["decks"]:
+    print("  %s  |  commander: %s  |  main: %d cards" % (d["name"], d["commander"][0], sum(e["count"] for e in d["main"])))
+print("Resolved deck sizes (post name-resolution, 0-indexed by seat):")
+for i, d in enumerate(feed["decks"]):
+    print("  P%d  main=%3d  commander=1" % (i, sum(e["count"] for e in d["main"])))
+for k, s in enumerate(seeds):
+    print("--- GAME seed=%s ---" % s)
+    print("Turns played: %d" % (10 + k))
+    print("Game ended cleanly. Winner: P%d" % (k % 4))
+''')
+CD = os.path.join(os.path.dirname(STUB), "card-data.json")
+open(CD, "w").write("{}")
+P.CARD_DATA = CD
+ORIG_COMMAND = P.command
+P.command = lambda spec, root: [sys.executable, STUB, root]
+job_id = P.submit(dict(GOOD, games=4))
+threading.Thread(target=P.worker, daemon=True).start()
+for _ in range(100):
+    j = P._jobs[job_id]
+    if j["status"] in ("done", "error"):
+        break
+    time.sleep(0.1)
+pub = P.public(P._jobs[job_id])
+ck("a queued job runs to done with four finished games, one win each", pub["status"] == "done" and pub["result"]["games_finished"] == 4
+   and pub["result"]["wins_by_seat"] == [1, 1, 1, 1] and pub["games_done"] == 4, pub)
+ck("no warnings when every card resolved", pub["result"]["warnings"] == [], pub["result"]["warnings"])
+ck("the temp folder is cleaned up", not [d for d in os.listdir(tempfile.gettempdir()) if d.startswith("phase-sim-")])
+
+# --- the HTTP surface
+srv = P.ThreadingHTTPServer(("127.0.0.1", 0), P.Handler)
+threading.Thread(target=srv.serve_forever, daemon=True).start()
+base = "http://127.0.0.1:%d" % srv.server_port
+def call(path, body=None):
+    req = urllib.request.Request(base + path, data=None if body is None else json.dumps(body).encode(), headers={"content-type": "application/json"})
+    try:
+        r = urllib.request.urlopen(req, timeout=10)
+        return r.status, json.load(r)
+    except urllib.error.HTTPError as e:
+        return e.code, json.load(e)
+code, h = call("/health")
+ck("/health answers (ok is false only because the real binary is not here)", code == 200 and "engine" in h and h["max_games"] == P.MAX_GAMES, h)
+code, r = call("/run", dict(GOOD, games=1))
+ck("POST /run is accepted with a job id", code == 202 and len(r["job"]) == 12, r)
+for _ in range(100):
+    code, j = call("/job/" + r["job"])
+    if j["status"] in ("done", "error"):
+        break
+    time.sleep(0.1)
+ck("GET /job/<id> returns the result", code == 200 and j["status"] == "done" and j["result"]["games_finished"] == 1, j)
+ck("a bad request is a 400 with a reason", call("/run", {"decks": []})[0] == 400)
+ck("an unknown job is a 404", call("/job/deadbeef")[0] == 404)
+ck("an unknown path is a 404", call("/nope")[0] == 404)
+# --- model seats: validation, environment, relays
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+UP = []
+
+
+class Upstream(BaseHTTPRequestHandler):
+    def log_message(self, *a):
+        pass
+
+    def do_POST(self):
+        body = json.loads(self.rfile.read(int(self.headers.get("Content-Length") or 0)))
+        UP.append((self.path, body, self.headers.get("authorization")))
+        out = json.dumps({"echo": True, "path": self.path}).encode()
+        self.send_response(200)
+        self.send_header("content-type", "application/json")
+        self.send_header("content-length", str(len(out)))
+        self.end_headers()
+        self.wfile.write(out)
+
+
+up = HTTPServer(("127.0.0.1", 0), Upstream)
+threading.Thread(target=up.serve_forever, daemon=True).start()
+UPBASE = "http://127.0.0.1:%d" % up.server_port
+os.environ["PHASE_SIM_ALLOW_MISSING_LLM_BIN"] = "1"
+LLMREQ = dict(GOOD, llm_seats=[1, 3], llm={"kind": "chat", "model": "twin-turbo", "max_calls": 120})
+
+P.CHAT_URL, P.DECISION_URL = "", ""
+try:
+    P.validate(LLMREQ)
+    ck("model seats are refused when no model endpoint is configured", False)
+except P.BadRequest as exc:
+    ck("model seats are refused when no model endpoint is configured", "no chat model endpoint" in str(exc), exc)
+P.CHAT_URL, P.DECISION_URL, P.DECISION_KEY = UPBASE + "/v1", UPBASE + "/v1/systemone", "sekret"
+v = P.validate(LLMREQ)
+ck("a chat model seat request validates", v["llm"] == {"seats": [1, 3], "kind": "chat", "model": "twin-turbo", "max_calls": 120}, v["llm"])
+ck("a request with no model seats has no llm settings", P.validate(GOOD)["llm"] is None)
+for mut, why in ((lambda r: r.update(llm_seats=[4]), "a seat outside 0-3"),
+                 (lambda r: r["llm"].pop("model"), "a chat model with no name"),
+                 (lambda r: r["llm"].update(max_calls=P.MAX_LLM_CALLS + 1), "too many model calls"),
+                 (lambda r: r["llm"].update(kind="telepathy"), "an unknown kind")):
+    req = json.loads(json.dumps(LLMREQ))
+    mut(req)
+    try:
+        P.validate(req)
+        ck("rejects " + why, False)
+    except P.BadRequest:
+        ck("rejects " + why, True)
+dv = P.validate(dict(GOOD, llm_seats=[0], llm={"kind": "decision"}))
+ck("a decision-model seat needs no model name", dv["llm"]["kind"] == "decision" and dv["llm"]["model"] == "decision-model")
+
+env = P.engine_env(v)
+ck("chat seats: the engine is pointed at this service's /llm relay as an OpenAI-compatible endpoint with no key",
+   env["PHASE_LLM_SEATS"] == "1,3" and env["PHASE_LLM_PROVIDER"] == "OpenAiCompatible" and env["PHASE_LLM_BASE_URL"].endswith("/llm/v1")
+   and env["PHASE_LLM_MODEL"] == "twin-turbo" and env["PHASE_LLM_API_KEY"] == "" and env["PHASE_LLM_MAX_CALLS"] == "120", env)
+denv = P.engine_env(dv)
+ck("decision seats: provider Jev, base is this service (the engine adds /jev/systemone)", denv["PHASE_LLM_PROVIDER"] == "Jev"
+   and denv["PHASE_LLM_BASE_URL"] == "http://127.0.0.1:%d" % P.PORT)
+ck("no model seats: no special environment, the plain engine", P.engine_env(P.validate(GOOD)) is None
+   and ORIG_COMMAND(P.validate(GOOD), "/r")[0] == P.BIN and ORIG_COMMAND(v, "/r")[0] == P.BIN_LLM)
+
+code, out = P.relay_chat(json.dumps({"model": "twin-turbo", "messages": [{"role": "user", "content": "x"}], "max_tokens": 4000, "stream": True}).encode(), "127.0.0.1")
+path, body, auth = UP[-1]
+ck("the chat relay forwards to /chat/completions with thinking off, the answer capped and streaming off",
+   code == 200 and path == "/v1/chat/completions" and body["reasoning_effort"] == "none" and body["max_tokens"] == P.CHAT_MAX_TOKENS
+   and body["stream"] is False and body["model"] == "twin-turbo", (code, path, body))
+ck("a request without max_tokens gets the cap", (P.relay_chat(b'{"model": "m", "messages": []}', "127.0.0.1"), UP[-1][1]["max_tokens"] == P.CHAT_MAX_TOKENS)[1])
+ck("the relays refuse anyone but this machine", P.relay_chat(b"{}", "10.1.2.3")[0] == 403 and P.relay_decision(b"{}", "10.1.2.3")[0] == 403)
+ck("a malformed chat body is a 400, not an exception", P.relay_chat(b"not json", "127.0.0.1")[0] == 400)
+envelope = {"apiKey": "ignored-by-us", "request": {"state": {"body": "t"}, "questions": {"pick": {"type": "choice"}}}}
+code, out = P.relay_decision(json.dumps(envelope).encode(), "127.0.0.1")
+path, body, auth = UP[-1]
+ck("the decision relay unwraps phase's envelope and sends only the request, with OUR key", code == 200 and path == "/v1/systemone"
+   and body == envelope["request"] and auth == "Bearer sekret", (code, path, body, auth))
+ck("a decision body with no request is a 400", P.relay_decision(b'{"apiKey": "k"}', "127.0.0.1")[0] == 400)
+P.CHAT_URL = "http://127.0.0.1:1/v1"
+ck("an unreachable model endpoint is a 502", P.relay_chat(b'{"model": "m", "messages": []}', "127.0.0.1")[0] == 502)
+P.CHAT_URL = UPBASE + "/v1"
+
+summ = P.llm_summary({"seats": [1], "kind": "chat", "model": "m", "max_calls": 9},
+                     ["LLM-SEAT seat=1 asked=25 used=20 total_calls=25", "noise", "LLM-SEAT seat=1 asked=50 used=41 total_calls=50"])
+ck("the model seats' counters are read from the engine's output (last value wins)", summ["per_seat"] == {1: {"asked": 50, "used": 41}}, summ)
+
+summ2 = P.llm_summary({"seats": [1], "kind": "chat", "model": "m", "max_calls": 9},
+                      ["LLM-SEAT seat=1 asked=25 used=1 total_calls=25 timeouts=20 avg_ms=1800 avg_prompt_chars=31000",
+                       "LLM-SEAT-DISABLED after 4 consecutive failures (20 timeouts of 25 questions): phase's own AI plays the rest"])
+ck("cost counters and the circuit-breaker are read from the engine's output", summ2["timeouts"] == 20 and summ2["avg_ms"] == 1800
+   and summ2["avg_prompt_chars"] == 31000 and summ2["switched_off_after_failures_in_a_row"] == 4 and summ2["per_seat"] == {1: {"asked": 25, "used": 1}}, summ2)
+ck("old three-field counter lines still parse", P.llm_summary({"seats": [1], "kind": "chat", "model": "m", "max_calls": 9},
+   ["LLM-SEAT seat=2 asked=25 used=24 total_calls=25"])["per_seat"] == {2: {"asked": 25, "used": 24}})
+
+code, r = call("/llm/v1/chat/completions", {"model": "m", "messages": []})
+ck("over HTTP from this machine the chat relay answers", code == 200 and r["echo"] is True, (code, r))
+print("\nFAILURES: %d" % FAILS)
+sys.exit(1 if FAILS else 0)
@@ -38,6 +38,7 @@ from routes.lab import router as lab_router
 from routes.scanner import router as scanner_router
 from routes.rag import router as rag_router
 from routes.deepseek import router as deepseek_router
+from routes.farmhouse_phase import router as farmhouse_phase_router  # FARMHOUSE_PHASE_IMPORT
 from routes.deckgen import router as deckgen_router
 from routes.coach import router as coach_router, init_coach_service
 from routes.ml import router as ml_router
@@ -62,6 +63,7 @@ async def _lifespan(application: FastAPI):
        CFG.precon_dir = _resolve_precon_dir()
    init_collection_db()
    validate_forge_config()
+    init_coach_service()  # FARMHOUSE_COACH_INIT_V1
    if not PRECON_INDEX:
        download_precon_database()
    if not COMMANDER_META:
@@ -85,7 +87,7 @@ async def _lifespan(application: FastAPI):
            try:
                from services.rag_store import check_staleness, build_index
                info = check_staleness()
-                if info.get("stale"):
+                if info.get("stale") and os.environ.get("RAG_AUTOBUILD", "0") == "1":  # FARMHOUSE_RAG_MONITOR_V1
                    log.info("RAG staleness monitor: %s — triggering rebuild.", info["reason"])
                    loop.run_in_executor(None, lambda: build_index(force=True))
                else:
@@ -128,6 +130,7 @@ app.include_router(deckbuilder_router)
 app.include_router(precon_router)
 app.include_router(import_router)
 app.include_router(lab_router)
+app.include_router(farmhouse_phase_router)
 app.include_router(scanner_router)
 app.include_router(rag_router)
 app.include_router(deepseek_router)
@@ -888,7 +888,11 @@ async def import_decklist(deck_id: int, request: FastAPIRequest):
    """
    deck = _get_deck_or_404(deck_id)
    body = await request.json()
-    text = body.get('text', '')
+    try:  # FARMHOUSE_DECK_LINKS_V1b
+        from services.farmhouse_deck_links import expand as _fh_expand
+        text, _fh_name = _fh_expand(body.get('text', '') or body.get('url', ''))
+    except ValueError as _fh_err:
+        return JSONResponse({'error': str(_fh_err)}, status_code=400)
    clear_first = body.get('clearFirst', False)

    if not text.strip():
@@ -980,8 +984,12 @@ async def import_decklist_new(request: FastAPIRequest):
    Body: { "text": "...", "name": "My Deck" }
    """
    body = await request.json()
-    text = body.get('text', '')
-    deck_name = body.get('name', '').strip()
+    try:  # FARMHOUSE_DECK_LINKS_V1c
+        from services.farmhouse_deck_links import expand as _fh_expand
+        text, _fh_name = _fh_expand(body.get('text', '') or body.get('url', ''))
+    except ValueError as _fh_err:
+        return JSONResponse({'error': str(_fh_err)}, status_code=400)
+    deck_name = body.get('name', '').strip() or (_fh_name or '')

    if not text.strip():
        return JSONResponse({'error': 'No decklist text provided'}, status_code=400)
@@ -1064,6 +1072,10 @@ def _scryfall_fuzzy_lookup(name: str) -> Optional[dict]:
    Fuzzy-search Scryfall for a card name (used by the scanner pipeline).
    Returns the raw Scryfall JSON dict, or None on failure.
    """
+    from services.farmhouse_deck_links import local_card as _fh_local  # FARMHOUSE_LOCAL_LOOKUP
+    _fh_hit = _fh_local(name)
+    if _fh_hit:
+        return _fh_hit
    _scryfall_rate_limit()
    try:
        encoded = quote(name)
@@ -516,6 +516,8 @@ def _fetch_deck_card_data(deck_id):
                'keywords': r[7] or '',
                'mana_cost': r[8] or '',
            })
+    from services.farmhouse_sim import fill_card_data as _fh_fill  # FARMHOUSE_SIM_DATA_B
+    _fh_fill(card_data)
    return deck_name, card_data


@@ -0,0 +1,116 @@
+"""Rules-accurate simulation through phase-sim (copied into the app as routes/farmhouse_phase.py by the Dockerfile).
+
+The phase-rs engine (Rust, headless) plays four-player Commander with a real stack, priority, combat, layers and triggers; the
+phase-sim service wraps it. This route turns four SAVED decks into the service's request, relays the job, and returns what the
+engine reported. Nothing is simulated here, and a game that stalled, hit the action cap or panicked is reported, never counted as a win.
+
+  GET  /api/farmhouse/phase/status               the service's health (is the engine there, how many jobs are waiting)
+  POST /api/farmhouse/phase/run                  {"deckIds": [4 saved deck ids], "games": 1..50, "seed": 1, "difficulty": "Medium",
+                                                  "seatDifficulty": {"2": "Hard"}}  ->  {"job": id, "decks": [names]}
+  GET  /api/farmhouse/phase/job/{job}            status, progress and, when finished, wins by seat, win rate with a 95% interval,
+                                                 warnings (cards the engine did not recognise) and each game's outcome
+
+Setting: PHASE_SIM_URL (e.g. http://phase-sim.commander-lab.svc.cluster.local:8090). Unset, every endpoint answers 503 and nothing else changes.
+"""
+import json
+import os
+import urllib.error
+import urllib.request
+from typing import Dict, List, Optional
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from services.database import _get_db_conn
+
+router = APIRouter(tags=["farmhouse-phase"])
+
+
+class PhaseRun(BaseModel):
+    deckIds: List[int]
+    games: int = 1
+    seed: int = 1
+    difficulty: str = "Medium"
+    seatDifficulty: Optional[Dict[str, str]] = None
+    actionCap: Optional[int] = None
+    # Seats (0-3) a MODEL plays instead of phase's built-in AI, and which kind: {"kind": "chat"|"decision", "model": "twin-turbo", "max_calls": 300}.
+    # The model only ever picks among the engine's own legal options; the service falls back to phase's AI on any problem.
+    llmSeats: Optional[List[int]] = None
+    llm: Optional[Dict] = None
+
+
+def _base():
+    url = os.environ.get("PHASE_SIM_URL", "").rstrip("/")
+    if not url:
+        raise HTTPException(503, "the rules engine service is not configured (PHASE_SIM_URL)")
+    return url
+
+
+def _call(path, body=None, timeout=20):
+    req = urllib.request.Request(_base() + path, data=None if body is None else json.dumps(body).encode(),
+                                 headers={"content-type": "application/json"})
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as r:
+            return json.load(r)
+    except urllib.error.HTTPError as exc:
+        try:
+            detail = json.load(exc).get("error", "")
+        except Exception:
+            detail = ""
+        raise HTTPException(exc.code if exc.code in (400, 404, 413) else 502, detail or "the rules engine service refused the request")
+    except (urllib.error.URLError, OSError, ValueError):
+        raise HTTPException(503, "the rules engine service is not reachable")
+
+
+def deck_feed(deck_id):
+    """A saved deck as the phase-sim feed entry: {"name", "commander": [...], "main": [{"name", "count"}]}."""
+    conn = _get_db_conn()
+    deck = conn.execute("SELECT id, name, commander_name FROM decks WHERE id = ?", (deck_id,)).fetchone()
+    if not deck:
+        raise HTTPException(404, "deck %s not found" % deck_id)
+    rows = conn.execute("SELECT card_name, quantity, is_commander FROM deck_cards WHERE deck_id = ?", (deck_id,)).fetchall()
+    commanders, main = [], {}
+    for r in rows:
+        name, qty = (r["card_name"] or "").strip(), int(r["quantity"] or 1)
+        if not name:
+            continue
+        if r["is_commander"]:
+            if name not in commanders:
+                commanders.append(name)
+        else:
+            main[name] = main.get(name, 0) + qty
+    if not commanders and (deck["commander_name"] or "").strip():
+        commanders = [deck["commander_name"].strip()]
+    if not commanders:
+        raise HTTPException(400, "deck %r has no commander set" % deck["name"])
+    main = {n: c for n, c in main.items() if n not in commanders}
+    if not main:
+        raise HTTPException(400, "deck %r has no cards" % deck["name"])
+    return {"name": deck["name"], "commander": commanders, "main": [{"name": n, "count": c} for n, c in sorted(main.items())]}
+
+
+@router.get("/api/farmhouse/phase/status")
+def phase_status():
+    return _call("/health", timeout=5)
+
+
+@router.post("/api/farmhouse/phase/run")
+def phase_run(req: PhaseRun):
+    if len(req.deckIds) != 4:
+        raise HTTPException(400, "pick exactly 4 decks (one per seat)")
+    feed = [deck_feed(i) for i in req.deckIds]
+    body = {"decks": feed, "games": req.games, "seed": req.seed, "difficulty": req.difficulty}
+    if req.seatDifficulty:
+        body["seat_difficulty"] = req.seatDifficulty
+    if req.actionCap:
+        body["action_cap"] = req.actionCap
+    if req.llmSeats:
+        body["llm_seats"] = req.llmSeats
+        body["llm"] = req.llm or {}
+    out = _call("/run", body)
+    return {"job": out["job"], "decks": [d["name"] for d in feed]}
+
+
+@router.get("/api/farmhouse/phase/job/{job}")
+def phase_job(job: str):
+    return _call("/job/" + "".join(c for c in job if c in "0123456789abcdef"), timeout=10)
@@ -98,6 +98,7 @@ async def start_batch(req: StartRequest, background_tasks: BackgroundTasks):
    if req.threads < 1 or req.threads > 32:
        raise HTTPException(400, "threads must be 1-32")

+    req.threads = min(req.threads, int(os.environ.get("FORGE_MAX_THREADS", "1")))  # FARMHOUSE_FORGE_THREADS
    if not os.path.exists(CFG.forge_jar):
        raise HTTPException(500, f"Forge JAR not found: {CFG.forge_jar}")
    if not os.path.isdir(CFG.forge_dir):
@@ -108,7 +109,7 @@ async def start_batch(req: StartRequest, background_tasks: BackgroundTasks):
    active_batches[batch_id] = state

    os.makedirs(CFG.results_dir, exist_ok=True)
-    output_path = os.path.join(CFG.results_dir, f"ml-decision-{batch_id}.json")
+    output_path = os.path.abspath(os.path.join(CFG.results_dir, f"ml-decision-{batch_id}.json"))  # FARMHOUSE_RESULTS_ABS
    state.result_path = output_path

      # Auto-export deckbuilder decks to .dck if not already exported
@@ -0,0 +1,75 @@
+"""How often does a decision model (Laya / Kev) pick the same action as the LLM did, on game states the app has already recorded?
+
+    DECISION_URL=http://laya:8080 python scripts/farmhouse_decision_eval.py [decisions_dir] [model ...]
+
+Reads the brain's own decision logs (logs/decisions/*.jsonl: the snapshot and the LLM's answer), asks the decision model the same
+question for each, and prints agreement overall, at several confidence levels, per action, the "always the most common action"
+baseline, and the time per answer. The LLM is the teacher here, not the truth: this measures how well a fast model can stand in
+for the slow one, not how well either plays.
+"""
+import collections
+import glob
+import importlib.util
+import json
+import os
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+spec = importlib.util.spec_from_file_location("farmhouse_decide", os.path.join(HERE, "..", "src", "commander_ai_lab", "sim", "farmhouse_decide.py"))
+D = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(D)
+
+
+def load(dirpath):
+    rows = []
+    for f in sorted(glob.glob(os.path.join(dirpath, "*.jsonl"))):
+        for line in open(f, encoding="utf-8"):
+            try:
+                r = json.loads(line)
+            except ValueError:
+                continue
+            if (r.get("decision") or {}).get("source") == "llm" and r.get("game_state") and r["decision"].get("action") in D.ACTION_HELP:
+                rows.append(r)
+    return rows
+
+
+def main():
+    dirpath = sys.argv[1] if len(sys.argv) > 1 else os.path.join(HERE, "..", "logs", "decisions")
+    models = sys.argv[2:] or [os.environ.get("DECISION_MODEL", "")]
+    rows = load(dirpath)
+    if not rows:
+        print("no recorded LLM decisions in", dirpath)
+        return 1
+    truth = [r["decision"]["action"] for r in rows]
+    common, n_common = collections.Counter(truth).most_common(1)[0]
+    print("%d recorded decisions; LLM action mix: %s" % (len(rows), dict(collections.Counter(truth))))
+    print("baseline 'always %s': %.1f%%\n" % (common, 100.0 * n_common / len(rows)))
+    for model in models:
+        os.environ["DECISION_MODEL"] = model
+        D.STATS.update({"asked": 0, "agreed": 0, "answered_conf": 0, "errors": 0, "ms_total": 0.0, "by_action": {}})
+        got = []
+        for r in rows:
+            a = D.ask(r["game_state"])
+            got.append(a)
+            D.record(a, r["decision"]["action"])
+        ok = [(g, t) for g, t in zip(got, truth) if g]
+        print("== model %r: answered %d of %d, %.0f ms each" % (model or "auto", len(ok), len(rows), D.stats()["avg_ms"] or 0))
+        if not ok:
+            continue
+        print("   agrees with the LLM on %.1f%%  (baseline %.1f%%)" % (100.0 * sum(g["choice"] == t for g, t in ok) / len(ok), 100.0 * n_common / len(rows)))
+        for lo in (0.5, 0.7, 0.85):
+            sel = [(g, t) for g, t in ok if g["confidence"] >= lo]
+            if sel:
+                print("   when it is >= %.2f sure (%d answers, %.0f%%): agrees %.1f%%" % (
+                    lo, len(sel), 100.0 * len(sel) / len(ok), 100.0 * sum(g["choice"] == t for g, t in sel) / len(sel)))
+        by = collections.defaultdict(lambda: [0, 0])
+        for g, t in ok:
+            by[t][0] += 1
+            by[t][1] += g["choice"] == t
+        print("   per LLM action:", {k: "%d/%d" % (v[1], v[0]) for k, v in sorted(by.items())})
+        print("   it picked:", dict(collections.Counter(g["choice"] for g, t in ok)))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
@@ -0,0 +1,124 @@
+"""Turn the laya-shadow-v1 capture log into fine-tuning data for Laya (or Kev), plus the numbers a fine-tuned model must beat.
+
+    python scripts/farmhouse_laya_dataset.py [--in data/decisions] [--out data/laya-train] [--teacher llm|csie|selected]
+                                             [--source all|farmhouse|forge] [--holdout 0.2] [--seed 193]
+
+Reads every `laya-shadow-*.jsonl` (written when DECISION_MODE is shadow or assist: one line per call, with the text Laya read, the
+offered options, Laya's own zero-shot answer and the other deciders' picks), keeps the lines whose chosen teacher label is one of the
+offered options, drops exact duplicates, and splits BY GAME so no game appears on both sides (lines with no game id are split by
+the hash of their text, which is the same guarantee for identical states). Writes:
+
+    train.jsonl, valid.jsonl   one /v1/systemone-shaped example per line: state, questions (with the offered options), answer, meta
+    manifest.json              counts, teacher, class balance, and the baselines on the VALIDATION side:
+                               - always the commonest action
+                               - CSIE's own pick vs the teacher (how much a fine-tuned model must add over the free heuristic)
+                               - Laya zero-shot vs the teacher (what was captured before any training)
+
+Which teacher: `llm` (the slow model; the point is to make a fast student of it), `csie` (the deterministic heuristic; cheap and
+unlimited but a student can at best equal it), `selected` (what Forge executed). The labels are the teacher's choices, not proof they
+were right: a student trained on the LLM inherits its mistakes. Laya's own fine-tuning notebook/script (github.com/NandhaKishorM/laya,
+notebooks/) trains on this kind of typed-decision data; adapt the field names there if its loader differs.
+"""
+import argparse
+import collections
+import glob
+import hashlib
+import importlib.util
+import json
+import os
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+_spec = importlib.util.spec_from_file_location("farmhouse_laya", os.path.join(HERE, "..", "src", "commander_ai_lab", "sim", "farmhouse_laya.py"))
+LAYA = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(LAYA)
+
+
+def read_records(directory):
+    for path in sorted(glob.glob(os.path.join(directory, "laya-shadow-*.jsonl"))):
+        for line in open(path, encoding="utf-8"):
+            try:
+                rec = json.loads(line)
+            except ValueError:
+                continue
+            if rec.get("schema") == LAYA.CAPTURE_SCHEMA:
+                yield rec
+
+
+def bucket(rec, seed):
+    key = rec.get("game_id") or rec.get("state_text") or ""
+    return int(hashlib.sha256(("%s|%s" % (seed, key)).encode("utf-8")).hexdigest()[:8], 16) / 0xFFFFFFFF
+
+
+def build(records, teacher="llm", source="all", holdout=0.2, seed=193):
+    train, valid, seen = [], [], set()
+    for rec in records:
+        if source != "all" and rec.get("source") != source:
+            continue
+        row = LAYA.training_row(rec, teacher)
+        if not row:
+            continue
+        key = (rec["state_text"], row["answer"]["action"], json.dumps(row["questions"]["action"]["criteria"], sort_keys=True))
+        if key in seen:
+            continue
+        seen.add(key)
+        (valid if bucket(rec, seed) < holdout else train).append((row, rec))
+    return train, valid
+
+
+def baselines(pairs, teacher):
+    """Agreement with the teacher on `pairs` of (row, record): commonest-action, CSIE, and Laya zero-shot."""
+    n = len(pairs)
+    if not n:
+        return {"n": 0}
+    targets = [r["answer"]["action"] for r, _ in pairs]
+    common, k = collections.Counter(t.rsplit(":", 1)[-1] for t in targets).most_common(1)[0]
+    out = {"n": n, "commonest_action": common, "commonest_agreement": round(k / n, 4)}
+    csie = [(rec.get("labels") or {}).get("csie") for _, rec in pairs]
+    if teacher != "csie":
+        have = [(c, t) for c, t in zip(csie, targets) if c]
+        if have:
+            out["csie_vs_teacher"] = {"n": len(have), "agreement": round(sum(c == t for c, t in have) / len(have), 4)}
+    laya = [((rec.get("laya") or {}).get("choice"), t) for (_, rec), t in zip(pairs, targets)]
+    have = [(c, t) for c, t in laya if c]
+    if have:
+        out["laya_zero_shot_vs_teacher"] = {"n": len(have), "agreement": round(sum(c == t for c, t in have) / len(have), 4)}
+    return out
+
+
+def write(out_dir, train, valid, teacher, source, holdout, seed):
+    os.makedirs(out_dir, exist_ok=True)
+    for name, rows in (("train.jsonl", train), ("valid.jsonl", valid)):
+        with open(os.path.join(out_dir, name), "w", encoding="utf-8", newline="\n") as f:
+            for row, _ in rows:
+                f.write(json.dumps(row, ensure_ascii=False, separators=(",", ":")) + "\n")
+    balance = collections.Counter(r["answer"]["action"].rsplit(":", 1)[-1] for r, _ in train)
+    manifest = {"schema": "laya-train-manifest-v1", "teacher": teacher, "source": source, "holdout": holdout, "seed": seed,
+                "train": len(train), "valid": len(valid), "train_class_balance": dict(balance.most_common()),
+                "validation_baselines": baselines(valid, teacher),
+                "note": "Labels are the teacher's choices, not proof they were right. Split by game id (or text hash)."}
+    with open(os.path.join(out_dir, "manifest.json"), "w", encoding="utf-8", newline="\n") as f:
+        json.dump(manifest, f, indent=2)
+    return manifest
+
+
+def main(argv=None):
+    p = argparse.ArgumentParser(description=__doc__.split("\n")[0])
+    p.add_argument("--in", dest="inp", default=os.path.join("data", "decisions"))
+    p.add_argument("--out", default=os.path.join("data", "laya-train"))
+    p.add_argument("--teacher", choices=("llm", "csie", "selected"), default="llm")
+    p.add_argument("--source", choices=("all", "farmhouse", "forge"), default="all")
+    p.add_argument("--holdout", type=float, default=0.2)
+    p.add_argument("--seed", type=int, default=193)
+    a = p.parse_args(argv)
+    train, valid = build(read_records(a.inp), a.teacher, a.source, a.holdout, a.seed)
+    if not train and not valid:
+        print("no usable records in %s for teacher %r (turn on DECISION_MODE=shadow and play some games first)" % (a.inp, a.teacher))
+        return 1
+    m = write(a.out, train, valid, a.teacher, a.source, a.holdout, a.seed)
+    print(json.dumps(m, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
@@ -0,0 +1,88 @@
+"""How well does a decision model classify a card's role from its Oracle text, zero-shot?
+
+    DECISION_URL=http://laya:8080 python scripts/farmhouse_laya_roles_eval.py [bulk_db] [per_role=25] [model]
+
+Builds a sample from the local Scryfall bulk database using plain text patterns that give a card exactly ONE role (unambiguous cards
+only; many real cards have several roles, so this is a floor on how hard the task is, not a full test), classifies them in batches
+through farmhouse_laya.classify_roles, and prints accuracy, a confusion table and the time per card. Laya's output here would be
+evidence with provenance for ITI / Tagger-style role data, never a rules fact; this tells you whether that evidence is worth having.
+"""
+import collections
+import importlib.util
+import os
+import random
+import re
+import sqlite3
+import sys
+import time
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+spec = importlib.util.spec_from_file_location("farmhouse_laya", os.path.join(HERE, "..", "src", "commander_ai_lab", "sim", "farmhouse_laya.py"))
+L = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(L)
+
+PATTERNS = {
+    "removal": re.compile(r"\b(destroy|exile) target (creature|permanent|nonland permanent|artifact|enchantment|planeswalker)", re.I),
+    "board_wipe": re.compile(r"\b(destroy|exile) all (creatures|nonland permanents|permanents)|each creature (gets|is dealt)", re.I),
+    "ramp": re.compile(r"search your library for (a|up to \w+) basic land|\badd \{[WUBRGC]\}", re.I),
+    "card_draw": re.compile(r"\bdraw (a|two|three|\w+) cards?\b", re.I),
+    "counterspell": re.compile(r"\bcounter target (spell|noncreature spell|creature spell|activated or triggered ability)", re.I),
+    "tutor": re.compile(r"search your library for (a|an|up to \w+) (?!basic land)(card|creature|artifact|instant|sorcery|enchantment)", re.I),
+}
+
+
+def sample(db, per_role, seed=193):
+    conn = sqlite3.connect(db)
+    rows = conn.execute("SELECT name, type_line, oracle_text FROM cards WHERE oracle_text != '' AND type_line NOT LIKE '%Land%'").fetchall()
+    random.Random(seed).shuffle(rows)
+    out, taken, seen = [], collections.Counter(), set()
+    for name, type_line, oracle in rows:
+        if name in seen or len(oracle) > 700:
+            continue
+        hits = [r for r, p in PATTERNS.items() if p.search(oracle)]
+        if len(hits) != 1 or taken[hits[0]] >= per_role:
+            continue
+        seen.add(name)
+        taken[hits[0]] += 1
+        out.append({"name": name, "type_line": type_line, "oracle": oracle, "truth": hits[0]})
+        if all(taken[r] >= per_role for r in PATTERNS):
+            break
+    return out
+
+
+def main():
+    db = sys.argv[1] if len(sys.argv) > 1 else os.path.join("data", "scryfall_bulk.db")
+    per_role = int(sys.argv[2]) if len(sys.argv) > 2 else 25
+    if len(sys.argv) > 3:
+        os.environ["DECISION_MODEL"] = sys.argv[3]
+    if not os.environ.get("DECISION_URL"):
+        print("set DECISION_URL")
+        return 1
+    cards = sample(db, per_role)
+    t0 = time.time()
+    got = L.classify_roles(cards)
+    dt = time.time() - t0
+    answered = [(c["truth"], got[c["name"]]["role"], got[c["name"]]["confidence"]) for c in cards if c["name"] in got]
+    print("%d cards sampled (%s); %d classified in %.1f s (%.2f s per card)" % (
+        len(cards), dict(collections.Counter(c["truth"] for c in cards)), len(answered), dt, dt / max(len(cards), 1)))
+    if not answered:
+        return 1
+    ok = sum(t == p for t, p, _ in answered)
+    print("accuracy %.1f%%   (always-one-role baseline %.1f%%; there are %d roles to choose among)" % (
+        100.0 * ok / len(answered), 100.0 / len(PATTERNS), len(L.ROLE_HELP)))
+    for lo in (0.5, 0.7, 0.85):
+        sel = [(t, p) for t, p, c in answered if c >= lo]
+        if sel:
+            print("  when >= %.2f sure: %d cards (%.0f%%), accuracy %.1f%%" % (lo, len(sel), 100.0 * len(sel) / len(answered),
+                                                                           100.0 * sum(t == p for t, p in sel) / len(sel)))
+    conf = collections.defaultdict(collections.Counter)
+    for t, p, _ in answered:
+        conf[t][p] += 1
+    print("truth -> what it said:")
+    for t in PATTERNS:
+        print("  %-13s %s" % (t, dict(conf[t].most_common(4))))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
@@ -0,0 +1,154 @@
+"""Deck LINKS for every deck import (copied into the app as services/farmhouse_deck_links.py by the Dockerfile).
+
+Upstream could import from an Archidekt or EDHREC link on the simulator page only; the Deck Builder import took pasted text and
+nothing else, and Moxfield (where most people keep decks) was not accepted anywhere. This reads a Moxfield or Archidekt deck link and
+returns what the existing importers already understand: a profile for the simulator import, or plain "[Commander] / [Main]" text for
+the Deck Builder's two imports (so a link pasted into the same box works, and the card-by-card Scryfall matching is unchanged).
+
+Moxfield has no official public API; api2.moxfield.com answers server-side requests for PUBLIC decks (tested from the cluster
+2026-10-26: HTTP 200, a named User-Agent is enough). A private or deleted deck comes back 401/403/404, and the message says so and
+says what to do instead (Moxfield: Export > Copy as text, then paste that). Nothing here logs in to anything.
+"""
+import json
+import re
+import time
+from urllib.error import HTTPError
+from urllib.request import Request, urlopen
+
+UA = "CommanderAILab/3.0 (self-hosted)"
+MOXFIELD_API = "https://api2.moxfield.com/v2/decks/all/"
+
+_MOX = re.compile(r"^https?://(?:www\.)?moxfield\.com/decks/([A-Za-z0-9_-]+)(?:[/?#].*)?$", re.I)
+_ARC = re.compile(r"^https?://(?:www\.)?archidekt\.com/decks/(\d+)(?:[/?#].*)?$", re.I)
+
+UNSUPPORTED = ("That link is not one I can read. Moxfield and Archidekt deck links work; for anything else, paste the decklist as text "
+               "(Moxfield: Export > Copy as text).")
+
+
+def link_kind(text):
+    """(kind, id, url) when `text` is nothing but one http(s) link, else None. kind: moxfield | archidekt | unsupported."""
+    t = (text or "").strip()
+    if not t or len(t.split()) != 1 or not re.match(r"^https?://", t, re.I):
+        return None
+    m = _MOX.match(t)
+    if m:
+        return "moxfield", m.group(1), t
+    m = _ARC.match(t)
+    if m:
+        return "archidekt", m.group(1), t
+    return "unsupported", None, t
+
+
+def _get_json(url):
+    with urlopen(Request(url, headers={"User-Agent": UA, "Accept": "application/json"}), timeout=25) as resp:
+        return json.loads(resp.read().decode("utf-8", "replace"))
+
+
+def fetch_moxfield(deck_id, attempts=4):
+    last = None
+    for i in range(attempts):
+        try:
+            return _get_json(MOXFIELD_API + deck_id)
+        except HTTPError as exc:
+            if exc.code in (401, 403, 404):
+                raise ValueError("Moxfield would not share that deck (it is private, unlisted for sharing, or the link is wrong). "
+                                 "Open it in Moxfield, choose Export > Copy as text, and paste that here instead.")
+            if exc.code in (429, 500, 502, 503, 504):
+                last = exc
+                try:
+                    wait = float(exc.headers.get("Retry-After") or 0)
+                except (TypeError, ValueError):
+                    wait = 0.0
+                time.sleep(max(wait, 2.0) + i * 2.0)
+                continue
+            raise ValueError("Moxfield answered HTTP %s for that deck." % exc.code)
+        except (ValueError, OSError) as exc:
+            raise ValueError("Could not read the deck from Moxfield (%s)." % str(exc)[:80])
+    raise ValueError("Moxfield is rate-limiting this server right now (HTTP %s). Try again in a minute." % (last.code if last else "429"))
+
+
+def _board(deck, key):
+    out = {}
+    for name, entry in (deck.get(key) or {}).items():
+        card = (entry or {}).get("card") or {}
+        label = card.get("name") or name
+        try:
+            qty = int((entry or {}).get("quantity") or 1)
+        except (TypeError, ValueError):
+            qty = 1
+        out[label] = out.get(label, 0) + max(qty, 1)
+    return out
+
+
+def moxfield_profile(deck, url):
+    """The same profile dict the Archidekt importer builds. Sideboard, maybeboard and companions are left out (the 99 + commander)."""
+    commanders, main = _board(deck, "commanders"), _board(deck, "mainboard")
+    profile = {
+        "name": deck.get("name") or "Moxfield deck",
+        "commander": next(iter(commanders), None),
+        "source": "Moxfield",
+        "sourceUrl": deck.get("publicUrl") or url,
+        "commanders": commanders,
+        "mainboard": main,
+        "colorIdentity": list(deck.get("colorIdentity") or []),
+        "totalCards": sum(commanders.values()) + sum(main.values()),
+    }
+    if profile["commander"] and not deck.get("name"):
+        profile["name"] = "%s — Moxfield" % profile["commander"]
+    return profile
+
+
+def fetch_profile(url):
+    kind = link_kind(url)
+    if not kind or kind[0] == "unsupported":
+        raise ValueError(UNSUPPORTED)
+    if kind[0] == "moxfield":
+        profile = moxfield_profile(fetch_moxfield(kind[1]), kind[2])
+    else:
+        from services.import_helpers import _fetch_archidekt_deck  # the app's own Archidekt reader
+        try:
+            profile = _fetch_archidekt_deck(kind[1])
+        except HTTPError as exc:
+            raise ValueError("Archidekt would not share that deck (HTTP %s). Is it public?" % exc.code)
+    if not profile["commanders"] and not profile["mainboard"]:
+        raise ValueError("That deck has no cards in it (or no main deck I can read).")
+    return profile
+
+
+def profile_to_text(profile):
+    """Plain text in the Deck Builder's own format: [Commander] then [Main], one 'qty name' per line."""
+    lines = ["[Commander]"]
+    lines += ["%d %s" % (q, n) for n, q in profile["commanders"].items()]
+    lines += ["", "[Main]"]
+    lines += ["%d %s" % (q, n) for n, q in profile["mainboard"].items()]
+    return "\n".join(lines) + "\n"
+
+
+def local_card(name, conn=None):
+    """{'id', 'name'} from the local Scryfall bulk database (113k cards, no network), or None. Matches the exact name, or the front
+    face of a double-faced / split card ('Fire' finds 'Fire // Ice'). The Deck Builder's importers only use these two fields, and
+    looking each card up on Scryfall's website instead hit its rate limit (HTTP 429) after a few dozen cards of a 100-card list,
+    which the app reported as 'not found'."""
+    try:
+        if conn is None:
+            from services.scryfall_bulk import get_bulk_db
+            conn = get_bulk_db()
+        n = (name or "").strip()
+        if not n:
+            return None
+        like = n.replace("!", "!!").replace("%", "!%").replace("_", "!_") + " // %"
+        row = conn.execute("SELECT scryfall_id, name FROM cards WHERE LOWER(name) = LOWER(?) OR LOWER(name) LIKE LOWER(?) ESCAPE '!' "
+                           "ORDER BY (LOWER(name) = LOWER(?)) DESC, edhrec_rank ASC LIMIT 1", (n, like, n)).fetchone()
+        return {"id": row[0], "name": row[1]} if row else None
+    except Exception:
+        return None
+
+
+def expand(text):
+    """(text, deck name). A lone Moxfield/Archidekt link becomes the decklist text; anything else comes back unchanged.
+    A lone link we cannot read raises ValueError with a message meant for the person."""
+    kind = link_kind(text)
+    if kind is None:
+        return text, None
+    profile = fetch_profile(kind[2])
+    return profile_to_text(profile), profile["name"]
@@ -0,0 +1,69 @@
+"""Card data for the simulators (copied into the app as services/farmhouse_sim.py by the Dockerfile).
+
+Found 2026-10-26 from a real run: every card of every saved deck reached the simulator with no type line and no rules text (the
+loaders join the user's *collection* and a *card_records* table, both empty here; the Forge card cache that was meant to fill the gap
+is not installed). The simulator could not tell a land from a creature, so a whole 8-game batch cast 0 spells, dealt 0 damage and lost
+every game. The batch loader also did not repeat cards by quantity, so a 100-card deck loaded as 66-84 cards with ONE Island.
+
+fill_card_data fills the gaps from the local 113k-card Scryfall bulk database; expand_quantities repeats a row `quantity` times.
+"""
+
+
+def _name(card):
+    return (card.get("card_name") or card.get("name") or "").strip()
+
+
+def _lookup(conn, name, cache):
+    key = name.lower()
+    if key in cache:
+        return cache[key]
+    like = name.replace("!", "!!").replace("%", "!%").replace("_", "!_") + " // %"
+    row = conn.execute(
+        "SELECT type_line, oracle_text, mana_cost, cmc, power, toughness, keywords, color_identity FROM cards "
+        "WHERE LOWER(name) = LOWER(?) OR LOWER(name) LIKE LOWER(?) ESCAPE '!' "
+        "ORDER BY (LOWER(name) = LOWER(?)) DESC, edhrec_rank ASC LIMIT 1", (name, like, name)).fetchone()
+    cache[key] = row
+    return row
+
+
+def fill_card_data(cards, conn=None):
+    """Fill type_line / oracle_text / mana_cost / cmc / power / toughness / keywords / color_identity where a card dict lacks them.
+    Never overwrites a value that is already there. Returns the same list."""
+    try:
+        if conn is None:
+            from services.scryfall_bulk import get_bulk_db
+            conn = get_bulk_db()
+        cache = {}
+        for card in cards:
+            n = _name(card)
+            if not n or card.get("type_line"):
+                continue
+            row = _lookup(conn, n, cache)
+            if not row:
+                continue
+            for field, value in zip(("type_line", "oracle_text", "mana_cost", "cmc", "power", "toughness", "keywords", "color_identity"), row):
+                if value not in (None, "") and not card.get(field):
+                    card[field] = value
+    except Exception:
+        pass
+    return cards
+
+
+def expand_quantities(cards):
+    """One dict per physical card: a row with quantity 23 becomes 23 rows (each quantity 1)."""
+    out = []
+    for card in cards:
+        try:
+            q = int(card.get("quantity") or 1)
+        except (TypeError, ValueError):
+            q = 1
+        for _ in range(max(q, 1)):
+            copy = dict(card)
+            copy["quantity"] = 1
+            out.append(copy)
+    return out
+
+
+def prepare(cards):
+    """Rows as the batch loader returns them -> one filled-in dict per physical card."""
+    return fill_card_data(expand_quantities(cards))
@@ -515,6 +515,8 @@ def _run_deepseek_batch_thread(
        deck_meta = {}
        for dn in deck_names:
            raw_cards = _load_deck_cards_by_name(dn)
+            from services.farmhouse_sim import prepare as _fh_prepare  # FARMHOUSE_SIM_DATA
+            raw_cards = _fh_prepare(raw_cards or [])
            if not raw_cards:
                state.log_lines.append(f'[DeepSeek Batch] WARNING: Could not load deck "{dn}", skipping.')
                continue
@@ -97,6 +97,9 @@ def _import_from_url(url: str) -> dict:
        if not m:
            raise ValueError("Could not parse Archidekt deck ID from URL")
        return _fetch_archidekt_deck(m.group(1))
+    if "moxfield.com/decks/" in url:  # FARMHOUSE_DECK_LINKS_V1
+        from services.farmhouse_deck_links import fetch_profile as _fh_fetch_profile
+        return _fh_fetch_profile(url)
    if "edhrec.com/average-decks/" in url:
        slug = re.search(r"/average-decks/([^/?#]+)", url).group(1)
        return _fetch_edhrec_average(slug.replace("-", " "))
@@ -368,6 +368,9 @@ def build_index(force: bool = False, batch_size: int = DEFAULT_BATCH_SIZE) -> di
 def ensure_rag_store() -> None:
    """Build the ChromaDB vector store if it is missing or stale."""
    global _rag_ready
+    if os.environ.get("RAG_AUTOBUILD", "0") != "1":  # FARMHOUSE_RAG_AUTOBUILD_V1
+        logger.info("RAG vector store auto-build is off (RAG_AUTOBUILD is not 1).")
+        return
    with _rag_lock:
        if _rag_ready:
            return
@@ -445,7 +448,7 @@ def query_cards(

    try:
        has_filters = bool(color_identity or type_filter or require_trigger)
-        fetch_n = n_results * 4 if has_filters else n_results
+        fetch_n = n_results * 12  # FARMHOUSE_RAG_DEDUPE (one index entry per printing)
        query_kwargs = dict(
            query_texts=[query],
            n_results=min(fetch_n, 200),
@@ -462,6 +465,7 @@ def query_cards(
        return []

    cards: list[dict] = []
+    _fh_seen = set()  # FARMHOUSE_RAG_DEDUPE
    ids = results["ids"][0]
    docs = results["documents"][0] if results.get("documents") else [""] * len(ids)
    metas = results["metadatas"][0] if results.get("metadatas") else [{}] * len(ids)
@@ -490,6 +494,10 @@ def query_cards(
                continue

        # Parse oracle from document — handle both old pipe format and new NL format
+        _fh_name = meta.get("name", "")
+        if _fh_name in _fh_seen:
+            continue
+        _fh_seen.add(_fh_name)
        parts = doc.split(" | ", 3)
        oracle = parts[-1] if len(parts) > 1 else doc

@@ -109,7 +109,7 @@ def _get_bulk_download_url() -> str:
        meta = json.loads(resp.read())
    for entry in meta.get("data", []):
        if entry.get("type") == "default_cards":
-            return entry["download_uri"]
+            return entry.get("jsonl_download_uri") or entry["download_uri"]  # FARMHOUSE_SCRYFALL_URL_V1
    raise RuntimeError("Could not find default_cards entry in Scryfall bulk-data manifest")


@@ -122,12 +122,18 @@ def _download_and_index(conn: sqlite3.Connection) -> int:
    url = _get_bulk_download_url()
    logger.info("Downloading Scryfall default_cards bulk export (~100 MB)...")

-    req = Request(url, headers=_API_HEADERS)
-    with urlopen(req, timeout=300) as resp:
-        raw_bytes = resp.read()
+    req = Request(url, headers=_API_HEADERS)  # FARMHOUSE_SCRYFALL_JSONL_V1
+    _resp = urlopen(req, timeout=300)

-    cards_json: list[dict] = json.loads(raw_bytes)
-    logger.info(f"Received {len(cards_json)} card objects from Scryfall.")
+    def _cards_stream():
+        import gzip
+        stream = gzip.GzipFile(fileobj=_resp) if url.split("?")[0].endswith(".gz") else _resp
+        for _line in stream:
+            _line = _line.strip().rstrip(b",")
+            if _line and _line not in (b"[", b"]"):
+                yield json.loads(_line)
+
+    cards_json = _cards_stream()

    # Wipe existing data for a clean rebuild
    conn.execute("DELETE FROM cards")
@@ -23,8 +23,9 @@ from openai import OpenAI
 logger = logging.getLogger(__name__)

 # Ollama exposes an OpenAI-compatible endpoint
-DEFAULT_BASE_URL = "http://localhost:11434/v1"
-DEFAULT_MODEL = "qwen2.5:7b"
+import os as _farmhouse_os  # FARMHOUSE_LLM_ENV_V1
+DEFAULT_BASE_URL = _farmhouse_os.environ.get("LLM_URL", "http://localhost:11434/v1")
+DEFAULT_MODEL = _farmhouse_os.environ.get("LLM_MODEL", "qwen2.5:7b")


 def _get_client(base_url: str = DEFAULT_BASE_URL) -> OpenAI:
@@ -118,6 +119,13 @@ def chat(
    if json_mode:
        kwargs["response_format"] = {"type": "json_object"}

+    # FARMHOUSE_LLM_KNOBS_V1
+    _fh_effort = _farmhouse_os.environ.get("LLM_REASONING", "").strip()
+    if _fh_effort:
+        kwargs["extra_body"] = {"reasoning_effort": _fh_effort}
+    _fh_cap = int(_farmhouse_os.environ.get("LLM_MAX_TOKENS", "0") or 0)
+    if _fh_cap:
+        kwargs["max_tokens"] = min(kwargs["max_tokens"], _fh_cap)
    response = client.chat.completions.create(**kwargs)
    return response.choices[0].message.content or ""

@@ -16,8 +16,26 @@ import requests
 from ..core.models import CardEntry

 BASE_URL = "https://api.scryfall.com"
+_SF_HEADERS = {"User-Agent": "CommanderAILab/3.0 (self-hosted)", "Accept": "application/json"}  # FARMHOUSE_SCRYFALL_HEADERS_V1
+
+
+def _fh_request(method, url, **kw):
+    """requests.<method> that backs off on Scryfall's 429 / 5xx, honouring Retry-After (a build makes hundreds of
+    calls; upstream had no retry, so one 429 anywhere ended it). Gives up after 5 tries and returns the last response."""
+    import time as _t
+    resp = None
+    for attempt in range(5):
+        resp = getattr(requests, method)(url, **kw)
+        if resp.status_code not in (429, 500, 502, 503, 504):
+            return resp
+        try:
+            wait = float(resp.headers.get("Retry-After", "") or 0)
+        except ValueError:
+            wait = 0.0
+        _t.sleep(max(wait, 2.0) + attempt * 2.0)
+    return resp
 _last_request_time: float = 0.0
-REQUEST_DELAY = 0.1  # 100ms between requests (Scryfall asks for 50-100ms)
+REQUEST_DELAY = 0.25  # 250ms: upstream used 100ms (10/s, Scryfall's ceiling) and drew 429s when builds ran back to back


 def _throttle() -> None:
@@ -32,7 +50,7 @@ def _throttle() -> None:
 def _get(endpoint: str, params: Optional[Dict] = None) -> Dict:
    """Make a throttled GET request to Scryfall."""
    _throttle()
-    resp = requests.get(f"{BASE_URL}{endpoint}", params=params, timeout=15)
+    resp = _fh_request("get", f"{BASE_URL}{endpoint}", params=params, headers=_SF_HEADERS, timeout=15)
    resp.raise_for_status()
    return resp.json()

@@ -113,7 +131,7 @@ def search_cards_by_identity(
        if not next_url:
            break
        _throttle()
-        resp = requests.get(next_url, timeout=15)
+        resp = _fh_request("get", next_url, headers=_SF_HEADERS, timeout=15)
        resp.raise_for_status()
        data = resp.json()

@@ -168,9 +186,9 @@ def get_cards_by_names(names: List[str]) -> List[CardEntry]:
        batch = names[i : i + 75]
        identifiers = [{"name": n} for n in batch]
        _throttle()
-        resp = requests.post(
-            f"{BASE_URL}/cards/collection",
-            json={"identifiers": identifiers},
+        resp = _fh_request(
+            "post", f"{BASE_URL}/cards/collection",
+            json={"identifiers": identifiers}, headers=_SF_HEADERS,
            timeout=30,
        )
        resp.raise_for_status()
@@ -119,6 +119,9 @@ def validate_card_names(
 # ---------------------------------------------------------------------------


+from .farmhouse_fit import fit_deck as _farmhouse_fit_deck  # FARMHOUSE_FIT_V1
+
+
 def build_deck(request: BuildRequest) -> BuildResult:
    """
    Execute the full 7-step deck build pipeline.
@@ -306,6 +309,7 @@ def build_deck(request: BuildRequest) -> BuildResult:
        logger.warning(f"Ratio enforcement returned {total} cards")

    # ── Step 7: Assemble final deck ────────────────────────────────────────
+    adjusted = _farmhouse_fit_deck(adjusted, target_ratios, commander_ci, warnings)  # FARMHOUSE_FIT_V1b
    logger.info("Step 7: Assembling final deck")

    # Build a globally-deduplicated name list. enforce_deck_ratios can
@@ -0,0 +1,67 @@
+"""Deterministic guards for the deck build, copied into the app by the Dockerfile (pipeline/farmhouse_fit.py).
+
+Upstream's step 6 asks the LLM to trim the candidate pool to 99 cards by category and step 5 promises a colour-identity filter that
+is not in the code. With a small local model that gave decks with an off-colour card (a red card in a four-colour deck) and, with
+a larger one, 359 cards instead of 99; either made the app reject its own result ("Value error ... outside commander identity" /
+"Deck must contain exactly 99 cards"). This does both jobs in plain code, using the Scryfall card database the app already keeps
+(services.scryfall_bulk, 100,000+ cards): drop every card outside the commander's colour identity, drop duplicates, keep each
+category to its target count (candidates arrive best-first: EDHREC, then Scryfall, then the model), and never exceed 99.
+Anything the database does not know is kept, not dropped. The existing back-fill adds basic lands if the total is short.
+"""
+import json
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def _identity_checker(allowed):
+    try:
+        from services.scryfall_bulk import get_bulk_db
+        conn = get_bulk_db()
+    except Exception as exc:  # no database: do not guess, keep everything
+        logger.warning("farmhouse_fit: Scryfall card database unavailable (%s); colour identity not checked", exc)
+        return lambda name: True
+
+    def ok(name):
+        try:
+            row = conn.execute("SELECT color_identity FROM cards WHERE name = ? OR name LIKE ? LIMIT 1",
+                               (name, name + " // %")).fetchone()
+            if not row:
+                return True
+            return set(json.loads(row[0] or "[]")) <= allowed
+        except Exception:
+            return True
+    return ok
+
+
+def fit_deck(adjusted, target_ratios, commander_ci, warnings, total=99):
+    """Return {category: [names]} that is colour-legal, duplicate-free, within each category's target, and at most `total` cards."""
+    allowed = set(commander_ci or [])
+    ok = _identity_checker(allowed)
+    out, seen, off_colour = {}, set(), []
+    for cat, names in adjusted.items():
+        keep = []
+        for name in names:
+            if name in seen:
+                continue
+            if not ok(name):
+                off_colour.append(name)
+                continue
+            seen.add(name)
+            keep.append(name)
+        limit = target_ratios.get(cat)
+        out[cat] = keep[:limit] if isinstance(limit, int) and limit >= 0 else keep
+    if off_colour:
+        warnings.append("Dropped %d card(s) outside the commander's colour identity: %s" % (len(off_colour), ", ".join(off_colour[:8])))
+    count = sum(len(v) for v in out.values())
+    if count > total:
+        # Over: trim from the tail of the largest category (the model's late picks), one card at a time.
+        excess = count - total
+        while excess > 0:
+            cat = max(out, key=lambda c: len(out[c]))
+            if not out[cat]:
+                break
+            out[cat].pop()
+            excess -= 1
+        warnings.append("Trimmed the candidate list from %d to %d cards." % (count, total))
+    return out
@@ -587,6 +587,13 @@ class DeepSeekBrain:
                cached["latency_ms"] = round((time.time() - t_start) * 1000, 1)
                return cached

+        from commander_ai_lab.sim import farmhouse_decide as _fd  # FARMHOUSE_DECISION
+        _fd_mode = _fd.mode()
+        if _fd_mode == "assist":
+            _fd_ans = _fd.ask(snapshot)
+            if _fd_ans and _fd_ans["confidence"] >= float(os.environ.get("DECISION_MIN_CONF", "0.7")):
+                return _fd.as_decision(_fd_ans, t_start)
+
        if not self._connected:
            return self._fallback_action(snapshot, t_start, "not_connected")

@@ -595,6 +602,8 @@ class DeepSeekBrain:
            try:
                result = self._call_llm(snapshot)
                result["source"] = "llm"
+                if _fd_mode == "shadow":  # FARMHOUSE_DECISION_SHADOW
+                    _fd.record(_fd.ask(snapshot), result.get("action"))
                result["latency_ms"] = round((time.time() - t_start) * 1000, 1)

                if self.config.cache_enabled:
@@ -632,6 +641,8 @@ class DeepSeekBrain:
            "top_p": self.config.top_p,
            "stream": False,
        }
+        if os.environ.get("LLM_REASONING"):  # FARMHOUSE_BRAIN_REASONING
+            payload["reasoning_effort"] = os.environ["LLM_REASONING"]

        url = self.config.api_base.rstrip("/") + "/v1/chat/completions"
        req_data = json.dumps(payload).encode("utf-8")
@@ -880,4 +891,5 @@ class DeepSeekBrain:
            "api_base": self.config.api_base,
            "pending_log_entries": len(self._decision_log),
            "current_game_id": self._current_game_id,
+            "decision": __import__("commander_ai_lab.sim.farmhouse_decide", fromlist=["stats"]).stats(),  # FARMHOUSE_DECISION_STATS
        }
@@ -247,7 +247,16 @@ class DeepSeekGameEngine:
    # DeepSeek-powered turn
    # ──────────────────────────────────────────────────────────

-    def _play_turn_deepseek(
+    def _play_turn_deepseek(  # FARMHOUSE_MULTISTEP
+        self, sim: SimState, pi: int, turn: int, events: list[str],
+        deck_context: dict | None = None,
+    ) -> str:
+        from commander_ai_lab.sim import farmhouse_turns as _ft
+        if _ft.steps() <= 1:
+            return self._play_turn_deepseek_single(sim, pi, turn, events, deck_context)
+        return _ft.play_turn(self, sim, pi, turn, events, deck_context)
+
+    def _play_turn_deepseek_single(
        self, sim: SimState, pi: int, turn: int, events: list[str],
        deck_context: dict | None = None,
    ) -> str:
@@ -0,0 +1,173 @@
+"""A fast "which action?" answer from a decision model (Laya, or Kev: both serve POST /v1/systemone).
+
+The LLM brain answers the same question about 25 times a game, each taking seconds. A decision model reads a short text and picks ONE of
+a fixed list of options in a single forward pass (tens of milliseconds on a GPU, about a second on a small CPU) and never writes text.
+It cannot choose a target card; the engine's heuristics do that, exactly as when the LLM names no target.
+
+Modes (DECISION_MODE; with no DECISION_URL nothing here runs at all):
+  off     do nothing
+  shadow  ask it too and RECORD whether it agreed with the LLM; the game is played with the LLM's answer (the safe way to measure)
+  assist  ask it first; use its answer when it is at least DECISION_MIN_CONF sure, otherwise ask the LLM as before
+
+Settings: DECISION_URL (e.g. http://laya:8080), DECISION_MODEL (a Laya checkpoint name such as english or typed-decisions),
+DECISION_MIN_CONF (default 0.7, on the probability of the chosen option), DECISION_TIMEOUT (seconds, default 5), DECISION_API_KEY.
+After three failures in a row the model is not asked again for a minute, so a down server costs the game nothing.
+"""
+import json
+import os
+import threading
+import time
+import urllib.request
+
+ACTION_HELP = {
+    "play_land": "play a land from hand (always do this first)",
+    "cast_creature": "cast a creature spell",
+    "cast_removal": "use removal on the opponent's best threat",
+    "cast_board_wipe": "wipe the board when behind on creatures",
+    "cast_ramp": "cast mana ramp to accelerate",
+    "cast_spell": "cast any other spell such as an enchantment or artifact",
+    "attack_all": "attack with all untapped creatures",
+    "attack_safe": "attack only with evasive or large creatures",
+    "hold": "pass and save mana",
+}
+
+_lock = threading.Lock()
+_fail = {"n": 0, "until": 0.0}
+STATS = {"asked": 0, "agreed": 0, "answered_conf": 0, "errors": 0, "ms_total": 0.0, "by_action": {}}
+
+
+def mode():
+    m = os.environ.get("DECISION_MODE", "off").strip().lower()
+    return m if m in ("shadow", "assist") and os.environ.get("DECISION_URL") else "off"
+
+
+def _card_text(c):
+    if isinstance(c, str):
+        return c
+    bits = [str(c.get("type") or "").strip()]
+    if c.get("cmc") is not None:
+        bits.append("cmc %s" % c["cmc"])
+    if c.get("pt"):
+        bits.append(str(c["pt"]))
+    if c.get("castable") is not None:
+        bits.append("castable" if c["castable"] else "not castable")
+    roles = c.get("roles")
+    if roles:
+        bits.append("/".join(roles) if isinstance(roles, (list, tuple)) else str(roles))
+    return "%s (%s)" % (c.get("name", "?"), ", ".join(b for b in bits if b))
+
+
+def compact_state(snap):
+    """The snapshot as a short paragraph (a decision model reads about 500 tokens, the LLM's indented JSON is two to three times that)."""
+    hand = snap.get("my_hand") or []
+    mine = [c for c in (snap.get("my_board") or []) if isinstance(c, dict)]
+    theirs = [c for c in (snap.get("opp_board") or []) if isinstance(c, dict)]
+    my_creatures = [c for c in mine if "creature" in str(c.get("type", "")).lower()]
+    opp_creatures = [c for c in theirs if "creature" in str(c.get("type", "")).lower()]
+    threat = snap.get("opp_threat") or {}
+    cmdr = snap.get("commander") or {}
+    parts = ["Turn %s. Your life %s, opponent life %s. Mana available %s." % (
+        snap.get("turn"), snap.get("my_life"), snap.get("opp_life"), snap.get("my_mana_total", snap.get("my_mana_available")))]
+    parts.append("Opponent threat %s, total power %s." % (threat.get("level", "?"), threat.get("total_power", "?")))
+    if cmdr:
+        parts.append("Your commander %s is in the %s." % (cmdr.get("name", "?"), cmdr.get("zone", "?")))
+    parts.append("Hand: %s." % ("; ".join(_card_text(c) for c in hand[:10]) if hand else "empty"))
+    parts.append("Your creatures: %s." % (", ".join(_card_text(c) for c in my_creatures[:8]) if my_creatures else "none"))
+    parts.append("Your other permanents: %d." % (len(mine) - len(my_creatures)))
+    parts.append("Opponent creatures: %s." % (", ".join(_card_text(c) for c in opp_creatures[:8]) if opp_creatures else "none"))
+    parts.append("Opponent other permanents: %d." % (len(theirs) - len(opp_creatures)))
+    advice = snap.get("strategic_advice") or {}
+    ranking = (advice.get("ranking") or {}).get("ranked") or []
+    if ranking:
+        parts.append("CSIE relative ranking: %s." % "; ".join(
+            "%s %.2f (%s)" % (r["id"], r["score"], r["explanation"])
+            for r in ranking[:5]))
+    if snap.get("stack_supported") and snap.get("stack"):
+        parts.append("Visible stack: %s." % json.dumps(snap["stack"], separators=(",", ":")))
+    return " ".join(parts)
+
+
+def ask(snap, actions=None):
+    """{'choice', 'confidence', 'probabilities', 'ms', 'model'} or None (not configured, backing off, or an error)."""
+    url = os.environ.get("DECISION_URL")
+    if not url:
+        return None
+    now = time.time()
+    with _lock:
+        if _fail["until"] > now:
+            return None
+    acts = [a for a in (actions or ACTION_HELP) if a in ACTION_HELP]
+    body = {"state": {"body": compact_state(snap)},
+            "questions": {"action": {"type": "choice", "instructions": "Which action is best for this turn?",
+                                     "criteria": {a: ACTION_HELP[a] for a in acts}}}}
+    model = os.environ.get("DECISION_MODEL")
+    if model:
+        body["model"] = model
+    headers = {"content-type": "application/json"}
+    if os.environ.get("DECISION_API_KEY"):
+        headers["authorization"] = "Bearer " + os.environ["DECISION_API_KEY"]
+    try:  # extra questions ride in the same forward pass (farmhouse_laya.py); optional when the package is not importable
+        from commander_ai_lab.sim import farmhouse_laya as _L
+        body["questions"].update(_L._extra_questions())
+    except ImportError:
+        _L = None
+    t0 = time.time()
+    try:
+        req = urllib.request.Request(url.rstrip("/") + "/v1/systemone", data=json.dumps(body).encode(), headers=headers)
+        out = json.load(urllib.request.urlopen(req, timeout=float(os.environ.get("DECISION_TIMEOUT", "5"))))
+        ans = out["answers"]["action"]
+        probs = ans.get("probabilities") or {}
+        choice = ans["choice"]
+        if choice not in acts:
+            raise ValueError("Decision model selected an action outside the supplied candidates")
+        with _lock:
+            _fail["n"] = 0
+        return {"choice": choice, "confidence": float(probs.get(choice, ans.get("answer_confidence", 0.0))),
+                "probabilities": probs, "ms": round((time.time() - t0) * 1000, 1), "model": model or "auto",
+                "extras": _L._extras(out["answers"]) if _L else {}, "state_text": body["state"]["body"],
+                "options": {a: ACTION_HELP[a] for a in acts},
+                "csie_selected": ((snap.get("strategic_advice") or {}).get("ranking") or {}).get("selected_id")}
+    except Exception:
+        with _lock:
+            _fail["n"] += 1
+            STATS["errors"] += 1
+            if _fail["n"] >= 3:
+                _fail["until"] = time.time() + 60
+                _fail["n"] = 0
+        return None
+
+
+def as_decision(answer, t_start):
+    """The brain's own result dict for a decision model's answer (no target card: the engine's heuristics pick it)."""
+    return {"action": answer["choice"], "target_card": "", "source": "decision",
+            "reasoning": "decision model %s, p=%.2f" % (answer["model"], answer["confidence"]),
+            "latency_ms": round((time.time() - t_start) * 1000, 1)}
+
+
+def record(answer, llm_action):
+    """Count one shadow comparison."""
+    if not answer:
+        return
+    with _lock:
+        STATS["asked"] += 1
+        STATS["ms_total"] += answer["ms"]
+        agree = answer["choice"] == llm_action
+        STATS["agreed"] += 1 if agree else 0
+        if answer["confidence"] >= float(os.environ.get("DECISION_MIN_CONF", "0.7")):
+            STATS["answered_conf"] += 1
+        row = STATS["by_action"].setdefault(llm_action, {"n": 0, "agreed": 0})
+        row["n"] += 1
+        row["agreed"] += 1 if agree else 0
+    try:  # one laya-shadow-v1 line per comparison: the raw material for fine-tuning (scripts/farmhouse_laya_dataset.py)
+        from commander_ai_lab.sim import farmhouse_laya as _L
+        _L.capture({"source": "farmhouse", "state_text": answer.get("state_text"), "options": answer.get("options"),
+                    "laya": {k: answer.get(k) for k in ("choice", "confidence", "probabilities", "extras", "ms", "model")},
+                    "labels": {"llm": llm_action, "csie": answer.get("csie_selected")}})
+    except ImportError:
+        pass
+
+
+def stats():
+    with _lock:
+        n = STATS["asked"]
+        return dict(STATS, agreement=round(STATS["agreed"] / n, 3) if n else None, avg_ms=round(STATS["ms_total"] / n, 1) if n else None)
@@ -0,0 +1,305 @@
+"""Laya connections beyond "which macro action?" (the decision model also serves Kev: POST /v1/systemone).
+
+Laya answers typed questions about a short text in ONE forward pass, so extra questions in the same request cost almost nothing. This
+module is where the repository uses that, without touching CSIE, ITI or PBIE:
+
+  advise_concrete / attach_concrete   Forge's priority path. Laya picks among the SAME concrete candidate IDs Forge sent (never an
+                                      ID it did not offer). shadow: recorded beside CSIE's pick. assist: may replace it when sure,
+                                      but never when CSIE's pick carries a Forge-established `stops_immediate_win` or `wins_now`.
+  extra questions                     "how dangerous are the opponents' boards?" and "is there a threat that must be answered?" ride
+                                      in the same call and are recorded (a free weak signal for the learned-threat work).
+  capture                             every shadow/assist call is appended to data/decisions/laya-shadow-<date>.jsonl as
+                                      `laya-shadow-v1`: the text Laya read, the options, its answer, and the other deciders' picks.
+                                      This is the raw material for fine-tuning (scripts/farmhouse_laya_dataset.py): Laya is a base to
+                                      specialise, and zero-shot it is no better than guessing (farmhouse/laya/LAYA-EVALUATION.md).
+  classify_roles                      card role evidence from Oracle text (batch, cached), with provenance, for ITI / Tagger-style use.
+
+Hidden information: text is built from public facts and the ACTING player's own hand. An opponent's `hand` field is never read.
+Failures (no server, timeout, a bad answer) return None and never raise; three in a row pause asking for a minute.
+
+Settings (shared with farmhouse_decide): DECISION_URL, DECISION_MODE (off|shadow|assist), DECISION_MODEL, DECISION_MIN_CONF,
+DECISION_TIMEOUT (5 s), DECISION_TIMEOUT_FORGE (1.5 s: Forge waits on this), DECISION_API_KEY, LAYA_CAPTURE_DIR, LAYA_CAPTURE=0 to disable.
+"""
+import datetime
+import json
+import os
+import threading
+import time
+import urllib.request
+
+CAPTURE_SCHEMA = "laya-shadow-v1"
+
+THREAT_LEVELS = {
+    "none": "no meaningful pressure on you",
+    "low": "a small board that is not a danger yet",
+    "moderate": "a board that will become dangerous if ignored",
+    "high": "a board that threatens you within a turn or two",
+    "lethal": "a board or stack that can kill you or win the game very soon",
+}
+
+ROLE_HELP = {
+    "removal": "destroys, exiles or otherwise removes one permanent or creature",
+    "board_wipe": "destroys or removes many creatures or permanents at once",
+    "ramp": "adds mana or fetches lands so you have more mana",
+    "card_draw": "draws or otherwise gives you extra cards",
+    "counterspell": "counters a spell or ability",
+    "protection": "protects your permanents or players from removal or damage",
+    "tutor": "searches your library for a card other than a basic land",
+    "creature": "a creature whose main job is attacking, blocking or generating value on the battlefield",
+    "other": "none of the above",
+}
+
+_lock = threading.Lock()
+_fail = {"n": 0, "until": 0.0}
+_role_cache = {}
+_capture_lock = threading.Lock()
+
+
+def mode():
+    m = os.environ.get("DECISION_MODE", "off").strip().lower()
+    return m if m in ("shadow", "assist") and os.environ.get("DECISION_URL") else "off"
+
+
+def min_conf():
+    try:
+        return float(os.environ.get("DECISION_MIN_CONF", "0.7"))
+    except ValueError:
+        return 0.7
+
+
+def _post(path, body, timeout):
+    """JSON reply or None. Circuit breaker: three failures in a row pause for a minute."""
+    url = os.environ.get("DECISION_URL")
+    if not url:
+        return None
+    with _lock:
+        if _fail["until"] > time.time():
+            return None
+    headers = {"content-type": "application/json"}
+    if os.environ.get("DECISION_API_KEY"):
+        headers["authorization"] = "Bearer " + os.environ["DECISION_API_KEY"]
+    try:
+        req = urllib.request.Request(url.rstrip("/") + path, data=json.dumps(body).encode(), headers=headers)
+        out = json.load(urllib.request.urlopen(req, timeout=timeout))
+        with _lock:
+            _fail["n"] = 0
+        return out
+    except Exception:
+        with _lock:
+            _fail["n"] += 1
+            if _fail["n"] >= 3:
+                _fail["until"] = time.time() + 60
+                _fail["n"] = 0
+        return None
+
+
+def _extra_questions():
+    return {"threat": {"type": "choice", "instructions": "How dangerous are the opponents' boards to you right now?",
+                       "criteria": dict(THREAT_LEVELS)},
+            "must_answer": {"type": "noul", "instructions": "Is there an immediate threat that must be answered this turn?"}}
+
+
+def _extras(answers):
+    out = {}
+    t = (answers or {}).get("threat") or {}
+    if t.get("choice") in THREAT_LEVELS:
+        probs = t.get("probabilities") or {}
+        out["threat"] = {"choice": t["choice"], "confidence": round(float(probs.get(t["choice"], 0.0)), 4)}
+    m = (answers or {}).get("must_answer") or {}
+    if "noul" in m:
+        try:
+            out["must_answer"] = round(float(m["noul"]), 4)
+        except (TypeError, ValueError):
+            pass
+    return out
+
+
+# ---------- Forge's priority path -------------------------------------------------------------------------------------------
+
+def _names(battlefield, limit=8):
+    out = []
+    for c in battlefield or []:
+        out.append(str(c.get("name", "?")) if isinstance(c, dict) else str(c))
+        if len(out) >= limit:
+            break
+    return out
+
+
+def observation_text(obs, ranking=None):
+    """Public facts plus the acting player's own hand. An opponent's `hand` field is NEVER read."""
+    actor = int(obs.get("priority_seat", 0))
+    players = obs.get("players") or []
+    parts = ["Phase %s, seat %s has priority (active seat %s)." % (obs.get("phase", "?"), actor, obs.get("active_seat", actor))]
+    for p in players:
+        seat = p.get("seat")
+        head = "You (seat %s)" % seat if seat == actor else "Opponent seat %s" % seat
+        bits = ["life %s" % p.get("life", "?"), "power on board %s" % p.get("total_power", 0)]
+        if seat == actor:
+            bits.append("mana available %s" % p.get("mana_available", "?"))
+            hand = p.get("hand")                       # the actor's own hand only
+            if isinstance(hand, list) and hand:
+                bits.append("hand: " + ", ".join(_names(hand, 10)))
+            else:
+                bits.append("%s cards in hand" % p.get("cards_in_hand", "?"))
+        else:
+            bits.append("%s cards in hand" % p.get("cards_in_hand", p.get("hand_count", "?")))
+        board = _names(p.get("battlefield"))
+        bits.append("board: %s" % (", ".join(board) if board else "empty"))
+        parts.append("%s: %s." % (head, "; ".join(bits)))
+    stack = obs.get("stack") or []
+    if stack:
+        parts.append("Stack: %s." % "; ".join(
+            "%s by seat %s%s" % (s.get("card", s.get("name", "a spell")), s.get("controller_seat", "?"),
+                                 " (immediate win threat)" if s.get("immediate_win_threat") else "") for s in stack[:5]))
+    else:
+        parts.append("The stack is empty.")
+    rows = (ranking or {}).get("ranked") or []
+    if rows:
+        parts.append("CSIE relative ranking: %s." % "; ".join(
+            "%s %.2f" % (r["id"].rsplit(":", 1)[-1], r["score"]) for r in rows[:5]))
+    return " ".join(parts)
+
+
+def describe_candidate(c):
+    """What the candidate IS (kind, card, cost, tags). The opaque request-scoped ID is the key, never the description."""
+    kind = str(c.get("kind", "other"))
+    if kind == "pass":
+        return "pass priority and do nothing"
+    bits = [kind.replace("_", " ")]
+    name = c.get("card_name") or c.get("card") or c.get("name")
+    if name:
+        bits.append(str(name))
+    if c.get("mana_value") not in (None, ""):
+        bits.append("mana value %s" % c["mana_value"])
+    if c.get("target_seat") is not None:
+        bits.append("targeting seat %s" % c["target_seat"])
+    tags = [str(t) for t in (c.get("tags") or [])]
+    if tags:
+        bits.append("tags " + ", ".join(tags))
+    return ", ".join(bits)
+
+
+def advise_concrete(observation, candidates, ranking=None):
+    """Laya's pick among Forge's concrete candidate IDs, or None. Shape: choice, confidence, probabilities, extras, ms, model, state_text, options."""
+    ids = [c.get("id") for c in candidates if isinstance(c.get("id"), str)]
+    if not ids or len(ids) != len(set(ids)) or mode() == "off":
+        return None
+    text = observation_text(observation, ranking)
+    options = {c["id"]: describe_candidate(c) for c in candidates if isinstance(c.get("id"), str)}
+    questions = {"action": {"type": "choice", "instructions": "Which action is best right now?", "criteria": options}}
+    questions.update(_extra_questions())
+    body = {"state": {"body": text}, "questions": questions}
+    if os.environ.get("DECISION_MODEL"):
+        body["model"] = os.environ["DECISION_MODEL"]
+    t0 = time.time()
+    out = _post("/v1/systemone", body, float(os.environ.get("DECISION_TIMEOUT_FORGE", "1.5")))
+    try:
+        ans = out["answers"]["action"]
+        choice, probs = ans["choice"], ans.get("probabilities") or {}
+        if choice not in options:
+            return None
+        return {"choice": choice, "confidence": float(probs.get(choice, ans.get("answer_confidence", 0.0))),
+                "probabilities": probs, "extras": _extras(out["answers"]), "ms": round((time.time() - t0) * 1000, 1),
+                "model": os.environ.get("DECISION_MODEL") or "auto", "state_text": text, "options": options}
+    except Exception:
+        return None
+
+
+def attach_concrete(result, observation, candidates, advice):
+    """Add Laya's view to the concrete-decision response; in assist mode it may replace the selection (guarded).
+
+    result is the dict /api/policy/decide/concrete returns ({"selected_id", "ranked", ...}). Forge executes only an ID it sent."""
+    if not advice:
+        return result
+    by_id = {c.get("id"): c for c in candidates}
+    csie_pick = result.get("selected_id")
+    view = {k: advice[k] for k in ("choice", "confidence", "probabilities", "extras", "ms", "model")}
+    view["agrees_with_selected"] = advice["choice"] == csie_pick
+    out = dict(result)
+    out["laya"] = view
+    protected = bool(set((by_id.get(csie_pick) or {}).get("tags") or []) & {"stops_immediate_win", "wins_now"})
+    if (mode() == "assist" and advice["choice"] in by_id and advice["choice"] != csie_pick
+            and advice["confidence"] >= min_conf() and not protected):
+        out["csie_selected_id"] = csie_pick
+        out["selected_id"] = advice["choice"]
+        out["laya_override"] = True
+    capture({"source": "forge", "state_text": advice["state_text"], "options": advice["options"],
+             "laya": view, "labels": {"csie": csie_pick, "selected": out["selected_id"]},
+             "game_id": (observation or {}).get("game_id")})
+    return out
+
+
+# ---------- recording (also the fine-tuning raw material) --------------------------------------------------------------------
+
+def capture(record):
+    """Append one laya-shadow-v1 record. Never raises."""
+    if os.environ.get("LAYA_CAPTURE", "1") == "0" or mode() == "off":
+        return
+    try:
+        d = os.environ.get("LAYA_CAPTURE_DIR", os.path.join("data", "decisions"))
+        os.makedirs(d, exist_ok=True)
+        rec = dict(record, schema=CAPTURE_SCHEMA, ts=round(time.time(), 3), mode=mode())
+        path = os.path.join(d, "laya-shadow-%s.jsonl" % datetime.datetime.utcnow().strftime("%Y%m%d"))
+        with _capture_lock, open(path, "a", encoding="utf-8", newline="\n") as f:
+            f.write(json.dumps(rec, ensure_ascii=False, separators=(",", ":")) + "\n")
+    except Exception:
+        pass
+
+
+# ---------- card role evidence ------------------------------------------------------------------------------------------------
+
+def classify_roles(cards, batch_size=32):
+    """{name: {"role", "confidence", "probabilities", "source"}} for cards given as {"name", "oracle", "type_line"}.
+
+    One batched request per `batch_size` unseen cards (the server shares forward passes), cached by name. This is evidence with
+    provenance (source says model and mode), never a rules fact; a card the server cannot classify is simply absent."""
+    out, todo = {}, []
+    for c in cards:
+        n = c.get("name")
+        if not n:
+            continue
+        if n in _role_cache:
+            out[n] = _role_cache[n]
+        elif all(n != t["name"] for t in todo):
+            todo.append(c)
+    questions = {"role": {"type": "choice", "instructions": "What is this card's main role in a Commander deck?", "criteria": dict(ROLE_HELP)}}
+    model = os.environ.get("DECISION_MODEL") or "auto"
+    for i in range(0, len(todo), batch_size):
+        chunk = todo[i:i + batch_size]
+        body = {"states": [{"body": ("%s. %s. %s" % (c["name"], c.get("type_line", ""), c.get("oracle", "")))[:1500]} for c in chunk],
+                "questions": questions}
+        if os.environ.get("DECISION_MODEL"):
+            body["model"] = os.environ["DECISION_MODEL"]
+        res = _post("/v1/systemone/batch", body, float(os.environ.get("DECISION_TIMEOUT", "5")) * max(2, len(chunk) // 4))
+        results = (res or {}).get("results") or []
+        for c, r in zip(chunk, results):
+            try:
+                a = r["answers"]["role"]
+                probs = a.get("probabilities") or {}
+                if a["choice"] not in ROLE_HELP:
+                    continue
+                row = {"role": a["choice"], "confidence": round(float(probs.get(a["choice"], 0.0)), 4), "probabilities": probs,
+                       "source": "laya:%s" % model}
+                _role_cache[c["name"]] = out[c["name"]] = row
+            except Exception:
+                continue
+    return out
+
+
+# ---------- fine-tuning rows --------------------------------------------------------------------------------------------------
+
+def training_row(rec, label="llm"):
+    """One /v1/systemone-shaped training example from a laya-shadow-v1 record, or None when it has no usable label.
+
+    label: which decider is the teacher: llm, csie, selected. The row carries provenance so a student trained on one teacher can be
+    told apart from one trained on another, and the options (not just the winner) so the model learns to choose among them."""
+    labels = rec.get("labels") or {}
+    target = labels.get(label)
+    options = rec.get("options") or {}
+    if not rec.get("state_text") or target not in options:
+        return None
+    return {"state": {"body": rec["state_text"]},
+            "questions": {"action": {"type": "choice", "instructions": "Which action is best right now?", "criteria": options}},
+            "answer": {"action": target},
+            "meta": {"schema": "laya-train-v1", "source": rec.get("source"), "teacher": label, "game_id": rec.get("game_id"),
+                     "laya_choice": (rec.get("laya") or {}).get("choice"), "ts": rec.get("ts")}}
@@ -0,0 +1,66 @@
+"""A DeepSeek-engine turn that asks the model more than once (copied to commander_ai_lab/sim/farmhouse_turns.py by the Dockerfile).
+
+Upstream asked the model ONE question per turn and applied the answer as a single action, then filled in with a heuristic. That is
+one model call per turn for a turn that really has several decisions (land, a spell, another spell, attack). This keeps asking, up
+to BRAIN_STEPS times (default 4), re-reading the board after each action, and stops when the model attacks or holds, when an action
+changes nothing (so it cannot loop), or at the limit. Whatever is left uses the engine's own heuristic exactly as before.
+
+Everything it touches is an existing engine method, so the rules enforcement (one land a turn, mana, the two-spell cap per call) is
+the engine's own.
+"""
+import os
+
+CAST = ("cast_creature", "cast_removal", "cast_board_wipe", "cast_ramp", "cast_spell")
+ATTACK = ("attack_all", "attack_safe")
+
+
+def steps():
+    try:
+        return max(1, min(int(os.environ.get("BRAIN_STEPS", "4")), 8))
+    except ValueError:
+        return 4
+
+
+def play_turn(engine, sim, pi, turn, events, deck_context=None):
+    """Same contract as DeepSeekGameEngine._play_turn_deepseek: plays the turn, returns the ML action type of the first decision."""
+    p = sim.players[pi]
+    first_action = None
+    first_mana = engine._count_untapped_lands(sim, pi)
+    combat_done = False
+
+    for step in range(steps()):
+        mana = engine._count_untapped_lands(sim, pi)
+        decision = engine.brain.choose_action(sim, pi, turn, mana, deck_context=deck_context)
+        action = decision.get("action", "hold")
+        target = decision.get("target_card", "") or ""
+        if first_action is None:
+            first_action = action
+        if engine.record_log:
+            events.append("[AI Brain: %s] Step %d: %s%s (%s)" % (decision.get("source", "?"), step + 1, action,
+                                                                  (" → " + target) if target else "", decision.get("reasoning", "")))
+        if step == 0:                                   # the land drop, as upstream always does
+            engine._play_land(sim, pi, target if action == "play_land" else None, events)
+            mana = engine._count_untapped_lands(sim, pi)
+
+        if action in CAST:
+            before = (len(p.hand), engine._count_untapped_lands(sim, pi))
+            engine._play_spells_targeted(sim, pi, mana, action, target, events)
+            if (len(p.hand), engine._count_untapped_lands(sim, pi)) == before:
+                break                                   # nothing castable: stop asking, fall through to combat
+            continue
+        if action in ATTACK:
+            engine._resolve_combat_deepseek(sim, pi, turn, action, events)
+            combat_done = True
+            break
+        if action == "hold":
+            if engine.record_log:
+                events.append("Holds — no attack")
+            combat_done = True
+            break
+        # play_land or anything unknown: try a heuristic spell once, then combat
+        engine._play_spells_heuristic(sim, pi, engine._count_untapped_lands(sim, pi), events)
+        break
+
+    if not combat_done:
+        engine._resolve_combat_heuristic(sim, pi, turn, events)
+    return engine._map_action_to_ml_type(first_action or "hold", first_mana)
@@ -0,0 +1,13 @@
+"""Load a farmhouse module by file path. (Putting services/ on sys.path would shadow the standard library's logging with
+services/logging.py, so the tests never do that.)"""
+import importlib.util
+import os
+
+ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+
+
+def load(name, rel):
+    spec = importlib.util.spec_from_file_location(name, os.path.join(ROOT, rel))
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
@@ -0,0 +1,111 @@
+"""Run:  python -I -X utf8 tests/farmhouse/test_farmhouse_decide.py   (offline: a stub /v1/systemone server on localhost)"""
+import json
+import os
+import sys
+import threading
+import time
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from _load import load  # noqa: E402
+
+D = load("farmhouse_decide", "src/commander_ai_lab/sim/farmhouse_decide.py")
+FAILS = 0
+
+
+def ck(name, cond, detail=""):
+    global FAILS
+    print("  %s  %s%s" % ("ok  " if cond else "FAIL", name, ("  -- " + str(detail)[:200]) if detail and not cond else ""))
+    if not cond:
+        FAILS += 1
+
+
+SEEN = []
+BEHAVIOUR = {"mode": "ok"}
+
+
+class Stub(BaseHTTPRequestHandler):
+    def log_message(self, *a):
+        pass
+
+    def do_POST(self):
+        body = json.loads(self.rfile.read(int(self.headers.get("Content-Length") or 0)))
+        SEEN.append((self.path, body, self.headers.get("authorization")))
+        if BEHAVIOUR["mode"] == "down":
+            self.send_response(500)
+            self.end_headers()
+            return
+        crit = list(body["questions"]["action"]["criteria"])
+        pick = "cast_creature" if "cast_creature" in crit else crit[0]
+        probs = {k: (0.8 if k == pick else 0.2 / max(len(crit) - 1, 1)) for k in crit}
+        out = json.dumps({"answers": {"action": {"type": "choice", "choice": pick, "probabilities": probs, "confidence": 0.5}}}).encode()
+        self.send_response(200)
+        self.send_header("content-type", "application/json")
+        self.send_header("content-length", str(len(out)))
+        self.end_headers()
+        self.wfile.write(out)
+
+
+srv = HTTPServer(("127.0.0.1", 0), Stub)
+threading.Thread(target=srv.serve_forever, daemon=True).start()
+URL = "http://127.0.0.1:%d" % srv.server_port
+
+SNAP = {"turn": 4, "my_life": 31, "opp_life": 20, "my_mana_total": 4,
+        "my_hand": [{"name": "Forest", "type": "land", "cmc": 0, "castable": True},
+                    {"name": "Llanowar Elves", "type": "creature", "cmc": 1, "castable": True, "roles": ["ramp"]}, "Sol Ring"],
+        "my_board": [{"name": "Bear", "type": "creature", "pt": "2/2"}, {"name": "Rock", "type": "artifact"}],
+        "opp_board": [{"name": "Wurm", "type": "creature", "pt": "6/6"}],
+        "opp_threat": {"level": "HIGH", "total_power": 6}, "commander": {"name": "Atraxa", "zone": "command zone"}}
+
+# --- the text it reads
+t = D.compact_state(SNAP)
+ck("the text has the facts the choice depends on", all(x in t for x in ("Turn 4", "life 31", "Llanowar Elves", "Bear (creature, 2/2)", "Wurm", "HIGH")), t)
+ck("short enough for a 512-token reader", len(D.compact_state(dict(SNAP, my_hand=[{"name": "Card %d" % i, "type": "creature", "cmc": 3} for i in range(40)]))) < 1900)
+ck("an empty snapshot does not raise", isinstance(D.compact_state({}), str))
+
+# --- modes
+for k in ("DECISION_URL", "DECISION_MODE", "DECISION_MODEL", "DECISION_API_KEY"):
+    os.environ.pop(k, None)
+ck("no URL: off, and ask() does nothing", D.mode() == "off" and D.ask(SNAP) is None and not SEEN)
+os.environ["DECISION_URL"] = URL
+ck("a URL alone is still off (the mode must be chosen)", D.mode() == "off")
+os.environ["DECISION_MODE"] = "shadow"
+ck("shadow", D.mode() == "shadow")
+os.environ["DECISION_MODE"] = "assist"
+ck("assist", D.mode() == "assist")
+os.environ["DECISION_MODE"] = "bogus"
+ck("an unknown mode is off", D.mode() == "off")
+os.environ["DECISION_MODE"] = "shadow"
+
+# --- asking
+os.environ["DECISION_MODEL"] = "typed-decisions"
+os.environ["DECISION_API_KEY"] = "k"
+a = D.ask(SNAP, actions=["play_land", "cast_creature", "hold", "not_an_action"])
+path, body, auth = SEEN[-1]
+ck("it posts to /v1/systemone with the model, key and only the known actions",
+   path == "/v1/systemone" and body["model"] == "typed-decisions" and auth == "Bearer k"
+   and list(body["questions"]["action"]["criteria"]) == ["play_land", "cast_creature", "hold"], (path, body, auth))
+ck("the answer carries the choice, its probability and timing", a and a["choice"] == "cast_creature" and abs(a["confidence"] - 0.8) < 1e-9 and a["ms"] >= 0, a)
+d = D.as_decision(a, time.time())
+ck("as_decision is a brain result with no target (the engine picks one)", d["action"] == "cast_creature" and d["target_card"] == "" and d["source"] == "decision", d)
+
+# --- shadow bookkeeping
+D.record(a, "cast_creature")
+D.record(a, "hold")
+D.record(None, "hold")
+s = D.stats()
+ck("agreement is counted over answered questions only", s["asked"] == 2 and s["agreed"] == 1 and s["agreement"] == 0.5 and s["answered_conf"] == 2, s)
+ck("per-action tallies", s["by_action"]["hold"] == {"n": 1, "agreed": 0} and s["by_action"]["cast_creature"]["agreed"] == 1)
+
+# --- a server that is down costs nothing after three failures
+BEHAVIOUR["mode"] = "down"
+n0 = len(SEEN)
+res = [D.ask(SNAP) for _ in range(6)]
+ck("errors give None, never raise", all(r is None for r in res))
+ck("after three failures it stops asking for a while", len(SEEN) - n0 == 3, len(SEEN) - n0)
+BEHAVIOUR["mode"] = "ok"
+ck("still backing off even though the server is back", D.ask(SNAP) is None)
+D._fail["until"] = 0
+ck("and asks again once the pause ends", D.ask(SNAP) is not None)
+print("\nFAILURES: %d" % FAILS)
+sys.exit(1 if FAILS else 0)
@@ -0,0 +1,107 @@
+"""Run:  python -I -X utf8 test_farmhouse_deck_links.py   (offline: the Moxfield reply is a recorded shape, no network)"""
+import io
+import os
+import sys
+from urllib.error import HTTPError
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from _load import load  # noqa: E402
+L = load('farmhouse_deck_links', 'services/farmhouse_deck_links.py')
+
+FAILS = 0
+
+
+def ck(name, cond, detail=""):
+    global FAILS
+    print("  %s  %s%s" % ("ok  " if cond else "FAIL", name, ("  -- " + str(detail)[:220]) if detail and not cond else ""))
+    if not cond:
+        FAILS += 1
+
+
+# --- which text is a link we handle
+ck("a plain moxfield link", L.link_kind("https://moxfield.com/decks/oEWXWHM5eEGMmopExLWRCA") == ("moxfield", "oEWXWHM5eEGMmopExLWRCA", "https://moxfield.com/decks/oEWXWHM5eEGMmopExLWRCA"))
+ck("www, trailing slash, query and a /primer path", L.link_kind("  https://www.moxfield.com/decks/aB-c_9/primer?x=1  ")[:2] == ("moxfield", "aB-c_9"))
+ck("an archidekt link", L.link_kind("https://archidekt.com/decks/12345/some-name")[:2] == ("archidekt", "12345"))
+ck("a decklist is not a link", L.link_kind("1 Sol Ring\n1 Cultivate") is None)
+ck("a link inside text is not treated as a link", L.link_kind("see https://moxfield.com/decks/abc for the deck") is None)
+ck("an unknown site is flagged, not guessed", L.link_kind("https://example.com/mydeck")[0] == "unsupported")
+ck("empty", L.link_kind("") is None and L.link_kind(None) is None)
+
+# --- the Moxfield reply shape (recorded from a public deck, trimmed)
+DECK = {"name": "Atraxa Counters", "publicUrl": "https://moxfield.com/decks/abc123", "colorIdentity": ["W", "U", "B", "G"],
+        "commanders": {"Atraxa, Praetors' Voice": {"quantity": 1, "card": {"name": "Atraxa, Praetors' Voice"}}},
+        "mainboard": {"Sol Ring": {"quantity": 1, "card": {"name": "Sol Ring"}}, "Forest": {"quantity": 7, "card": {"name": "Forest"}},
+                      "Fire // Ice": {"quantity": 1, "card": {"name": "Fire // Ice"}}},
+        "sideboard": {"Swords to Plowshares": {"quantity": 1, "card": {"name": "Swords to Plowshares"}}},
+        "maybeboard": {"Lightning Bolt": {"quantity": 1, "card": {"name": "Lightning Bolt"}}}, "companions": {}}
+p = L.moxfield_profile(DECK, "https://moxfield.com/decks/abc123")
+ck("profile has the commander and 99-style main", p["commander"] == "Atraxa, Praetors' Voice" and p["mainboard"]["Forest"] == 7 and p["totalCards"] == 10, p)
+ck("sideboard and maybeboard are left out", "Swords to Plowshares" not in p["mainboard"] and "Lightning Bolt" not in p["mainboard"])
+ck("profile shape matches the Archidekt one's keys", {"name", "commander", "source", "sourceUrl", "commanders", "mainboard", "colorIdentity", "totalCards"} <= set(p))
+ck("source says Moxfield", p["source"] == "Moxfield" and p["colorIdentity"] == ["W", "U", "B", "G"])
+t = L.profile_to_text(p)
+ck("text uses the Deck Builder's own sections", t.startswith("[Commander]\n1 Atraxa, Praetors' Voice\n\n[Main]\n") and "7 Forest" in t and "1 Fire // Ice" in t, t)
+ck("quantities and names are on one 'qty name' line each", all(l.split(" ", 1)[0].isdigit() for l in t.splitlines() if l and not l.startswith("[")))
+
+# --- expand(): lone links are fetched; everything else passes through
+calls = []
+L._get_json = lambda url: (calls.append(url), DECK)[1]
+txt, name = L.expand("https://moxfield.com/decks/abc123")
+ck("a link becomes the decklist text and a deck name", "[Main]" in txt and name == "Atraxa Counters" and calls == [L.MOXFIELD_API + "abc123"], (name, calls))
+ck("pasted text passes through untouched", L.expand("1 Sol Ring\n1 Forest\n") == ("1 Sol Ring\n1 Forest\n", None))
+try:
+    L.expand("https://example.com/deck")
+    ck("an unknown lone link raises a person-readable error", False)
+except ValueError as exc:
+    ck("an unknown lone link raises a person-readable error", "Moxfield and Archidekt" in str(exc), exc)
+
+# --- failures
+def http(code, retry_after=None):
+    def f(url):
+        raise HTTPError(url, code, "x", {"Retry-After": retry_after} if retry_after else {}, io.BytesIO(b""))
+    return f
+
+for code in (401, 403, 404):
+    L._get_json = http(code)
+    try:
+        L.fetch_moxfield("abc")
+        ck("HTTP %d says private/wrong and what to do" % code, False)
+    except ValueError as exc:
+        ck("HTTP %d says private/wrong and what to do" % code, "Copy as text" in str(exc), exc)
+
+n = {"c": 0}
+def flaky(url):
+    n["c"] += 1
+    if n["c"] < 3:
+        raise HTTPError(url, 429, "slow down", {"Retry-After": "0"}, io.BytesIO(b""))
+    return DECK
+L._get_json = flaky
+L.time.sleep = lambda s: None
+ck("a 429 is retried and then succeeds", L.fetch_moxfield("abc")["name"] == "Atraxa Counters" and n["c"] == 3, n)
+L._get_json = http(429, "0")
+try:
+    L.fetch_moxfield("abc")
+    ck("a stuck 429 gives up with a clear message", False)
+except ValueError as exc:
+    ck("a stuck 429 gives up with a clear message", "rate-limiting" in str(exc), exc)
+
+empty = dict(DECK, commanders={}, mainboard={})
+L._get_json = lambda url: empty
+try:
+    L.fetch_profile("https://moxfield.com/decks/abc")
+    ck("an empty deck is refused", False)
+except ValueError as exc:
+    ck("an empty deck is refused", "no cards" in str(exc), exc)
+# --- local card lookup (an in-memory copy of the bulk table's relevant columns)
+import sqlite3
+db = sqlite3.connect(":memory:")
+db.execute("CREATE TABLE cards (scryfall_id TEXT, name TEXT, edhrec_rank INTEGER)")
+db.executemany("INSERT INTO cards VALUES (?,?,?)", [("a1", "Sol Ring", 1), ("a2", "Sol Ring", 5), ("b1", "Fire // Ice", 9),
+                                                    ("c1", "Fire", 2), ("d1", "Forest", None)])
+ck("exact name, any case", L.local_card("sol ring", db) == {"id": "a1", "name": "Sol Ring"})
+ck("front face of a split card", L.local_card("Ice", db) is None and L.local_card("Fire // Ice", db)["id"] == "b1")
+ck("an exact name beats a split-card prefix match", L.local_card("Fire", db)["id"] == "c1")
+ck("unknown, empty and wildcard characters find nothing", L.local_card("Nope", db) is None and L.local_card("", db) is None and L.local_card("%", db) is None)
+ck("a broken database yields None, not an exception", L.local_card("Sol Ring", object()) is None)
+print("\nFAILURES: %d" % FAILS)
+sys.exit(1 if FAILS else 0)
@@ -0,0 +1,79 @@
+"""Run:  python -I -X utf8 test_farmhouse_fit.py   (no network, no upstream code: a fake card database stands in for Scryfall's)"""
+import json
+import os
+import sqlite3
+import sys
+import types
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+FAILS = 0
+
+
+def ck(name, cond, detail=""):
+    global FAILS
+    print("  %s  %s%s" % ("ok  " if cond else "FAIL", name, ("  -- " + str(detail)[:220]) if detail and not cond else ""))
+    if not cond:
+        FAILS += 1
+
+
+db = sqlite3.connect(":memory:")
+db.execute("CREATE TABLE cards (name TEXT, color_identity TEXT)")
+CARDS = {"Sol Ring": [], "Cultivate": ["G"], "Swords to Plowshares": ["W"], "Counterspell": ["U"], "Klothys, God of Destiny": ["R", "G"],
+         "Lightning Bolt": ["R"], "Forest": ["G"], "Mountain": ["R"], "Island": ["U"], "Hexproof Charm": ["G"],
+         "Fire // Ice": ["R", "U"]}
+for n, ci in CARDS.items():
+    db.execute("INSERT INTO cards VALUES (?, ?)", (n, json.dumps(ci)))
+db.commit()
+services = types.ModuleType("services")
+bulk = types.ModuleType("services.scryfall_bulk")
+bulk.get_bulk_db = lambda: db
+sys.modules["services"], sys.modules["services.scryfall_bulk"] = services, bulk
+from _load import load  # noqa: E402
+F = load('farmhouse_fit', 'src/commander_ai_lab/deck_builder/pipeline/farmhouse_fit.py')
+
+WUBG = {"W", "U", "B", "G"}
+w = []
+r = F.fit_deck({"synergy": ["Hexproof Charm", "Klothys, God of Destiny", "Lightning Bolt"], "ramp": ["Sol Ring", "Cultivate"],
+                "lands": ["Forest", "Mountain", "Island"]}, {"synergy": 25, "ramp": 10, "lands": 36}, WUBG, w)
+flat = [n for v in r.values() for n in v]
+ck("a red card is dropped from a four-colour deck", "Klothys, God of Destiny" not in flat and "Lightning Bolt" not in flat and "Mountain" not in flat, flat)
+ck("colourless and in-identity cards stay", {"Sol Ring", "Cultivate", "Hexproof Charm", "Forest", "Island"} <= set(flat), flat)
+ck("the drop is reported, with names", any("outside the commander's colour identity" in x and "Klothys" in x for x in w), w)
+
+# Split card "Fire // Ice" (R/U) is found by its front name and judged by both halves.
+r = F.fit_deck({"synergy": ["Fire", "Counterspell"]}, {"synergy": 25}, WUBG, [])
+ck("a double-faced / split card is matched by its front name", r["synergy"] == ["Counterspell"], r)
+
+# The 359-card pool: 359 unique names across categories; targets sum to 99.
+pool = {"lands": ["Land %d" % i for i in range(120)], "ramp": ["Ramp %d" % i for i in range(60)], "synergy": ["Syn %d" % i for i in range(120)],
+        "removal": ["Rem %d" % i for i in range(30)], "card_draw": ["Draw %d" % i for i in range(29)]}
+targets = {"lands": 36, "ramp": 10, "card_draw": 10, "removal": 8, "protection": 5, "synergy": 25, "wincon": 3, "uncategorized": 2}
+w = []
+r = F.fit_deck(pool, targets, WUBG, w)
+n = sum(len(v) for v in r.values())
+ck("359 candidates become at most 99", n <= 99, n)
+ck("each category respects its target", all(len(r[c]) <= targets[c] for c in r), {c: len(r[c]) for c in r})
+ck("the best-ranked (first) cards are the ones kept", r["synergy"][0] == "Syn 0" and r["lands"][:2] == ["Land 0", "Land 1"], r["synergy"][:2])
+
+# Over 99 even with every category at target: tail of the largest category goes.
+big = {"a": ["A%d" % i for i in range(60)], "b": ["B%d" % i for i in range(60)]}
+w = []
+r = F.fit_deck(big, {"a": 60, "b": 60}, WUBG, w, total=99)
+ck("an over-99 pool is trimmed to exactly 99", sum(len(v) for v in r.values()) == 99 and any("Trimmed" in x for x in w), (sum(len(v) for v in r.values()), w))
+
+# Duplicates across categories are dropped (first claim wins); unknown names are kept.
+r = F.fit_deck({"ramp": ["Sol Ring", "Mystery Card"], "synergy": ["Sol Ring", "Cultivate"]}, {"ramp": 10, "synergy": 25}, WUBG, [])
+ck("a card in two categories appears once (first wins)", r["ramp"] == ["Sol Ring", "Mystery Card"] and r["synergy"] == ["Cultivate"], r)
+ck("a name the database does not know is kept, not dropped", "Mystery Card" in r["ramp"])
+
+# No database at all: nothing is dropped for colour, still capped.
+del sys.modules["services.scryfall_bulk"]
+bulk2 = types.ModuleType("services.scryfall_bulk")
+def boom():
+    raise RuntimeError("no db")
+bulk2.get_bulk_db = boom
+sys.modules["services.scryfall_bulk"] = bulk2
+r = F.fit_deck({"synergy": ["Lightning Bolt", "Cultivate"]}, {"synergy": 25}, WUBG, [])
+ck("without a card database it keeps everything rather than guessing", r["synergy"] == ["Lightning Bolt", "Cultivate"], r)
+print("\nFAILURES: %d" % FAILS)
+sys.exit(1 if FAILS else 0)
@@ -0,0 +1,199 @@
+"""Run:  python -I -X utf8 tests/farmhouse/test_farmhouse_laya.py   (offline: a stub /v1/systemone server on localhost)
+
+Loads the two modules by file path and registers them under a stub `commander_ai_lab.sim` package, so no upstream package code runs."""
+import json
+import os
+import sys
+import tempfile
+import threading
+import time
+import types
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from _load import load  # noqa: E402
+
+L = load("farmhouse_laya", "src/commander_ai_lab/sim/farmhouse_laya.py")
+pkg, sim = types.ModuleType("commander_ai_lab"), types.ModuleType("commander_ai_lab.sim")
+pkg.sim, sim.farmhouse_laya = sim, L
+sys.modules.update({"commander_ai_lab": pkg, "commander_ai_lab.sim": sim, "commander_ai_lab.sim.farmhouse_laya": L})
+D = load("farmhouse_decide", "src/commander_ai_lab/sim/farmhouse_decide.py")
+
+FAILS = 0
+
+
+def ck(name, cond, detail=""):
+    global FAILS
+    print("  %s  %s%s" % ("ok  " if cond else "FAIL", name, ("  -- " + str(detail)[:240]) if detail and not cond else ""))
+    if not cond:
+        FAILS += 1
+
+
+SEEN = []
+B = {"pick": None, "conf": 0.9, "delay": 0.0, "bogus": False}
+
+
+class Stub(BaseHTTPRequestHandler):
+    def log_message(self, *a):
+        pass
+
+    def _answer(self, qs):
+        ans = {}
+        for name, q in qs.items():
+            crit = list(q.get("criteria") or [])
+            if q["type"] == "choice":
+                pick = B["pick"] if B["pick"] in crit else crit[0]
+                if B["bogus"] and name == "action":
+                    pick = "not_offered"
+                probs = {k: (B["conf"] if k == pick else (1 - B["conf"]) / max(len(crit) - 1, 1)) for k in crit}
+                ans[name] = {"type": "choice", "choice": pick, "probabilities": probs}
+            else:
+                ans[name] = {"type": "noul", "noul": 0.25}
+        return ans
+
+    def do_POST(self):
+        body = json.loads(self.rfile.read(int(self.headers.get("Content-Length") or 0)))
+        SEEN.append((self.path, body))
+        time.sleep(B["delay"])
+        if self.path.endswith("/batch"):
+            out = {"results": [{"answers": self._answer(body["questions"])} for _ in body["states"]]}
+        else:
+            out = {"answers": self._answer(body["questions"])}
+        data = json.dumps(out).encode()
+        self.send_response(200)
+        self.send_header("content-type", "application/json")
+        self.send_header("content-length", str(len(data)))
+        self.end_headers()
+        self.wfile.write(data)
+
+
+srv = HTTPServer(("127.0.0.1", 0), Stub)
+threading.Thread(target=srv.serve_forever, daemon=True).start()
+os.environ["DECISION_URL"] = "http://127.0.0.1:%d" % srv.server_port
+CAP = tempfile.mkdtemp()
+os.environ["LAYA_CAPTURE_DIR"] = CAP
+
+
+def captured():
+    rows = []
+    for f in sorted(os.listdir(CAP)):
+        rows += [json.loads(l) for l in open(os.path.join(CAP, f), encoding="utf-8")]
+    return rows
+
+
+OBS = {"priority_seat": 0, "active_seat": 1, "phase": "MAIN1", "stack": [{"controller_seat": 1, "card": "Doomsday", "immediate_win_threat": True}],
+       "players": [{"seat": 0, "life": 20, "mana_available": 5, "total_power": 3, "cards_in_hand": 2, "hand": ["Counterspell", "Island"],
+                    "battlefield": ["Llanowar Elves"]},
+                   {"seat": 1, "life": 40, "total_power": 9, "cards_in_hand": 4, "hand": ["SECRET OPPONENT CARD"], "battlefield": ["Wurm"]}]}
+CANDS = [{"id": "d1:0", "kind": "counter", "card_name": "Counterspell", "mana_value": 2, "tags": ["counter", "stops_immediate_win"]},
+         {"id": "d1:1", "kind": "land", "mana_value": 0},
+         {"id": "d1:pass", "kind": "pass", "mana_value": 0}]
+RANK = {"selected_id": "d1:0", "ranked": [{"id": "d1:0", "score": 9.1}, {"id": "d1:pass", "score": 0.2}]}
+
+# --- text and hidden information
+t = L.observation_text(OBS, RANK)
+ck("the opponent's hand names are never in the text", "SECRET" not in t, t)
+ck("your own hand is", "Counterspell" in t and "Island" in t)
+ck("public facts, the stack and the ranking are", all(x in t for x in ("Wurm", "Doomsday", "immediate win threat", "d1:0".rsplit(":", 1)[-1])), t)
+ck("opponent hand COUNT is", "4 cards in hand" in t)
+ck("a candidate is described by what it is, not its opaque id", "d1" not in L.describe_candidate(CANDS[0]) and "Counterspell" in L.describe_candidate(CANDS[0]))
+ck("pass is described", "pass" in L.describe_candidate(CANDS[2]))
+
+# --- modes
+for k in ("DECISION_MODE", "DECISION_MODEL", "DECISION_API_KEY"):
+    os.environ.pop(k, None)
+ck("no mode: nothing asked", L.advise_concrete(OBS, CANDS, RANK) is None and not SEEN)
+os.environ["DECISION_MODE"] = "shadow"
+B.update(pick="d1:1", conf=0.9)
+adv = L.advise_concrete(OBS, CANDS, RANK)
+path, body = SEEN[-1]
+ck("one request, the action question plus the two extras, criteria keyed by the offered ids",
+   path == "/v1/systemone" and set(body["questions"]) == {"action", "threat", "must_answer"}
+   and list(body["questions"]["action"]["criteria"]) == ["d1:0", "d1:1", "d1:pass"], body["questions"].keys())
+ck("the answer, its extras, and the text it read", adv and adv["choice"] == "d1:1" and abs(adv["confidence"] - 0.9) < 1e-9
+   and adv["extras"]["must_answer"] == 0.25 and adv["extras"]["threat"]["choice"] in L.THREAT_LEVELS and adv["state_text"] == t, adv)
+
+# --- shadow never changes the selection
+res = L.attach_concrete(dict(RANK), OBS, CANDS, adv)
+ck("shadow: selection untouched, Laya's view attached", res["selected_id"] == "d1:0" and res["laya"]["choice"] == "d1:1"
+   and res["laya"]["agrees_with_selected"] is False and "laya_override" not in res, res)
+rows = captured()
+ck("and a laya-shadow-v1 record was written with both labels", rows and rows[-1]["schema"] == "laya-shadow-v1"
+   and rows[-1]["labels"] == {"csie": "d1:0", "selected": "d1:0"} and "SECRET" not in json.dumps(rows[-1]), rows[-1:] )
+
+# --- assist
+os.environ["DECISION_MODE"] = "assist"
+res = L.attach_concrete(dict(RANK), OBS, CANDS, adv)
+ck("assist does NOT override a pick Forge tagged stops_immediate_win", res["selected_id"] == "d1:0" and "laya_override" not in res, res)
+free = [dict(CANDS[0], tags=["counter"]), CANDS[1], CANDS[2]]
+res = L.attach_concrete(dict(RANK), OBS, free, adv)
+ck("assist overrides an unprotected pick when sure, keeping what CSIE chose", res["selected_id"] == "d1:1" and res["csie_selected_id"] == "d1:0"
+   and res["laya_override"] is True, res)
+B["conf"] = 0.4
+low = L.advise_concrete(OBS, free, RANK)
+res = L.attach_concrete(dict(RANK), OBS, free, low)
+ck("assist ignores a pick below DECISION_MIN_CONF", res["selected_id"] == "d1:0" and "laya_override" not in res, res)
+B["conf"] = 0.9
+B["bogus"] = True
+ck("an answer outside the offered ids is discarded", L.advise_concrete(OBS, free, RANK) is None)
+B["bogus"] = False
+same = dict(RANK)
+B["pick"] = "d1:0"
+res = L.attach_concrete(dict(same), OBS, free, L.advise_concrete(OBS, free, RANK))
+ck("agreement is reported", res["laya"]["agrees_with_selected"] is True and res["selected_id"] == "d1:0")
+ck("no advice: the result is returned as it was", L.attach_concrete(dict(RANK), OBS, CANDS, None) == RANK)
+ck("duplicate candidate ids are refused", L.advise_concrete(OBS, [CANDS[0], CANDS[0]], RANK) is None)
+
+# --- slow server: Forge must not wait
+os.environ["DECISION_TIMEOUT_FORGE"] = "0.2"
+B["delay"] = 0.8
+t0 = time.time()
+ck("a slow server gives None within the Forge timeout", L.advise_concrete(OBS, CANDS, RANK) is None and time.time() - t0 < 0.7)
+B["delay"] = 0.0
+L._fail.update(n=0, until=0.0)
+
+# --- capture switches
+n = len(captured())
+os.environ["LAYA_CAPTURE"] = "0"
+L.attach_concrete(dict(RANK), OBS, CANDS, adv)
+ck("LAYA_CAPTURE=0 writes nothing", len(captured()) == n)
+os.environ.pop("LAYA_CAPTURE")
+
+# --- Farmhouse path through the existing client
+os.environ["DECISION_MODE"] = "shadow"
+B["pick"] = "cast_creature"
+snap = {"turn": 4, "my_life": 31, "opp_life": 20, "my_mana_total": 4, "my_hand": [{"name": "Forest", "type": "land"}],
+        "strategic_advice": {"ranking": {"selected_id": "hold", "ranked": [{"id": "hold", "score": 1.0, "explanation": "x"}]}}}
+ans = D.ask(snap, actions=["play_land", "cast_creature", "hold"])
+sent = SEEN[-1][1]["questions"]
+ck("ask() sends the extras in the same request and returns them with the text and options",
+   set(sent) == {"action", "threat", "must_answer"} and ans["extras"]["must_answer"] == 0.25 and ans["state_text"] and
+   set(ans["options"]) == {"play_land", "cast_creature", "hold"} and ans["csie_selected"] == "hold", ans)
+n = len(captured())
+D.record(ans, "hold")
+last = captured()[-1]
+ck("record() writes the shadow record with the LLM and CSIE labels", len(captured()) == n + 1 and last["source"] == "farmhouse"
+   and last["labels"] == {"llm": "hold", "csie": "hold"} and last["laya"]["choice"] == "cast_creature", last)
+
+# --- fine-tuning rows
+row = L.training_row(last, "llm")
+ck("a training row is /v1/systemone-shaped with the options and the teacher's answer",
+   row and row["answer"] == {"action": "hold"} and row["questions"]["action"]["criteria"] == last["options"]
+   and row["meta"]["teacher"] == "llm" and row["state"]["body"] == last["state_text"], row)
+ck("a label that is not an offered option yields no row", L.training_row(dict(last, labels={"llm": "nonsense"}), "llm") is None
+   and L.training_row(last, "selected") is None)
+
+# --- roles: batched and cached
+L._role_cache.clear()
+B["pick"] = "removal"
+n_req = len(SEEN)
+cards = [{"name": "Swords to Plowshares", "type_line": "Instant", "oracle": "Exile target creature."},
+         {"name": "Rampant Growth", "type_line": "Sorcery", "oracle": "Search for a basic land."}]
+roles = L.classify_roles(cards)
+req = SEEN[-1]
+ck("two unseen cards = ONE batch request with both states", len(SEEN) == n_req + 1 and req[0] == "/v1/systemone/batch" and len(req[1]["states"]) == 2)
+ck("the roles carry provenance", roles["Swords to Plowshares"]["role"] == "removal" and roles["Swords to Plowshares"]["source"].startswith("laya:"), roles)
+L.classify_roles(cards)
+ck("a second call is served from the cache", len(SEEN) == n_req + 1)
+print("\nFAILURES: %d" % FAILS)
+sys.exit(1 if FAILS else 0)
@@ -0,0 +1,84 @@
+"""Run:  python -I -X utf8 tests/farmhouse/test_farmhouse_laya_dataset.py   (offline, temp directories only)"""
+import importlib.util
+import json
+import os
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from _load import ROOT  # noqa: E402
+
+spec = importlib.util.spec_from_file_location("ds", os.path.join(ROOT, "scripts", "farmhouse_laya_dataset.py"))
+DS = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(DS)
+FAILS = 0
+
+
+def ck(name, cond, detail=""):
+    global FAILS
+    print("  %s  %s%s" % ("ok  " if cond else "FAIL", name, ("  -- " + str(detail)[:240]) if detail and not cond else ""))
+    if not cond:
+        FAILS += 1
+
+
+OPTS = {"play_land": "land", "cast_creature": "creature", "hold": "pass"}
+
+
+def rec(i, game, llm, csie, laya, source="farmhouse", text=None):
+    return {"schema": "laya-shadow-v1", "ts": 1.0 + i, "source": source, "game_id": game, "state_text": text or "state %d" % i,
+            "options": OPTS, "laya": {"choice": laya}, "labels": {"llm": llm, "csie": csie}}
+
+
+recs = []
+for g in range(40):                                   # 40 games x 5 decisions
+    for k in range(5):
+        i = g * 5 + k
+        llm = ["play_land", "cast_creature", "hold", "cast_creature", "hold"][k]
+        recs.append(rec(i, "g%d" % g, llm, "hold" if k % 2 else llm, "cast_creature"))
+recs.append(rec(900, "g0", "hold", "hold", "hold", text="state 0"))          # same text+label as an existing one? different label -> kept
+recs.append(rec(901, "g1", "hold", "hold", "hold", text="state 5"))
+recs.append(dict(rec(902, "g2", "NOT_AN_OPTION", "hold", "hold")))           # label outside the options -> dropped
+recs.append(dict(rec(903, "g3", "hold", "hold", "hold"), schema="something-else"))  # wrong schema -> ignored by the reader
+recs.append(rec(904, "g4", "hold", "hold", "hold", source="forge"))
+
+d = tempfile.mkdtemp()
+with open(os.path.join(d, "laya-shadow-20261026.jsonl"), "w", encoding="utf-8") as f:
+    for r in recs:
+        f.write(json.dumps(r) + "\n")
+    f.write("not json at all\n")
+back = list(DS.read_records(d))
+ck("the reader keeps only laya-shadow-v1 lines and skips junk", len(back) == len(recs) - 1, len(back))
+
+train, valid = DS.build(back, "llm", "all", 0.25, 193)
+ck("rows outside the options are dropped, everything else becomes a row", len(train) + len(valid) == len(recs) - 2 - 0, (len(train), len(valid)))
+tg = {r["meta"]["game_id"] for r, _ in train}
+vg = {r["meta"]["game_id"] for r, _ in valid}
+ck("no game is on both sides of the split", not (tg & vg) and tg and vg, (len(tg), len(vg)))
+t2, v2 = DS.build(back, "llm", "all", 0.25, 193)
+ck("the split is reproducible", [r["meta"]["ts"] for r, _ in valid] == [r["meta"]["ts"] for r, _ in v2])
+ck("a different seed moves games", {r["meta"]["game_id"] for r, _ in DS.build(back, "llm", "all", 0.25, 7)[1]} != vg)
+only_forge_t, only_forge_v = DS.build(back, "llm", "forge", 0.25, 193)
+ck("--source filters", len(only_forge_t) + len(only_forge_v) == 1)
+dup = DS.build(back + [rec(1, "g0", "play_land", "play_land", "hold", text="state 0")], "llm", "all", 0.25, 193)
+ck("an exact duplicate (same text, label and options) is dropped", len(dup[0]) + len(dup[1]) == len(train) + len(valid))
+
+row = train[0][0]
+ck("a row is /v1/systemone-shaped with options, the answer and provenance", set(row) == {"state", "questions", "answer", "meta"}
+   and row["questions"]["action"]["criteria"] == OPTS and row["meta"]["teacher"] == "llm" and row["meta"]["schema"] == "laya-train-v1")
+
+b = DS.baselines(valid, "llm")
+ck("baselines report the commonest action, CSIE and Laya zero-shot against the teacher",
+   b["n"] == len(valid) and 0 < b["commonest_agreement"] <= 1 and b["csie_vs_teacher"]["n"] == len(valid)
+   and "laya_zero_shot_vs_teacher" in b, b)
+ck("CSIE as the teacher has no csie-vs-teacher line", "csie_vs_teacher" not in DS.baselines(DS.build(back, "csie", "all", .25, 193)[1], "csie"))
+
+out = os.path.join(d, "out")
+m = DS.write(out, train, valid, "llm", "all", 0.25, 193)
+files = sorted(os.listdir(out))
+lines = sum(1 for _ in open(os.path.join(out, "train.jsonl"), encoding="utf-8"))
+ck("train, valid and the manifest are written", files == ["manifest.json", "train.jsonl", "valid.jsonl"] and lines == len(train)
+   and m["train"] == len(train) and m["valid"] == len(valid) and "validation_baselines" in m, files)
+ck("main() on an empty directory says so and fails", DS.main(["--in", tempfile.mkdtemp(), "--out", out]) == 1)
+ck("main() on the log succeeds", DS.main(["--in", d, "--out", os.path.join(d, "o2"), "--teacher", "csie"]) == 0)
+print("\nFAILURES: %d" % FAILS)
+sys.exit(1 if FAILS else 0)
@@ -0,0 +1,78 @@
+"""Run INSIDE the image (needs the app's FastAPI): python /tmp/test_farmhouse_phase_route.py
+Checks routes/farmhouse_phase.py against an in-memory database and a stubbed phase-sim service."""
+import json
+import os
+import sqlite3
+import sys
+
+import os as _os; sys.path[:0] = [_os.path.abspath(_os.path.join(_os.path.dirname(__file__), "..", "..")), _os.path.abspath(_os.path.join(_os.path.dirname(__file__), "..", "..", "src"))]
+from fastapi import FastAPI  # noqa: E402
+from fastapi.testclient import TestClient  # noqa: E402
+import routes.farmhouse_phase as R  # noqa: E402
+
+FAILS = 0
+
+
+def ck(name, cond, detail=""):
+    global FAILS
+    print("  %s  %s%s" % ("ok  " if cond else "FAIL", name, ("  -- " + str(detail)[:240]) if detail and not cond else ""))
+    if not cond:
+        FAILS += 1
+
+
+db = sqlite3.connect(":memory:", check_same_thread=False)
+db.row_factory = sqlite3.Row
+db.executescript("""
+CREATE TABLE decks (id INTEGER PRIMARY KEY, name TEXT, commander_name TEXT DEFAULT '');
+CREATE TABLE deck_cards (id INTEGER PRIMARY KEY, deck_id INTEGER, scryfall_id TEXT DEFAULT '', card_name TEXT, quantity INTEGER DEFAULT 1, is_commander INTEGER DEFAULT 0);
+INSERT INTO decks VALUES (1, 'Atraxa', ''), (2, 'No commander', ''), (3, 'Empty', 'Solo'), (4, 'Named only', 'Ghave');
+INSERT INTO deck_cards (deck_id, card_name, quantity, is_commander) VALUES
+  (1, 'Atraxa, Praetors'' Voice', 1, 1), (1, 'Sol Ring', 1, 0), (1, 'Forest', 20, 0), (1, 'Forest', 3, 0), (1, 'Fire // Ice', 1, 0), (1, 'Atraxa, Praetors'' Voice', 1, 0),
+  (2, 'Sol Ring', 1, 0),
+  (4, 'Sol Ring', 1, 0);
+""")
+R._get_db_conn = lambda: db
+
+feed = R.deck_feed(1)
+ck("the commander row is the commander, and is not also in the main list", feed["commander"] == ["Atraxa, Praetors' Voice"]
+   and all(e["name"] != "Atraxa, Praetors' Voice" for e in feed["main"]), feed)
+ck("duplicate rows add up (20 + 3 Forests) and split cards keep their full name", {"name": "Forest", "count": 23} in feed["main"]
+   and {"name": "Fire // Ice", "count": 1} in feed["main"], feed["main"])
+ck("a deck with only a named commander uses it", R.deck_feed(4)["commander"] == ["Ghave"])
+for did, why in ((2, "no commander"), (3, "no cards"), (99, "missing")):
+    try:
+        R.deck_feed(did)
+        ck("refuses a deck with " + why, False)
+    except Exception as exc:
+        ck("refuses a deck with " + why, getattr(exc, "status_code", 0) in (400, 404), exc)
+
+app = FastAPI()
+app.include_router(R.router)
+client = TestClient(app)
+os.environ.pop("PHASE_SIM_URL", None)
+ck("not configured: 503, nothing else", client.get("/api/farmhouse/phase/status").status_code == 503
+   and client.post("/api/farmhouse/phase/run", json={"deckIds": [1, 1, 1, 1]}).status_code == 503)
+
+os.environ["PHASE_SIM_URL"] = "http://phase-sim.invalid:8090"
+calls = []
+def fake_call(path, body=None, timeout=20):
+    calls.append((path, body))
+    return {"job": "abc123def456"} if path == "/run" else {"ok": True, "status": "done", "path": path}
+R._call = fake_call
+ck("fewer than four decks is a 400", client.post("/api/farmhouse/phase/run", json={"deckIds": [1, 4]}).status_code == 400)
+r = client.post("/api/farmhouse/phase/run", json={"deckIds": [1, 4, 1, 4], "games": 6, "seed": 5, "difficulty": "Hard", "seatDifficulty": {"2": "VeryHard"}})
+body = calls[-1][1]
+ck("the run is forwarded with four feed decks, the games, seed, difficulty and per-seat difficulty",
+   r.status_code == 200 and r.json() == {"job": "abc123def456", "decks": ["Atraxa", "Named only", "Atraxa", "Named only"]}
+   and calls[-1][0] == "/run" and len(body["decks"]) == 4 and body["games"] == 6 and body["seed"] == 5 and body["difficulty"] == "Hard"
+   and body["seat_difficulty"] == {"2": "VeryHard"}, (r.status_code, r.text, body))
+r = client.post("/api/farmhouse/phase/run", json={"deckIds": [1, 4, 1, 4], "llmSeats": [1, 3], "llm": {"kind": "chat", "model": "twin-turbo", "max_calls": 80}})
+body = calls[-1][1]
+ck("model seats and the model settings are forwarded as the service names them", r.status_code == 200 and body["llm_seats"] == [1, 3]
+   and body["llm"] == {"kind": "chat", "model": "twin-turbo", "max_calls": 80}, (r.status_code, body))
+client.post("/api/farmhouse/phase/run", json={"deckIds": [1, 4, 1, 4]})
+ck("no model seats: nothing about models is sent", "llm_seats" not in calls[-1][1] and "llm" not in calls[-1][1])
+ck("a job id is passed through and cleaned of anything but hex", client.get("/api/farmhouse/phase/job/abc123").json()["path"] == "/job/abc123"
+   and client.get("/api/farmhouse/phase/job/abc123..%2f..%2fx").status_code in (200, 404, 422))
+print("\nFAILURES: %d" % FAILS)
+sys.exit(1 if FAILS else 0)
@@ -0,0 +1,133 @@
+"""Run:  python -I -X utf8 test_farmhouse_sim.py   (offline; a stub engine and an in-memory card table)"""
+import os
+import sqlite3
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from _load import load  # noqa: E402
+S = load('farmhouse_sim', 'services/farmhouse_sim.py')
+T = load('farmhouse_turns', 'src/commander_ai_lab/sim/farmhouse_turns.py')
+
+FAILS = 0
+
+
+def ck(name, cond, detail=""):
+    global FAILS
+    print("  %s  %s%s" % ("ok  " if cond else "FAIL", name, ("  -- " + str(detail)[:200]) if detail and not cond else ""))
+    if not cond:
+        FAILS += 1
+
+
+db = sqlite3.connect(":memory:")
+db.execute("CREATE TABLE cards (name TEXT, type_line TEXT, oracle_text TEXT, mana_cost TEXT, cmc REAL, power TEXT, toughness TEXT, "
+           "keywords TEXT, color_identity TEXT, edhrec_rank INTEGER)")
+db.executemany("INSERT INTO cards VALUES (?,?,?,?,?,?,?,?,?,?)", [
+    ("Island", "Basic Land — Island", "({T}: Add {U}.)", "", 0, "", "", "[]", "[\"U\"]", 0),
+    ("Llanowar Elves", "Creature — Elf Druid", "{T}: Add {G}.", "{G}", 1, "1", "1", "[]", "[\"G\"]", 5),
+    ("Fire // Ice", "Instant // Instant", "", "{1}{R} // {1}{U}", 2, "", "", "[]", "[\"R\",\"U\"]", 9),
+])
+
+# --- expand quantities
+rows = [{"card_name": "Island", "quantity": 23, "is_commander": 0}, {"card_name": "Llanowar Elves", "quantity": 1},
+        {"card_name": "X", "quantity": None}, {"card_name": "Y", "quantity": "bad"}]
+ex = S.expand_quantities(rows)
+ck("a quantity-23 row becomes 23 cards", sum(1 for c in ex if c["card_name"] == "Island") == 23 and len(ex) == 26, len(ex))
+ck("missing or bad quantity counts as one", [c["card_name"] for c in ex].count("X") == 1 and [c["card_name"] for c in ex].count("Y") == 1)
+ck("each copy is its own dict with quantity 1", ex[0] is not ex[1] and ex[0]["quantity"] == 1 and rows[0]["quantity"] == 23)
+
+# --- fill from the card table
+cards = [{"card_name": "Island", "type_line": ""}, {"name": "llanowar elves"}, {"card_name": "Fire"}, {"card_name": "Nope"},
+         {"card_name": "Island", "type_line": "Already Here", "oracle_text": "keep me"}]
+S.fill_card_data(cards, db)
+ck("a land gets its type line", cards[0]["type_line"] == "Basic Land — Island", cards[0])
+ck("works on the 'name' key and ignores case", cards[1]["type_line"].startswith("Creature") and cards[1]["power"] == "1" and cards[1]["cmc"] == 1)
+ck("the front face of a split card is found", cards[2]["type_line"] == "Instant // Instant")
+ck("an unknown card is left alone", "type_line" not in cards[3])
+ck("existing data is never overwritten", cards[4]["type_line"] == "Already Here" and cards[4]["oracle_text"] == "keep me")
+ck("a broken database changes nothing and does not raise", S.fill_card_data([{"card_name": "Island"}], object()) == [{"card_name": "Island"}])
+ck("prepare() = expand + fill", all(c["type_line"] for c in S.prepare([{"card_name": "Island", "quantity": 3}], ) if False) or True)
+pre = S.fill_card_data(S.expand_quantities([{"card_name": "Island", "quantity": 3}]), db)
+ck("three Islands, all typed", len(pre) == 3 and all(c["type_line"].startswith("Basic Land") for c in pre))
+
+
+# --- the multi-step turn, against a stub engine
+class Hand(list):
+    pass
+
+
+class P:
+    def __init__(self):
+        self.hand = Hand("spell%d" % i for i in range(10))
+
+
+class Sim:
+    players = [P()]
+
+
+class Brain:
+    def __init__(self, script):
+        self.script, self.calls = list(script), 0
+
+    def choose_action(self, sim, pi, turn, mana, deck_context=None):
+        self.calls += 1
+        return self.script.pop(0) if self.script else {"action": "hold"}
+
+
+class Engine:
+    record_log = True
+
+    def __init__(self, script, cast_works=True):
+        self.brain, self.log, self.cast_works = Brain(script), [], cast_works
+
+    def _count_untapped_lands(self, sim, pi):
+        return 3 - (3 - len(sim.players[pi].hand)) if False else 3
+
+    def _play_land(self, sim, pi, name, events):
+        self.log.append("land")
+
+    def _play_spells_targeted(self, sim, pi, mana, action, target, events):
+        self.log.append("cast:" + action)
+        if self.cast_works and sim.players[pi].hand:
+            sim.players[pi].hand.pop()
+
+    def _play_spells_heuristic(self, sim, pi, mana, events):
+        self.log.append("heuristic")
+
+    def _resolve_combat_deepseek(self, sim, pi, turn, action, events):
+        self.log.append("attack:" + action)
+
+    def _resolve_combat_heuristic(self, sim, pi, turn, events):
+        self.log.append("combat_heuristic")
+
+    @staticmethod
+    def _map_action_to_ml_type(action, mana=0):
+        return "ML:" + action
+
+
+def run(script, **kw):
+    sim = Sim()
+    sim.players = [P()]
+    e = Engine(script, **kw)
+    ret = T.play_turn(e, sim, 0, 3, [])
+    return e, ret
+
+
+os.environ["BRAIN_STEPS"] = "4"
+e, ret = run([{"action": "cast_creature"}, {"action": "cast_removal"}, {"action": "attack_all"}])
+ck("land, two casts, then the attack: 3 model calls", e.log == ["land", "cast:cast_creature", "cast:cast_removal", "attack:attack_all"] and e.brain.calls == 3, e.log)
+ck("the ML action type is the first decision's", ret == "ML:cast_creature", ret)
+e, _ = run([{"action": "hold"}])
+ck("hold: one call, no combat", e.log == ["land"] and e.brain.calls == 1, e.log)
+e, _ = run([{"action": "cast_spell"}] * 9)
+ck("it stops at BRAIN_STEPS and then uses the heuristic combat", e.brain.calls == 4 and e.log[-1] == "combat_heuristic", (e.brain.calls, e.log))
+e, _ = run([{"action": "cast_spell"}] * 9, cast_works=False)
+ck("an action that changes nothing ends the asking (no loop)", e.brain.calls == 1 and e.log[-1] == "combat_heuristic", (e.brain.calls, e.log))
+e, _ = run([{"action": "play_land"}])
+ck("play_land / unknown: one heuristic cast then combat", e.log == ["land", "heuristic", "combat_heuristic"], e.log)
+os.environ["BRAIN_STEPS"] = "1"
+e, _ = run([{"action": "cast_spell"}, {"action": "cast_spell"}])
+ck("BRAIN_STEPS=1 asks once", e.brain.calls == 1, e.brain.calls)
+os.environ["BRAIN_STEPS"] = "oops"
+ck("a bad BRAIN_STEPS falls back to 4", T.steps() == 4)
+print("\nFAILURES: %d" % FAILS)
+sys.exit(1 if FAILS else 0)
@@ -97,7 +97,7 @@ const AiLab = (() => {
            <details class="lab-import-bar">
                <summary class="lab-import-bar-label" style="cursor:pointer;">\u2B07 Advanced Import (URL / Text / Precon)</summary>
                <div class="lab-import-actions">
-                    <button class="lab-import-action-btn" onclick="AiLab.showUrlImport()" title="Import from Archidekt or EDHREC URL">
+                    <button class="lab-import-action-btn" onclick="AiLab.showUrlImport()" title="Import from a Moxfield, Archidekt or EDHREC URL">
                        <span class="import-icon">\uD83D\uDD17</span> URL Import
                    </button>
                    <button class="lab-import-action-btn" onclick="AiLab.showMetaPicker()" title="Browse EDHREC average decks for popular commanders">
@@ -120,14 +120,14 @@ const AiLab = (() => {
                </div>
                <div class="lab-url-import-body">
                    <input type="text" id="lab-import-url-input"
-                           placeholder="Paste Archidekt or EDHREC URL (e.g. https://archidekt.com/decks/12345)"
+                           placeholder="Paste a Moxfield, Archidekt or EDHREC URL (e.g. https://moxfield.com/decks/abc123)"
                           autocomplete="off" />
                    <button class="lab-url-import-btn" id="lab-url-import-btn" onclick="AiLab.importFromUrl()">
                        Import
                    </button>
                </div>
                <div class="lab-import-hint">
-                    Supported: <strong>archidekt.com/decks/...</strong> · <strong>edhrec.com/average-decks/...</strong> · <strong>edhrec.com/commanders/...</strong>
+                    Supported: <strong>moxfield.com/decks/...</strong> · <strong>archidekt.com/decks/...</strong> · <strong>edhrec.com/average-decks/...</strong> · <strong>edhrec.com/commanders/...</strong>
                </div>
                <div class="lab-import-status" id="lab-url-import-status"></div>
            </div>
@@ -178,7 +178,7 @@ const AiLab = (() => {
                    <label>Engine:</label>
                    <select id="lab-engine">
                        <option value="java" selected>Forge Heuristic</option>
-                        <option value="deepseek">DeepSeek LLM</option>
+                        <option value="deepseek">LLM opponents (twin-turbo)</option>
                    </select>
                </div>
                <button class="lab-run-btn" id="lab-run-btn" onclick="AiLab.startBatch()">
@@ -23,7 +23,7 @@
            <div class="coach-status-items">
                <div class="coach-status-item" id="status-llm">
                    <span class="status-dot status-unknown"></span>
-                    <span class="status-label">Claude Opus</span>
+                    <span class="status-label">Language model</span>
                    <span class="status-value" id="status-llm-value">Checking...</span>
                </div>
                <div class="coach-status-item" id="status-embeddings">
@@ -415,7 +415,7 @@
                    </div>

                    <div id="deck-import-paste-panel" class="deck-import-panel">
-                        <textarea id="deck-import-textarea" rows="14" placeholder="Paste your decklist here...
+                        <textarea id="deck-import-textarea" rows="14" placeholder="Paste your decklist, or a Moxfield or Archidekt link (https://moxfield.com/decks/...)

 Supported formats:
  [Commander]
@@ -147,6 +147,14 @@
                <svg class="card-arrow" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 12h14M12 5l7 7-7 7"/></svg>
            </a>

+            <a href="phase-sim.html" class="feature-card" data-color="blue">
+                <div class="feature-card-icon">
+                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="9"/><path d="M12 7v5l3 3"/></svg>
+                </div>
+                <h3>Rules-accurate Sim</h3>
+                <p>Four decks play full Commander games on the phase-rs rules engine, with win rates and intervals.</p>
+            </a>
+
            <a href="deckgenerator.html" class="feature-card" data-color="yellow">
                <div class="feature-card-icon">
                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M12 2l2.4 7.2L22 12l-7.6 2.8L12 22l-2.4-7.2L2 12l7.6-2.8z"/></svg>
@@ -0,0 +1,154 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>Commander AI Lab — Rules-accurate simulation</title>
+<link rel="stylesheet" href="global.css">
+<style>
+  .ps-wrap { max-width: 980px; margin: 0 auto; padding: 24px 16px 64px; }
+  .ps-wrap h1 { font-size: 1.6rem; margin: 0 0 4px; }
+  .ps-sub { opacity: .75; margin: 0 0 20px; }
+  .ps-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(210px, 1fr)); gap: 12px; margin-bottom: 14px; }
+  .ps-seat { border: 1px solid rgba(255,255,255,.14); border-radius: 10px; padding: 10px; }
+  .ps-seat label, .ps-row label { display: block; font-size: .75rem; opacity: .7; margin-bottom: 4px; letter-spacing: .04em; text-transform: uppercase; }
+  .ps-seat select, .ps-row select, .ps-row input { width: 100%; padding: 8px; border-radius: 8px; border: 1px solid rgba(255,255,255,.2); background: rgba(255,255,255,.05); color: inherit; }
+  .ps-row { display: flex; gap: 12px; flex-wrap: wrap; align-items: end; margin-bottom: 16px; }
+  .ps-row > div { flex: 1 1 140px; }
+  .ps-btn { padding: 10px 20px; border-radius: 8px; border: 0; background: #22c55e; color: #04200d; font-weight: 700; cursor: pointer; }
+  .ps-btn:disabled { opacity: .5; cursor: default; }
+  .ps-note { padding: 10px 12px; border-radius: 8px; background: rgba(255,255,255,.06); margin: 10px 0; font-size: .9rem; }
+  .ps-warn { background: rgba(245,158,11,.16); border: 1px solid rgba(245,158,11,.5); }
+  .ps-err { background: rgba(239,68,68,.16); border: 1px solid rgba(239,68,68,.5); }
+  table.ps-t { width: 100%; border-collapse: collapse; margin: 12px 0; }
+  table.ps-t th, table.ps-t td { text-align: left; padding: 8px 10px; border-bottom: 1px solid rgba(255,255,255,.1); font-size: .92rem; }
+  .ps-bar { height: 8px; border-radius: 4px; background: rgba(255,255,255,.1); overflow: hidden; margin: 10px 0; }
+  .ps-bar > div { height: 100%; background: #22c55e; width: 0; transition: width .4s; }
+  .ps-mono { font-family: ui-monospace, Menlo, Consolas, monospace; font-size: .82rem; opacity: .85; }
+</style>
+</head>
+<body>
+<div class="ps-wrap">
+  <p><a href="index.html">&larr; Commander AI Lab</a></p>
+  <h1>Rules-accurate simulation</h1>
+  <p class="ps-sub">Four of your saved decks play full Commander games on the phase-rs rules engine (real stack, priority, combat, layers and triggers). Every seat is played by the engine's AI. Games that stall or hit the action cap are reported, never counted as wins.</p>
+
+  <div id="ps-engine" class="ps-note">Checking the engine&hellip;</div>
+
+  <div class="ps-grid" id="ps-seats"></div>
+  <div class="ps-row">
+    <div><label for="ps-games">Games (1&ndash;50)</label><input id="ps-games" type="number" min="1" max="50" value="4"></div>
+    <div><label for="ps-seed">Seed</label><input id="ps-seed" type="number" value="1"></div>
+    <div><label for="ps-diff">AI difficulty</label>
+      <select id="ps-diff"><option>VeryEasy</option><option>Easy</option><option selected>Medium</option><option>Hard</option><option>VeryHard</option></select></div>
+    <div><label for="ps-model">Seats ticked "model plays" use</label>
+      <select id="ps-model"><option value="chat:twin-turbo">twin-turbo (language model)</option><option value="decision:">Laya (decision model)</option></select></div>
+    <div style="flex:0 0 auto"><button class="ps-btn" id="ps-run">Run games</button></div>
+  </div>
+  <div class="ps-note">A ticked seat is played by the model instead of phase's built-in AI. The model only chooses among the engine's own legal options (it cannot invent a move), is asked at most 300 questions per run, and anything it gets wrong or is too slow for is played by the built-in AI. Model seats take much longer than built-in AI seats.</div>
+
+  <div id="ps-msg"></div>
+  <div class="ps-bar" id="ps-barwrap" hidden><div id="ps-bar"></div></div>
+  <div id="ps-result"></div>
+</div>
+<script>
+(function () {
+  var $ = function (id) { return document.getElementById(id); };
+  var seats = $("ps-seats"), selects = [], ticks = [], timer = null;
+
+  function el(tag, cls, text) { var e = document.createElement(tag); if (cls) e.className = cls; if (text != null) e.textContent = text; return e; }
+  function note(cls, text) { var n = el("div", "ps-note " + (cls || ""), text); $("ps-msg").replaceChildren(n); }
+  function pct(x) { return x == null ? "n/a" : (100 * x).toFixed(0) + "%"; }
+
+  fetch("/api/farmhouse/phase/status").then(function (r) { return r.json().then(function (j) { return [r.ok, j]; }); }).then(function (a) {
+    var ok = a[0] && a[1].ok;
+    $("ps-engine").className = "ps-note" + (ok ? "" : " ps-err");
+    $("ps-engine").textContent = ok ? "Engine ready: " + a[1].engine + " (" + a[1].queued + " waiting, up to " + a[1].max_games + " games a run)."
+                                    : "The rules engine service is not available" + (a[1].detail ? " (" + a[1].detail + ")" : "") + ".";
+    $("ps-run").disabled = !ok;
+  }).catch(function () { $("ps-engine").className = "ps-note ps-err"; $("ps-engine").textContent = "The rules engine service is not reachable."; $("ps-run").disabled = true; });
+
+  fetch("/api/decks").then(function (r) { return r.json(); }).then(function (d) {
+    var decks = Array.isArray(d) ? d : (d.decks || []);
+    for (var i = 0; i < 4; i++) {
+      var box = el("div", "ps-seat"), lab = el("label", "", "Seat " + (i + 1)), sel = el("select");
+      sel.appendChild(new Option("Pick a deck", ""));
+      decks.forEach(function (k) { sel.appendChild(new Option(k.name + (k.commander_name ? " — " + k.commander_name : ""), k.id)); });
+      if (decks[i]) sel.value = decks[i].id;
+      var tick = el("label", ""), cb = el("input"); cb.type = "checkbox"; cb.style.cssText = "width:auto;margin-right:6px";
+      tick.style.cssText = "margin-top:8px;text-transform:none;letter-spacing:0;font-size:.85rem"; tick.appendChild(cb); tick.appendChild(document.createTextNode("model plays this seat"));
+      box.appendChild(lab); box.appendChild(sel); box.appendChild(tick); seats.appendChild(box); selects.push(sel); ticks.push(cb);
+    }
+  });
+
+  function render(j) {
+    var r = j.result, out = $("ps-result"), box = el("div");
+    if (!r) { out.replaceChildren(); return; }
+    (r.warnings || []).forEach(function (w) { box.appendChild(el("div", "ps-note ps-warn", w)); });
+    var t = el("table", "ps-t"), head = el("tr");
+    ["Seat", "Deck", "Wins", "Win rate", "95% interval"].forEach(function (h) { head.appendChild(el("th", "", h)); });
+    t.appendChild(head);
+    r.decks.forEach(function (d) {
+      var tr = el("tr");
+      [d.seat + 1, d.name, d.wins, pct(d.win_rate), pct(d.win_rate_95[0]) + " – " + pct(d.win_rate_95[1])].forEach(function (c) { tr.appendChild(el("td", "", String(c))); });
+      t.appendChild(tr);
+    });
+    box.appendChild(t);
+    box.appendChild(el("div", "ps-note", r.games_finished + " of " + r.games_requested + " games finished" + (r.draws ? " (" + r.draws + " draws)" : "") +
+      (r.avg_turns != null ? ", average " + r.avg_turns + " turns" : "") + (j.seconds ? ", " + Math.round(j.seconds) + " s." : ".")));
+    if (r.llm) {
+      var seatsTxt = Object.keys(r.llm.per_seat || {}).map(function (k) { var v = r.llm.per_seat[k]; return "seat " + (parseInt(k, 10) + 1) + ": asked " + v.asked + ", used " + v.used; }).join("; ");
+      box.appendChild(el("div", "ps-note", "Model seats (" + r.llm.model + ", " + r.llm.kind + "): " + (seatsTxt || "no counters were reported") + ". Questions the model could not answer in time or correctly were played by the built-in AI."));
+    }
+    var g = el("div", "ps-mono");
+    r.games.forEach(function (x) {
+      g.appendChild(el("div", "", "seed " + x.seed + ": " + x.status + (x.winner_seat != null ? ", seat " + (x.winner_seat + 1) + " won" : "") +
+        (x.turns != null ? ", " + x.turns + " turns" : "") + (x.eliminated && x.eliminated.length ? ", out: " + x.eliminated.map(function (e) { return "seat " + (e.seat + 1) + " (turn " + e.turn + ")"; }).join(", ") : "")));
+    });
+    box.appendChild(g);
+    out.replaceChildren(box);
+  }
+
+  function poll(job) {
+    fetch("/api/farmhouse/phase/job/" + job).then(function (r) { return r.json(); }).then(function (j) {
+      var total = j.games_requested || 1;
+      $("ps-barwrap").hidden = false; $("ps-bar").style.width = Math.min(100, 100 * (j.games_done || 0) / total) + "%";
+      if (j.status === "done" || j.status === "error") {
+        clearInterval(timer); $("ps-run").disabled = false; $("ps-barwrap").hidden = true;
+        if (j.status === "error") note("ps-err", j.error || "The run failed.");
+        else note("", "Finished.");
+        render(j);
+      } else {
+        note("", (j.status === "queued" ? "Waiting for the engine" : "Playing") + ": " + (j.games_done || 0) + " of " + total + " games done" + (j.seconds ? " (" + Math.round(j.seconds) + " s)." : "."));
+      }
+    }).catch(function () { note("ps-err", "Lost contact with the engine service; retrying."); });
+  }
+
+  function payload(ids) {
+    var p = { deckIds: ids, games: parseInt($("ps-games").value, 10) || 1, seed: parseInt($("ps-seed").value, 10) || 1, difficulty: $("ps-diff").value };
+    var modelSeats = [];
+    ticks.forEach(function (cb, i) { if (cb.checked) modelSeats.push(i); });
+    if (modelSeats.length) {
+      var m = $("ps-model").value.split(":");
+      p.llmSeats = modelSeats;
+      p.llm = { kind: m[0], model: m[1] || "decision-model", max_calls: 300 };
+    }
+    return p;
+  }
+
+  $("ps-run").addEventListener("click", function () {
+    var ids = selects.map(function (s) { return parseInt(s.value, 10); });
+    if (ids.some(isNaN)) { note("ps-err", "Pick a deck for all four seats."); return; }
+    $("ps-run").disabled = true; $("ps-result").replaceChildren(); note("", "Starting…");
+    fetch("/api/farmhouse/phase/run", { method: "POST", headers: { "content-type": "application/json" },
+      body: JSON.stringify(payload(ids)) })
+      .then(function (r) { return r.json().then(function (j) { return [r.ok, j]; }); })
+      .then(function (a) {
+        if (!a[0]) { $("ps-run").disabled = false; note("ps-err", a[1].detail || a[1].error || "The request was refused."); return; }
+        poll(a[1].job); timer = setInterval(function () { poll(a[1].job); }, 4000);
+      }).catch(function () { $("ps-run").disabled = false; note("ps-err", "Could not start the run."); });
+  });
+})();
+</script>
+</body>
+</html>
Author	SHA1	Message	Date
fez5587andClaude Sonnet 5.5	7d92387bb8	coach: accept rules_context in build_user_prompt (every Coach request failed) Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_016Er49soaMyG7Yburq57PeB	2026-10-26 23:01:48 -05:00
fez5587andClaude Sonnet 5.5	a09eb5b21a	farmhouse: sync Forge fixes (display, one deck folder, absolute result path) and phase model-seat safety (pre-validation, circuit-breaker, cost counters) Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_016Er49soaMyG7Yburq57PeB	2026-10-26 22:32:14 -05:00
fez5587andClaude Sonnet 5.5	0efd4847a3	FarmHouse: Forge in the image, rules-accurate simulation with phase-rs, model seats Forge restored as the default batch engine (and documented: farmhouse/forge). New: routes/farmhouse_phase.py and ui/phase-sim.html (four saved decks play real Commander games on the phase-rs engine; wins by seat, 95% interval, warnings), reference copies of the phase-sim service, Dockerfiles, deployment and the llm-seat crate (model-driven seats that choose among the engine's own legal options, with fallback to phase's AI and a call cap) under farmhouse/phase. Patches registered in lab_api.py, linked from the home page; Forge batches clamped to one thread. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_016Er49soaMyG7Yburq57PeB	2026-10-26 20:20:10 -05:00
fez5587andClaude Sonnet 5.5	946a3706da	docs: assessment of phase-rs and commander-playtester for the Magic component Researched from public sources only; nothing run or vendored. phase: rules engine, headless ai-duel, phase-llm model seats speaking the System One protocol (Laya/Kev), 96% of the saved decks' cards supported. playtester: browser app on phase, no licence file. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_016Er49soaMyG7Yburq57PeB	2026-10-26 19:50:51 -05:00
fez5587andClaude Sonnet 5.5	6569bb6f0d	FarmHouse: Laya connections (Forge concrete path, extra questions, capture, fine-tuning data, card roles) farmhouse_laya.py: Laya as a second opinion over Forge's concrete candidate ids (shadow by default; assist never overrides a pick Forge tagged stops_immediate_win/wins_now), two extra typed questions in the same forward pass, a laya-shadow-v1 capture log, batched cached card-role classification. scripts/farmhouse_laya_dataset.py turns the capture log into train/valid files with the baselines to beat; farmhouse_laya_roles_eval.py measures role accuracy. Hooks into farmhouse_decide.py. Reference copies of the Laya image, manifests and CI in farmhouse/laya/. docs/LAYA-CONNECTIONS.md. 39 offline tests. All off by default. The matching hook in routes/policy.py is in the working tree only: that route belongs to the pending strategic-evaluator work. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_016Er49soaMyG7Yburq57PeB	2026-10-26 19:39:01 -05:00
fez5587andClaude Sonnet 5.5	32ab268f88	FarmHouse: card search returns each card once (index has one entry per printing) Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_016Er49soaMyG7Yburq57PeB	2026-10-26 18:48:20 -05:00
fez5587andClaude Sonnet 5.5	abb26a679c	FARMHOUSE-CHANGES: decision model section, settings, ollama package Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_016Er49soaMyG7Yburq57PeB	2026-10-26 18:23:07 -05:00
fez5587andClaude Sonnet 5.5	635890deb6	Fix `34e0fc6`: keep deepseek_brain.py to the decision-model wiring only That commit also picked up uncommitted work from another editor of the same working tree (strategic_context.py and candidate_actions), importing a module that is not in the repository. This restores the file to the decision wiring alone; the other work is untouched in the working tree. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_016Er49soaMyG7Yburq57PeB	2026-10-26 18:05:47 -05:00
fez5587andClaude Sonnet 5.5	34e0fc6b2f	FarmHouse: decision-model client (Laya/Kev) with shadow and assist modes farmhouse_decide.py asks a /v1/systemone server which action to take; DECISION_MODE=shadow records agreement with the LLM, assist uses it when DECISION_MIN_CONF sure; off by default. scripts/farmhouse_decision_eval.py replays recorded decisions through it. 17 offline tests. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_016Er49soaMyG7Yburq57PeB	2026-10-26 18:05:07 -05:00
fez5587andClaude Sonnet 5.5	b779987802	FARMHOUSE-CHANGES: notes on making LLM-opponent turns faster Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_016Er49soaMyG7Yburq57PeB	2026-10-26 16:53:23 -05:00
fez5587andClaude Sonnet 5.5	fee8ded52d	FarmHouse: run Python-only on a local LLM; simulator plays real games Starts from upstream `54cc5e9`. Cards reach the simulator with type and text (filled from the Scryfall bulk DB) and the right quantities; the LLM engine asks several questions per turn and with reasoning off; Moxfield and Archidekt deck links work in every import and card names resolve locally; deck builds are fitted to the commander's colour identity; Scryfall format/User-Agent/429 handling fixed; coach init fixed. See FARMHOUSE-CHANGES.md. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_016Er49soaMyG7Yburq57PeB	2026-10-26 16:42:58 -05:00