| 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: |
| |
| |
| 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() |
|
|
