ForgeBench v1: 100 tasks (api/mixin/migration/debug/build) + harness, verified 19/19

README.md

@@ -0,0 +1,85 @@
+# ForgeBench v1 — independent benchmark for Minecraft-modding LLMs
+
+Contamination-free evaluation benchmark for models fine-tuned on the
+`ComerX/forge-neoforge-sft-*` dataset family. Targets **NeoForge 1.21.1** and
+**Forge 1.20.1** (Mojang mappings). 100 tasks, 5 modules × 20.
+
+## Layout
+
+```
+data/
+  forgebench_full.jsonl    # 100 tasks (single JSONL, one task per line)
+  schema_example.jsonl     # 3 complete examples (Mixin / Migration / Crash log)
+harness/
+  Dockerfile               # sandbox image: JDK 21 + Gradle 8.9 + prebuilt MDK template
+  sandbox_runner.py        # injects answer into MDK -> ./gradlew build -x test -> Pass@1
+  ast_eval.py              # javalang AST gate: syntax, forbidden APIs, hallucinated
+                           # imports, required annotations, version-mix penalties
+  gametest_runner.py       # GameTest template generation + headless run
+  judge_prompt.txt         # strict LLM-as-a-judge rubric for debug/build tasks
+  run_benchmark.py         # driver: aggregates sandbox + AST + judge into a report
+  requirements.txt
+template/                  # minimal NeoForge 1.21.1 MDK (NeoGradle 7 userdev)
+VERIFICATION.md            # benchmark self-verification results (19/19)
+verification_result.json   # machine-readable check log
+```
+
+## Task schema (strict)
+
+```json
+{
+  "task_id": "MIXIN_014",
+  "module": "api | mixin | migration | debug | build",
+  "instruction": "prompt given to the evaluated LLM",
+  "context": "vanilla snippet / crash log / legacy code (may be empty)",
+  "golden_reference": "reference answer",
+  "eval_criteria": {
+    "must_compile": true,
+    "required_annotations": ["@Inject"],
+    "forbidden_apis": ["net.minecraft.util.text"],
+    "gametest_required": false
+  }
+}
+```
+
+## Modules
+
+| Module | Count | Task type | Grading |
+|---|---|---|---|
+| `api` (API & registration) | 20 | instruction→code | compile + AST gate |
+| `mixin` (Mojmap targets) | 20 | FIM / translation | compile + AST gate |
+| `migration` (1.20.1→1.21.1) | 20 | refactoring | compile + AST gate (legacy APIs forbidden) |
+| `debug` (FML crash logs) | 20 | log analysis → JSON | judge + JSON-shape gate |
+| `build` (Gradle KTS / mods.toml) | 20 | config generation | judge + required-token gate |
+
+## Running
+
+```bash
+# 0. build the sandbox image (once)
+docker build -t forgebench-sandbox:1.21.1 .
+
+# 1. produce answers.jsonl: {"task_id": ..., "answer": ...} per row
+
+# 2a. offline static gate only
+python3 harness/run_benchmark.py --data data/forgebench_full.jsonl \
+    --answers answers.jsonl --skip-compile --out report.json
+
+# 2b. full compile evaluation (inside Docker)
+python3 harness/run_benchmark.py --data data/forgebench_full.jsonl \
+    --answers answers.jsonl --out report.json
+
+# 3. judge-graded tasks (debug/build): run your judge LLM with harness/judge_prompt.txt
+#    and pass scores via --scores '{"DEBUG_004": {"score": 9, "verdict": "pass"}, ...}'
+```
+
+## Contamination status
+
+Golden references and instructions were screened against the public SFT corpus
+(`ComerX/forge-neoforge-sft-v2.1.0-rc2` + `-rc1`, sampled shards): **0 hits**
+(normalized 300-char prefix containment). The benchmark tasks are synthetic
+examples, not derived from any corpus repository.
+
+## Integrity
+
+- Frozen artifact: `SHA256SUMS.txt` (published alongside the dataset).
+- The benchmark is immutable once published; changes require a new version tag.

VERIFICATION.md

@@ -0,0 +1,48 @@
+# ForgeBench v1 — Verification Report
+
+- Date: 2026-10-27T08:16:51
+- Scope: dataset (100 tasks) + evaluation harness (offline tests)
+- Result: **19/19 checks passed**
+
+## Checks
+
+| # | Check | Status | Detail |
+|---|-------|--------|--------|
+| 1 | V1 strict schema (field set/order/types) | PASS | 100 rows |
+| 2 | V2 unique task_ids | PASS |  |
+| 3 | V2 id pattern ^[A-Z]+_\d{3}$ | PASS |  |
+| 4 | V2 20 tasks per module | PASS | {'api': 20, 'mixin': 20, 'migration': 20, 'debug': 20, 'build': 20} |
+| 5 | V2 module order api<mixin<migration<debug<build | PASS |  |
+| 6 | V3 required_annotations present in goldens | PASS |  |
+| 7 | V4 forbidden_apis absent from goldens (comments stripped) | PASS |  |
+| 8 | V5 debug goldens = valid JSON (root_cause/fix_explanation/code_patch) | PASS |  |
+| 9 | V6 Java goldens parse (javalang) | PASS |  \| parsed=57 non-java=23 |
+| 10 | V7 all golden imports on NeoForge 1.21.1 allowlist | PASS |  |
+| 11 | V8 contamination screen vs SFT corpus | PASS | 0 hits; shards=6; corpus_chars=4998017 |
+| 12 | V9a sandbox --dry-run prepares workspace | PASS | ": null,   "log_tail": "",   "dry_run": true,   "gradle_command": "./gradlew build -x test --console=plain --no-daemon",   "injected_file": "/tmp/tmpth5s1_d_/ws/src/main/java/com/example/generated" }  |
+| 13 | V9b ast_eval passes its own golden (API_001) | PASS | [] |
+| 14 | V9c ast_eval flags Forge namespace + 1.16 text API | PASS | forbidden API present: net.minecraftforge forbidden API present: net.minecraft.util.text import not on NeoForge 1.21.1 classpath: net.minecraftforge.registries.DeferredItem (Forge namespace does not exist on NeoForge (use net.neoforged)) |
+| 15 | V9d gametest template generation (offline) | PASS | ",   "generated": {     "test_class": "/tmp/tmpth5s1_d_/gt_ws/src/test/java/com/example/examplemod/gametest/ForgeBenchGameTest.java",     "logic_class": "/tmp/tmpth5s1_d_/gt_ws/src/test/java/com/example/examplemod/gametest/GeneratedGameTestLogic.java",     "hoisted_imports": 0   },   "ran": false }  |
+| 16 | V9e run_benchmark driver (dry-run) | PASS |  |
+| 17 | V10 Dockerfile references existing build context | PASS |  |
+| 18 | V10 judge prompt rubric sections | PASS |  |
+| 19 | V10 no javac/Mockito execution in harness | PASS | doc mentions of the ban are fine; executable use is not |
+
+## What each gate means
+
+- **V1-V2** enforce the strict task schema from the ForgeBench spec (field order, types, id pattern, 20 tasks/module).
+- **V3** required annotations/tokens must appear in golden *code* (Java comments stripped so prose cannot satisfy them; config goldens may carry tokens in comments by design).
+- **V4** forbidden (legacy/Forge-namespace) APIs must be absent from golden code even after comment stripping — guarantees migration goldens are pure NeoForge 1.21.1.
+- **V5** debug goldens are machine-parseable `{root_cause, fix_explanation, code_patch}` JSON.
+- **V6** every Java golden parses with javalang (records / pattern-matching `instanceof` shimmed for the Java-8 parser).
+- **V7** every import in every golden is on the NeoForge 1.21.1 + Mojmap allowlist — no hallucinated packages.
+- **V8** contamination screen: normalized golden/instruction prefixes (>=80 chars) were searched in sampled corpus shards of ComerX/forge-neoforge-sft-v2.1.0-rc2 and -rc1 (3 shards each): 0 hits.
+- **V9** harness offline tests: sandbox workspace preparation (--dry-run), ast_eval passing its own golden, ast_eval catching poisoned answers (Forge namespace + 1.16 text API), GameTest template generation, and the run_benchmark driver.
+- **V10** Dockerfile/template coherence, judge rubric presence, and the no-raw-javac/no-Mockito rule (executable use).
+
+## Known limitations (honest scope)
+
+1. The Gradle compile path (sandbox_runner) was verified structurally (workspace preparation, command assembly, output parsing) but NOT executed end-to-end in this sandbox: no Docker daemon and no 8 GB RAM budget for NeoForm decompile are available here. The same limitation is documented for the main SFT audit (compile_verified unreachable).
+2. javalang is a Java-8 parser; Java 14+ syntax (records, pattern matching) is shimmed for validation only. The real gate is the Gradle compile inside the MDK.
+3. Contamination screen is sampled (6 shards), not exhaustive; it screens exact-prefix containment, not paraphrase-level overlap.
+4. Plugin versions in build-module goldens (NeoGradle 7.0.145, ModDevGradle 1.0.24, Minotaur 2.+, curseforgegradle 1.1.24) reflect mid-2024/2025 releases; syntax is the graded property, not the pinned version.

