Upload folder using huggingface_hub

README.md

@@ -0,0 +1,113 @@
+---
+license: other
+task_categories:
+  - text-generation
+tags:
+  - agentic-sft
+  - planning
+  - godot
+  - phaser
+---
+
+# GameDoctor plan corpus, distilled from finished games
+
+908 plan-stage SFT rows distilled from **finished games** — 832 Godot, 76 web —
+across 17 archetype families. Each row is `brief -> file-level implementation
+plan`.
+
+This exists because plan data does not need a recorded agent session. The corpus
+these came from holds ~900 finished games with no trajectory files, which made
+them useless for generation training but perfectly usable here: the brief comes
+from the task definition, and the plan is read off the finished file tree.
+
+## Row format
+
+Byte-identical in shape to the original 454-row `plan.jsonl`, so the two pool
+cleanly:
+
+```json
+{
+  "task": "cardgame-arcane-rail",
+  "archetype": "cardgame",
+  "model": "gpt-5.5",
+  "n_chars": 3067,
+  "engine": "godot",
+  "source": "basegen_unpublished",
+  "messages": [
+    {"role": "system",    "content": "You are a senior game engineer. Given a game brief, produce a file-level implementation plan: which files to MODIFY and which to CREATE, with a one-line reason for each."},
+    {"role": "user",      "content": "<the game brief>"},
+    {"role": "assistant", "content": "Implementation plan before coding:\n\n- **Files to MODIFY**\n  - `path`: reason\n- **Files to CREATE**\n  - ..."}
+  ]
+}
+```
+
+`engine` and `source` are added for provenance; only `messages` is trained on.
+
+## How it was distilled, and what makes it honest
+
+Two rules, both about not writing fiction:
+
+* **The plan is read off the ACTUAL file tree, never off a narration.** The
+  distiller receives the brief plus the real file listing and excerpts of the main
+  source files. A game whose README claimed a physics system it does not contain
+  would otherwise have that claim copied into the training target.
+* **Only COMPLETE games are distilled.** Godot needs `project.godot` plus at least
+  one script or scene; web needs `package.json` plus a `src/` tree. A plan
+  distilled from a half-built game is a plan for half-building.
+
+The distiller prompt is **engine-specific**. A Phaser prompt pointed at a Godot
+game produces plans full of TypeScript files that do not exist, so Godot runs are
+told the vocabulary is `.tscn` / `.gd` / `project.godot` and web runs are told it
+is `src/*.ts` / `package.json` / `vite`.
+
+## Verification
+
+Every backticked path in every plan was checked against the real game's file tree:
+
+```
+923 games attempted
+922 distilled   (1 skipped: incomplete game; 0 API failures; 0 malformed)
+ 14 dropped     (invented paths, or wrong engine vocabulary)
+908 kept
+
+23,785 file paths referenced
+     0 not found in the game            (0.0%)
+     0 rows with wrong engine vocabulary
+```
+
+The 14 dropped rows include a few false positives from a deliberately strict
+checker — `res://Main.tscn` is valid Godot syntax and `src/` is a directory, not a
+file — but at 1.5% of the corpus, dropping them is cheaper than reasoning about
+which are safe.
+
+## Composition
+
+| | this corpus | original `plan.jsonl` |
+|---|---|---|
+| rows | 908 | 454 |
+| engines | Godot 832, web 76 | web only |
+| archetype families | **17** | 15 |
+| plan length | 1,310 – 7,228 chars (p50 2,791) | 908 – 3,106 (p50 2,041) |
+
+Top families: simulation 127, platformer 90, cardgame 89, horror 81, roguelike 55,
+strategy 54, towerdefense 47, sports 43.
+
+**Note the length difference.** Web games carry ~64 files against Godot's ~20–32,
+so their plans run longer than anything in the original corpus. The content is
+verified accurate, so files were not trimmed out to hit a length target — but
+pooling the two shifts the length distribution upward, and that is a property to
+know rather than a defect to hide.
+
+## Caveat if you pool this with generation data
+
+The original stage-2 mix was 409 gen + 454 plan, and the concern that motivated a
+reweighting experiment was that generation was being outvoted at 47%. Adding these
+908 rows takes plan to **1,362 against 409 gen — generation falls to 23%**. If that
+concern was ever real, this makes it substantially worse, not better. Consider the
+gen:plan ratio deliberately rather than pooling everything by default.
+
+---
+
+**Pipeline code:** [WenyiWU0111/OpenGame-reproduce · `gamedoctor_sft/`](https://github.com/WenyiWU0111/OpenGame-reproduce/tree/d3-mechanic-runtime/gamedoctor_sft)
+
+**Companion repos:** [adapters](https://huggingface.co/dCoder30/gamedoctor-qwen38-adapters) · [training corpora](https://huggingface.co/datasets/dCoder30/gamedoctor-sft-data) · [eval results](https://huggingface.co/datasets/dCoder30/gamedoctor-eval) · [raw trajectories](https://huggingface.co/datasets/dCoder30/gamedoctor-raw-trajectories)

distill_plans_from_games.py

@@ -0,0 +1,241 @@
+"""Distil PLAN training rows from finished games -- Godot and web.
+
+A plan row is three messages: a fixed system prompt, the game BRIEF as the user
+turn, and a file-level "Files to MODIFY / CREATE" plan as the assistant target.
+Nothing about that requires a recorded agent session, which is why finished games
+are usable here even though they carry no trajectory.
+
+TWO RULES, both borrowed from distill_realized_plan.py, both about not writing
+fiction:
+
+  * The plan is read off the ACTUAL file tree, never off any narration. A game
+    whose README claims a physics system it does not contain would otherwise have
+    that claim copied into the training target.
+  * Only COMPLETE games are distilled. Godot needs project.godot plus at least
+    one script or scene; web needs package.json plus a src/ tree. A plan distilled
+    from a half-built game is a plan for half-building.
+
+The row's system prompt is byte-identical to the 454 existing plan rows, so the
+corpus stays homogeneous. The prompt sent to the distiller is a separate thing and
+is engine-specific: a Phaser prompt asked about a Godot game produces plans full
+of TypeScript files that do not exist.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import threading
+import urllib.error
+import urllib.request
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+ENV = '/home/tiger/OpenGame-Aayush/agent-test/.env'
+TASKS = Path('/tmp/corpus_new/tasks')
+SRC_ROOTS = [
+    ('godot', Path('/tmp/plan_src/basegen_unpublished')),
+    ('godot', Path('/tmp/plan_src/_basegames_new')),
+    ('web', Path('/tmp/plan_src/gen953_opengame_0')),
+    ('web', Path('/tmp/plan_src/gen953_opengame_1')),
+    ('web', Path('/tmp/plan_src/gen953_opengame_2')),
+]
+
+# byte-identical to the existing 454 rows
+ROW_SYSTEM = ('You are a senior game engineer. Given a game brief, produce a '
+              'file-level implementation plan: which files to MODIFY and which '
+              'to CREATE, with a one-line reason for each.')
+
+DISTILL_PROMPT = """You are given a game brief and the COMPLETE file tree of the finished game that was built from it, with excerpts of its main source files.
+
+Write the file-level implementation plan that would have produced this game. Format exactly:
+
+Implementation plan before coding:
+
+- **Files to MODIFY**
+  - `path`: one-line reason
+- **Files to CREATE**
+  - `path`: one-line reason
+
+Rules:
+- Reference ONLY files that appear in the tree. Never invent a path.
+- {engine_note}
+- One line per file, naming what that file is responsible for.
+- No preamble, no closing commentary. Start with "Implementation plan before coding:".
+- Aim for 900-3000 characters."""
+
+ENGINE_NOTE = {
+    'godot': ('This is a GODOT project: scenes are .tscn, scripts are .gd, the '
+              'project file is project.godot. Do not mention TypeScript, Phaser, '
+              'vite or package.json.'),
+    'web': ('This is a WEB project built with Phaser and vite: source is '
+            'TypeScript under src/, config in package.json and vite.config.js. '
+            'Do not mention .gd or .tscn files.'),
+}
+
+SKIP_DIRS = {'.git', 'node_modules', '.godot', 'dist', '__pycache__', '.qwen'}
+MAIN_FILES = {
+    'godot': ['project.godot', 'Main.tscn', 'scripts/main.gd'],
+    'web': ['package.json', 'src/main.ts', 'src/gameConfig.json'],
+}
+MAX_TREE = 120          # files listed
+MAX_EXCERPT = 2500      # chars per main file
+_lock = threading.Lock()
+
+
+def load_env():
+    for line in open(ENV):
+        line = line.strip()
+        if line and not line.startswith('#') and '=' in line:
+            k, v = line.split('=', 1)
+            os.environ.setdefault(k.strip(), v.strip().strip('"').strip("'"))
+
+
+def call_model(system: str, user: str, model: str, retries: int = 3) -> str:
+    base = os.environ['OPENGAME_REASONING_BASE_URL'].rstrip('/')
+    body = json.dumps({
+        'model': model,
+        'messages': [{'role': 'system', 'content': system},
+                     {'role': 'user', 'content': user}],
+        'max_tokens': 4000,
+    }).encode()
+    last = ''
+    for attempt in range(retries):
+        try:
+            req = urllib.request.Request(
+                base + '/chat/completions', data=body,
+                headers={'Content-Type': 'application/json',
+                         'Authorization': 'Bearer ' + os.environ['OPENGAME_REASONING_API_KEY']})
+            r = json.loads(urllib.request.urlopen(req, timeout=300).read())
+            txt = (r['choices'][0]['message'].get('content') or '').strip()
+            if txt:
+                return txt
+            last = 'empty response'
+        except Exception as e:                       # noqa: BLE001
+            last = f'{type(e).__name__}: {e}'
+        import time
+        time.sleep(3 * (attempt + 1))
+    raise RuntimeError(last)
+
+
+def game_is_complete(engine: str, d: Path) -> bool:
+    if engine == 'godot':
+        if not (d / 'project.godot').exists():
+            return False
+        return any(d.rglob('*.gd')) or any(d.rglob('*.tscn'))
+    if not (d / 'package.json').exists():
+        return False
+    return (d / 'src').is_dir()
+
+
+def describe(engine: str, d: Path) -> str:
+    files = []
+    for p in sorted(d.rglob('*')):
+        if p.is_dir() or any(s in p.parts for s in SKIP_DIRS):
+            continue
+        try:
+            files.append(f'{p.relative_to(d)}  ({p.stat().st_size}B)')
+        except OSError:
+            continue
+    shown = files[:MAX_TREE]
+    out = [f'FILE TREE ({len(files)} files' +
+           (f', showing {len(shown)}' if len(files) > len(shown) else '') + '):']
+    out += ['  ' + f for f in shown]
+    for rel in MAIN_FILES[engine]:
+        f = d / rel
+        if f.exists() and f.is_file():
+            try:
+                txt = f.read_text(errors='replace')[:MAX_EXCERPT]
+            except OSError:
+                continue
+            out.append(f'\n--- {rel} (first {len(txt)} chars) ---\n{txt}')
+    return '\n'.join(out)
+
+
+def one(engine: str, d: Path, model: str):
+    task = d.name
+    brief_f = TASKS / task / 'instruction.md'
+    if not brief_f.exists():
+        return ('no_brief', task, None)
+    if not game_is_complete(engine, d):
+        return ('incomplete', task, None)
+    brief = brief_f.read_text(errors='replace').strip()
+    user = (f'GAME BRIEF:\n{brief}\n\n'
+            f'{describe(engine, d)}')
+    system = DISTILL_PROMPT.format(engine_note=ENGINE_NOTE[engine])
+    try:
+        plan = call_model(system, user, model)
+    except Exception as e:                            # noqa: BLE001
+        return ('failed', task, str(e)[:120])
+    if not plan.startswith('Implementation plan'):
+        i = plan.find('Implementation plan')
+        if i < 0:
+            return ('bad_format', task, plan[:80])
+        plan = plan[i:]
+    row = {
+        'task': task,
+        'archetype': task.split('-')[0],
+        'model': model,
+        'n_chars': len(plan),
+        'engine': engine,
+        'source': d.parent.name,
+        'messages': [
+            {'role': 'system', 'content': ROW_SYSTEM},
+            {'role': 'user', 'content': brief},
+            {'role': 'assistant', 'content': plan},
+        ],
+    }
+    return ('ok', task, row)
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument('--out', default='/mnt/hdfs/bi_algo_a2f/minghao.fu/'
+                                     'gamedoctor_sft_pipeline/data/plan_games.jsonl')
+    ap.add_argument('--limit', type=int, default=0, help='pilot: only N games')
+    ap.add_argument('--workers', type=int, default=10)
+    ap.add_argument('--model', default='')
+    a = ap.parse_args(argv)
+
+    load_env()
+    model = a.model or os.environ.get('OPENGAME_REASONING_MODEL', 'gpt-5.5')
+
+    jobs = []
+    for engine, root in SRC_ROOTS:
+        if not root.is_dir():
+            print(f'  missing source root {root}')
+            continue
+        for d in sorted(root.iterdir()):
+            if d.is_dir():
+                jobs.append((engine, d))
+    # interleave engines so a pilot sees both
+    jobs.sort(key=lambda j: (j[1].name, j[0]))
+    if a.limit:
+        god = [j for j in jobs if j[0] == 'godot'][:a.limit // 2 or 1]
+        web = [j for j in jobs if j[0] == 'web'][:a.limit - len(god)]
+        jobs = god + web
+    print(f'{len(jobs)} games to distil with {model} ({a.workers} workers)')
+
+    done = {'ok': 0, 'no_brief': 0, 'incomplete': 0, 'failed': 0, 'bad_format': 0}
+    out = open(a.out, 'w')
+    with ThreadPoolExecutor(max_workers=a.workers) as ex:
+        for status, task, payload in ex.map(lambda j: one(j[0], j[1], model), jobs):
+            done[status] += 1
+            if status == 'ok':
+                with _lock:
+                    out.write(json.dumps(payload, ensure_ascii=False) + '\n')
+                    out.flush()
+            elif status in ('failed', 'bad_format'):
+                print(f'  {status}: {task}: {payload}')
+            n = sum(done.values())
+            if n % 50 == 0:
+                print(f'  {n}/{len(jobs)}  {done}', flush=True)
+    out.close()
+    print(f'\nDONE {done}')
+    print(f'wrote {a.out}')
+    return 0 if done['ok'] else 1
+
+
+if __name__ == '__main__':
+    sys.exit(main())

filter_plans.py

@@ -0,0 +1,58 @@
+"""Drop any distilled plan that names a file the game does not contain.
+
+Full-run validation found 23 bad paths across 24,257 (0.1%) and one row using the
+wrong engine's vocabulary. That is a good rate, but a plan containing even one
+invented path teaches the model to invent paths -- and at 922 rows, discarding the
+handful that fail costs almost nothing. Lowering the gate to let them through
+would be the wrong trade.
+"""
+import json
+import re
+import sys
+from pathlib import Path
+
+ROOTS = [Path('/tmp/plan_src/basegen_unpublished'), Path('/tmp/plan_src/_basegames_new'),
+         Path('/tmp/plan_src/gen953_opengame_0'), Path('/tmp/plan_src/gen953_opengame_1'),
+         Path('/tmp/plan_src/gen953_opengame_2')]
+WRONG_VOCAB = {
+    'godot': re.compile(r'\.ts\b|package\.json|vite|Phaser', re.I),
+    'web': re.compile(r'\.gd\b|\.tscn\b|project\.godot', re.I),
+}
+SRC = sys.argv[1]
+DST = sys.argv[2]
+
+kept, dropped = [], []
+for line in open(SRC):
+    if not line.strip():
+        continue
+    r = json.loads(line)
+    task, engine = r['task'], r['engine']
+    plan = r['messages'][-1]['content']
+    d = next((x / task for x in ROOTS if (x / task).is_dir()), None)
+    reason = None
+    if d is None:
+        reason = 'game dir not found'
+    else:
+        have = {str(p.relative_to(d)) for p in d.rglob('*') if p.is_file()}
+        refs = {x.strip().lstrip('./') for x in re.findall(r'`([^`]+)`', plan)
+                if '/' in x or '.' in x}
+        miss = [x for x in refs
+                if x not in have and not any(h.endswith('/' + x) for h in have)]
+        if miss:
+            reason = f'{len(miss)} invented path(s): {miss[:3]}'
+        elif WRONG_VOCAB[engine].search(plan):
+            reason = f'wrong engine vocabulary for {engine}'
+    if reason:
+        dropped.append((task, reason))
+    else:
+        kept.append(r)
+
+with open(DST, 'w') as fh:
+    for r in kept:
+        fh.write(json.dumps(r, ensure_ascii=False) + '\n')
+
+print(f'kept    {len(kept)}')
+print(f'dropped {len(dropped)}')
+for t, why in dropped:
+    print(f'  {t}: {why}')
+print(f'\nwrote {DST}')

verify_plans.py

@@ -0,0 +1,60 @@
+"""Verify distilled plans against the real games.
+
+The failure mode that would silently poison the corpus is a plan naming files
+that do not exist -- a hallucinated `src/PlayerController.ts` in a Godot project
+trains the model to invent paths. So every backticked path in the plan is checked
+against the actual file tree, and the engine's file vocabulary is checked too.
+"""
+import json
+import re
+import sys
+from pathlib import Path
+
+ROOTS = [Path('/tmp/plan_src/basegen_unpublished'), Path('/tmp/plan_src/_basegames_new'),
+         Path('/tmp/plan_src/gen953_opengame_0'), Path('/tmp/plan_src/gen953_opengame_1'),
+         Path('/tmp/plan_src/gen953_opengame_2')]
+WRONG_VOCAB = {
+    'godot': re.compile(r'\.ts\b|package\.json|vite|Phaser', re.I),
+    'web': re.compile(r'\.gd\b|\.tscn\b|project\.godot', re.I),
+}
+
+path = sys.argv[1] if len(sys.argv) > 1 else '/tmp/plan_pilot.jsonl'
+rows = [json.loads(l) for l in open(path) if l.strip()]
+print(f'{len(rows)} rows in {path}\n')
+
+tot_paths = tot_missing = vocab_bad = 0
+for r in rows:
+    task, engine = r['task'], r['engine']
+    d = next((x / task for x in ROOTS if (x / task).is_dir()), None)
+    plan = r['messages'][-1]['content']
+    refs = set(re.findall(r'`([^`]+)`', plan))
+    refs = {x for x in refs if '/' in x or '.' in x}
+    missing = []
+    if d:
+        have = {str(p.relative_to(d)) for p in d.rglob('*') if p.is_file()}
+        for ref in refs:
+            clean = ref.strip().lstrip('./')
+            if clean not in have and not any(h.endswith('/' + clean) or h == clean for h in have):
+                missing.append(ref)
+    tot_paths += len(refs)
+    tot_missing += len(missing)
+    bad = WRONG_VOCAB[engine].findall(plan)
+    if bad:
+        vocab_bad += 1
+    flag = '' if not missing and not bad else '   <-- CHECK'
+    print(f'{task:<36} {engine:<6} {len(plan):>5}ch  paths={len(refs):<3} '
+          f'missing={len(missing):<3} wrong-vocab={len(bad)}{flag}')
+    if missing[:4]:
+        print(f'    missing: {missing[:4]}')
+    if bad[:4]:
+        print(f'    wrong vocab: {bad[:4]}')
+
+print()
+pct = 100 * tot_missing / max(1, tot_paths)
+print(f'paths referenced: {tot_paths}   not found in the game: {tot_missing} ({pct:.1f}%)')
+print(f'rows using the wrong engine vocabulary: {vocab_bad}/{len(rows)}')
+print()
+if pct > 10 or vocab_bad:
+    print('QUALITY GATE FAILED - fix the prompt before scaling up')
+    sys.exit(1)
+print('QUALITY GATE PASSED')