generator.py

from __future__ import annotations

import argparse
import hashlib
import json
import random
from pathlib import Path

FAMILIES = [
    "wrong_target",
    "navigation_loop",
    "missing_prerequisite",
    "premature_interaction",
    "resource_exhaustion",
    "low_health_attack",
    "locked_door",
    "missing_tool",
    "failed_extraction",
    "wrong_sequence",
]

def canon(x):
    return json.dumps(x, sort_keys=True, separators=(",", ":"), ensure_ascii=False)

def sha(x):
    return hashlib.sha256(canon(x).encode()).hexdigest()

def split_for(i):
    b = i % 10
    return "train" if b < 8 else "validation" if b == 8 else "test"

def build(family, r):
    if family == "wrong_target":
        state = {"target":"objective_A","selected":"objective_B","distance":r.randint(1,5)}
        failure = "interact_wrong_target"
        failed = dict(state)
        failed["progress"] = False
        recovery = "select_objective_A"
        recovered = dict(state)
        recovered["selected"] = "objective_A"
        return state,failure,failed,recovery,recovered

    if family == "navigation_loop":
        state = {"x":2,"y":2,"visited_same_cell":r.randint(3,8),"goal_x":5,"goal_y":2}
        failure = "move_west"
        failed = dict(state)
        failed["x"] = 1
        recovery = "move_east"
        recovered = dict(state)
        recovered["x"] = 3
        recovered["visited_same_cell"] = 0
        return state,failure,failed,recovery,recovered

    if family == "missing_prerequisite":
        state = {"has_key":False,"door_locked":True,"key_visible":True}
        failure = "open_door"
        failed = dict(state)
        recovery = "pickup_key"
        recovered = dict(state)
        recovered["has_key"] = True
        recovered["key_visible"] = False
        return state,failure,failed,recovery,recovered

    if family == "premature_interaction":
        state = {"distance_to_terminal":r.randint(2,5),"terminal_ready":True}
        failure = "interact"
        failed = dict(state)
        recovery = "move_closer"
        recovered = dict(state)
        recovered["distance_to_terminal"] -= 1
        return state,failure,failed,recovery,recovered

    if family == "resource_exhaustion":
        state = {"ammo":0,"enemy_present":True,"reserve_ammo":r.randint(1,5)}
        failure = "attack"
        failed = dict(state)
        recovery = "reload"
        recovered = dict(state)
        recovered["ammo"] = recovered["reserve_ammo"]
        recovered["reserve_ammo"] = 0
        return state,failure,failed,recovery,recovered

    if family == "low_health_attack":
        hp = r.randint(5,30)
        state = {"hp":hp,"medkits":1,"enemy_present":True}
        failure = "attack"
        failed = dict(state)
        failed["hp"] = max(0,hp-15)
        recovery = "heal"
        recovered = dict(state)
        recovered["hp"] = min(100,hp+35)
        recovered["medkits"] = 0
        return state,failure,failed,recovery,recovered

    if family == "locked_door":
        state = {"door_locked":True,"has_key":True}
        failure = "move_through_door"
        failed = dict(state)
        recovery = "unlock_door"
        recovered = dict(state)
        recovered["door_locked"] = False
        return state,failure,failed,recovery,recovered

    if family == "missing_tool":
        state = {"has_tool":False,"machine_damaged":True,"tool_visible":True}
        failure = "repair"
        failed = dict(state)
        recovery = "pickup_tool"
        recovered = dict(state)
        recovered["has_tool"] = True
        recovered["tool_visible"] = False
        return state,failure,failed,recovery,recovered

    if family == "failed_extraction":
        required = r.randint(3,6)
        collected = required-1
        state = {"required":required,"collected":collected,"at_extraction":True}
        failure = "extract"
        failed = dict(state)
        recovery = "collect_remaining_item"
        recovered = dict(state)
        recovered["collected"] = required
        return state,failure,failed,recovery,recovered

    if family == "wrong_sequence":
        stage = r.randint(0,2)
        state = {
            "stage":stage,
            "token":stage>=1,
            "terminal":stage>=2,
            "vault":False
        }

        failed = dict(state)

        if stage == 0:
            failure = "open_vault"
            recovery = "pickup_token"
            recovered = dict(state)
            recovered["token"] = True
            recovered["stage"] = 1

        elif stage == 1:
            failure = "open_vault"
            recovery = "unlock_terminal"
            recovered = dict(state)
            recovered["terminal"] = True
            recovered["stage"] = 2

        else:
            # At stage 2 opening the vault is correct.
            # Use premature extraction as the actual failure.
            failure = "extract"
            recovery = "open_vault"
            recovered = dict(state)
            recovered["vault"] = True
            recovered["stage"] = 3

        return state,failure,failed,recovery,recovered

    raise ValueError(family)

def make_record(i, seed):
    family = FAMILIES[i % len(FAMILIES)]
    local_seed = seed + i*12007
    r = random.Random(local_seed)

    state, failure_action, failed_state, recovery_action, recovered_state = build(family,r)

    body = {
        "seed":local_seed,
        "family":family,
        "split":split_for(i),
        "state_before_failure":state,
        "failed_action":failure_action,
        "state_after_failure":failed_state,
        "failure_detected":True,
        "recovery_action":recovery_action,
        "state_after_recovery":recovered_state,
        "labels":{
            "failed_action_correct":False,
            "recovery_action_correct":True
        },
        "provenance":{
            "synthetic":True,
            "copied_records":0,
            "copyrighted_gameplay":False,
            "contains_pii":False,
            "llm_generated_ground_truth":False,
            "oracle":"deterministic recovery state machine"
        }
    }

    rid=sha(body)[:32]
    w=dict(body)
    w["id"]=rid

    return {
        "id":rid,
        **body,
        "fingerprint_sha256":sha(w)
    }

def main():
    ap=argparse.ArgumentParser()
    ap.add_argument("--output",type=Path,required=True)
    ap.add_argument("--records",type=int,default=100000)
    ap.add_argument("--seed",type=int,default=20260930)
    a=ap.parse_args()

    a.output.parent.mkdir(parents=True,exist_ok=True)

    h=hashlib.sha256()

    with a.output.open("w",encoding="utf-8",newline="\n") as f:
        for i in range(a.records):
            row=make_record(i,a.seed)
            line=json.dumps(row,ensure_ascii=False,sort_keys=True)+"\n"
            f.write(line)
            h.update(line.encode())

    print(json.dumps({
        "status":"GENERATED",
        "records":a.records,
        "families":len(FAMILIES),
        "sha256":h.hexdigest()
    }))

if __name__=="__main__":
    main()