data/schema_example.jsonl

@@ -0,0 +1,3 @@
+{"task_id": "MIXIN_002", "module": "mixin", "instruction": "Write a Mixin that cancels ALL fire damage in LivingEntity#hurt. Target (Mojang mappings): net.minecraft.world.entity.LivingEntity#hurt(Lnet/minecraft/world/damagesource/DamageSource;F)Z. Cancel only when the DamageSource type is IN_FIRE.", "context": "", "golden_reference": "package com.example.examplemod.mixin;\n\nimport net.minecraft.world.damagesource.DamageSource;\nimport net.minecraft.world.damagesource.DamageTypes;\nimport net.minecraft.world.entity.LivingEntity;\nimport org.spongepowered.asm.mixin.Mixin;\nimport org.spongepowered.asm.mixin.injection.At;\nimport org.spongepowered.asm.mixin.injection.Inject;\nimport org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;\n\n@Mixin(LivingEntity.class)\npublic abstract class LivingEntityMixin {\n\n    // Injecting into a boolean-returning method: CallbackInfoReturnable<Boolean>.\n    // `cir.setReturnValue(true)` cancels the method and makes hurt() report \"handled\".\n    @Inject(method = \"hurt(Lnet/minecraft/world/damagesource/DamageSource;F)Z\",\n            at = @At(\"HEAD\"), cancellable = true)\n    private void examplemod$cancelFireDamage(DamageSource source, float amount,\n                                             CallbackInfoReturnable<Boolean> cir) {\n        if (source.is(DamageTypes.IN_FIRE) || source.is(DamageTypes.ON_FIRE)) {\n            cir.setReturnValue(false);\n        }\n    }\n}", "eval_criteria": {"must_compile": true, "required_annotations": ["@Inject"], "forbidden_apis": ["net.minecraftforge"], "gametest_required": false}}
+{"task_id": "MIG_004", "module": "migration", "instruction": "Migrate this Forge 1.20.1 item that stores an `energy` value in item NBT to NeoForge 1.21.1 using a registered DataComponentType instead of CompoundTag.", "context": "// Forge 1.20.1\npublic class BatteryItem extends Item {\n    public BatteryItem(Properties props) { super(props); }\n\n    public int getEnergy(ItemStack stack) {\n        return stack.getOrCreateTag().getInt(\"energy\");\n    }\n\n    public void setEnergy(ItemStack stack, int value) {\n        stack.getOrCreateTag().putInt(\"energy\", Math.max(0, value));\n    }\n\n    public static void register(IEventBus bus) {\n        // nothing special in 1.20.1\n    }\n}", "golden_reference": "// NeoForge 1.21.1\npackage com.example.examplemod;\n\nimport com.mojang.serialization.Codec;\nimport net.minecraft.core.component.DataComponentType;\nimport net.minecraft.core.registries.Registries;\nimport net.minecraft.network.codec.ByteBufCodecs;\nimport net.minecraft.world.item.Item;\nimport net.minecraft.world.item.ItemStack;\nimport net.neoforged.bus.api.IEventBus;\nimport net.neoforged.neoforge.registries.DeferredHolder;\nimport net.neoforged.neoforge.registries.DeferredRegister;\n\npublic class BatteryItem extends Item {\n    public BatteryItem(Properties props) { super(props); }\n\n    public int getEnergy(ItemStack stack) {\n        return stack.getOrDefault(ExampleMod.ENERGY.get(), 0);\n    }\n\n    public void setEnergy(ItemStack stack, int value) {\n        stack.set(ExampleMod.ENERGY.get(), Math.max(0, value));\n    }\n}\n\nclass ExampleMod {\n    public static final String MODID = \"examplemod\";\n\n    public static final DeferredRegister<DataComponentType<?>> DATA_COMPONENTS =\n            DeferredRegister.create(Registries.DATA_COMPONENT_TYPE, MODID);\n\n    public static final DeferredHolder<DataComponentType<?>, DataComponentType<Integer>> ENERGY =\n            DATA_COMPONENTS.registerComponent(\"energy\",\n                    builder -> builder\n                            .persistent(Codec.INT)\n                            .networkSynchronized(ByteBufCodecs.VAR_INT)\n                            .build());\n\n    public ExampleMod(IEventBus modBus) {\n        DATA_COMPONENTS.register(modBus);\n    }\n}", "eval_criteria": {"must_compile": true, "required_annotations": [], "forbidden_apis": ["net.minecraftforge", "MinecraftForge.EVENT_BUS", "net.minecraft.util.text", "LazyOptional", "getOrCreateTag", "NetworkRegistry", "SimpleChannel", "FMLJavaModLoadingContext", "ForgeConfigSpec", "DistExecutor", "DeferredWorkQueue", "ForgeSpawnEggItem", "setRegistryName", "TickEvent.PlayerTickEvent"], "gametest_required": false}}
+{"task_id": "DEBUG_004", "module": "debug", "instruction": "Analyze the FML crash/log snippet below for a NeoForge 1.21.1 dedicated server. Return ONLY a JSON object with keys root_cause, fix_explanation, code_patch. Reference concrete FML/NeoForge terminology; do not give generic advice such as 'update your Java' unless the log shows a class-version error.", "context": "[main/ERROR] [ne.fml.lo.mo/]: Mod 'examplemod' caused an exception during modloading\nCaused by: java.lang.RuntimeException: Attempted to load class net/minecraft/client/Minecraft for invalid dist DEDICATED_SERVER\n\tat TRANSFORMER/examplemod@1.0.0/com.example.ClientProxy.<init>(ClientProxy.java:18)\n\tat TRANSFORMER/examplemod@1.0.0/com.example.CommonProxy.<init>(CommonProxy.java:9)\n\tat TRANSFORMER/examplemod@1.0.0/com.example.ExampleMod.<init>(ExampleMod.java:14)\nDist: DEDICATED_SERVER", "golden_reference": "{\n  \"root_cause\": \"The common code path unconditionally constructs ClientProxy, whose constructor references net.minecraft.client.Minecraft - a client-only class. On a dedicated server (dist DEDICATED_SERVER) the class fails to load with 'invalid dist DEDICATED_SERVER'.\",\n  \"fix_explanation\": \"Never touch client classes from common code. Remove the ClientProxy construction from the common path and either (a) isolate client logic in classes registered via @Mod.EventBusSubscriber(value = Dist.CLIENT) or a second @Mod entry point with dist = Dist.CLIENT, or (b) guard with FMLEnvironment.dist checks at the call boundary. Runtime-guarded lazy loading only helps if the client class is not referenced in the loaded code path at all.\",\n  \"code_patch\": \"// common\\npublic ExampleMod(IEventBus modBus) {\\n    // no client construction here\\n}\\n\\n// client-only\\n@Mod(value = ExampleMod.MODID, dist = Dist.CLIENT)\\npublic class ExampleModClient { ... }\"\n}", "eval_criteria": {"must_compile": false, "required_annotations": [], "forbidden_apis": [], "gametest_required": false}}

