A loaded policy still has to make the decisions

Pulse Court had a strict smoke path that loaded policy metadata and then ran a scripted controller. It could produce a completed game without establishing that the requested network had chosen the actions. A successful load and a plausible replay were individually true observations with a missing connection between them.

The project is a native arena simulation with a policy runtime, a headless runner, and replay verification. A smoke run is meant to establish that these pieces work together before stronger evaluation. If the runner quietly substitutes a different controller, it can pass while failing its central purpose. The repair had to make controller identity observable throughout execution.

The repaired runner retains a loaded strict policy for execution and makes scripted smoke an explicit choice. Missing strict inputs fail before session evidence is created. That prevents a fallback game from being mistaken for a run of the requested artifact.

There is a separate compatibility boundary. The September preview used ruleset 2, while the strict policy contract expected ruleset 4. A manifest passing its schema checks could not make those simulation rules compatible. The strict loader rejected that mismatch, so the six-game execution evidence comes from an explicitly non-certified preview using a synthetic, untrained development policy.

This is a useful division of responsibilities. Schema validation asks whether an artifact is well formed. Compatibility asks whether its assumptions match the runtime. Execution asks whether it actually controls behavior. None of those checks establishes that its behavior is good. Keeping the modes explicit makes a failure at one boundary visible without borrowing credibility from another.

The original v2 preview recorded 9,483 native network decisions across six games, exercising both seats. Six explicitly scripted control games recorded zero network decisions. All six preview replays passed verification. These numbers demonstrate the exercised paths and preserved execution, not learned playing strength.

The decision counter is tied to fresh PolicyController decisions. A separate regression check reconstructs the bot inputs and state hashes with an independent controller and simulation, matches the recorded count, and checks that the network's input stream differs from the scripted stream. That last comparison matters: a counter increment in the wrong place could otherwise report inference while gameplay still follows a fallback.

The checks therefore connect several observations. The requested mode selects the controller, the controller produces inputs, the inputs enter the recorded game, and replay verification checks the resulting state progression. A log line saying model loaded covers only the beginning of that chain.

The included preview replay contains 5,720 ticks and 478 network decisions. The synthetic policy lost. It was selected because it was the smallest replay to package, while the full six-game results remain available in the evidence JSON.

For this question, the loss is compatible with success. The objective was to verify native policy execution and replay integrity. An untrained fixture can exercise that path without being a capable player. Using its game outcome as a strength metric would change the experiment after the fact.

The artifact also has a practical advantage: replay verification does not require the policy bundle. Once the actions have been recorded, the simulator can check their consequences independently of another inference pass. That helps distinguish a problem in choosing actions from a problem in reproducing their effects.

A September 20 synthetic audit exposed why the strict loader rejects a ruleset mismatch. The same core velocity produces different network inputs under the two rulesets, and body contact loses ownership information in the older runtime. All 648 decoded action and seat-mirroring cases matched, but matching actions did not make the observed game equivalent. No trained policy was loaded for this audit.

A later local v4 migration fixes the simulation and observation semantics together and removes the lossy compatibility shim. It matches the reference across 34 synthetic fixtures and 78 snapshots, with separate native-adapter tests using generated untrained policies. Strict deployment still stays disabled: matching these contracts does not bind a trained artifact to accepted certification evidence. The old v2 replay remains verifiable through a separate frozen core.

Fixing the ruleset leaves another question: which compiled simulator did the evaluator actually use? A filename in a report cannot answer that on its own. The September 21 integration checks a pinned build receipt, source, configuration and DLL, then gives the environment the same protected library object. Its Windows file handle stays open through native teardown and the final identity check.

The difficult case is a failed close. If native destruction raises, releasing protection would assume that the native state had stopped using the library. The wrapper instead keeps ownership until the process exits and withholds completed identity. The producer requires that completed record before writing a report. This turns an uncertain cleanup into an explicit failure rather than a convincing-looking result.

The retained 62 software test methods exercise the wrapper, both evaluator paths and report rejection, with synthetic native and ML dependencies. A separate native probe called five getters to inspect the DLL's build identity and ABI. It did not create an environment or evaluate a policy. Historical training-DLL identity is still unbound, so this repair supplies a prospective evaluation contract without retroactively certifying old checkpoints.

Release and Debug regression suites passed, and missing strict inputs returned an error without creating session evidence. Those are meaningful checks for the repair. They do not complete trained-policy certification, deployment parity, inference-latency measurement, graphical acceptance, or a human challenge.

The lesson I would carry into another agent system is to trace the selected artifact into the behavior that matters. A model name in configuration can be correct while a fallback handles the request. A tool can initialize without supplying the action an agent eventually takes. Useful runtime evidence records the actual path and gives a verifier something stronger than an initialization message.

Pulse Court's result is now intentionally modest and inspectable: the synthetic preview exercised native network decisions, the scripted control did not, and the recorded preview games verified. That is a solid boundary to build on precisely because it does not pretend to answer the separate question of whether the policy can play well.