Rules that do not depend on the AI being right.

The state lives in the engine: cards, players, tokens, castle goals. The model is sent a JSON portrait of the state (player, hand, tokens, what has happened) and returns a decision. The engine checks whether that decision is legal and, if it is, applies it. Never the other way round: the model does not touch the state.

Every card effect is a hand-written function over the state. The model does not know how a card effect works: it only knows that an option with that name exists. Everything that can get it wrong sits outside the rules, and the rules do not depend on anybody.

The engine is deterministic when the AI is not involved. The dice come from a seeded generator, so a game is repeatable: if something breaks on round sixty-three, you replay round sixty-three and look at it. Without that, debugging a game by simulation is impossible.

Five instruction texts: one with the game rules and four different strategic profiles (team player, team dealer, conservative player, conservative dealer), because the same model has to play like a different style depending on who it represents.

The reading happens in two stages. First a strict json.loads. If it fails, a second attempt trimming from the first opening brace to the last closing one, which is how you survive the model explaining itself before it answers.

Then comes the important part: a normaliser that checks every field against the real vocabulary of the engine. The reward has to be on the list of rewards; the betting action, one of four possible values. What is not on that list does not exist and turns into the neutral option. An invented name does not throw an exception: it degrades to none and the game carries on.

And a ceiling on everything that comes in from outside: the name of the beneficiary of a shot is cut at eighty characters. A free-text field that ends up in a query or in a window is an open door, and here the text is written by a model that nobody controls.

There is a counter of consecutive failures that trips a permanent short circuit. On the second failure in a row the AI provider is disabled for the rest of that simulation and every remaining decision is taken by a local heuristic, with a warning in the log so that nobody later reads it as if the model had been playing.

The counter resets with a single valid response. An unstable network does not switch the AI off for good: only during that run, which is the only horizon over which you can decide.

Every call carries a configurable timeout with a floor of three seconds (the code writes max(3, timeout)) so that a badly filled field cannot produce an indefinite wait. There is never an unlimited wait, which is the only kind that does not recover.

The heuristic is not an empty patch: it reproduces a real conservative strategy, so a game finished by heuristic is still useful for validating rules. That was the objective from the beginning: measure the game, not measure the model.

A double of urllib.request.urlopen returns whatever I am interested in: valid JSON, unstructured text, a transport error. That checks the happy path and the two ways of breaking, and the engine is tested with no network and no model downloaded.

The test profiles play six named players plus a dealer, with a maximum of one hundred rounds and a summary at the end. If a rule makes it so that nobody can win, the profile does not finish and the maximum stops it: an infinite loop in a game engine is exactly that case.

And what is missing

With TEST_PROFILE_MAX_ROUNDS = 100 the cost of a regression is high and the current tests do not cover the twenty-four effects one by one against fixed states. It is real and bounded debt. The reason every effect is already a separate function is precisely that: they can be tested without rewriting anything of the engine.