harness/Dockerfile

@@ -0,0 +1,60 @@
+# ForgeBench sandbox image
+# Pre-configured NeoForge 1.21.1 MDK template + Gradle 8.9 + JDK 21.
+# The runner (sandbox_runner.py) injects an LLM-generated .java file into the template
+# and executes `./gradlew build -x test` headlessly. No Minecraft server is launched.
+#
+# Build:  docker build -t forgebench-sandbox:1.21.1 .
+# Run:    docker run --rm -v $(pwd)/out:/out forgebench-sandbox \
+#           python3 /opt/forgebench/sandbox_runner.py --task-file /out/task.json --code-file /out/answer.java
+
+FROM eclipse-temurin:21-jdk-jammy
+
+ARG GRADLE_VERSION=8.9
+ARG NEOFORGE_VERSION=21.1.77
+ARG MOD_TEMPLATE_ID=examplemod
+
+ENV DEBIAN_FRONTEND=noninteractive
+ENV GRADLE_USER_HOME=/opt/gradle-home
+ENV NEOFORGE_VERSION=${NEOFORGE_VERSION}
+
+# --- system deps -------------------------------------------------------------
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        git curl unzip ca-certificates python3 python3-pip jq \
+    && rm -rf /var/lib/apt/lists/*
+
+# --- gradle 8.9 --------------------------------------------------------------
+RUN curl -fsSLo /tmp/gradle.zip https://services.gradle.org/distributions/gradle-${GRADLE_VERSION}-bin.zip \
+    && unzip -q /tmp/gradle.zip -d /opt/ \
+    && ln -s /opt/gradle-${GRADLE_VERSION}/bin/gradle /usr/local/bin/gradle \
+    && rm /tmp/gradle.zip
+
+# --- python harness deps -----------------------------------------------------
+COPY harness/requirements.txt /opt/forgebench/requirements.txt
+RUN pip3 install --no-cache-dir -r /opt/forgebench/requirements.txt
+
+# --- NeoForge MDK template ---------------------------------------------------
+# template/ contains a minimal but COMPLETE NeoForge 1.21.1 mod project:
+#   build.gradle.kts      (NeoGradle 7 userdev / or ModDevGradle - see template README)
+#   settings.gradle.kts
+#   gradle.properties
+#   src/main/resources/META-INF/neoforge.mods.toml
+#   src/main/resources/examplemod.mixins.json
+#   src/main/java/com/example/examplemod/  (empty package marker)
+COPY template/ /opt/forgebench/template/
+
+# Pre-warm the dependency cache so each evaluation does not re-download the world.
+# (First build populates /opt/gradle-home; subsequent runs are offline-capable.)
+RUN cd /opt/forgebench/template \
+    && gradle --no-daemon help || true
+
+COPY harness/ /opt/forgebench/harness/
+
+# Non-root runner; keep the build filesystem writable
+RUN useradd -ms /bin/bash evaluator
+USER evaluator
+WORKDIR /home/evaluator
+
+# Hardened defaults: no network flapping, fixed locale
+ENV LANG=C.UTF-8 LC_ALL=C.UTF-8
+
+ENTRYPOINT ["python3", "/opt/forgebench/harness/sandbox_runner.py"]

harness/ast_eval.py

@@ -0,0 +1,216 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+ForgeBench static AST analyzer.
+
+Parses the LLM's Java output with `javalang` and performs classpath-aware checks:
+
+  1. SYNTAX        - full parse (any AST error = fail for must_compile tasks)
+  2. FORBIDDEN     - forbidden_apis from eval_criteria: legacy / cross-loader symbols
+                     (net.minecraft.util.text, net.minecraftforge.*, LazyOptional, ...)
+  3. HALLUCINATION - every import must resolve to (a) the vanilla/Mojmap+NeoForge 1.21.1
+                     allowlist, (b) the Mixin/MixinExtras/ASM toolchain, (c) the mod-local
+                     package, or (d) an explicit optional-allowlist (Jei).
+                     Unknown roots are reported as potential hallucinated APIs.
+  4. ANNOTATIONS   - required_annotations must be present on declarations
+  5. VERSION MIX   - penalty scan for 1.16-era / Forge-era APIs that never existed
+                     on NeoForge 1.21.1
+
+Usage:
+  python3 ast_eval.py --code answer.java --task task.json [--out result.json]
+
+Output: JSON verdict {passed, score, findings[]}.
+The script never executes the code; it is a static gate that complements the
+Gradle compile check (sandbox_runner.py) and the LLM judge (debug/build tasks).
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+
+try:
+    import javalang
+except ImportError:  # pragma: no cover
+    print("pip install javalang", file=sys.stderr)
+    raise
+
+# --- classpath allowlist: NeoForge 1.21.1 + vanilla Mojmap + toolchain ------------
+ALLOWED_IMPORT_ROOTS = (
+    "net.minecraft.",        # vanilla, Mojang mappings (1.21.1)
+    "net.neoforged.",        # NeoForge (FML, bus, neoforge.*)
+    "com.mojang.",           # brigadier, blaze3d, datafixers, serialization
+    "org.spongepowered.",    # Mixin
+    "com.llamalad7.",        # MixinExtras (bundled with NeoForge 1.21.1)
+    "org.objectweb.asm.",    # ASM (mixin opcodes)
+    "org.lwjgl.glfw.",       # GLFW (client keys)
+    "org.jetbrains.",        # annotations (@Nullable)
+    "io.netty.",             # ByteBuf for payloads
+    "com.google.",           # guava
+    "javax.annotation.",     # jsr305
+    "java.",                 # JRE
+    "javax.",
+)
+MOD_LOCAL_ROOT = "com.example."          # examplemod + generated answers
+OPTIONAL_ROOTS = {"mezz.jei.": "Jei optional dependency (client-side tasks only)"}
+
+# --- known-dead / legacy symbols (hard fail when imported) ------------------------
+LEGACY_IMPORTS = {
+    "net.minecraft.util.text": "1.16-era text API removed since 1.17 (use net.minecraft.network.chat)",
+    "net.minecraftforge": "Forge namespace does not exist on NeoForge (use net.neoforged)",
+    "net.minecraftforge.eventbus.api.SubscribeEvent": "use net.neoforged.bus.api.SubscribeEvent",
+    "net.minecraftforge.fml.DistExecutor": "DistExecutor removed; use FMLEnvironment.dist",
+    "net.minecraftforge.items.CapabilityItemHandler": "use net.neoforged.neoforge.capabilities.Capabilities",
+}
+
+# --- penalty scan (soft signals; lower score, not instant fail) -------------------
+PENALTY_PATTERNS = [
+    (r"\bnew\s+ResourceLocation\s*\(",
+     "ResourceLocation constructor removed in 1.20.6; use ResourceLocation.fromNamespaceAndPath"),
+    (r"\bgetOrCreateTag\s*\(", "item NBT getOrCreateTag removed in 1.20.5; use data components"),
+    (r"\bMinecraftForge\.EVENT_BUS\b", "Forge game bus; use NeoForge.EVENT_BUS"),
+    (r"\bDistExecutor\b", "DistExecutor removed in NeoForge"),
+    (r"\bLazyOptional\b", "LazyOptional removed in NeoForge capability system"),
+    (r"\bTickEvent\.PlayerTickEvent\b", "TickEvent split into PlayerTickEvent.Pre/Post in NeoForge 1.21"),
+    (r"\bIFormattableTextComponent\b", "use MutableComponent"),
+    (r"\bRegistryObject\b", "Forge type; use DeferredHolder/DeferredItem"),
+]
+
+
+def parse(source: str):
+    try:
+        tree = javalang.parse.parse(source)
+        return tree, None
+    except (javalang.parser.JavaSyntaxError, javalang.tokenizer.LexerError) as e:
+        return None, f"syntax error: {e}"
+
+
+def strip_java_comments(src: str) -> str:
+    """Remove // and /* */ comments: explanatory mentions of a legacy API must not
+    be treated as usage (and required annotations must not be satisfied by comments)."""
+    src = re.sub(r"/\*.*?\*/", " ", src, flags=re.S)
+    src = re.sub(r"^\s*//.*$", " ", src, flags=re.M)
+    src = re.sub(r"(?<=[^:])//[^\n]*", " ", src)  # keep 'https://' intact
+    return src
+
+
+def collect_imports(tree) -> list[str]:
+    return [imp.path for imp in tree.imports]
+
+
+def walk_annotations(tree) -> list[str]:
+    names: list[str] = []
+    for path, node in tree.filter(javalang.tree.Annotation):
+        names.append(node.name)
+    return names
+
+
+def full_text_with_annotations(source: str) -> str:
+    return source
+
+
+def find_subtree_source(source: str, position) -> str:
+    """Extract a line context around a javalang position tuple."""
+    if not position or not isinstance(position, tuple):
+        return ""
+    line = min(position.line, len(source.splitlines())) - 1
+    lines = source.splitlines()
+    return "\n".join(lines[max(0, line - 2): line + 2])
+
+
+def evaluate_source(task: dict, source: str) -> dict:
+    criteria = task.get("eval_criteria", {})
+    must_compile = criteria.get("must_compile", False)
+    forbidden = criteria.get("forbidden_apis", [])
+    required = criteria.get("required_annotations", [])
+
+    findings: list[dict] = []
+    penalties = 0
+
+    tree, err = parse(source)
+    if err:
+        findings.append({"check": "SYNTAX", "severity": "error", "message": err})
+        return {"passed": False, "score": 0.0, "findings": findings}
+
+    # Comments are stripped once: all text-based checks below operate on real code only.
+    code = strip_java_comments(source)
+
+    # 2. forbidden APIs (eval_criteria-driven, substring over stripped code)
+    for token in forbidden:
+        if token and token in code:
+            findings.append({"check": "FORBIDDEN", "severity": "error",
+                             "message": f"forbidden API present: {token}"})
+
+    # 3. import allowlist / hallucination + legacy imports
+    for imp in collect_imports(tree):
+        if any(imp == r or imp.startswith(r) for r in ALLOWED_IMPORT_ROOTS):
+            continue
+        if imp.startswith(MOD_LOCAL_ROOT):
+            continue
+        hit = next((note for root, note in OPTIONAL_ROOTS.items() if imp.startswith(root)), None)
+        if hit:
+            findings.append({"check": "OPTIONAL_DEP", "severity": "info",
+                             "message": f"{imp}: {hit}"})
+            continue
+        legacy = next((msg for bad, msg in LEGACY_IMPORTS.items() if imp.startswith(bad)), None)
+        findings.append({"check": "HALLUCINATION", "severity": "error",
+                         "message": f"import not on NeoForge 1.21.1 classpath: {imp}"
+                                    + (f" ({legacy})" if legacy else "")})
+        penalties += 1
+
+    # 4. required annotations (declaration-level via AST + text fallback on code)
+    annos = walk_annotations(tree)
+    for req in required:
+        short = req.lstrip("@")
+        present = (any(a == short or a.endswith("." + short) or a == req
+                       for a in annos)
+                   or req in code)  # composite tokens like "@Mod.EventBusSubscriber"
+        if not present:
+            findings.append({"check": "ANNOTATION", "severity": "error",
+                             "message": f"required annotation/token missing: {req}"})
+
+    # 5. version-mix penalty scan
+    for pattern, msg in PENALTY_PATTERNS:
+        if re.search(pattern, code):
+            findings.append({"check": "VERSION_MIX", "severity": "warning",
+                             "message": msg})
+            penalties += 1
+
+    errors = [f for f in findings if f["severity"] == "error"]
+    score = 1.0
+    if errors:
+        score = 0.0
+    else:
+        score = max(0.0, 1.0 - 0.2 * penalties)
+
+    return {
+        "passed": not errors,
+        "score": round(score, 2),
+        "findings": findings,
+    }
+
+
+def main() -> int:
+    p = argparse.ArgumentParser(description="ForgeBench AST analyzer")
+    p.add_argument("--code", required=True, help="LLM-generated .java file")
+    p.add_argument("--task", required=True, help="task JSON file")
+    p.add_argument("--out", default=None)
+    args = p.parse_args()
+
+    source = Path(args.code).read_text(encoding="utf-8")
+    task = json.loads(Path(args.task).read_text(encoding="utf-8"))
+
+    result = evaluate_source(task, source)
+    result["task_id"] = task.get("task_id")
+
+    payload = json.dumps(result, ensure_ascii=False, indent=2)
+    if args.out:
+        Path(args.out).write_text(payload, encoding="utf-8")
+    print(payload)
+    return 0 if result["passed"] else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

harness/gametest_runner.py

@@ -0,0 +1,166 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+ForgeBench GameTest integration runner.
+
+For tasks with eval_criteria.gametest_required = true this script:
+
+  1. Generates a NeoForge 1.21.1 GameTest template class (Batches + @GameTest methods)
+     wrapping the LLM's logic.
+  2. Injects it into the MDK template's test source set.
+  3. Runs the GameTest harness inside a headless container - the vanilla server
+     environment is real (real Level, real entities), so NO Mockito / no mocking of
+     Level or Player classes is required or allowed.
+
+Command used by default: ./gradlew runGameTestServer  (NeoGradle 7 exposes the
+`gametest` run; ModDevGradle exposes gameTestServer - override with --gradle-command
+when the template uses MDG).
+
+Offline/CI mode: --generate-only writes the test class without running Gradle, which
+is how this script is unit-tested inside the ForgeBench verification suite.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+TEMPLATE_CLASS = '''package com.example.examplemod.gametest;
+
+import com.example.generated.GeneratedGameTestLogic;
+import net.minecraft.core.BlockPos;
+import net.minecraft.gametest.framework.GameTest;
+import net.minecraft.gametest.framework.GameTestHelper;
+import net.neoforged.neoforge.gametest.GameTestPrefix;
+
+@GameTestPrefix("examplemod")
+public final class ForgeBenchGameTest {{
+
+    /**
+     * Task: {task_id}
+     * Structure template: forgebench:{structure}
+     * The LLM-generated logic is invoked through the stable seam below so that the
+     * harness itself never needs modification per-task.
+     */
+    @GameTest(template = "{structure}", timeoutTicks = {timeout})
+    public static void forgebench(GameTestHelper helper) {{
+        try {{
+            boolean ok = GeneratedGameTestLogic.run(helper);
+            if (ok) {{
+                helper.succeed();
+            }} else {{
+                helper.fail("forgebench: GeneratedGameTestLogic.run returned false");
+            }}
+        }} catch (Throwable t) {{
+            helper.fail("forgebench: exception during gametest: " + t);
+        }}
+    }}
+
+    private ForgeBenchGameTest() {{}}
+}}
+'''
+
+LOGIC_CLASS = '''package com.example.generated;
+
+import net.minecraft.gametest.framework.GameTestHelper;
+
+/**
+ * Seam class that hosts the LLM-generated logic for GameTest-required tasks.
+ * The reference answer (golden_reference) replaces the body of run(...).
+ */
+public final class GeneratedGameTestLogic {{
+
+    private GeneratedGameTestLogic() {{}}
+
+    public static boolean run(GameTestHelper helper) {{
+        // === FORGEBENCH GENERATED CODE START ===
+{code}
+        // === FORGEBENCH GENERATED CODE END ===
+        return true;
+    }}
+}}
+'''
+
+
+def generate(task: dict, code: str, out_dir: Path, structure: str = "forgebench:empty3x3x3",
+             timeout: int = 100) -> dict:
+    out_dir.mkdir(parents=True, exist_ok=True)
+    test_java = out_dir / "ForgeBenchGameTest.java"
+    logic_java = out_dir / "GeneratedGameTestLogic.java"
+
+    test_java.write_text(TEMPLATE_CLASS.format(
+        task_id=task.get("task_id", "unknown"),
+        structure=structure,
+        timeout=timeout,
+    ), encoding="utf-8")
+
+    # Hoist any import statements out of the answer and drop package declarations:
+    # the seam class already has its own package, and imports are illegal inside a body.
+    imports = re.findall(r"^\s*import\s+[\w.*]+\s*;", code, re.M)
+    body = re.sub(r"^\s*package\s+[\w.]+\s*;\s*$", "", code, flags=re.M)
+    body = re.sub(r"^\s*import\s+[\w.*]+\s*;\s*$", "", body, flags=re.M)
+    indented = "\n".join("        " + ln if ln.strip() else ln
+                         for ln in ("\n".join(imports) + "\n" + body).splitlines())
+    logic_java.write_text(LOGIC_CLASS.format(code=indented), encoding="utf-8")
+
+    return {"test_class": str(test_java), "logic_class": str(logic_java),
+            "hoisted_imports": len(imports)}
+
+
+def run_gametest(workdir: Path, gradle_command: str, timeout: int) -> dict:
+    args = gradle_command.split() + ["--console=plain", "--no-daemon"]
+    t0 = time.time()
+    try:
+        proc = subprocess.run(args, cwd=str(workdir),
+                              stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+                              text=True, timeout=timeout, shell=False)
+        code, log = proc.returncode, proc.stdout
+    except subprocess.TimeoutExpired as e:
+        code, log = 124, (e.stdout or "") + f"\n! gametest timed out after {timeout}s"
+    passed = code == 0 and "BUILD SUCCESSFUL" in log and not re.search(r"failed.*gametest", log, re.I)
+    return {"passed": passed, "exit_code": code,
+            "seconds": round(time.time() - t0, 2),
+            "log_tail": "\n".join(log.strip().splitlines()[-50:])}
+
+
+def main() -> int:
+    p = argparse.ArgumentParser(description="ForgeBench GameTest runner")
+    p.add_argument("--task-file", required=True)
+    p.add_argument("--code-file", required=True, help=".java file with the logic / reference")
+    p.add_argument("--workdir", required=True, help="prepared MDK workspace")
+    p.add_argument("--gradle-command", default="./gradlew runGameTestServer",
+                   help="Gradle task that boots the GameTest server (template-dependent)")
+    p.add_argument("--timeout", type=int, default=1200)
+    p.add_argument("--structure", default="forgebench:empty3x3x3")
+    p.add_argument("--generate-only", action="store_true",
+                   help="only generate the test classes (offline verification)")
+    p.add_argument("--out", default=None)
+    args = p.parse_args()
+
+    task = json.loads(Path(args.task_file).read_text(encoding="utf-8"))
+    code = Path(args.code_file).read_text(encoding="utf-8")
+
+    if not task.get("eval_criteria", {}).get("gametest_required", False):
+        result = {"task_id": task.get("task_id"), "skipped": "gametest_required=false"}
+    else:
+        test_src = Path(args.workdir) / "src" / "test" / "java" / "com" / "example" / "examplemod" / "gametest"
+        paths = generate(task, code, test_src, structure=args.structure)
+        if args.generate_only:
+            result = {"task_id": task.get("task_id"), "generated": paths, "ran": False}
+        else:
+            run = run_gametest(Path(args.workdir), args.gradle_command, args.timeout)
+            result = {"task_id": task.get("task_id"), "generated": paths, "ran": True, **run}
+
+    payload = json.dumps(result, ensure_ascii=False, indent=2)
+    if args.out:
+        Path(args.out).write_text(payload, encoding="utf-8")
+    print(payload)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

harness/judge_prompt.txt

@@ -0,0 +1,79 @@
+FORGEBENCH LLM-AS-A-JUDGE — SYSTEM PROMPT (debug & build modules)
+==================================================================
+You are ForgeBench-Judge, a strict senior Minecraft modding engineer specializing in
+NeoForge 1.21.1, Forge 1.20.1, FML loading internals, Mixin, and Gradle builds.
+You grade answers to ForgeBench debug (crash-log analysis) and build (Gradle/TOML
+configuration) tasks. Grade ONLY on technical correctness. Never reward fluency.
+
+INPUTS YOU RECEIVE
+------------------
+- TASK: the instruction given to the evaluated model.
+- CONTEXT: the raw crash log / debug log snippet, or the legacy build file.
+- ANSWER: the evaluated model's output (for debug tasks: a JSON object with keys
+  root_cause, fix_explanation, code_patch; for build tasks: the generated config).
+
+SCORING RUBRIC (0-10, then map to verdict)
+------------------------------------------
+10-9  Root cause is exactly right AND the fix is complete, safe, and idiomatic for
+      NeoForge 1.21.1. FML terminology is used precisely. No factual errors.
+8-7   Root cause correct; fix correct but misses a secondary detail (e.g. refmap note,
+      side='BOTH' omission) that would not change the outcome.
+6-5   Root cause partially correct (right subsystem, wrong mechanism) or fix works but
+      contains one technical inaccuracy.
+4-3   Wrong subsystem or generic advice; fix would not resolve the crash.
+2-1   Factually wrong (misidentifies the failing class/loader phase, wrong API names).
+0     Refusal, empty, or entirely hallucinated content.
+
+MANDATORY TERMINOLOGY CHECKS (reward precise use, penalize vagueness)
+---------------------------------------------------------------------
+* Distinguish: mod construction (CONSTRUCT phase) vs registry events vs FMLCommonSetupEvent
+  vs first world load. "Registry Object not present" answers MUST reference the parallel
+  mod-loading/DeferredHolder lifecycle, not "try again later".
+* Mixin failures: name the exact mechanism (descriptor mismatch, refmap missing, target
+  class side mismatch, LocalCapture strictness) - "your mixin is broken" scores <= 3.
+* Dedicated-server crashes: answers MUST mention dist (DEDICATED_SERVER vs CLIENT) and the
+  class-loading consequence (client-only class on server), not "your server is broken".
+* NoSuchMethodError / NoClassDefFoundError: answers MUST explain binary incompatibility
+  against a specific class member (name the changed signature or namespace), never
+  "corrupted jar".
+* Dependency errors: quote the versionRange algebra from the log; fix must update
+  neoforge.mods.toml `type`/`versionRange` (NOT `mandatory`) for 1.21.1.
+
+HARD PENALTIES (cap at 3)
+-------------------------
+* Suggests "update your Java" for anything EXCEPT class-version errors
+  (UnsupportedClassVersionError / class file 65 vs 61) -> cap 2.
+* Suggests deleting crash-reports or reinstalling Java/system -> cap 1.
+* Claims a Forge-namespace class (net.minecraftforge.*) exists on NeoForge 1.21.1 -> cap 1.
+* Fabric APIs (net.fabricmc.*) attributed to NeoForge -> cap 1.
+* Invents log lines that are not in CONTEXT to support the diagnosis -> cap 2.
+* Proposes mocking Level/Player (Mockito) or raw `javac` compilation as a fix -> cap 0.
+
+CODE_PATCH RULES (debug tasks)
+------------------------------
+- code_patch must be REAL NeoForge 1.21.1 Java/TOML/KTS, not pseudocode.
+- Imports shown must use net.neoforged.* / net.minecraft.* (Mojmap) only.
+- Patches that "fix" by removing safety checks or swallowing exceptions cap at 4.
+
+BUILD TASK RULES
+----------------
+- Gradle 8.x Kotlin DSL syntax must parse: quotes, parentheses, task names.
+- 1.20.1 ForgeGradle idioms (`minecraft { mappings ... }`, `reobfJar`, `mandatory =`)
+  in a 1.21.1 answer are automatic fail (score <= 2).
+- neoforge.mods.toml answers must use [[dependencies.<modid>]] tables with
+  type/versionRange/ordering/side.
+
+OUTPUT FORMAT
+-------------
+Return ONLY valid JSON:
+{
+  "score": <0-10>,
+  "verdict": "pass" | "borderline" | "fail",   // pass >= 8, borderline 5-7, fail < 5
+  "root_cause_ok": true | false,
+  "fix_ok": true | false,
+  "terminology_ok": true | false,
+  "penalties_applied": ["..."],
+  "notes": "2-4 sentences, cite the exact log line / API that drove the decision"
+}
+
+Do not include any text outside the JSON.

harness/requirements.txt

@@ -0,0 +1,4 @@
+javalang>=0.13.0
+# optional: tree-sitter based parsing (ast_eval falls back to javalang if absent)
+# tree-sitter>=0.21
+# tree-sitter-java>=0.21

harness/run_benchmark.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+ForgeBench driver: run sandbox compile check + AST analysis (and collect judge scores)
+over an answers.jsonl file.
+
+answers.jsonl rows:
+  {"task_id": "...", "answer": "<generated java or json answer>"}
+
+Usage:
+  python3 run_benchmark.py --data forgebench_full.jsonl --answers answers.jsonl \
+      [--workdir build_ws] [--out report.json] [--skip-compile] [--dry-run]
+
+For each answer:
+  * module in {api, mixin, migration} with must_compile=true -> sandbox_runner (Gradle)
+    + ast_eval static gate
+  * module debug -> judge_prompt.txt contract (scores must be provided via --scores
+    JSON {task_id: {"score": n, "verdict": ...}}), static JSON-shape check runs here
+  * module build -> static required-token + forbidden check (fast, no Gradle)
+  * gametest_required -> gametest_runner (only when --run-gametests)
+
+Aggregate: per-module Pass@1, mean score, failure table.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+
+
+def load_jsonl(path: Path) -> list[dict]:
+    return [json.loads(l) for l in path.read_text(encoding="utf-8").splitlines() if l.strip()]
+
+
+def run_ast(task: dict, answer: str, workdir: Path) -> dict:
+    tf, cf = workdir / "task.json", workdir / "answer.java"
+    tf.write_text(json.dumps(task, ensure_ascii=False), encoding="utf-8")
+    cf.write_text(answer, encoding="utf-8")
+    proc = subprocess.run([sys.executable, str(HERE / "ast_eval.py"),
+                           "--code", str(cf), "--task", str(tf)],
+                          capture_output=True, text=True)
+    try:
+        return json.loads(proc.stdout)
+    except json.JSONDecodeError:
+        return {"passed": False, "score": 0.0, "error": proc.stderr[-500:]}
+
+
+def run_sandbox(task: dict, answer: str, workdir: Path, dry: bool) -> dict:
+    tf, cf = workdir / "task.json", workdir / "answer.java"
+    tf.write_text(json.dumps(task, ensure_ascii=False), encoding="utf-8")
+    cf.write_text(answer, encoding="utf-8")
+    cmd = [sys.executable, str(HERE / "sandbox_runner.py"),
+           "--task-file", str(tf), "--code-file", str(cf),
+           "--workdir", str(workdir / "ws")]
+    if dry:
+        cmd.append("--dry-run")
+    proc = subprocess.run(cmd, capture_output=True, text=True)
+    try:
+        return json.loads(proc.stdout)
+    except json.JSONDecodeError:
+        return {"passed": False, "error": proc.stderr[-500:]}
+
+
+def main() -> int:
+    p = argparse.ArgumentParser()
+    p.add_argument("--data", required=True)
+    p.add_argument("--answers", required=True)
+    p.add_argument("--out", default=None)
+    p.add_argument("--workdir", default=None)
+    p.add_argument("--dry-run", action="store_true")
+    p.add_argument("--skip-compile", action="store_true",
+                   help="AST/static gate only (no Gradle) - offline mode")
+    p.add_argument("--scores", default=None,
+                   help="JSON {task_id: {score, verdict,...}} for debug tasks")
+    args = p.parse_args()
+
+    tasks = {t["task_id"]: t for t in load_jsonl(Path(args.data))}
+    answers = load_jsonl(Path(args.answers))
+    scores = json.loads(Path(args.scores).read_text()) if args.scores else {}
+    workdir = Path(args.workdir or tempfile.mkdtemp(prefix="forgebench_run_"))
+    workdir.mkdir(parents=True, exist_ok=True)
+
+    rows, by_module = [], {}
+    for row in answers:
+        task = tasks.get(row["task_id"])
+        if task is None:
+            continue
+        answer = row["answer"]
+        module = task["module"]
+
+        rec = {"task_id": task["task_id"], "module": module}
+        if module == "debug":
+            try:
+                obj = json.loads(answer)
+                ok = all(k in obj for k in ("root_cause", "fix_explanation", "code_patch"))
+                rec.update(static_json_ok=ok, **scores.get(task["task_id"], {}))
+            except json.JSONDecodeError:
+                rec.update(static_json_ok=False, verdict="fail")
+        else:
+            ast = run_ast(task, answer, workdir)
+            rec["ast_passed"] = ast.get("passed")
+            rec["ast_score"] = ast.get("score")
+            if task["eval_criteria"]["must_compile"] and not args.skip_compile and not args.dry_run:
+                sb = run_sandbox(task, answer, workdir, dry=False)
+                rec["compile_pass@1"] = sb.get("passed")
+            elif args.dry_run:
+                sb = run_sandbox(task, answer, workdir, dry=True)
+                rec["compile_pass@1"] = None
+                rec["sandbox_dry_run"] = True
+            final = scores.get(task["task_id"], {}).get("verdict")
+            rec["verdict"] = final or ("pass" if rec.get("compile_pass@1") is not False
+                                       and rec.get("ast_passed") else "fail")
+        rows.append(rec)
+        by_module.setdefault(module, []).append(rec)
+
+    summary = {}
+    for module, recs in by_module.items():
+        n = len(recs)
+        summary[module] = {
+            "n": n,
+            "pass@1": round(sum(1 for r in recs if r.get("compile_pass@1") is True) / n, 3)
+                      if any("compile_pass@1" in r for r in recs) else None,
+            "ast_pass_rate": round(sum(1 for r in recs if r.get("ast_passed")) / n, 3),
+            "judge_pass_rate": round(sum(1 for r in recs if r.get("verdict") == "pass") / n, 3),
+        }
+
+    report = {"summary": summary, "rows": rows}
+    payload = json.dumps(report, ensure_ascii=False, indent=2)
+    if args.out:
+        Path(args.out).write_text(payload, encoding="utf-8")
+    print(payload)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

harness/sandbox_runner.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+ForgeBench sandbox runner.
+
+Takes an LLM-generated .java file, injects it into a pre-configured NeoForge 1.21.1
+MDK template, runs `./gradlew build -x test` in a subprocess, and parses the Gradle
+output to determine Pass@1 (compilation success).
+
+Rules honoured (ForgeBench spec):
+  * raw `javac` is NEVER used - compilation happens inside the real MDK Gradle build,
+    so the full NeoForge 1.21.1 + vanilla Mojmap classpath is available;
+  * no Minecraft server is launched;
+  * no Mockito / no mocking of Level or Player classes.
+
+Exit codes of this runner (independent of the build):
+  0 - evaluation executed (result JSON printed to stdout / --out file)
+  2 - usage / input error
+  3 - internal runner error
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import time
+from pathlib import Path
+
+DEFAULT_TEMPLATE = os.environ.get("FORGEBENCH_TEMPLATE", "/opt/forgebench/template")
+if not Path(DEFAULT_TEMPLATE).exists():
+    # local / source-tree fallback: harness/ sits next to template/ in the repo
+    _sibling = Path(__file__).resolve().parent.parent / "template"
+    if _sibling.exists():
+        DEFAULT_TEMPLATE = str(_sibling)
+DEFAULT_GRADLE = os.environ.get("FORGEBENCH_GRADLE", "./gradlew")
+
+GRADLE_SUCCESS_RE = re.compile(r"^BUILD SUCCESSFUL\b", re.MULTILINE)
+GRADLE_FAIL_RE = re.compile(r"^BUILD FAILED\b", re.MULTILINE)
+
+# Task id -> package under which the answer is injected (kept stable so package
+# declarations inside the LLM answer can be normalized).
+INJECT_PACKAGE = "com.example.generated"
+
+
+class SandboxResult(dict):
+    """JSON-serialisable evaluation result."""
+
+
+def _normalize_package(java_source: str, package: str) -> str:
+    """Rewrite the package declaration of the generated file to the injection package.
+
+    Keeps imports intact. If the source has no package declaration, one is added.
+    """
+    src = java_source
+    if re.search(r"^\s*package\s+[\w.]+\s*;", src, re.MULTILINE):
+        src = re.sub(r"^\s*package\s+[\w.]+\s*;", f"package {package};", src, count=1)
+    else:
+        src = f"package {package};\n\n" + src
+    return src
+
+
+def _class_name(java_source: str, fallback: str) -> str:
+    m = re.search(r"\b(?:class|interface|enum|record)\s+(\w+)", java_source)
+    return m.group(1) if m else fallback
+
+
+def prepare_workspace(template_dir: Path, java_source: str, task: dict,
+                      workdir: Path) -> Path:
+    """Copy the MDK template and inject the answer + task metadata."""
+    if workdir.exists():
+        shutil.rmtree(workdir)
+    shutil.copytree(template_dir, workdir)
+
+    src_root = workdir / "src" / "main" / "java"
+    pkg_dir = src_root.joinpath(*INJECT_PACKAGE.split("."))
+    pkg_dir.mkdir(parents=True, exist_ok=True)
+
+    normalized = _normalize_package(java_source, INJECT_PACKAGE)
+    class_name = _class_name(normalized, "GeneratedAnswer")
+    (pkg_dir / f"{class_name}.java").write_text(normalized, encoding="utf-8")
+
+    meta = {
+        "task_id": task.get("task_id"),
+        "module": task.get("module"),
+        "must_compile": task.get("eval_criteria", {}).get("must_compile", False),
+    }
+    (workdir / "forgebench_task.json").write_text(
+        json.dumps(meta, ensure_ascii=False, indent=2), encoding="utf-8")
+    return workdir
+
+
+def run_gradle_build(workdir: Path, timeout: int, gradle_cmd: str,
+                     extra_args: list[str] | None = None) -> tuple[int, str, float]:
+    """Execute the headless Gradle build. Returns (exit_code, combined_log, seconds)."""
+    args = gradle_cmd.split() + ["build", "-x", "test", "--console=plain", "--no-daemon"]
+    if extra_args:
+        args += list(extra_args)
+    t0 = time.time()
+    try:
+        proc = subprocess.run(
+            args, cwd=str(workdir),
+            stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+            text=True, timeout=timeout, shell=False,
+        )
+        code, log = proc.returncode, proc.stdout
+    except subprocess.TimeoutExpired as e:
+        code = 124
+        log = (e.stdout or "") + f"\n! FORGEBENCH: build timed out after {timeout}s"
+    except FileNotFoundError:
+        code = 127
+        log = f"! FORGEBENCH: gradle command not found: {gradle_cmd}"
+    return code, log, time.time() - t0
+
+
+def evaluate(task_file: Path, code_file: Path, template_dir: Path, workdir: Path,
+             timeout: int, gradle_cmd: str, dry_run: bool) -> SandboxResult:
+    task = json.loads(task_file.read_text(encoding="utf-8"))
+    java_source = code_file.read_text(encoding="utf-8")
+    must_compile = task.get("eval_criteria", {}).get("must_compile", False)
+
+    result = SandboxResult(
+        task_id=task.get("task_id"),
+        module=task.get("module"),
+        must_compile=must_compile,
+        passed=False,
+        exit_code=None,
+        seconds=None,
+        log_tail="",
+    )
+
+    if not must_compile:
+        # Non-compile tasks (debug/build/diagnosis) are graded by ast_eval/judge,
+        # not by the sandbox.
+        result["skipped"] = "task does not require compilation (must_compile=false)"
+        return result
+
+    prepare_workspace(template_dir, java_source, task, workdir)
+
+    if dry_run:
+        result["dry_run"] = True
+        result["gradle_command"] = f"{gradle_cmd} build -x test --console=plain --no-daemon"
+        result["injected_file"] = str(
+            workdir / "src" / "main" / "java" / Path(*INJECT_PACKAGE.split(".")))
+        return result
+
+    code, log, seconds = run_gradle_build(workdir, timeout, gradle_cmd)
+    success = code == 0 and GRADLE_SUCCESS_RE.search(log) and not GRADLE_FAIL_RE.search(log)
+
+    result["passed"] = bool(success)          # Pass@1
+    result["exit_code"] = code
+    result["seconds"] = round(seconds, 2)
+    result["log_tail"] = "\n".join(log.strip().splitlines()[-60:])
+    return result
+
+
+def main() -> int:
+    p = argparse.ArgumentParser(description="ForgeBench sandbox runner (compile check)")
+    p.add_argument("--task-file", required=True, help="JSONL line of the task as JSON file")
+    p.add_argument("--code-file", required=True, help="LLM-generated .java file")
+    p.add_argument("--workdir", default=None, help="workspace dir (default: mkdtemp)")
+    p.add_argument("--template", default=DEFAULT_TEMPLATE, help="MDK template dir")
+    p.add_argument("--timeout", type=int, default=900, help="gradle timeout seconds")
+    p.add_argument("--gradle", default=DEFAULT_GRADLE, help="gradle command")
+    p.add_argument("--out", default=None, help="write result JSON here")
+    p.add_argument("--dry-run", action="store_true",
+                   help="prepare workspace + show command, do not build")
+    args = p.parse_args()
+
+    try:
+        workdir = Path(args.workdir) if args.workdir else Path(tempfile.mkdtemp(prefix="forgebench_"))
+        result = evaluate(Path(args.task_file), Path(args.code_file), Path(args.template),
+                          workdir, args.timeout, args.gradle, args.dry_run)
+    except Exception as e:  # runner error, never a "pass"
+        result = SandboxResult(error=str(e), passed=False, exit_code=3)
+        print(json.dumps(result, ensure_ascii=False, indent=2), file=sys.stderr)
+        return 3
+
+    payload = json.dumps(result, ensure_ascii=False, indent=2)
+    if args.out:
+        Path(args.out).write_text(payload, encoding="utf-8")
+    print(payload)
+
+    # keep workspace for debugging when explicitly requested
+    if not args.workdir and not args.dry_run:
+        shutil.rmtree(workdir, ignore_errors=True)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

template/build.gradle.kts

@@ -0,0 +1,41 @@
+plugins {
+    id("java-library")
+    id("net.neoforged.gradle.userdev") version "7.0.145"
+}
+
+group = "com.example"
+version = "1.0.0"
+
+java {
+    toolchain {
+        languageVersion = JavaLanguageVersion.of(21)
+    }
+}
+
+base {
+    archivesName = "examplemod"
+}
+
+repositories {
+    mavenCentral()
+    maven("https://maven.neoforged.net/releases")
+}
+
+dependencies {
+    implementation("net.neoforged:neoforge:21.1.77")
+}
+
+runs {
+    configureEach {
+        modSource(project.sourceSets.main)
+    }
+    client {
+        client()
+        gameDirectory = file("run-client")
+    }
+    server {
+        server()
+        gameDirectory = file("run-server")
+        programArgument("--nogui")
+    }
+}

template/gradle.properties

@@ -0,0 +1,3 @@
+org.gradle.jvmargs=-Xmx3G -XX:+UseParallelGC
+org.gradle.parallel=true
+org.gradle.caching=true

template/settings.gradle.kts

@@ -0,0 +1,8 @@
+pluginManagement {
+    repositories {
+        gradlePluginPortal()
+        maven("https://maven.neoforged.net/releases")
+    }
+}
+
+rootProject.name = "examplemod"

template/src/main/resources/META-INF/neoforge.mods.toml

@@ -0,0 +1,26 @@
+modLoader = "javafml"
+loaderVersion = "[4,)"
+license = "MIT"
+
+[[mods]]
+modId = "examplemod"
+version = "1.0.0"
+displayName = "ForgeBench Sandbox Mod"
+description = "Minimal NeoForge 1.21.1 MDK template used by the ForgeBench sandbox."
+
+[[mixins]]
+config = "examplemod.mixins.json"
+
+[[dependencies.neoforge]]
+modId = "neoforge"
+type = "required"
+versionRange = "[21.1.0,)"
+ordering = "NONE"
+side = "BOTH"
+
+[[dependencies.minecraft]]
+modId = "minecraft"
+type = "required"
+versionRange = "[1.21.1]"
+ordering = "NONE"
+side = "BOTH"

template/src/main/resources/examplemod.mixins.json

@@ -0,0 +1,13 @@
+{
+  "required": true,
+  "minVersion": "0.8.5",
+  "package": "com.example.examplemod.mixin",
+  "compatibilityLevel": "JAVA_21",
+  "refmap": "examplemod.refmap.json",
+  "injectors": {
+    "defaultRequire": 1
+  },
+  "mixins": [],
+  "client": [],
+  "server": []
+}

verification_result.json

@@ -0,0 +1,101 @@
+{
+  "passed": 19,
+  "failed": 0,
+  "results": [
+    {
+      "check": "V1 strict schema (field set/order/types)",
+      "status": "PASS",
+      "detail": "100 rows"
+    },
+    {
+      "check": "V2 unique task_ids",
+      "status": "PASS",
+      "detail": ""
+    },
+    {
+      "check": "V2 id pattern ^[A-Z]+_\\d{3}$",
+      "status": "PASS",
+      "detail": ""
+    },
+    {
+      "check": "V2 20 tasks per module",
+      "status": "PASS",
+      "detail": "{'api': 20, 'mixin': 20, 'migration': 20, 'debug': 20, 'build': 20}"
+    },
+    {
+      "check": "V2 module order api<mixin<migration<debug<build",
+      "status": "PASS",
+      "detail": ""
+    },
+    {
+      "check": "V3 required_annotations present in goldens",
+      "status": "PASS",
+      "detail": ""
+    },
+    {
+      "check": "V4 forbidden_apis absent from goldens (comments stripped)",
+      "status": "PASS",
+      "detail": ""
+    },
+    {
+      "check": "V5 debug goldens = valid JSON (root_cause/fix_explanation/code_patch)",
+      "status": "PASS",
+      "detail": ""
+    },
+    {
+      "check": "V6 Java goldens parse (javalang)",
+      "status": "PASS",
+      "detail": " | parsed=57 non-java=23"
+    },
+    {
+      "check": "V7 all golden imports on NeoForge 1.21.1 allowlist",
+      "status": "PASS",
+      "detail": ""
+    },
+    {
+      "check": "V8 contamination screen vs SFT corpus",
+      "status": "PASS",
+      "detail": "0 hits; shards=6; corpus_chars=4998017"
+    },
+    {
+      "check": "V9a sandbox --dry-run prepares workspace",
+      "status": "PASS",
+      "detail": "\": null,\n  \"log_tail\": \"\",\n  \"dry_run\": true,\n  \"gradle_command\": \"./gradlew build -x test --console=plain --no-daemon\",\n  \"injected_file\": \"/tmp/tmpth5s1_d_/ws/src/main/java/com/example/generated\"\n}\n"
+    },
+    {
+      "check": "V9b ast_eval passes its own golden (API_001)",
+      "status": "PASS",
+      "detail": "[]"
+    },
+    {
+      "check": "V9c ast_eval flags Forge namespace + 1.16 text API",
+      "status": "PASS",
+      "detail": "forbidden API present: net.minecraftforge forbidden API present: net.minecraft.util.text import not on NeoForge 1.21.1 classpath: net.minecraftforge.registries.DeferredItem (Forge namespace does not exist on NeoForge (use net.neoforged))"
+    },
+    {
+      "check": "V9d gametest template generation (offline)",
+      "status": "PASS",
+      "detail": "\",\n  \"generated\": {\n    \"test_class\": \"/tmp/tmpth5s1_d_/gt_ws/src/test/java/com/example/examplemod/gametest/ForgeBenchGameTest.java\",\n    \"logic_class\": \"/tmp/tmpth5s1_d_/gt_ws/src/test/java/com/example/examplemod/gametest/GeneratedGameTestLogic.java\",\n    \"hoisted_imports\": 0\n  },\n  \"ran\": false\n}\n"
+    },
+    {
+      "check": "V9e run_benchmark driver (dry-run)",
+      "status": "PASS",
+      "detail": ""
+    },
+    {
+      "check": "V10 Dockerfile references existing build context",
+      "status": "PASS",
+      "detail": ""
+    },
+    {
+      "check": "V10 judge prompt rubric sections",
+      "status": "PASS",
+      "detail": ""
+    },
+    {
+      "check": "V10 no javac/Mockito execution in harness",
+      "status": "PASS",
+      "detail": "doc mentions of the ban are fine; executable use is not"
+    }
+  ]
+}