The Verifier is the Curriculum: Execution-Gated Self-Distillation for Cross-Family Game Generation

# Execution-Gated Self-Distillation for Cross-Family Game Generation
Source: [https://arxiv.org/html/2607.09709](https://arxiv.org/html/2607.09709)
## The Verifier is the Curriculum: Execution\-Gated Self\-Distillation for Cross\-Family Game Generation

Chenyu Zhou1Qiliang Jiang2Shuning Wu3Xu Zhou3 1School of Engineering, Institute of Science Tokyo, Japan 2College of Control Science and Engineering, Zhejiang University, China 3Department of Electrical and Computer Engineering, National University of Singapore, Singapore zhou\.c\.76d6@m\.isct\.ac\.jpjiangqiliang@zju\.edu\.cnshuningwu@u\.nus\.eduzhouxu\_nus@u\.nus\.edu

###### Abstract

Post\-training a code generator against a learned judge can optimize proxy features that raise the score without improving the artifact\. We study the opposite signal: a*deterministic, judge\-free, ungameable*filter—whether a generated project launches cleanly under a headless engine \(strict\-launch\)\. Under this gate, rejection\-sampling self\-distillation*compounds*out\-of\-family generalization\. On GameCraft\-Bench \(mapping a natural\-language brief to a complete Godot project\), a 14B model \(Qwen3\-14B\+\+LoRA\) distilled understrict\-launchraises clean generation on four unseen game families from8\.8%8\.8\\%to42\.2%\\mathbf\{42\.2\\%\}per\-candidate and best\-of\-KKcoverage from18/2518/25to𝟐𝟓/𝟐𝟓\\mathbf\{25/25\}\(the gold ceiling\) over three rounds, each a significant gain \(p=0\.0019p\\\!=\\\!0\.0019,p<10−4p\\\!<\\\!10^\{\-4\},p<10−4p\\\!<\\\!10^\{\-4\}\)\. The gain is not from merely adding data: an exactly\-matched gold\-duplication control*regresses*below the base model \(5\.6%5\.6\\%vs\.8\.8%8\.8\\%,p=0\.019p\\\!=\\\!0\.019\), while a count\-matched decomposition splits the round\-1\-to\-2 jump into comparable quality \(\+8\.8\+8\.8pp\) and quantity \(\+8\.5\+8\.5pp\) channels\. Most directly, rerunning the loop with only the filter swapped—the lenient BUILD check, which passes99\.9%99\.9\\%of generations, in place of the launch gate—erases the gain entirely \(back to base,p=10−3p\\\!=\\\!10^\{\-3\}vs\. the launch\-gated round\), isolating verifier precision rather than the optimizer\. A second ungameable signal, headless*execution grounding*, rises monotonically across rounds and yields far more grounded candidates than gold\-duplication at a matched budget \(1616vs\.55\), confirming the gains are functional, not launch\-but\-empty\. Game generation is a verifiable testbed for one lesson: the verifier is the curriculum—what it certifies is what the model learns\.

## 1Introduction

Post\-training a code\-generation model requires a signal that says whether a candidate is good\. The dominant choice for open\-ended generation tasks is a*learned judge*—an LLM or a multimodal model prompted to score the output\. This is convenient and correlates with human preference, but it has a structural failure mode: a learned judge maps an output to a score through whatever surface features drive its prediction, and if any of those features is cheap to manipulate without improving the artifact, a model optimized against the judge will find it\. A companion study establishes separately \(§[3](https://arxiv.org/html/2607.09709#S3)\) that GameCraft\-Bench’s official judge has exactly such a feature: an agent lifts its art score by swapping solid\-color placeholders for real assets while the game’s code is frozen\. That learned judges and automatic benchmarks can be gamed is by now well documented\[[22](https://arxiv.org/html/2607.09709#bib.bib22),[23](https://arxiv.org/html/2607.09709#bib.bib23),[16](https://arxiv.org/html/2607.09709#bib.bib16)\]; the constructive question we ask is what post\-training does when the signal instead*cannot*be gamed\.

This paper takes the opposite stance on*which signal to train against*\. Rather than chase a better learned judge, we make the training filter a*deterministic, judge\-free, ungameable*execution check and put it at the gate of an iterative self\-distillation loop\. A candidate passes only if the materialized project launches cleanly under a headless engine—it returns exit code0with no parse, load, or runtime error \(strict\-launch\)\. This signal exposes no scalar score to manipulate: it is a property of the artifact under a fixed engine, not an opinion\.

The task we study, GameCraft\[[11](https://arxiv.org/html/2607.09709#bib.bib11)\], maps a one\-paragraph brief to a*complete*Godot project from scratch: an engine configuration, scenes, the GDScript that drives them, and a recorded demo trace\. Unlike snippet\-level code generation, every artifact must cohere—a scene that references a missing script, or a script with a parse error, yields nothing that runs\. This makes GameCraft a stringent and naturally*verifiable*testbed: success is executable, not merely plausible\.

Our central finding is that under thestrict\-launchgate, rejection\-sampling self\-distillation*compounds*\. Starting from a supervised model that generates clean projects for unseen families only8\.8%8\.8\\%of the time, three rounds of “generate on the training families, keep what launches cleanly, retrain” lift per\-candidate clean generation to42\.2%42\.2\\%and push best\-of\-KKcoverage of the2525held\-out tasks from1818to the full2525, the gold\-reference ceiling\. The gains are significant at every round and, crucially, are driven by the*diversity*of self\-generated content rather than by the mere duplication of gold: an exactly\-duplicated gold control actually hurts\.

### The verifier is the curriculum\.

This points to a single principle: in self\-distillation the acceptance filter defines the next training distribution, so what it certifies is what the model learns\. Not*any*verifier yields capability \(a lenient or gameable one amplifies its own blind spots, as our controls show\); only a deterministic, ungameable filter precise enough to separate functional from broken projects makes the amplification transfer across families\. Game generation is the testbed where this principle is directly measurable\. Stated this way the principle is falsifiable on two load\-bearing conditions, which we test in turn\.*Precision*: a deterministic filter too lenient to separate functional from broken projects should not drive compounding—and indeed, rerunning the loop with the lenient BUILD gate, which accepts almost every candidate, erases the gain \(§[7](https://arxiv.org/html/2607.09709#S7)\), while the functional audits of §[8](https://arxiv.org/html/2607.09709#S8)confirm the clean projects are full, not stubs\.*Exploration*: a precise filter that left the generator nothing new to explore would stall, but the per\-round increments do not collapse \(§[7](https://arxiv.org/html/2607.09709#S7)\)\. The precision condition thus has a direct filter\-swap test; the exploration condition is supported by the non\-collapsing increments\.

### Contributions\.

1. 1\.Compounding under an ungameable gate\.Iterative self\-distillation filtered by a deterministic launch check compounds out\-of\-family generation \(8\.8→13\.6→30\.9→42\.2%8\.8\\\!\\to\\\!13\.6\\\!\\to\\\!30\.9\\\!\\to\\\!42\.2\\%per\-candidate; best\-of\-KKcoverage18/25→25/2518/25\\\!\\to\\\!25/25, the gold ceiling\), with each round a significant improvement over the last \(§[6](https://arxiv.org/html/2607.09709#S6)\)\.
2. 2\.Mechanism: the filter’s precision is causal\.An exactly\-matched gold\-duplication control significantly regresses below the base model, a count\-matched decomposition isolates a significant quality channel \(\+8\.8\+8\.8pp\) alongside a quantity channel \(\+8\.5\+8\.5pp\), and a filter\-swap control—rerunning the loop with the lenient BUILD gate in place ofstrict\-launch—erases the gain entirely, isolating verifier precision rather than the optimizer as the cause \(§[7](https://arxiv.org/html/2607.09709#S7)\)\.
3. 3\.The transferred capability is functional, not stub\-inflated, verified by an independent execution\-grounding signal that drives the SceneTree headless and by a static code audit \(§[8](https://arxiv.org/html/2607.09709#S8)\)\.

## 2Setup: the GameCraft task

GameCraft\-Bench\[[11](https://arxiv.org/html/2607.09709#bib.bib11)\]poses end\-to\-end game synthesis: given a short natural\-language design brief, a model must emit a complete, runnable Godot 4 project\. A valid output contains, at minimum, aproject\.godotengine configuration, one or more\.tscnscene files, the\.gdGDScript that implements behavior, and ademo\_outputs/trace of recorded input events that exercises the game\. The benchmark’s official metric,Overall, is a GPT\-5\.5 visual judge that renders the running game and scores it on multiple qualitative axes\.

### Why from\-scratch artifacts are hard\.

Snippet\-level code generation can be partially correct—a function that almost works still resembles its target\. A game project cannot: the engine refuses to run if a scene references a script that fails to parse, if a resource path is malformed, or if an autoload errors at startup\. Correctness is*conjunctive*across heterogeneous artifacts \(engine config∧\\wedgescene graph∧\\wedgescripts∧\\wedgeresources\), so the from\-scratch setting is far less forgiving than editing or extending an existing project\. This conjunctive structure is also what makes it a clean verifiable testbed: a project either launches or it does not, with no partial credit and no surface\-only signal for a learned judge to reward\.

### Families and the held\-out split\.

The benchmark groups its140140tasks into fifteen game families \(platformer, strategy, roguelike, simulation, …\)\. We partition by family to measure*cross\-family*generalization rather than in\-distribution memorization: we hold out four families the model never trains on—horror,rhythm,puzzle,shooter\(2525tasks\)—and train on the gold references of ten other families \(111111projects\)\. The remaining family is excluded from both training and evaluation\. The held\-out families are excluded from training at every stage, including from the self\-distillation harvest, which draws only from training\-family briefs; we verified zero held\-out leakage into any round’s fuel—every harvested brief carries a training\-family label and matches no held\-out brief\.

## 3The learned judge is gameable

Before choosing a training signal we make precise what we are avoiding\. We call a filter*gameable*if there exists a cheap transformation of the artifact that raises the filter’s score while leaving its task\-relevant executable behavior unchanged\. Under this definition the benchmark’s visual judge is gameable, and our deterministic launch check is not—it is not a score to be raised but a fixed engine predicate\.

### An agentic probe exposes the judge’s blind spot\.

Gameability is established by a companion study’s diagnostic probe—an agentic build pipeline, used here purely as an analytical instrument \(Appendix[A](https://arxiv.org/html/2607.09709#A1)\)\. The probe adds a material\-grounding pass that fetches real CC0 sprites to replace solid\-color placeholders, which raises the judge’s art\-related score*with the game’s code held fixed*\. Two controls localize the lever: substituting*randomly chosen*sprites still moves the score, so what the judge rewards is the presence of bitmap assets, not their fitness; and the manipulated outputs score inconsistently across independent judges\. A filter that can be moved this cheaply is unsafe to optimize against\.

### The from\-scratch generator cannot reach this lever\.

Our*generator*, by contrast, cannot reach this lever: from\-scratch candidates that failstrict\-launchrender nothing for the visual judge and scoreOverall=0=0\(Appendix[A](https://arxiv.org/html/2607.09709#A1)\), so in the from\-scratch regime launchability gates the judge from below\. This is why we train against an ungameable launch signal rather than the judge: optimizing against a judge that rewards cosmetic asset presence would chase a high score decoupled from executable behavior\.

## 4From diagnosis to a verification ladder

Given a gameable judge, what should we train against? We order the available signals for a generated game by how much they certify \(Figure[1](https://arxiv.org/html/2607.09709#S4.F1)\), train against the strongest rung cheap enough to apply as a per\-sample filter, and report on the others\. Read as verifiers, the rungs differ in*precision*: BUILD admits many non\-functional projects \(a high false\-positive rate\), whereasstrict\-launchaccepts a project only if it actually runs\. The gap is large: on the supervised model’s training\-task generations, BUILD accepts887887of888888candidates \(99\.9%99\.9\\%\) whilestrict\-launchaccepts7373\(8\.2%8\.2\\%\)—nearly every candidate “builds,” but few run clean\. Because post\-training amplifies the properties of whatever its filter accepts, a high\-false\-positive gate would feed self\-distillation on broken projects; we therefore train against the high\-precision rung, and test the consequence of not doing so in §[7](https://arxiv.org/html/2607.09709#S7)\.

![Refer to caption](https://arxiv.org/html/2607.09709v1/x1.png)Figure 1:The verification ladder, ordered by how much each signal certifies\.BUILD—opening the project headless and quitting—is near\-vacuous: a project with parse errors in its scenes can still exit cleanly, so BUILD=1=1does not imply the game runs\.strict\-launch, our training gate, requires a clean headless launch \(exit code0and no parse, load, or runtime error; Appendix[B](https://arxiv.org/html/2607.09709#A2)\)—deterministic, judge\-free, and ungameable\.Execution grounding\(§[8](https://arxiv.org/html/2607.09709#S8)\) drives the running SceneTree and measures real state change, a functional lower bound we report but do not train against\. The top rung, a multimodal visual judge, certifies the most but is gameable \(§[3](https://arxiv.org/html/2607.09709#S3)\)\.
## 5Method: launch\-gated iterative self\-distillation

The procedure is rejection\-sampling self\-distillation\[[18](https://arxiv.org/html/2607.09709#bib.bib18),[4](https://arxiv.org/html/2607.09709#bib.bib4),[17](https://arxiv.org/html/2607.09709#bib.bib17)\]with one deliberate choice: the acceptance filter is the deterministicstrict\-launchgate of §[4](https://arxiv.org/html/2607.09709#S4), applied only to training\-family briefs\. Fixing the optimizer to a standard rejection\-sampling loop makes the only experimental variable what the acceptance filter certifies, so differences in transfer are attributable to the signal\. Algorithm[1](https://arxiv.org/html/2607.09709#algorithm1)states one round\.

input :model

MtM\_\{t\}; training\-family briefs

ℬ\\mathcal\{B\}; gold pool

𝒟t\\mathcal\{D\}\_\{t\}; samples per brief

KK
for*each briefb∈ℬb\\in\\mathcal\{B\}*do

sample

KKcandidate projects

\{c1,…,cK\}∼Mt\(⋅∣b\)\\\{c\_\{1\},\\dots,c\_\{K\}\\\}\\sim M\_\{t\}\(\\cdot\\mid b\);

for*each candidatecc*do

materialize

ccto a project tree ;

if**strict\-launch*​\(c\)\\textsc\{strict\-launch\}\(c\)andcchas at least three files*thenmark

ccas clean;

keep up to

22deduplicated clean candidates for

bb;

ℱt←\\mathcal\{F\}\_\{t\}\\leftarrowall kept clean candidates \(the round’s*fuel*\) ;

𝒟t\+1←𝒟t∪ℱt\\mathcal\{D\}\_\{t\+1\}\\leftarrow\\mathcal\{D\}\_\{t\}\\cup\\mathcal\{F\}\_\{t\};

Mt\+1←fine\-tune​\(base,𝒟t\+1\)M\_\{t\+1\}\\leftarrow\\textsc\{fine\-tune\}\(\\text\{base\},\\mathcal\{D\}\_\{t\+1\}\);

output :

Mt\+1M\_\{t\+1\},

ℱt\\mathcal\{F\}\_\{t\}

Algorithm 1One round of launch\-gated self\-distillation### Rounds\.

Round0is the supervised modelM0M\_\{0\}\(SFT\) trained on the111111gold training\-family projects; we write RFT\-rkkfor the model afterkkrounds of this rejection\-filtered training\. Each subsequent round generates with the previous model, harvests its clean self\-generated set \(the*fuel*—the round’s accepted candidates\), appends it to the*gold*pool \(which remains the anchor\), and retrains a fresh LoRA from the base\. The fuel grows every round—6767clean projects fromM0M\_\{0\},123123fromM1M\_\{1\},186186fromM2M\_\{2\}—a self\-reinforcing cycle: a better generator yields more and better fuel\.

### Generation and training\.

We sampleK=8K\\\!=\\\!8candidates per brief with vLLM\[[10](https://arxiv.org/html/2607.09709#bib.bib10)\]serving the LoRA adapter unmerged atbfloat16\. Training is LoRA\[[6](https://arxiv.org/html/2607.09709#bib.bib6)\]\(r=16r\\\!=\\\!16,α=32\\alpha\\\!=\\\!32\) on Qwen3\-14B\[[12](https://arxiv.org/html/2607.09709#bib.bib12)\]for88epochs at learning rate10−410^\{\-4\}; the full serving and training configuration is in Appendix[C](https://arxiv.org/html/2607.09709#A3)\.

### Controls \(§[7](https://arxiv.org/html/2607.09709#S7)\)\.

To attribute the gain we build three controls, each matched to round 1’s fuel*per task*, so each holds quantity and task coverage fixed and varies one thing\.CTRLappends6767*exact duplicates*of gold training projects, varying only content \(duplicated vs\. diverse\)\.Count\-matchedappends6767round\-2 fuel candidates matched to round 1’s task counts, swapping only the*generator*\(M0→M1M\_\{0\}\\\!\\to\\\!M\_\{1\}\) to isolate fuel quality from quantity\.BUILD\-gatedreruns round 1’s loop with a single change—the acceptance filter is the lenient BUILD check of §[4](https://arxiv.org/html/2607.09709#S4)instead ofstrict\-launch—to isolate the filter’s precision from the optimizer, the budget, and the task distribution\.

### Evaluation protocol\.

For each model we drawK=8K\\\!=\\\!8candidates per held\-out task across four seeds \(800800candidates per model\)\. The primary metric is per\-candidate clean\-launch rate with task\-level paired testing \(cluster\-permutation, with the task as the resampling unit,N=25N\\\!=\\\!25\); we report Wilson95%95\\%intervals on the per\-candidate rate\. best\-of\-KKcoverage \(a task is covered if any of its candidates launches cleanly\) is reported at a fixed two\-seed budget—best\-of\-1616, i\.e\.88candidates over two seeds\. All comparisons between rounds are paired by task\.

## 6Results

### Compounding to the gold ceiling\.

Table[1](https://arxiv.org/html/2607.09709#S6.T1)and Figure[2](https://arxiv.org/html/2607.09709#S6.F2)give the main result\. Under thestrict\-launchgate, three rounds of self\-distillation lift per\-candidate clean\-launch on the four unseen families from8\.8%8\.8\\%to42\.2%42\.2\\%, and best\-of\-KKcoverage from18/2518/25to the full25/2525/25—the gold\-reference ceiling, since all2525held\-out gold projects themselves launch cleanly \(100%100\\%\)\. Every round is a significant improvement over the last\.

Table 1:Held\-out results on four unseen families \(horror / rhythm / puzzle / shooter;2525tasks\)\. The per\-candidate clean\-launch rate \(over four seeds\) is reported with a Wilson95%95\\%interval; best\-of\-KKcoverage is reported at a fixed best\-of\-1616budget \(88candidates over two seeds\)\. RFT rounds are launch\-gated self\-distillation; CTRL duplicates gold exactly; BUILD\-gated runs the same round\-1 loop with the lenient BUILD filter instead ofstrict\-launch; count\-matched is the generator\-swap control\. The gold reference launches cleanly on all2525\.![Refer to caption](https://arxiv.org/html/2607.09709v1/x2.png)Figure 2:Three rounds compound\. per\-candidate clean\-launch on unseen families \(blue\) climbs8\.8→13\.6→30\.9→42\.2%8\.8\\\!\\to\\\!13\.6\\\!\\to\\\!30\.9\\\!\\to\\\!42\.2\\%; best\-of\-KKcoverage of the2525tasks \(orange, as % of2525\) climbs72→76→88→100%72\\\!\\to\\\!76\\\!\\to\\\!88\\\!\\to\\\!100\\%, reaching the gold ceiling\.
### Significance at every round\.

The improvements survive paired, task\-level testing \(cluster\-permutation,N=25N\\\!=\\\!25\)\. The first round’s gain over SFT is significant \(p=0\.0019p\\\!=\\\!0\.0019; bootstrap\+4\.9\+4\.9pp\[1\.9,8\.1\]\[1\.9,8\.1\], excluding zero\)\. The remaining rounds are decisive:

- •RFT\-r2 vs\. r1: wins/losses\+22/−2\+22/\-2across tasks,p<10−4p\\\!<\\\!10^\{\-4\}\.
- •RFT\-r3 vs\. r2:\+20/−5\+20/\-5,p<10−4p\\\!<\\\!10^\{\-4\}\.
- •RFT\-r3 vs\. SFT:\+𝟐𝟓/−𝟎\\mathbf\{\+25/\-0\}—round 3 beats the supervised model on*every one*of the2525held\-out tasks,p<10−4p\\\!<\\\!10^\{\-4\}\.

### Robustness to training randomness\.

The compounding curve is not an artifact of a single training run\. Retraining round 1 under three independent training seeds gives a per\-candidate clean\-launch of13\.25±0\.65%13\.25\\pm 0\.65\\%\(mean±\\pms\.d\. over800800candidates per seed; vs\. SFT’s8\.8%8\.8\\%\), so the first\-round gain is stable to training randomness\.

### Per\-family: every family reaches full coverage\.

Table[2](https://arxiv.org/html/2607.09709#S6.T2)breaks best\-of\-KKcoverage down by family\. The weakest family for the supervised model,*rhythm*, goes from2/52/5to5/55/5;*puzzle*from5/85/8to8/88/8;*shooter*from6/76/7to7/77/7;*horror*stays saturated\. By round 3 every family is at full coverage\.

### Sample efficiency\.

The rising per\-candidate rate translates directly into efficiency: the number of samples needed to obtain one clean held\-out game falls from≈11\\approx 11for the supervised model to≈2\.4\\approx 2\.4for round 3, a≈5×\\approx 5\\timesimprovement\.

Table 2:Per\-family best\-of\-KKcoverage \(two\-seed budget\)\. Round 3 reaches full coverage in every family, while the exact\-duplication control \(CTRL\) regresses in three of the four families and collapses overall to13/2513/25\.

## 7Mechanism: verifier precision, not gold duplication or optimizer

Compounding raises an attribution question: where does the gain come from? We answer it in three steps, each a matched control\. Holding thestrict\-launchfilter fixed, we first rule out content repetition \(a gold\-duplication control\) and then separate fuel quality from quantity \(a count\-matched control\), ruling out raw gold duplication as the driver\. Finally we hold the candidate pool, budget, and task distribution fixed and drop one rung on the verification ladder \(§[4](https://arxiv.org/html/2607.09709#S4)\), swappingstrict\-launchfor the lenient BUILD filter; the gain vanishes, identifying verifier precision as the causal variable\.

### Exact duplication regresses \(Figure[3](https://arxiv.org/html/2607.09709#S7.F3)\)\.

CTRL adds6767exact duplicates of gold training projects, matched per task to round 1’s fuel\. Despite the identical quantity and task coverage that drove round 1’s gain, CTRL*regresses below the base model*:5\.6%5\.6\\%per\-candidate vs\. SFT’s8\.8%8\.8\\%\(\+7/−13\+7/\-13across tasks,p=0\.019p\\\!=\\\!0\.019\), with its coverage collapsing to13/2513/25\(Tables[1](https://arxiv.org/html/2607.09709#S6.T1),[2](https://arxiv.org/html/2607.09709#S6.T2)\)\. The self\-distilled round 1, with the*same*budget, helps significantly: RFT\-r1≫\\ggCTRL is\+16/−5\+16/\-5,p<10−4p\\\!<\\\!10^\{\-4\}, and holds in every leave\-one\-family\-out fold \(p≤0\.017p\\\!\\leq\\\!0\.017\)\. The key factor is content diversity over exact repetition: the same6767\-sample budget helps only when the fuel is diverse, not when it duplicates gold\.

![Refer to caption](https://arxiv.org/html/2607.09709v1/x3.png)Figure 3:Same\+67\+67\-sample budget; only the high\-precision filter compounds\. Neither control that adds6767samples to gold improves on the base model \(SFT\): exactly duplicating gold significantly*regresses*\(CTRL,p=0\.019p\\\!=\\\!0\.019\), and self\-distilling under the lenient BUILD filter merely matches the base \(BUILD\-gated; no significant gain over SFT\)\. Onlystrict\-launch\-filtered self\-distillation \(RFT\-r1\) improves it—RFT\-r1≫\\ggCTRL \(p<10−4p\\\!<\\\!10^\{\-4\}\) and RFT\-r1≫\\ggBUILD\-gated \(p=10−3p\\\!=\\\!10^\{\-3\}\)\.
### A quality channel and a quantity channel\.

The round\-1→\\toround\-2 jump has two sources, which two matched contrasts separate\. Holding budget and task coverage fixed and swapping only the generator \(count\-matched vs\. round 1\) isolates a*quality*channel:\+8\.8\+8\.8pp,\+20/−3\+20/\-3,p=10−4p\\\!=\\\!10^\{\-4\}\. Adding the extra fuel that round 2 actually collected \(123123vs\.6767samples\) isolates a*quantity*channel:\+8\.5\+8\.5pp,p=2×10−4p\\\!=\\\!2\\\!\\times\\\!10^\{\-4\}\. Both channels are significant and comparable: the jump is genuinely quality\+\+quantity, and the quality channel alone \(\+8\.8\+8\.8pp\) exceeds round 1’s entire gain over the supervised model—each better generator makes*better*fuel, not just more of it\.

### The filter’s precision is the causal variable\.

The most direct attribution varies the signal itself\. The first two controls hold thestrict\-launchfilter fixed and vary the data; the BUILD\-gated control does the opposite, rerunning round 1’s loop with the data source fixed and only the filter changed—strict\-launchswapped for the lenient BUILD rung of the ladder \(§[4](https://arxiv.org/html/2607.09709#S4)\)\. Because BUILD accepts nearly every candidate whilestrict\-launchaccepts few \(§[4](https://arxiv.org/html/2607.09709#S4)\), the count\-matched BUILD fuel is81%81\\%strict\-launch\-broken \(54/6754/67\)\. Trained on it, the model reaches only8\.6%8\.6\\%per\-candidate clean\-launch on the held\-out families: indistinguishable from the base model \(8\.8%8\.8\\%, pairedp=1\.0p\\\!=\\\!1\.0\) and far below round 1’s13\.6%13\.6\\%\(\+5/−16\+5/\-16,p=10−3p\\\!=\\\!10^\{\-3\}\)\. Changing only the filter’s precision—nothing about the optimizer, the budget, or the task distribution—erases the entire first\-round gain\. Under a high\-false\-positive verifier, self\-distillation compounds on broken projects rather than working ones: the gain is a property of the*signal*, not of the method\.

### Why a launch gate produces diversity\.

A scalar learned judge concentrates the accepted set on the surface features its score rewards; a binary launch gate enforces only the minimal conjunctive requirement that the project run, leaving a broad set of functionally distinct solutions admissible\. Self\-distillation under this gate therefore behaves like a coverage process: each round harvests diverse clean projects that enlarge the model’s reachable set, while exact duplication adds none—which is exactly what the CTRL regression and the rising quality channel show\. The compounding is this coverage process reinforcing itself: a better generator passes the gate with a wider range of working projects, which in turn broadens the next model\. The BUILD\-gated control breaks the mechanism: a low\-precision gate fills the accepted set with broken projects, so the coverage process expands around non\-functional code rather than working variants, and no improvement follows\.

## 8The gains are functional, not stub\-inflated

A clean launch certifies that a project runs, not that it*does*anything; we confirm functional substance with two independent checks, one static and one dynamic\.

### Static: clean projects are rich, not stubs\.

Comparing clean RFT projects to clean SFT projects, the RFT projects are substantially richer:\+43%\+43\\%GDScript \(median331→473331\\\!\\to\\\!473lines\), roughly3×3\\timesas many signal connections, and more files \(8→9\.58\\\!\\to\\\!9\.5\)\. Across all rounds the clean candidates have a median of99files—these are full projects, not stubs\.

### Dynamic: a second ungameable signal\.

We also measure real runtime behavior with an independent execution\-grounding signal\.exec\-groundinjects an instrumentation probe into a copy of the project and steps the headless SceneTree for up to180180frames in three modes:*passive*\(no input\),*synthetic*\(raw key events, action triggers, button presses, and a mouse click\), and*replay*\(replaying the task’s recorded input traces\)\. The score is

score=𝟙​\[runtime\-error\-free\]⋅\(0\.35​sstate\+0\.25​spassive\+0\.40​sactive\),\\text\{score\}=\\mathbb\{1\}\[\\text\{runtime\-error\-free\}\]\\cdot\\big\(0\.35\\,s\_\{\\text\{state\}\}\+0\.25\\,s\_\{\\text\{passive\}\}\+0\.40\\,s\_\{\\text\{active\}\}\\big\),wheresstates\_\{\\text\{state\}\}measures rich runtime state \(including script\-exposed variables, so single\-node procedural games still register state\),spassives\_\{\\text\{passive\}\}is the frame\-change ratio with no input, andsactives\_\{\\text\{active\}\}is the input\-driven change ratio above the passive baseline\. A project is*grounded*ifscore≥0\.50\\text\{score\}\\geq 0\.50\. The signal is calibrated and discriminative: on a calibration subset of1515gold projects across families all are grounded \(score median0\.750\.75\), while1616negative controls—1515strict\-launch\-failing candidates plus a minimal empty project—all score near zero \(the empty project0\.0130\.013\)\.

### Self\-distillation improves functional behavior \(Figure[4](https://arxiv.org/html/2607.09709#S8.F4)\)\.

Across rounds, the number of held\-out tasks with at least one grounded clean candidate rises monotonically:10→12→14→1510\\to 12\\to 14\\to 15out of2525\(SFT→\\tor1→\\tor2→\\tor3\)\. And the diversity signal reappears: at a matched budget, round 1 produces far more grounded candidates than the gold\-duplication control—1616vs\.55\. The launch\-verified gains are functional, not launch\-but\-empty\.

![Refer to caption](https://arxiv.org/html/2607.09709v1/x4.png)Figure 4:Execution grounding rises monotonically: held\-out tasks with at least one grounded \(≥0\.5\\geq 0\.5\) clean candidate,10→12→14→1510\\\!\\to\\\!12\\\!\\to\\\!14\\\!\\to\\\!15of2525\. Self\-distillation also yields far more grounded candidates than exact duplication \(1616vs\.55, not shown\), and the signal is validated by15/1515/15grounded gold vs\.0/160/16grounded known\-bad projects\.

## 9Related work

### Self\-training and rejection\-sampling fine\-tuning\.

Bootstrapping a model on its own filtered generations is well established: STaR\[[18](https://arxiv.org/html/2607.09709#bib.bib18)\]and V\-STaR\[[5](https://arxiv.org/html/2607.09709#bib.bib5)\]on reasoning, ReST\[[4](https://arxiv.org/html/2607.09709#bib.bib4)\]and ReST\-EM\[[13](https://arxiv.org/html/2607.09709#bib.bib13)\]as EM\-style self\-training, and rejection\-sampling fine\-tuning for math\[[17](https://arxiv.org/html/2607.09709#bib.bib17)\]; recent variants extend self\-distillation on\-policy\[[21](https://arxiv.org/html/2607.09709#bib.bib21)\]and to code generation\[[19](https://arxiv.org/html/2607.09709#bib.bib19)\]\. We isolate how the*ungameability and precision of the verification gate*shape what iterative self\-distillation transfers, and the resulting compounding to a coverage ceiling\. Holding the optimizer fixed while varying the verifier is what isolates the signal’s effect; varying the optimizer under the same gate \(for instance with policy\-gradient methods such as GRPO/RLVR\) is a natural next step\.

### Game generation and verifiable environments\.

A growing line studies code/game generation against executable checks, in professional engines\[[2](https://arxiv.org/html/2607.09709#bib.bib2),[15](https://arxiv.org/html/2607.09709#bib.bib15),[8](https://arxiv.org/html/2607.09709#bib.bib8)\]and via runtime verification of generated games\[[20](https://arxiv.org/html/2607.09709#bib.bib20),[7](https://arxiv.org/html/2607.09709#bib.bib7)\]\. We use GameCraft\-Bench\[[11](https://arxiv.org/html/2607.09709#bib.bib11)\], an existing benchmark with a learned visual judge, as a testbed to study a different axis: how an ungameable execution filter changes what post\-training transfers\.

### Reward hacking and gameable judges\.

Reward hacking is a known hazard\[[1](https://arxiv.org/html/2607.09709#bib.bib1),[14](https://arxiv.org/html/2607.09709#bib.bib14)\], and recent work shows automatic LLM benchmarks and judges can be cheated\[[22](https://arxiv.org/html/2607.09709#bib.bib22),[23](https://arxiv.org/html/2607.09709#bib.bib23)\], with a parallel effort to*detect*such exploits in code and agent settings\[[3](https://arxiv.org/html/2607.09709#bib.bib3),[16](https://arxiv.org/html/2607.09709#bib.bib16),[9](https://arxiv.org/html/2607.09709#bib.bib9)\]\. This literature largely studies*models hacking a reward*; our focus is the complementary coupling, how the \(un\)gameability of the filter signal shapes*what post\-training transfers*\.

## 10Limitations and future work

We validate on four unseen families within one benchmark \(N=25N\\\!=\\\!25\), with leave\-one\-family\-out robustness and a100%100\\%gold ceiling; broader families and larger models are the next test\. The diversity control is exact duplication, since each task carries a single gold reference\. Training\-seed robustness is established for round 1 \(§[6](https://arxiv.org/html/2607.09709#S6)\); extending it to rounds 2 and 3 is a natural next check\. Execution grounding is a functional lower bound, not a measure of playability\.

## 11Conclusion

The verifier is the curriculum: what it certifies is what the model learns\. When that curriculum is a learned judge, the model learns the judge’s blind spots; we showed an agent moving GameCraft’s visual judge with assets alone, code frozen\. When it is instead a deterministic, judge\-free, ungameable launch check, the same family of methods—rejection\-sampling self\-distillation—does something qualitatively different: it*compounds*\. Three rounds carry a 14B model from8\.8%8\.8\\%to42\.2%42\.2\\%per\-candidate clean generation on unseen game families and from18/2518/25to full25/2525/25coverage, the gold\-reference ceiling, with every round a significant gain, with the effect attributable to the diversity and quality of self\-generated fuel rather than the mere duplication of gold, and with the improvements confirmed functional by an independent execution\-grounding signal\.

Game generation served here as a verifiable testbed, not as the subject\. Within it we establish a directional principle, with a controlled filter swap on both sides: under the deterministic, ungameable launch gate, self\-distillation compounds cross\-family capability, while substituting the lenient, high\-false\-positive BUILD gate into the same loop erases the gain entirely \(§[7](https://arxiv.org/html/2607.09709#S7)\)\. We read this as one instance of a broader implication: in this testbed, and holding the optimizer fixed, the ceiling of a self\-improvement loop is set by the integrity of its verifier, not by data volume alone\. Testing that implication beyond game generation, and against richer optimizers under the same ungameable filter \(§[9](https://arxiv.org/html/2607.09709#S9)\), is the next test of the principle\.

## References

- Amodei et al\. \[2016\]Dario Amodei, Chris Olah, Jacob Steinhardt, Paul Christiano, John Schulman, and Dan Mané\.Concrete problems in AI safety\.*arXiv preprint arXiv:1606\.06565*, 2016\.URL[https://arxiv\.org/abs/1606\.06565](https://arxiv.org/abs/1606.06565)\.
- Chi et al\. \[2026\]Wayne Chi, Yixiong Fang, Arnav Yayavaram, Siddharth Yayavaram, Seth Karten, Qiuhong Anna Wei, Runkun Chen, Alexander Wang, Valerie Chen, Ameet Talwalkar, and Chris Donahue\.GameDevBench: Evaluating agentic capabilities through game development\.In*International Conference on Machine Learning \(ICML\)*, 2026\.URL[https://arxiv\.org/abs/2602\.11103](https://arxiv.org/abs/2602.11103)\.
- Deshpande et al\. \[2026\]Darshan Deshpande, Anand Kannappan, and Rebecca Qian\.Benchmarking reward hack detection in code environments via contrastive analysis\.*arXiv preprint arXiv:2601\.20103*, 2026\.URL[https://arxiv\.org/abs/2601\.20103](https://arxiv.org/abs/2601.20103)\.Introduces the TRACE benchmark\.
- Gulcehre et al\. \[2023\]Caglar Gulcehre, Tom Le Paine, Srivatsan Srinivasan, Ksenia Konyushkova, Lotte Weerts, Abhishek Sharma, Aditya Siddhant, Alex Ahern, Miaosen Wang, Chenjie Gu, Wolfgang Macherey, Arnaud Doucet, Orhan Firat, and Nando de Freitas\.Reinforced self\-training \(ReST\) for language modeling\.*arXiv preprint arXiv:2308\.08998*, 2023\.URL[https://arxiv\.org/abs/2308\.08998](https://arxiv.org/abs/2308.08998)\.
- Hosseini et al\. \[2024\]Arian Hosseini, Xingdi Yuan, Nikolay Malkin, Aaron Courville, Alessandro Sordoni, and Rishabh Agarwal\.V\-STaR: Training verifiers for self\-taught reasoners\.*arXiv preprint arXiv:2402\.06457*, 2024\.URL[https://arxiv\.org/abs/2402\.06457](https://arxiv.org/abs/2402.06457)\.
- Hu et al\. \[2022\]Edward J\. Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen\-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen\.LoRA: Low\-rank adaptation of large language models\.In*International Conference on Learning Representations \(ICLR\)*, 2022\.URL[https://arxiv\.org/abs/2106\.09685](https://arxiv.org/abs/2106.09685)\.
- Jia et al\. \[2026\]Chaobo Jia, Ruipeng Wan, Ting Sun, Weihao Tan, Borui Wan, Yuxuan Tong, Guangming Sheng, and Hong Xu\.GameGen\-Verifier: Parallel keypoint\-based verification for LLM\-generated games via runtime state injection\.*arXiv preprint arXiv:2605\.07442*, 2026\.URL[https://arxiv\.org/abs/2605\.07442](https://arxiv.org/abs/2605.07442)\.
- Jiang et al\. \[2026\]Yilei Jiang, Jinyuan Hu, Qianyin Xiao, Yaozhi Zheng, Ruize Ma, Kaituo Feng, Jiaming Han, Tianshuo Peng, Kaixuan Fan, Manyuan Zhang, and Xiangyu Yue\.OpenGame: Open agentic coding for games\.*arXiv preprint arXiv:2604\.18394*, 2026\.URL[https://arxiv\.org/abs/2604\.18394](https://arxiv.org/abs/2604.18394)\.Introduces the GameCoder\-27B code model and the OpenGame\-Bench benchmark\.
- Kwa et al\. \[2025\]Thomas Kwa, Ben West, Joel Becker, Amy Deng, Katharyn Garcia, Max Hasin, Sami Jawhar, Megan Kinniment, Nate Rush, Sydney Von Arx, Ryan Bloom, Thomas Broadley, Haoxing Du, Brian Goodrich, Nikola Jurkovic, Luke Harold Miles, Seraphina Nix, Tao Lin, Neev Parikh, David Rein, Lucas Jun Koba Sato, Hjalmar Wijk, Daniel M\. Ziegler, Elizabeth Barnes, and Lawrence Chan\.Measuring AI ability to complete long software tasks\.In*Advances in Neural Information Processing Systems \(NeurIPS\)*, 2025\.URL[https://arxiv\.org/abs/2503\.14499](https://arxiv.org/abs/2503.14499)\.METR\.
- Kwon et al\. \[2023\]Woosuk Kwon, Zhuohan Li, Siyuan Zhuang, Ying Sheng, Lianmin Zheng, Cody Hao Yu, Joseph E\. Gonzalez, Hao Zhang, and Ion Stoica\.Efficient memory management for large language model serving with PagedAttention\.In*Proceedings of the 29th Symposium on Operating Systems Principles \(SOSP\)*, 2023\.URL[https://arxiv\.org/abs/2309\.06180](https://arxiv.org/abs/2309.06180)\.
- Luo et al\. \[2026\]Tongxu Luo, Rongsheng Wang, Jiaxi Bi, Chenming Xu, Zhengyang Tang, Jianlong Chen, Juhao Liang, Ke Ji, Shuqi Guo, Yuhao Du, Fan Bu, Wenyu Du, Xiaotong Zhang, Kyle Li, Shaobo Wang, Linfeng Zhang, Yuxuan Liu, Xin Lai, Chenxin Li, Yiduo Guo, Zhexin Zhang, Xinyuan Wang, Tianyi Bai, Ziniu Li, and Benyou Wang\.GameCraft\-Bench: Can agents build playable games end\-to\-end in a real game engine?*arXiv preprint arXiv:2606\.17861*, 2026\.URL[https://arxiv\.org/abs/2606\.17861](https://arxiv.org/abs/2606.17861)\.
- Qwen Team \[2025\]Qwen Team\.Qwen3 technical report\.*arXiv preprint arXiv:2505\.09388*, 2025\.URL[https://arxiv\.org/abs/2505\.09388](https://arxiv.org/abs/2505.09388)\.
- Singh et al\. \[2024\]Avi Singh, John D\. Co\-Reyes, Rishabh Agarwal, et al\.Beyond human data: Scaling self\-training for problem\-solving with language models\.*Transactions on Machine Learning Research \(TMLR\)*, 2024\.URL[https://arxiv\.org/abs/2312\.06585](https://arxiv.org/abs/2312.06585)\.Introduces ReSTEM; first appeared as arXiv:2312\.06585\.
- Skalse et al\. \[2022\]Joar Skalse, Nikolaus H\. R\. Howe, Dmitrii Krasheninnikov, and David Krueger\.Defining and characterizing reward hacking\.In*Advances in Neural Information Processing Systems \(NeurIPS\)*, 2022\.URL[https://arxiv\.org/abs/2209\.13085](https://arxiv.org/abs/2209.13085)\.
- Sun et al\. \[2026\]Jianwen Sun, Chuanhao Li, Zizhen Li, Yukang Feng, Fanrui Zhang, Yifei Huang, Yu Dai, and Kaipeng Zhang\.JAMER: Project\-level code framework dataset and benchmark on professional game engines\.*arXiv preprint arXiv:2606\.19830*, 2026\.URL[https://arxiv\.org/abs/2606\.19830](https://arxiv.org/abs/2606.19830)\.
- Thaman \[2026\]Kunvar Thaman\.Reward hacking benchmark: Measuring exploits in LLM agents with tool use\.*arXiv preprint arXiv:2605\.02964*, 2026\.URL[https://arxiv\.org/abs/2605\.02964](https://arxiv.org/abs/2605.02964)\.
- Yuan et al\. \[2023\]Zheng Yuan, Hongyi Yuan, Chengpeng Li, Guanting Dong, Keming Lu, Chuanqi Tan, Chang Zhou, and Jingren Zhou\.Scaling relationship on learning mathematical reasoning with large language models\.*arXiv preprint arXiv:2308\.01825*, 2023\.URL[https://arxiv\.org/abs/2308\.01825](https://arxiv.org/abs/2308.01825)\.
- Zelikman et al\. \[2022\]Eric Zelikman, Yuhuai Wu, Jesse Mu, and Noah D\. Goodman\.STaR: Bootstrapping reasoning with reasoning\.In*Advances in Neural Information Processing Systems \(NeurIPS\)*, volume 35, pages 15476–15488, 2022\.URL[https://arxiv\.org/abs/2203\.14465](https://arxiv.org/abs/2203.14465)\.
- Zhang et al\. \[2026\]Ruixiang Zhang, Richard He Bai, Huangjie Zheng, Navdeep Jaitly, Ronan Collobert, and Yizhe Zhang\.Embarrassingly simple self\-distillation improves code generation\.*arXiv preprint arXiv:2604\.01193*, 2026\.URL[https://arxiv\.org/abs/2604\.01193](https://arxiv.org/abs/2604.01193)\.
- Zhang et al\. \[2025\]Wei Zhang, Jack Yang, Renshuai Tao, Lingzheng Chai, Shawn Guo, Jiajun Wu, Xiaoming Chen, Ganqu Cui, Ning Ding, Xander Xu, Hu Wei, and Bowen Zhou\.V\-GameGym: Visual game generation for code large language models\.*arXiv preprint arXiv:2509\.20136*, 2025\.URL[https://arxiv\.org/abs/2509\.20136](https://arxiv.org/abs/2509.20136)\.
- Zhao et al\. \[2026\]Siyan Zhao, Zhihui Xie, Mengchen Liu, Jing Huang, Guan Pang, Feiyu Chen, and Aditya Grover\.Self\-distilled reasoner: On\-policy self\-distillation for large language models\.*arXiv preprint arXiv:2601\.18734*, 2026\.URL[https://arxiv\.org/abs/2601\.18734](https://arxiv.org/abs/2601.18734)\.
- Zheng et al\. \[2025\]Xiaosen Zheng, Tianyu Pang, Chao Du, Qian Liu, Jing Jiang, and Min Lin\.Cheating automatic LLM benchmarks: Null models achieve high win rates\.In*International Conference on Learning Representations \(ICLR\)*, 2025\.URL[https://arxiv\.org/abs/2410\.07137](https://arxiv.org/abs/2410.07137)\.Oral\.
- Zhong et al\. \[2025\]Ziqian Zhong, Aditi Raghunathan, Nicholas Carlini, et al\.ImpossibleBench: Measuring LLMs’ propensity of exploiting test cases\.*arXiv preprint arXiv:2510\.20270*, 2025\.URL[https://arxiv\.org/abs/2510\.20270](https://arxiv.org/abs/2510.20270)\.

## Appendix AThe companion diagnosis study

Section[3](https://arxiv.org/html/2607.09709#S3)summarizes the evidence that the benchmark’s learned visual judge is gameable\. This appendix gives the details, which come from a companion line of work that builds games*agentically*\(a separate setting from the from\-scratch generator studied in the main text\) and shares the benchmark’s exact evaluation stack: the official Godot4\.6\.24\.6\.2runtime, headless replay, and the official GPT\-5\.5Overallvisual judge \(the same judge used on the public leaderboard, so scores are directly comparable\)\.

### The agentic pipeline and the asset lever\.

The companion agent constructs a project through a sequence of build passes, two of which are relevant here: a*visual self\-reflection*pass that lets the agent inspect rendered frames, and a*material\-grounding*pass that retrieves real CC0 sprite assets and substitutes them for the solid\-color placeholder rectangles an agent otherwise emits\. Enabling the material\-grounding pass raises the judge’s art\-related score with the game’s code held fixed\. Two ablations localize the lever: \(i\) freezing the code isolates presentation from behavior, and \(ii\) replacing the retrieved sprites with*randomly chosen*sprites of comparable provenance still raises the score, so what moves the judge is the presence of bitmap assets, not their fitness to the game\. The manipulated outputs additionally score inconsistently—even with negative rank correlation—across independent judges, the signature of judge\-specific surface exploitation rather than a genuine quality improvement\.

### Why the from\-scratch generator cannot use the lever\.

To check whether our*generator*could exploit the same shortcut, we scored3030training\-family candidates \(1515strict\-launch\-clean,1515dirty\) with the GPT\-5\.5Overalljudge\. The clean candidates score low but nonzero \(Overallmean0\.0640\.064, median0\.0520\.052, max0\.2330\.233\), while*every*dirty candidate scores exactly0\(mean, median, and max all0\.0000\.000; no dirty candidate reached the clean median\)\. A project that failsstrict\-launchrenders nothing for the visual judge, so the asset lever an agent uses on a running project is unreachable for a from\-scratch generator whose first obstacle is launching at all\. For reference, even the gold held\-out references score onlyOverall≈0\.197\\approx 0\.197on average on this benchmark, with strong per\-family variation \(horror≈0\.31\\approx 0\.31vs\. rhythm≈0\.08\\approx 0\.08\)\.

## Appendix BVerification signals in detail

### Why BUILD is near\-vacuous\.

The lenient BUILD check—open the project headless and quit \(godot \-\-headless \-\-quit\-after\)—does not treat parse, project, or scene\-resource errors as fatal: the process can still exit0\. On the held\-out families, supervised\-model outputs that pass this check are nonetheless non\-functional in concrete, diagnosable ways: scripts that fail to parse \(undeclared identifiers, calls to nonexistent methods\) and so never load; malformedproject\.godotfiles \(unquoted values, bare input\-map identifiers\) that cause the engine to open its project manager instead of the game; and broken\.tscnexternal\-resource references\. The same engine renders the corresponding gold projects without error, confirming these are generation defects, not harness artifacts\. Empirically this failure is parse\-dominated: of the888888round\-1 training\-family candidates, all815815that failstrict\-launchcontain a GDScript orproject\.godotparse error\.

### strict\-launch\.

A candidate passesstrict\-launchifgodot \-\-headless \-\-path P \-\-quit\-after 5returns exit code0*and*emits no parse/load/runtime error onstderr\(matching, e\.g\.,SCRIPT ERROR,Parse Error,ext\_resource, andFailed to loadpatterns\)\. The gate separates real from broken cleanly: all held\-out gold projects pass strict\-launch \(the25/2525/25gold ceiling\), while the supervised model’s BUILD\-passing held\-out outputs fail it on concrete parse or load errors\.

### Execution grounding\.

exec\-groundinjects an instrumentation probe into a temporary copy of the project and steps the headless SceneTree for up to180180frames in passive, synthetic, and demo\-replay modes, replaying up to three recordeddemo\_outputstraces per task\. The score is𝟙​\[runtime\-error\-free\]⋅\(0\.35​sstate\+0\.25​spassive\+0\.40​sactive\)\\mathbb\{1\}\[\\text\{runtime\-error\-free\}\]\\cdot\(0\.35\\,s\_\{\\text\{state\}\}\+0\.25\\,s\_\{\\text\{passive\}\}\+0\.40\\,s\_\{\\text\{active\}\}\), grounded at threshold0\.500\.50\. The state term reads script\-exposed member variables \(so single\-node procedural games still register state\); the active term subtracts the passive baseline so autonomous animation is not counted as interaction\. On the calibration set \(1515gold projects across families;1515strict\-launch\-dirty candidates plus one hand\-built empty shell\), gold scores a median of0\.750\.75\(minimum0\.580\.58\) and every negative scores near zero \(empty shell0\.0130\.013\), giving a wide separation margin at the0\.500\.50threshold\. The0\.580\.58\-vs\-0\.0130\.013gap between gold and negatives leaves the grounded/not\-grounded split insensitive to the exact threshold and term weights\.

## Appendix CTraining, generation, and data

### Data and split\.

The benchmark’s140140tasks are partitioned by family\. The held\-out set is four families never used in training—horror, rhythm, puzzle, shooter \(2525tasks\)—and the gold training pool is ten other families \(111111projects\); the fifteenth family is excluded from both\. The self\-distillation harvest draws only from training\-family briefs; we verified zero held\-out leakage into any round’s fuel\. Per round, the harvest keeps strict\-launch\-clean candidates with at least three files, deduplicated, capped at two per task: ofM0M\_\{0\}’s7373strict\-clean candidates this yields6767fuel projects, then123123fromM1M\_\{1\}and186186fromM2M\_\{2\}\. Code, adapters, and the harvested fuel will be released upon publication\.

### Training\.

LoRA \(r=16r\\\!=\\\!16,α=32\\alpha\\\!=\\\!32\) on Qwen3\-14B,88epochs, learning rate10−410^\{\-4\}, batch size11with gradient accumulation88, maximum sequence length2457624576, scaled dot\-product attention\.

### Generation\.

vLLM0\.11\.20\.11\.2serves the LoRA adapter unmerged atbfloat16\. Each training\-family brief is sampledK=8K\\\!=\\\!8times per seed\.

### Evaluation and statistics\.

Each model is evaluated withK=8K\\\!=\\\!8candidates per held\-out task across four seeds \(800800candidates per model\)\. The primary metric is the per\-candidate clean\-launch rate; comparisons between models are paired by task and tested with a cluster\-permutation test \(the task as the resampling unit,N=25N\\\!=\\\!25;30,00030\{,\}000random sign\-flip permutations\), with bootstrap confidence intervals on effect sizes and Wilson95%95\\%intervals on rates\. The RFT\-r1≫\\ggCTRL contrast is additionally checked in every leave\-one\-family\-out fold\. best\-of\-KKcoverage is reported at a fixed two\-seed budget\.