Add files using upload-large-folder tool

cube1/README.md

@@ -0,0 +1,59 @@
+# SimVerse / cube1
+
+Cube reconstruction (six-face map): given a blank cross net of a cube and a top-down image of the bottom-face imprints stamped along a roll path, reconstruct the patternId and rotation of every outer face.
+
+- **Records:** 502 levels
+- **Modality:** blank cross net image + top-down path-imprint image
+- **Output:** `{"faces": {"TOP": {patternId, rotation}, "BOTTOM": ..., ..., "RIGHT": ...}}`
+
+## Loading
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("Sayaka123/simverse2026", "cube1")
+example = ds["test"][0]
+
+system_text = example["prompt"]["system"]
+user_text   = example["prompt"]["user"]
+
+# Image paths (relative to this config's root)
+blank_net    = example["image_paths"]["blank_net_image"]       # e.g. "images/blank_nets/open.png"
+path_seq     = example["image_paths"]["path_sequence_image"]   # e.g. "images/path_sequences/C001_path_sequence.png"
+
+gold_faces = example["answer"]["faces"]                        # {TOP: {...}, BOTTOM: {...}, ...}
+```
+
+The image paths in `image_paths` are already relative to this config's root, so you can resolve them as-is.
+
+## Schema
+
+| Field | Type | Description |
+|---|---|---|
+| `sample_id` | string | Level id, e.g. `"C001"` |
+| `__sample_id__` | string | Same as `sample_id` |
+| `prompt.system` / `prompt.user` | string | Exact prompt text |
+| `net_layout` | string | Net layout name (e.g. `"standard_cross"`) |
+| `roll_sequence` | list[string] | Sequence of rolls, each `"N"`/`"S"`/`"E"`/`"W"` |
+| `observed_path_faces` | list of face observations | Per-step bottom-face imprints visible in the path image |
+| `image_paths.blank_net_image` | string | Blank cross net image path |
+| `image_paths.path_sequence_image` | string | Top-down path imprint image path |
+| `metadata` | dict | `difficulty`, `move_count`, `tier`, `tier_label`, etc. |
+| `net_faces` | list of face dicts | Net cells with their initial patterns and rotations |
+| `bottom_faces` | list of stamped face dicts | The imprints with their `(x, y)` positions |
+| `slot_sequence` / `required_slots` / `required_count` | various | Which faces the engine ranks for partial-credit scoring |
+| `true_solution_faces` | dict | Ground-truth full face map (used for scoring) |
+| `answer.faces` | dict | Reference `(patternId, rotation)` per face |
+| `legacy_answer` | dict | Pre-v1 bare face map (kept for back-compat) |
+
+## Companion file
+
+`catalog.json` mirrors the original `levels/index.json` — a fat JSON containing every level's full data inline. The frontend demo at <https://github.com/Sayaka123/simverse2026> reads this file. It is regenerable from `data/*.json` via `python cube1/regenerate_catalog.py` in the repo.
+
+## "?" sentinel rule
+
+Each face's `patternId` is either a string from the per-level allowed-patternId list, or the literal `"?"` meaning "cannot be uniquely determined". When `patternId == "?"`, `rotation` is forced to `0`. The validator scores `?` against `?` as correct; `?` against a concrete pattern (or vice versa) as wrong.
+
+## License
+
+MIT — see [LICENSE](../LICENSE) at the repo root.

cube1/data/C001.json

@@ -0,0 +1,215 @@
+{
+  "sample_id": "C001",
+  "text_description": "Task: reconstruct the six outer faces of the cube from the blank cross net image and the path-view observation image.\nThe net uses the fixed face names TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\nIf a face cannot be uniquely determined, output patternId='?' and rotation=0.\nRoll sequence: N -> E -> S\nThe puzzle images already show the roll path and the observed path-face states.",
+  "net_layout": "standard_cross",
+  "roll_sequence": [
+    "N",
+    "E",
+    "S"
+  ],
+  "observed_path_faces": [
+    {
+      "patternId": "5",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "smile",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "triangle",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "image_paths": {
+    "blank_net_image": "images/blank_nets/open.png",
+    "path_sequence_image": "images/path_sequences/C001_path_sequence.png"
+  },
+  "metadata": {
+    "level_id": 1,
+    "name": "Reconstruct 001",
+    "difficulty": 1,
+    "move_count": 3,
+    "tier": 1,
+    "source_level_path": "levels/reconstruct/generated-001.json",
+    "tier_label": "Difficulty 1"
+  },
+  "description": "3-move reconstruct puzzle",
+  "net_faces": [
+    {
+      "patternId": "4",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": false
+    },
+    {
+      "patternId": "G",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": false
+    },
+    {
+      "patternId": "smile",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": false
+    },
+    {
+      "patternId": "5",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": false
+    },
+    {
+      "patternId": "4",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": false
+    },
+    {
+      "patternId": "triangle",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": false
+    }
+  ],
+  "net_patterns": [
+    "4",
+    "G",
+    "smile",
+    "5",
+    "4",
+    "triangle"
+  ],
+  "start_x": 1,
+  "start_y": 2,
+  "grid_width": 4,
+  "grid_height": 4,
+  "true_solution_faces": {
+    "TOP": {
+      "patternId": "4",
+      "rotation": 90
+    },
+    "BOTTOM": {
+      "patternId": "triangle",
+      "rotation": 90
+    },
+    "FRONT": {
+      "patternId": "G",
+      "rotation": 90
+    },
+    "BACK": {
+      "patternId": "5",
+      "rotation": 0
+    },
+    "LEFT": {
+      "patternId": "4",
+      "rotation": 270
+    },
+    "RIGHT": {
+      "patternId": "smile",
+      "rotation": 180
+    }
+  },
+  "bottom_faces": [
+    {
+      "patternId": "triangle",
+      "rotation": 90,
+      "x": 1,
+      "y": 2
+    },
+    {
+      "patternId": "5",
+      "rotation": 180,
+      "x": 1,
+      "y": 1
+    },
+    {
+      "patternId": "smile",
+      "rotation": 0,
+      "x": 2,
+      "y": 1
+    },
+    {
+      "patternId": "triangle",
+      "rotation": 180,
+      "x": 2,
+      "y": 2
+    }
+  ],
+  "slot_sequence": [
+    "BACK",
+    "RIGHT",
+    "BOTTOM"
+  ],
+  "required_slots": [
+    "BACK",
+    "RIGHT",
+    "BOTTOM"
+  ],
+  "required_count": 3,
+  "answer": {
+    "faces": {
+      "TOP": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BOTTOM": {
+        "patternId": "triangle",
+        "rotation": 90
+      },
+      "FRONT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BACK": {
+        "patternId": "5",
+        "rotation": 180
+      },
+      "LEFT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "RIGHT": {
+        "patternId": "smile",
+        "rotation": 90
+      }
+    }
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BOTTOM": {
+      "patternId": "triangle",
+      "rotation": 90
+    },
+    "FRONT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BACK": {
+      "patternId": "5",
+      "rotation": 180
+    },
+    "LEFT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "RIGHT": {
+      "patternId": "smile",
+      "rotation": 90
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-reconstruction puzzle solver. Given a blank cross net of a cube and a top-down path image showing the bottom-face imprints stamped onto the road as the cube rolls, you reconstruct the patternId and rotation of every outer face.\n\nYou will receive: (a) one blank cross-net image (the unfolded outer surface, with the six face slots TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT), (b) one path-sequence image (top-down view of the cube's roll path with the bottom-face imprints visible), and (c) a structured text body listing the roll sequence, observed path faces, and the allowed patternId values for this task.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: <one-line JSON>\n\nThe JSON object must follow the faces schema described in section 8 of the user prompt. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf a face cannot be uniquely determined from the inputs, output patternId=\"?\" and rotation=0 for that face. Always emit a complete FINAL_JSON line covering all six face keys; never refuse, never return prose only.",
+    "user": "## 1. TASK\nReconstruct the patternId and absolute rotation of every face of a cube from a roll-trace image.\nThe puzzle is solved when every output face matches the cube's true outer-surface configuration; faces that cannot be uniquely determined are reported with patternId=\"?\" and rotation=0.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. Faces are named by their orientation in the world frame: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- Cross net: the unfolded outer surface laid flat in a cross shape. Each cell of the cross is one face of the cube.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell.\n- Path imprint / bottom-face stamp: as the cube rolls, the face touching the ground stamps that face's pattern (rotated according to the roll) onto the grid cell it lay on. The path-sequence image shows these imprints from a top-down view.\n- patternId: the symbolic name of a face's printed pattern (e.g. \"smile\", \"triangle\", \"5\"). The literal string \"?\" denotes \"cannot be uniquely determined\".\n- rotation: an integer in {0, 90, 180, 270} measured clockwise from the pattern's upright orientation when the face is viewed from outside the cube.\n\n## 3. VISUAL LEGEND\n- Blank cross net image: shows the six face slots arranged in a cross with TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT labelled.\n- Path sequence image: a top-down grid showing the cube's start cell, the roll path, and the bottom-face imprints stamped along the path. Each imprint is the bottom-face pattern at the moment the cube rested on that cell, viewed from above (NOT viewed from underneath looking up).\n- Coordinate system: top-down, with grid cell positions used to locate imprints; rotations are expressed in degrees clockwise.\n\n## 4. INPUT FIELDS\n- sample_id: C001\n- net_layout: standard_cross\n- difficulty: 1\n- move_count: 3\n- roll_sequence (N=up, S=down, W=left, E=right): N -> E -> S\n- observed_path_faces (one entry per stamped imprint, in roll order):\n- step 1: patternId=5, rotation=180, flipVertical=true\n- step 2: patternId=smile, rotation=0, flipVertical=true\n- step 3: patternId=triangle, rotation=180, flipVertical=true\n- allowed patternId values for this task: 5, smile, triangle, ?\n\n## 5. ACTION VOCABULARY\nA complete answer is one map from face name to its `(patternId, rotation)` pair:\n- face: one of {\"TOP\", \"BOTTOM\", \"FRONT\", \"BACK\", \"LEFT\", \"RIGHT\"}.\n- patternId: a string drawn from the allowed list above, or the literal \"?\" sentinel.\n- rotation: integer in {0, 90, 180, 270}.\nA face is \"uniquely determined\" iff the inputs (roll sequence, observed imprints, blank net) constrain its pattern and rotation to exactly one possibility.\n\n## 6. CONSTRAINTS\n- The output must list all six face keys exactly: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT (no extras, no omissions).\n- Each `patternId` must come from the allowed list, or be the literal \"?\".\n- When `patternId == \"?\"`, `rotation` must be 0.\n- Each rotation must be one of 0, 90, 180, 270.\n- Do not invent new patternIds. The model is scored only against the listed allowed values plus \"?\".\n\n## 7. SOLVING ADVICE\n- Trace the roll one step at a time: which face becomes the bottom after each roll? The path imprint at that step records that face.\n- When a stamped imprint is rotated relative to the original pattern's upright orientation, infer the cumulative rotation that the rolling chain has applied to that face.\n- Faces that never touch the ground may not appear in the imprints; if no other constraint pins them, they are \"?\".\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"faces\":{\"TOP\":{\"patternId\":<string>,\"rotation\":<int>},\"BOTTOM\":{...},\"FRONT\":{...},\"BACK\":{...},\"LEFT\":{...},\"RIGHT\":{...}}}\n- faces: object with exactly six keys TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- patternId: string from the allowed list, or \"?\".\n- rotation: integer in {0, 90, 180, 270}; 0 when patternId is \"?\".\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it."
+  }
+}

cube1/data/C002.json

@@ -0,0 +1,200 @@
+{
+  "sample_id": "C002",
+  "text_description": "Task: reconstruct the six outer faces of the cube from the blank cross net image and the path-view observation image.\nThe net uses the fixed face names TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\nIf a face cannot be uniquely determined, output patternId='?' and rotation=0.\nRoll sequence: S -> E\nThe puzzle images already show the roll path and the observed path-face states.",
+  "net_layout": "standard_cross",
+  "roll_sequence": [
+    "S",
+    "E"
+  ],
+  "observed_path_faces": [
+    {
+      "patternId": "diamond",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "M",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "image_paths": {
+    "blank_net_image": "images/blank_nets/open.png",
+    "path_sequence_image": "images/path_sequences/C002_path_sequence.png"
+  },
+  "metadata": {
+    "level_id": 2,
+    "name": "Reconstruct 002",
+    "difficulty": 1,
+    "move_count": 2,
+    "tier": 1,
+    "source_level_path": "levels/reconstruct/generated-002.json",
+    "tier_label": "Difficulty 1"
+  },
+  "description": "2-move reconstruct puzzle",
+  "net_faces": [
+    {
+      "patternId": "2",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": false
+    },
+    {
+      "patternId": "diamond",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": false
+    },
+    {
+      "patternId": "M",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": false
+    },
+    {
+      "patternId": "6",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": false
+    },
+    {
+      "patternId": "3",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": false
+    },
+    {
+      "patternId": "U",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": false
+    }
+  ],
+  "net_patterns": [
+    "2",
+    "diamond",
+    "M",
+    "6",
+    "3",
+    "U"
+  ],
+  "start_x": 1,
+  "start_y": 1,
+  "grid_width": 4,
+  "grid_height": 4,
+  "true_solution_faces": {
+    "TOP": {
+      "patternId": "2",
+      "rotation": 90
+    },
+    "BOTTOM": {
+      "patternId": "U",
+      "rotation": 270
+    },
+    "FRONT": {
+      "patternId": "diamond",
+      "rotation": 180
+    },
+    "BACK": {
+      "patternId": "6",
+      "rotation": 0
+    },
+    "LEFT": {
+      "patternId": "3",
+      "rotation": 270
+    },
+    "RIGHT": {
+      "patternId": "M",
+      "rotation": 270
+    }
+  },
+  "bottom_faces": [
+    {
+      "patternId": "U",
+      "rotation": 270,
+      "x": 1,
+      "y": 1
+    },
+    {
+      "patternId": "diamond",
+      "rotation": 180,
+      "x": 1,
+      "y": 2
+    },
+    {
+      "patternId": "M",
+      "rotation": 270,
+      "x": 2,
+      "y": 2
+    }
+  ],
+  "slot_sequence": [
+    "FRONT",
+    "RIGHT"
+  ],
+  "required_slots": [
+    "FRONT",
+    "RIGHT"
+  ],
+  "required_count": 2,
+  "answer": {
+    "faces": {
+      "TOP": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "FRONT": {
+        "patternId": "diamond",
+        "rotation": 180
+      },
+      "BACK": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "LEFT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "RIGHT": {
+        "patternId": "M",
+        "rotation": 180
+      }
+    }
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "FRONT": {
+      "patternId": "diamond",
+      "rotation": 180
+    },
+    "BACK": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "LEFT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "RIGHT": {
+      "patternId": "M",
+      "rotation": 180
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-reconstruction puzzle solver. Given a blank cross net of a cube and a top-down path image showing the bottom-face imprints stamped onto the road as the cube rolls, you reconstruct the patternId and rotation of every outer face.\n\nYou will receive: (a) one blank cross-net image (the unfolded outer surface, with the six face slots TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT), (b) one path-sequence image (top-down view of the cube's roll path with the bottom-face imprints visible), and (c) a structured text body listing the roll sequence, observed path faces, and the allowed patternId values for this task.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: <one-line JSON>\n\nThe JSON object must follow the faces schema described in section 8 of the user prompt. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf a face cannot be uniquely determined from the inputs, output patternId=\"?\" and rotation=0 for that face. Always emit a complete FINAL_JSON line covering all six face keys; never refuse, never return prose only.",
+    "user": "## 1. TASK\nReconstruct the patternId and absolute rotation of every face of a cube from a roll-trace image.\nThe puzzle is solved when every output face matches the cube's true outer-surface configuration; faces that cannot be uniquely determined are reported with patternId=\"?\" and rotation=0.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. Faces are named by their orientation in the world frame: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- Cross net: the unfolded outer surface laid flat in a cross shape. Each cell of the cross is one face of the cube.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell.\n- Path imprint / bottom-face stamp: as the cube rolls, the face touching the ground stamps that face's pattern (rotated according to the roll) onto the grid cell it lay on. The path-sequence image shows these imprints from a top-down view.\n- patternId: the symbolic name of a face's printed pattern (e.g. \"smile\", \"triangle\", \"5\"). The literal string \"?\" denotes \"cannot be uniquely determined\".\n- rotation: an integer in {0, 90, 180, 270} measured clockwise from the pattern's upright orientation when the face is viewed from outside the cube.\n\n## 3. VISUAL LEGEND\n- Blank cross net image: shows the six face slots arranged in a cross with TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT labelled.\n- Path sequence image: a top-down grid showing the cube's start cell, the roll path, and the bottom-face imprints stamped along the path. Each imprint is the bottom-face pattern at the moment the cube rested on that cell, viewed from above (NOT viewed from underneath looking up).\n- Coordinate system: top-down, with grid cell positions used to locate imprints; rotations are expressed in degrees clockwise.\n\n## 4. INPUT FIELDS\n- sample_id: C002\n- net_layout: standard_cross\n- difficulty: 1\n- move_count: 2\n- roll_sequence (N=up, S=down, W=left, E=right): S -> E\n- observed_path_faces (one entry per stamped imprint, in roll order):\n- step 1: patternId=diamond, rotation=180, flipVertical=true\n- step 2: patternId=M, rotation=270, flipVertical=true\n- allowed patternId values for this task: diamond, M, ?\n\n## 5. ACTION VOCABULARY\nA complete answer is one map from face name to its `(patternId, rotation)` pair:\n- face: one of {\"TOP\", \"BOTTOM\", \"FRONT\", \"BACK\", \"LEFT\", \"RIGHT\"}.\n- patternId: a string drawn from the allowed list above, or the literal \"?\" sentinel.\n- rotation: integer in {0, 90, 180, 270}.\nA face is \"uniquely determined\" iff the inputs (roll sequence, observed imprints, blank net) constrain its pattern and rotation to exactly one possibility.\n\n## 6. CONSTRAINTS\n- The output must list all six face keys exactly: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT (no extras, no omissions).\n- Each `patternId` must come from the allowed list, or be the literal \"?\".\n- When `patternId == \"?\"`, `rotation` must be 0.\n- Each rotation must be one of 0, 90, 180, 270.\n- Do not invent new patternIds. The model is scored only against the listed allowed values plus \"?\".\n\n## 7. SOLVING ADVICE\n- Trace the roll one step at a time: which face becomes the bottom after each roll? The path imprint at that step records that face.\n- When a stamped imprint is rotated relative to the original pattern's upright orientation, infer the cumulative rotation that the rolling chain has applied to that face.\n- Faces that never touch the ground may not appear in the imprints; if no other constraint pins them, they are \"?\".\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"faces\":{\"TOP\":{\"patternId\":<string>,\"rotation\":<int>},\"BOTTOM\":{...},\"FRONT\":{...},\"BACK\":{...},\"LEFT\":{...},\"RIGHT\":{...}}}\n- faces: object with exactly six keys TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- patternId: string from the allowed list, or \"?\".\n- rotation: integer in {0, 90, 180, 270}; 0 when patternId is \"?\".\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it."
+  }
+}

cube2/README.md

@@ -0,0 +1,55 @@
+# SimVerse / cube2
+
+Cube goal-roll (top-face directions): given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output a sequence of `N`/`S`/`E`/`W` rolls so the cube's top face matches the target.
+
+- **Records:** 502 levels
+- **Modality:** initial cross-net image + target top-face image
+- **Output:** `{"directions": ["N", "E", "S", ...]}` (open-ended; multiple sequences may be valid)
+
+## Loading
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("Sayaka123/simverse2026", "cube2")
+example = ds["test"][0]
+
+system_text = example["prompt"]["system"]
+user_text   = example["prompt"]["user"]
+
+initial_img  = example["images_relative_to_config"]["initialNetImage"]      # e.g. "images/C001/initial_net.png"
+target_img   = example["images_relative_to_config"]["targetTopFaceImage"]   # e.g. "images/C001/target_top_face.png"
+
+reference_directions = example["answer"]["directions"]   # one known-valid sequence, NOT the only valid one
+```
+
+## Schema
+
+| Field | Type | Description |
+|---|---|---|
+| `code` | string | Level id, e.g. `"C001"` |
+| `__sample_id__` | string | Same as `code` |
+| `prompt.system` / `prompt.user` | string | Exact prompt text |
+| `taskType` | string | Always `"roll_to_target_top_face"` |
+| `initialCube.net.cells` | list | The visible cross-net cells with `(faceKey, row, col, patternId, rotation)` |
+| `initialCube.solutionFaces` | dict | Visible faces' `(patternId, rotation)` mapping |
+| `targetTopFace` | dict | Target's `patternId, rotation` |
+| `rollSequence` | list[string] | The original roll sequence used to generate this puzzle |
+| `observedPathFaces` | list | Per-step bottom-face imprints (mostly informational) |
+| `metadata` | dict | `difficulty`, `tier`, `moveCount`, etc. |
+| `imagePaths` | dict | `initialNetImage`, `targetTopFaceImage` (relative to data dir) |
+| `images_relative_to_config` | dict | Same paths rewritten to be relative to this config's root |
+| `answer.directions` | list[string] | One known-valid direction sequence; the validator accepts any sequence whose simulated top-face matches the target |
+| `legacy_answer` | dict | Pre-v1 face-map answer from the original cube reconstruction task variant (kept for back-compat) |
+
+## Open-ended scoring
+
+cube2 is **open-ended**: the reference `answer.directions` is just *one* known-valid sequence. The benchmark's validator runs the engine on the model's directions and checks whether the resulting top face matches `targetTopFace`. Multiple distinct sequences can earn full credit.
+
+## Companion file
+
+`catalog.json` mirrors `data2/index.json` — a fat JSON the frontend demo uses for the level grid.
+
+## License
+
+MIT — see [LICENSE](../LICENSE) at the repo root.

cube2/catalog.json

@@ -0,0 +1,512 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "seed": 20260425,
+  "totalTasks": 502,
+  "taskCodes": [
+    "C001",
+    "C002",
+    "C003",
+    "C004",
+    "C005",
+    "C006",
+    "C007",
+    "C008",
+    "C009",
+    "C010",
+    "C011",
+    "C012",
+    "C013",
+    "C014",
+    "C015",
+    "C016",
+    "C017",
+    "C018",
+    "C019",
+    "C020",
+    "C021",
+    "C022",
+    "C023",
+    "C024",
+    "C025",
+    "C026",
+    "C027",
+    "C028",
+    "C029",
+    "C030",
+    "C031",
+    "C032",
+    "C033",
+    "C034",
+    "C035",
+    "C036",
+    "C037",
+    "C038",
+    "C039",
+    "C040",
+    "C041",
+    "C042",
+    "C043",
+    "C044",
+    "C045",
+    "C046",
+    "C047",
+    "C048",
+    "C049",
+    "C050",
+    "C051",
+    "C052",
+    "C053",
+    "C054",
+    "C055",
+    "C056",
+    "C057",
+    "C058",
+    "C059",
+    "C060",
+    "C061",
+    "C062",
+    "C063",
+    "C064",
+    "C065",
+    "C066",
+    "C067",
+    "C068",
+    "C069",
+    "C070",
+    "C071",
+    "C072",
+    "C073",
+    "C074",
+    "C075",
+    "C076",
+    "C077",
+    "C078",
+    "C079",
+    "C080",
+    "C081",
+    "C082",
+    "C083",
+    "C084",
+    "C085",
+    "C086",
+    "C087",
+    "C088",
+    "C089",
+    "C090",
+    "C091",
+    "C092",
+    "C093",
+    "C094",
+    "C095",
+    "C096",
+    "C097",
+    "C098",
+    "C099",
+    "C100",
+    "C101",
+    "C102",
+    "C103",
+    "C104",
+    "C105",
+    "C106",
+    "C107",
+    "C108",
+    "C109",
+    "C110",
+    "C111",
+    "C112",
+    "C113",
+    "C114",
+    "C115",
+    "C116",
+    "C117",
+    "C118",
+    "C119",
+    "C120",
+    "C121",
+    "C122",
+    "C123",
+    "C124",
+    "C125",
+    "C126",
+    "C127",
+    "C128",
+    "C129",
+    "C130",
+    "C131",
+    "C132",
+    "C133",
+    "C134",
+    "C135",
+    "C136",
+    "C137",
+    "C138",
+    "C139",
+    "C140",
+    "C141",
+    "C142",
+    "C143",
+    "C144",
+    "C145",
+    "C146",
+    "C147",
+    "C148",
+    "C149",
+    "C150",
+    "C151",
+    "C152",
+    "C153",
+    "C154",
+    "C155",
+    "C156",
+    "C157",
+    "C158",
+    "C159",
+    "C160",
+    "C161",
+    "C162",
+    "C163",
+    "C164",
+    "C165",
+    "C166",
+    "C167",
+    "C168",
+    "C169",
+    "C170",
+    "C171",
+    "C172",
+    "C173",
+    "C174",
+    "C175",
+    "C176",
+    "C177",
+    "C178",
+    "C179",
+    "C180",
+    "C181",
+    "C182",
+    "C183",
+    "C184",
+    "C185",
+    "C186",
+    "C187",
+    "C188",
+    "C189",
+    "C190",
+    "C191",
+    "C192",
+    "C193",
+    "C194",
+    "C195",
+    "C196",
+    "C197",
+    "C198",
+    "C199",
+    "C200",
+    "C201",
+    "C202",
+    "C203",
+    "C204",
+    "C205",
+    "C206",
+    "C207",
+    "C208",
+    "C209",
+    "C210",
+    "C211",
+    "C212",
+    "C213",
+    "C214",
+    "C215",
+    "C216",
+    "C217",
+    "C218",
+    "C219",
+    "C220",
+    "C221",
+    "C222",
+    "C223",
+    "C224",
+    "C225",
+    "C226",
+    "C227",
+    "C228",
+    "C229",
+    "C230",
+    "C231",
+    "C232",
+    "C233",
+    "C234",
+    "C235",
+    "C236",
+    "C237",
+    "C238",
+    "C239",
+    "C240",
+    "C241",
+    "C242",
+    "C243",
+    "C244",
+    "C245",
+    "C246",
+    "C247",
+    "C248",
+    "C249",
+    "C250",
+    "C251",
+    "C252",
+    "C253",
+    "C254",
+    "C255",
+    "C256",
+    "C257",
+    "C258",
+    "C259",
+    "C260",
+    "C261",
+    "C262",
+    "C263",
+    "C264",
+    "C265",
+    "C266",
+    "C267",
+    "C268",
+    "C269",
+    "C270",
+    "C271",
+    "C272",
+    "C273",
+    "C274",
+    "C275",
+    "C276",
+    "C277",
+    "C278",
+    "C279",
+    "C280",
+    "C281",
+    "C282",
+    "C283",
+    "C284",
+    "C285",
+    "C286",
+    "C287",
+    "C288",
+    "C289",
+    "C290",
+    "C291",
+    "C292",
+    "C293",
+    "C294",
+    "C295",
+    "C296",
+    "C297",
+    "C298",
+    "C299",
+    "C300",
+    "C301",
+    "C302",
+    "C303",
+    "C304",
+    "C305",
+    "C306",
+    "C307",
+    "C308",
+    "C309",
+    "C310",
+    "C311",
+    "C312",
+    "C313",
+    "C314",
+    "C315",
+    "C316",
+    "C317",
+    "C318",
+    "C319",
+    "C320",
+    "C321",
+    "C322",
+    "C323",
+    "C324",
+    "C325",
+    "C326",
+    "C327",
+    "C328",
+    "C329",
+    "C330",
+    "C331",
+    "C332",
+    "C333",
+    "C334",
+    "C335",
+    "C336",
+    "C337",
+    "C338",
+    "C339",
+    "C340",
+    "C341",
+    "C342",
+    "C343",
+    "C344",
+    "C345",
+    "C346",
+    "C347",
+    "C348",
+    "C349",
+    "C350",
+    "C351",
+    "C352",
+    "C353",
+    "C354",
+    "C355",
+    "C356",
+    "C357",
+    "C358",
+    "C359",
+    "C360",
+    "C361",
+    "C362",
+    "C363",
+    "C364",
+    "C365",
+    "C366",
+    "C367",
+    "C368",
+    "C369",
+    "C370",
+    "C371",
+    "C372",
+    "C373",
+    "C374",
+    "C375",
+    "C376",
+    "C377",
+    "C378",
+    "C379",
+    "C380",
+    "C381",
+    "C382",
+    "C383",
+    "C384",
+    "C385",
+    "C386",
+    "C387",
+    "C388",
+    "C389",
+    "C390",
+    "C391",
+    "C392",
+    "C393",
+    "C394",
+    "C395",
+    "C396",
+    "C397",
+    "C398",
+    "C399",
+    "C400",
+    "C401",
+    "C402",
+    "C403",
+    "C404",
+    "C405",
+    "C406",
+    "C407",
+    "C408",
+    "C409",
+    "C410",
+    "C411",
+    "C412",
+    "C413",
+    "C414",
+    "C415",
+    "C416",
+    "C417",
+    "C418",
+    "C419",
+    "C420",
+    "C421",
+    "C422",
+    "C423",
+    "C424",
+    "C425",
+    "C426",
+    "C427",
+    "C428",
+    "C429",
+    "C430",
+    "C431",
+    "C432",
+    "C433",
+    "C434",
+    "C435",
+    "C436",
+    "C437",
+    "C438",
+    "C439",
+    "C440",
+    "C441",
+    "C442",
+    "C443",
+    "C444",
+    "C445",
+    "C446",
+    "C447",
+    "C448",
+    "C449",
+    "C450",
+    "C451",
+    "C452",
+    "C453",
+    "C454",
+    "C455",
+    "C456",
+    "C457",
+    "C458",
+    "C459",
+    "C460",
+    "C461",
+    "C462",
+    "C463",
+    "C464",
+    "C465",
+    "C466",
+    "C467",
+    "C468",
+    "C469",
+    "C470",
+    "C471",
+    "C472",
+    "C473",
+    "C474",
+    "C475",
+    "C476",
+    "C477",
+    "C478",
+    "C479",
+    "C480",
+    "C481",
+    "C482",
+    "C483",
+    "C484",
+    "C485",
+    "C486",
+    "C487",
+    "C488",
+    "C489",
+    "C490",
+    "C491",
+    "C492",
+    "C493",
+    "C494",
+    "C495",
+    "C496",
+    "C497",
+    "C498",
+    "C499",
+    "C500",
+    "C501",
+    "C502"
+  ],
+  "taskDir": "data2/task_jsons",
+  "manifestPath": "data2/manifests/goal_roll_tasks.jsonl",
+  "imageDir": "images"
+}

cutrope/README.md

@@ -0,0 +1,72 @@
+# SimVerse / cutrope
+
+Cut the Rope video-to-command: watch a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and output a deterministic command script that, replayed from the same initial state, wins the level.
+
+- **Records:** 272 levels
+- **Modality:** short MP4 gameplay video (~3s each, 1920×1080)
+- **Output:** `{"commands": "...", "reason": "...", "confidence": 0..1}` (open-ended; many winning scripts may be valid)
+
+## Loading
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("Sayaka123/simverse2026", "cutrope")
+example = ds["test"][0]
+
+system_text = example["prompt"]["system"]
+user_text   = example["prompt"]["user"]
+
+video_path = example["video_relative_to_config"]["path"]   # e.g. "videos/rope-000.mp4"
+mime_type  = example["video_relative_to_config"]["mime_type"]
+
+gold_commands = example["answer"]["commands"]              # one known-3-star reference script
+```
+
+## Schema
+
+| Field | Type | Description |
+|---|---|---|
+| `level_id` | string | Level id, e.g. `"rope-000"` |
+| `__sample_id__` | string | Same as `level_id` |
+| `prompt.system` / `prompt.user` | string | Exact prompt text |
+| `video.path` | string | Original (project-relative) video path |
+| `video.mime_type` | string | Always `"video/mp4"` for shipped variants |
+| `video.duration_seconds` | int | Video length |
+| `video.fps` | int | Frame rate |
+| `prompt_level.canvas_width / canvas_height` | int | Game canvas dimensions |
+| `prompt_level.object_counts` | dict | Per-object-type counts: `target`, `candy`, `star`, `bubble`, `pump`, `gravity_button`, `grab_or_rope_anchor`, `left_candy`, `right_candy` |
+| `prompt_level.two_parts` | bool | Whether the level starts with split-candy halves |
+| `level_json_without_solution` | dict | The full level definition stripped of the gold solution; useful if you want to recreate the simulation state without seeing the answer |
+| `video_relative_to_config` | dict | `path` / `mime_type` rewritten to be relative to this config's root |
+| `answer.commands` | string | Reference winning command script (one command per line) |
+| `answer.reason` | string | Short explanation of the reference solution |
+| `answer.confidence` | float | Always `1.0` for the shipped reference |
+| `legacy_answer` | string | Same script under the pre-v1 field name `reference_solution` (kept for back-compat) |
+
+## Command DSL
+
+Commands accept these actions, optionally guarded by `when <CONDITION>`:
+
+```
+cut_rope N | cut_rope N,M,K       # cut one or more ropes
+pop_bubble N | pop_bubble_left | pop_bubble_right
+activate_pump N [times C] [every S] [until <CONDITION>]
+move_grab N X | move_grab N X Y
+kick_rope N
+toggle_gravity
+```
+
+Conditions include `candy_x`/`candy_y` thresholds, `candy_near X,Y,R [for S]`, `candy_still for S`, `rope_cut N`, `no_rope`, `candy_in_bubble`, plus split-candy variants `left_candy_*` / `right_candy_*`. Boolean combinators `and` / `or` and parentheses are supported. `wait_frames` is **not** allowed in this benchmark version — use condition-based waits.
+
+See the system + user prompt embedded in each record for the full vocabulary.
+
+## Companion files
+
+- `data/<id>.json` — per-record JSON (mirror of the JSONL records as individual files).
+- `source/<id>.json` — the original frontend-friendly level files (with `textCommandSolution`, gameplay metadata for the in-browser engine).
+- `videos/<id>.mp4` — the gameplay clips.
+
+## License
+
+MIT — see [LICENSE](../LICENSE) at the repo root.

lamp/README.md

@@ -0,0 +1,78 @@
+# SimVerse / lamp
+
+Mechanical-arm lamp targeting: choose one absolute angle for every joint of a fixed-base multi-segment arm so that the bulb at the tip illuminates a target point without any rod intersecting an obstacle.
+
+- **Records:** 610 levels
+- **Modality:** single rendered image (workspace with arm, target, obstacles)
+- **Output:** `{"actions": [{"joint": <int>, "angle": <int>}, ...]}`
+
+## Loading
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("Sayaka123/simverse2026", "lamp")
+example = ds["test"][0]
+
+# Prompt text (already in the record — no construction needed)
+system_text = example["prompt"]["system"]
+user_text   = example["prompt"]["user"]
+
+# Image
+image_path = example["images_relative_to_config"]["image"]   # e.g. "images/lamp-000.png"
+
+# Gold answer
+gold_actions = example["answer"]["actions"]                  # list of {joint, angle}
+
+# Other useful task fields
+print(example["arm"]["segmentCount"])       # number of joints
+print(example["arm"]["angleStep"])           # allowed angle granularity
+print(example["arm"]["angleMin"], example["arm"]["angleMax"])
+```
+
+## Schema
+
+| Field | Type | Description |
+|---|---|---|
+| `id` | string | Sample id, e.g. `"lamp-000"` |
+| `__sample_id__` | string | Same as `id`, exposed for HF loader convenience |
+| `prompt.system` | string | The exact 5-section system prompt the benchmark uses |
+| `prompt.user` | string | The exact 9-section user prompt for this level |
+| `arm.segmentCount` | int | Number of arm segments (= number of joints) |
+| `arm.segments` | list[{length}] | Lengths of each segment |
+| `arm.angleMin/Max/Step` | int | Allowed angle range and step size |
+| `target` | {x, y} | Target point coordinates |
+| `lamp.lightRadius` | float | Coverage radius of the bulb |
+| `obstacles` | list of obstacle objects | Striped wall blocks the rods must not intersect |
+| `images_relative_to_config.image` | string | Image path relative to this config's root |
+| `answer.actions` | list[{joint, angle}] | Reference solution; one known-valid joint configuration |
+| `legacy_answer` | list[int] | Pre-v1 flat-array form of the answer (kept for back-compat; see SimVerse repo migration notes) |
+
+## Solving by hand: minimal pipeline
+
+```python
+import openai
+
+def solve(example, model="gpt-5"):
+    response = openai.chat.completions.create(
+        model=model,
+        messages=[
+            {"role": "system", "content": example["prompt"]["system"]},
+            {"role": "user", "content": [
+                {"type": "text", "text": example["prompt"]["user"]},
+                {"type": "image_url",
+                 "image_url": {"url": f"file://{example['images_relative_to_config']['image']}"}},
+            ]},
+        ],
+    )
+    return response.choices[0].message.content
+
+# The reply ends with "FINAL_JSON: {...}" — extract and parse:
+import re, json
+reply = solve(example)
+final_json = json.loads(re.search(r"FINAL_JSON:\s*(\{.*\})", reply, re.DOTALL).group(1))
+```
+
+## License
+
+MIT — see [LICENSE](../LICENSE) at the repo root.

voi/README.md

@@ -0,0 +1,51 @@
+# SimVerse / voi
+
+Text-VOI spatial logic puzzle: choose how to rotate and translate base shapes onto a grid so that their XOR-overlapped union exactly reproduces a target pattern.
+
+- **Records:** 600 levels
+- **Modality:** target pattern image + one image per available base shape
+- **Output:** `{"placements": [{"shape", "angle", "vertex", "grid"}, ...]}`
+
+## Loading
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("Sayaka123/simverse2026", "voi")
+example = ds["test"][0]
+
+system_text = example["prompt"]["system"]
+user_text   = example["prompt"]["user"]
+target_img  = example["images_relative_to_config"]["target"]            # e.g. "data/voi-000/target.png"
+shape_imgs  = example["images_relative_to_config"]["shapes"]            # e.g. {"S1": "data/voi-000/shapes/S1.png", ...}
+
+gold_placements = example["answer"]["placements"]
+```
+
+## Schema
+
+| Field | Type | Description |
+|---|---|---|
+| `ID` | string | Level id, e.g. `"voi-000"` |
+| `__sample_id__` | string | Same as `ID` |
+| `prompt.system` / `prompt.user` | string | Exact prompt text |
+| `gridSize` | int | Square grid side length |
+| `inventory` | dict | `{shape_id: {V1: [x,y], V2: [x,y], ...}}` — each base shape's vertex coordinates |
+| `target` | list of polygon dicts | The goal silhouette (XOR of these polygons) |
+| `meta` | dict | `difficultyLabel`, `requiredShapeCount`, `distractorShapeCount`, `overlapAllowed` |
+| `imageAssets.target` | string | Target pattern image path (level-relative) |
+| `imageAssets.shapes` | dict | `{shape_id: image_path}` per available shape |
+| `images_relative_to_config` | dict | Same image paths but rewritten to be relative to the config root |
+| `answer.placements` | list[{shape, angle, vertex, grid}] | Reference solution |
+| `legacy_answer` | string | Pre-v1 plain-text DSL form of the answer |
+| `solutionText` | string | The DSL form of the answer (kept because the pixel engine consumes it for the reference mask) |
+
+## Output format details
+
+Each placement encodes: rotate `shape` clockwise by `angle ∈ {0,90,180,270}` around its local origin, then translate so the post-rotation `vertex` lands at grid coordinate `[gridX, gridY]`.
+
+The benchmark's pixel engine rasterizes the placements and XOR-combines them; a perfect score requires the resulting mask to equal the target pattern's mask.
+
+## License
+
+MIT — see [LICENSE](../LICENSE) at the repo root.