Add files using upload-large-folder tool

cube2/data/C050.json

@@ -0,0 +1,190 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C050",
+  "name": "Goal Roll C050",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "3",
+          "rotation": 180
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "P",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "8",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "FRONT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "RIGHT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BACK": {
+        "patternId": "3",
+        "rotation": 180
+      },
+      "LEFT": {
+        "patternId": "P",
+        "rotation": 0
+      },
+      "BOTTOM": {
+        "patternId": "8",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 0,
+    "stepNumber": 1,
+    "patternId": "3",
+    "rotation": 180
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C050/initial_net.png",
+    "targetTopFaceImage": "../images/C050/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 1,
+    "tier": 1,
+    "targetStepNumber": 1,
+    "targetRotationOffset": 180,
+    "levelId": 50,
+    "moveCount": 3,
+    "sourceLevelPath": "levels/reconstruct/generated-050.json"
+  },
+  "rollSequence": [
+    "W",
+    "E",
+    "N"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "P",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "8",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "3",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "W",
+      "E",
+      "N"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "FRONT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "RIGHT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BACK": {
+      "patternId": "3",
+      "rotation": 180
+    },
+    "LEFT": {
+      "patternId": "P",
+      "rotation": 0
+    },
+    "BOTTOM": {
+      "patternId": "8",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C050\n- task_type: roll_to_target_top_face\n- difficulty: 1\n- target_top_face: patternId=3, rotation=180\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=3, rotation=180]\n[LEFT: patternId=P, rotation=0] [TOP: patternId=?, rotation=0] [RIGHT: patternId=?, rotation=0]\n  [FRONT: patternId=?, rotation=0]\n  [BOTTOM: patternId=8, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=3, rotation=180\n- LEFT: patternId=P, rotation=0\n- TOP: patternId=?, rotation=0\n- RIGHT: patternId=?, rotation=0\n- FRONT: patternId=?, rotation=0\n- BOTTOM: patternId=8, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C051.json

@@ -0,0 +1,190 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C051",
+  "name": "Goal Roll C051",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "6",
+          "rotation": 0
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "L",
+          "rotation": 90
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "star",
+          "rotation": 270
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "6",
+        "rotation": 0
+      },
+      "FRONT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "RIGHT": {
+        "patternId": "L",
+        "rotation": 90
+      },
+      "BACK": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "LEFT": {
+        "patternId": "star",
+        "rotation": 270
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 0,
+    "stepNumber": 1,
+    "patternId": "L",
+    "rotation": 90
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C051/initial_net.png",
+    "targetTopFaceImage": "../images/C051/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 1,
+    "tier": 1,
+    "targetStepNumber": 1,
+    "targetRotationOffset": 90,
+    "levelId": 51,
+    "moveCount": 3,
+    "sourceLevelPath": "levels/reconstruct/generated-051.json"
+  },
+  "rollSequence": [
+    "W",
+    "W",
+    "W"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "star",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "6",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "L",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "W",
+      "W",
+      "W"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "6",
+      "rotation": 0
+    },
+    "FRONT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "RIGHT": {
+      "patternId": "L",
+      "rotation": 90
+    },
+    "BACK": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "LEFT": {
+      "patternId": "star",
+      "rotation": 270
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C051\n- task_type: roll_to_target_top_face\n- difficulty: 1\n- target_top_face: patternId=L, rotation=90\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=?, rotation=0]\n[LEFT: patternId=star, rotation=270] [TOP: patternId=6, rotation=0] [RIGHT: patternId=L, rotation=90]\n  [FRONT: patternId=?, rotation=0]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=?, rotation=0\n- LEFT: patternId=star, rotation=270\n- TOP: patternId=6, rotation=0\n- RIGHT: patternId=L, rotation=90\n- FRONT: patternId=?, rotation=0\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C052.json

@@ -0,0 +1,190 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C052",
+  "name": "Goal Roll C052",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "arrow_down",
+          "rotation": 90
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "P",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "FRONT": {
+        "patternId": "arrow_down",
+        "rotation": 90
+      },
+      "RIGHT": {
+        "patternId": "P",
+        "rotation": 0
+      },
+      "BACK": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "LEFT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 0,
+    "stepNumber": 1,
+    "patternId": "arrow_down",
+    "rotation": 270
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C052/initial_net.png",
+    "targetTopFaceImage": "../images/C052/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 1,
+    "tier": 1,
+    "targetStepNumber": 1,
+    "targetRotationOffset": 180,
+    "levelId": 52,
+    "moveCount": 3,
+    "sourceLevelPath": "levels/reconstruct/generated-052.json"
+  },
+  "rollSequence": [
+    "S",
+    "E",
+    "W"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "arrow_down",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "P",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "arrow_down",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "S",
+      "E",
+      "W"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "FRONT": {
+      "patternId": "arrow_down",
+      "rotation": 90
+    },
+    "RIGHT": {
+      "patternId": "P",
+      "rotation": 0
+    },
+    "BACK": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "LEFT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C052\n- task_type: roll_to_target_top_face\n- difficulty: 1\n- target_top_face: patternId=arrow_down, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=?, rotation=0]\n[LEFT: patternId=?, rotation=0] [TOP: patternId=?, rotation=0] [RIGHT: patternId=P, rotation=0]\n  [FRONT: patternId=arrow_down, rotation=90]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=?, rotation=0\n- LEFT: patternId=?, rotation=0\n- TOP: patternId=?, rotation=0\n- RIGHT: patternId=P, rotation=0\n- FRONT: patternId=arrow_down, rotation=90\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C053.json

@@ -0,0 +1,182 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C053",
+  "name": "Goal Roll C053",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "9",
+          "rotation": 0
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "heart",
+          "rotation": 270
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "9",
+        "rotation": 0
+      },
+      "FRONT": {
+        "patternId": "heart",
+        "rotation": 270
+      },
+      "RIGHT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BACK": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "LEFT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 0,
+    "stepNumber": 1,
+    "patternId": "heart",
+    "rotation": 0
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C053/initial_net.png",
+    "targetTopFaceImage": "../images/C053/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 1,
+    "tier": 1,
+    "targetStepNumber": 1,
+    "targetRotationOffset": 90,
+    "levelId": 53,
+    "moveCount": 2,
+    "sourceLevelPath": "levels/reconstruct/generated-053.json"
+  },
+  "rollSequence": [
+    "S",
+    "S"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "heart",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "9",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "S",
+      "S"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "9",
+      "rotation": 0
+    },
+    "FRONT": {
+      "patternId": "heart",
+      "rotation": 270
+    },
+    "RIGHT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BACK": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "LEFT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C053\n- task_type: roll_to_target_top_face\n- difficulty: 1\n- target_top_face: patternId=heart, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=?, rotation=0]\n[LEFT: patternId=?, rotation=0] [TOP: patternId=9, rotation=0] [RIGHT: patternId=?, rotation=0]\n  [FRONT: patternId=heart, rotation=270]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=?, rotation=0\n- LEFT: patternId=?, rotation=0\n- TOP: patternId=9, rotation=0\n- RIGHT: patternId=?, rotation=0\n- FRONT: patternId=heart, rotation=270\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C054.json

@@ -0,0 +1,190 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C054",
+  "name": "Goal Roll C054",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "M",
+          "rotation": 0
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "U",
+          "rotation": 180
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "5",
+          "rotation": 270
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "M",
+        "rotation": 0
+      },
+      "FRONT": {
+        "patternId": "U",
+        "rotation": 180
+      },
+      "RIGHT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BACK": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "LEFT": {
+        "patternId": "5",
+        "rotation": 270
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 0,
+    "stepNumber": 1,
+    "patternId": "U",
+    "rotation": 270
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C054/initial_net.png",
+    "targetTopFaceImage": "../images/C054/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 1,
+    "tier": 1,
+    "targetStepNumber": 1,
+    "targetRotationOffset": 90,
+    "levelId": 54,
+    "moveCount": 3,
+    "sourceLevelPath": "levels/reconstruct/generated-054.json"
+  },
+  "rollSequence": [
+    "S",
+    "W",
+    "S"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "U",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "5",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "M",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "S",
+      "W",
+      "S"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "M",
+      "rotation": 0
+    },
+    "FRONT": {
+      "patternId": "U",
+      "rotation": 180
+    },
+    "RIGHT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BACK": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "LEFT": {
+      "patternId": "5",
+      "rotation": 270
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C054\n- task_type: roll_to_target_top_face\n- difficulty: 1\n- target_top_face: patternId=U, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=?, rotation=0]\n[LEFT: patternId=5, rotation=270] [TOP: patternId=M, rotation=0] [RIGHT: patternId=?, rotation=0]\n  [FRONT: patternId=U, rotation=180]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=?, rotation=0\n- LEFT: patternId=5, rotation=270\n- TOP: patternId=M, rotation=0\n- RIGHT: patternId=?, rotation=0\n- FRONT: patternId=U, rotation=180\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C055.json

@@ -0,0 +1,190 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C055",
+  "name": "Goal Roll C055",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "K",
+          "rotation": 180
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "9",
+          "rotation": 90
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "9",
+          "rotation": 180
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "FRONT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "RIGHT": {
+        "patternId": "K",
+        "rotation": 180
+      },
+      "BACK": {
+        "patternId": "9",
+        "rotation": 90
+      },
+      "LEFT": {
+        "patternId": "9",
+        "rotation": 180
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 0,
+    "stepNumber": 1,
+    "patternId": "K",
+    "rotation": 0
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C055/initial_net.png",
+    "targetTopFaceImage": "../images/C055/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 1,
+    "tier": 1,
+    "targetStepNumber": 1,
+    "targetRotationOffset": 270,
+    "levelId": 55,
+    "moveCount": 3,
+    "sourceLevelPath": "levels/reconstruct/generated-055.json"
+  },
+  "rollSequence": [
+    "W",
+    "N",
+    "N"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "9",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "9",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "K",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "W",
+      "N",
+      "N"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "FRONT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "RIGHT": {
+      "patternId": "K",
+      "rotation": 180
+    },
+    "BACK": {
+      "patternId": "9",
+      "rotation": 90
+    },
+    "LEFT": {
+      "patternId": "9",
+      "rotation": 180
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C055\n- task_type: roll_to_target_top_face\n- difficulty: 1\n- target_top_face: patternId=K, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=9, rotation=90]\n[LEFT: patternId=9, rotation=180] [TOP: patternId=?, rotation=0] [RIGHT: patternId=K, rotation=180]\n  [FRONT: patternId=?, rotation=0]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=9, rotation=90\n- LEFT: patternId=9, rotation=180\n- TOP: patternId=?, rotation=0\n- RIGHT: patternId=K, rotation=180\n- FRONT: patternId=?, rotation=0\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C056.json

@@ -0,0 +1,182 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C056",
+  "name": "Goal Roll C056",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "J",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "star",
+          "rotation": 180
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "FRONT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "RIGHT": {
+        "patternId": "J",
+        "rotation": 0
+      },
+      "BACK": {
+        "patternId": "star",
+        "rotation": 180
+      },
+      "LEFT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 0,
+    "stepNumber": 1,
+    "patternId": "star",
+    "rotation": 180
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C056/initial_net.png",
+    "targetTopFaceImage": "../images/C056/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 1,
+    "tier": 1,
+    "targetStepNumber": 1,
+    "targetRotationOffset": 180,
+    "levelId": 56,
+    "moveCount": 2,
+    "sourceLevelPath": "levels/reconstruct/generated-056.json"
+  },
+  "rollSequence": [
+    "N",
+    "E"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "star",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "J",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "N",
+      "E"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "FRONT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "RIGHT": {
+      "patternId": "J",
+      "rotation": 0
+    },
+    "BACK": {
+      "patternId": "star",
+      "rotation": 180
+    },
+    "LEFT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C056\n- task_type: roll_to_target_top_face\n- difficulty: 1\n- target_top_face: patternId=star, rotation=180\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=star, rotation=180]\n[LEFT: patternId=?, rotation=0] [TOP: patternId=?, rotation=0] [RIGHT: patternId=J, rotation=0]\n  [FRONT: patternId=?, rotation=0]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=star, rotation=180\n- LEFT: patternId=?, rotation=0\n- TOP: patternId=?, rotation=0\n- RIGHT: patternId=J, rotation=0\n- FRONT: patternId=?, rotation=0\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C057.json

@@ -0,0 +1,190 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C057",
+  "name": "Goal Roll C057",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "7",
+          "rotation": 0
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "J",
+          "rotation": 270
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "R",
+          "rotation": 180
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "FRONT": {
+        "patternId": "7",
+        "rotation": 0
+      },
+      "RIGHT": {
+        "patternId": "J",
+        "rotation": 270
+      },
+      "BACK": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "LEFT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BOTTOM": {
+        "patternId": "R",
+        "rotation": 180
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 0,
+    "stepNumber": 1,
+    "patternId": "7",
+    "rotation": 180
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C057/initial_net.png",
+    "targetTopFaceImage": "../images/C057/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 1,
+    "tier": 1,
+    "targetStepNumber": 1,
+    "targetRotationOffset": 180,
+    "levelId": 57,
+    "moveCount": 3,
+    "sourceLevelPath": "levels/reconstruct/generated-057.json"
+  },
+  "rollSequence": [
+    "E",
+    "S",
+    "W"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "J",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "7",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "R",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "E",
+      "S",
+      "W"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "FRONT": {
+      "patternId": "7",
+      "rotation": 0
+    },
+    "RIGHT": {
+      "patternId": "J",
+      "rotation": 270
+    },
+    "BACK": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "LEFT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BOTTOM": {
+      "patternId": "R",
+      "rotation": 180
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C057\n- task_type: roll_to_target_top_face\n- difficulty: 1\n- target_top_face: patternId=7, rotation=180\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=?, rotation=0]\n[LEFT: patternId=?, rotation=0] [TOP: patternId=?, rotation=0] [RIGHT: patternId=J, rotation=270]\n  [FRONT: patternId=7, rotation=0]\n  [BOTTOM: patternId=R, rotation=180]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=?, rotation=0\n- LEFT: patternId=?, rotation=0\n- TOP: patternId=?, rotation=0\n- RIGHT: patternId=J, rotation=270\n- FRONT: patternId=7, rotation=0\n- BOTTOM: patternId=R, rotation=180\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C058.json

@@ -0,0 +1,190 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C058",
+  "name": "Goal Roll C058",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "J",
+          "rotation": 180
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "5",
+          "rotation": 90
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "G",
+          "rotation": 180
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "J",
+        "rotation": 180
+      },
+      "FRONT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "RIGHT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BACK": {
+        "patternId": "5",
+        "rotation": 90
+      },
+      "LEFT": {
+        "patternId": "G",
+        "rotation": 180
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 0,
+    "stepNumber": 1,
+    "patternId": "5",
+    "rotation": 90
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C058/initial_net.png",
+    "targetTopFaceImage": "../images/C058/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 1,
+    "tier": 1,
+    "targetStepNumber": 1,
+    "targetRotationOffset": 180,
+    "levelId": 58,
+    "moveCount": 3,
+    "sourceLevelPath": "levels/reconstruct/generated-058.json"
+  },
+  "rollSequence": [
+    "N",
+    "W",
+    "N"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "5",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "G",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "J",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "N",
+      "W",
+      "N"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "J",
+      "rotation": 180
+    },
+    "FRONT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "RIGHT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BACK": {
+      "patternId": "5",
+      "rotation": 90
+    },
+    "LEFT": {
+      "patternId": "G",
+      "rotation": 180
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C058\n- task_type: roll_to_target_top_face\n- difficulty: 1\n- target_top_face: patternId=5, rotation=90\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=5, rotation=90]\n[LEFT: patternId=G, rotation=180] [TOP: patternId=J, rotation=180] [RIGHT: patternId=?, rotation=0]\n  [FRONT: patternId=?, rotation=0]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=5, rotation=90\n- LEFT: patternId=G, rotation=180\n- TOP: patternId=J, rotation=180\n- RIGHT: patternId=?, rotation=0\n- FRONT: patternId=?, rotation=0\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C059.json

@@ -0,0 +1,190 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C059",
+  "name": "Goal Roll C059",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "diamond",
+          "rotation": 180
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "U",
+          "rotation": 90
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "diamond",
+        "rotation": 180
+      },
+      "FRONT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "RIGHT": {
+        "patternId": "U",
+        "rotation": 90
+      },
+      "BACK": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "LEFT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 0,
+    "stepNumber": 1,
+    "patternId": "U",
+    "rotation": 270
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C059/initial_net.png",
+    "targetTopFaceImage": "../images/C059/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 1,
+    "tier": 1,
+    "targetStepNumber": 1,
+    "targetRotationOffset": 270,
+    "levelId": 59,
+    "moveCount": 3,
+    "sourceLevelPath": "levels/reconstruct/generated-059.json"
+  },
+  "rollSequence": [
+    "E",
+    "E",
+    "W"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "U",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "diamond",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "U",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "E",
+      "E",
+      "W"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "diamond",
+      "rotation": 180
+    },
+    "FRONT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "RIGHT": {
+      "patternId": "U",
+      "rotation": 90
+    },
+    "BACK": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "LEFT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C059\n- task_type: roll_to_target_top_face\n- difficulty: 1\n- target_top_face: patternId=U, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=?, rotation=0]\n[LEFT: patternId=?, rotation=0] [TOP: patternId=diamond, rotation=180] [RIGHT: patternId=U, rotation=90]\n  [FRONT: patternId=?, rotation=0]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=?, rotation=0\n- LEFT: patternId=?, rotation=0\n- TOP: patternId=diamond, rotation=180\n- RIGHT: patternId=U, rotation=90\n- FRONT: patternId=?, rotation=0\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C060.json

@@ -0,0 +1,182 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C060",
+  "name": "Goal Roll C060",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "3",
+          "rotation": 90
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "M",
+          "rotation": 0
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "FRONT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "RIGHT": {
+        "patternId": "3",
+        "rotation": 90
+      },
+      "BACK": {
+        "patternId": "M",
+        "rotation": 0
+      },
+      "LEFT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 0,
+    "stepNumber": 1,
+    "patternId": "M",
+    "rotation": 0
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C060/initial_net.png",
+    "targetTopFaceImage": "../images/C060/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 1,
+    "tier": 1,
+    "targetStepNumber": 1,
+    "targetRotationOffset": 180,
+    "levelId": 60,
+    "moveCount": 2,
+    "sourceLevelPath": "levels/reconstruct/generated-060.json"
+  },
+  "rollSequence": [
+    "E",
+    "N"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "3",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "M",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "E",
+      "N"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "FRONT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "RIGHT": {
+      "patternId": "3",
+      "rotation": 90
+    },
+    "BACK": {
+      "patternId": "M",
+      "rotation": 0
+    },
+    "LEFT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C060\n- task_type: roll_to_target_top_face\n- difficulty: 1\n- target_top_face: patternId=M, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=M, rotation=0]\n[LEFT: patternId=?, rotation=0] [TOP: patternId=?, rotation=0] [RIGHT: patternId=3, rotation=90]\n  [FRONT: patternId=?, rotation=0]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=M, rotation=0\n- LEFT: patternId=?, rotation=0\n- TOP: patternId=?, rotation=0\n- RIGHT: patternId=3, rotation=90\n- FRONT: patternId=?, rotation=0\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C061.json

@@ -0,0 +1,182 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C061",
+  "name": "Goal Roll C061",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "Z",
+          "rotation": 0
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "D",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "Z",
+        "rotation": 0
+      },
+      "FRONT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "RIGHT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BACK": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "LEFT": {
+        "patternId": "D",
+        "rotation": 0
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 0,
+    "stepNumber": 1,
+    "patternId": "D",
+    "rotation": 270
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C061/initial_net.png",
+    "targetTopFaceImage": "../images/C061/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 1,
+    "tier": 1,
+    "targetStepNumber": 1,
+    "targetRotationOffset": 180,
+    "levelId": 61,
+    "moveCount": 2,
+    "sourceLevelPath": "levels/reconstruct/generated-061.json"
+  },
+  "rollSequence": [
+    "W",
+    "W"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "D",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "Z",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "W",
+      "W"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "Z",
+      "rotation": 0
+    },
+    "FRONT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "RIGHT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BACK": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "LEFT": {
+      "patternId": "D",
+      "rotation": 0
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C061\n- task_type: roll_to_target_top_face\n- difficulty: 1\n- target_top_face: patternId=D, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=?, rotation=0]\n[LEFT: patternId=D, rotation=0] [TOP: patternId=Z, rotation=0] [RIGHT: patternId=?, rotation=0]\n  [FRONT: patternId=?, rotation=0]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=?, rotation=0\n- LEFT: patternId=D, rotation=0\n- TOP: patternId=Z, rotation=0\n- RIGHT: patternId=?, rotation=0\n- FRONT: patternId=?, rotation=0\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C062.json

@@ -0,0 +1,182 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C062",
+  "name": "Goal Roll C062",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "L",
+          "rotation": 90
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "C",
+          "rotation": 180
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "L",
+        "rotation": 90
+      },
+      "FRONT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "RIGHT": {
+        "patternId": "C",
+        "rotation": 180
+      },
+      "BACK": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "LEFT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 0,
+    "stepNumber": 1,
+    "patternId": "C",
+    "rotation": 180
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C062/initial_net.png",
+    "targetTopFaceImage": "../images/C062/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 1,
+    "tier": 1,
+    "targetStepNumber": 1,
+    "targetRotationOffset": 90,
+    "levelId": 62,
+    "moveCount": 2,
+    "sourceLevelPath": "levels/reconstruct/generated-062.json"
+  },
+  "rollSequence": [
+    "E",
+    "E"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "C",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "L",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "E",
+      "E"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "L",
+      "rotation": 90
+    },
+    "FRONT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "RIGHT": {
+      "patternId": "C",
+      "rotation": 180
+    },
+    "BACK": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "LEFT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C062\n- task_type: roll_to_target_top_face\n- difficulty: 1\n- target_top_face: patternId=C, rotation=180\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=?, rotation=0]\n[LEFT: patternId=?, rotation=0] [TOP: patternId=L, rotation=90] [RIGHT: patternId=C, rotation=180]\n  [FRONT: patternId=?, rotation=0]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=?, rotation=0\n- LEFT: patternId=?, rotation=0\n- TOP: patternId=L, rotation=90\n- RIGHT: patternId=C, rotation=180\n- FRONT: patternId=?, rotation=0\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C063.json

@@ -0,0 +1,182 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C063",
+  "name": "Goal Roll C063",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "H",
+          "rotation": 0
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "triangle",
+          "rotation": 180
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "H",
+        "rotation": 0
+      },
+      "FRONT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "RIGHT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BACK": {
+        "patternId": "triangle",
+        "rotation": 180
+      },
+      "LEFT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 0,
+    "stepNumber": 1,
+    "patternId": "triangle",
+    "rotation": 90
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C063/initial_net.png",
+    "targetTopFaceImage": "../images/C063/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 1,
+    "tier": 1,
+    "targetStepNumber": 1,
+    "targetRotationOffset": 90,
+    "levelId": 63,
+    "moveCount": 2,
+    "sourceLevelPath": "levels/reconstruct/generated-063.json"
+  },
+  "rollSequence": [
+    "N",
+    "N"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "triangle",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "H",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "N",
+      "N"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "H",
+      "rotation": 0
+    },
+    "FRONT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "RIGHT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BACK": {
+      "patternId": "triangle",
+      "rotation": 180
+    },
+    "LEFT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C063\n- task_type: roll_to_target_top_face\n- difficulty: 1\n- target_top_face: patternId=triangle, rotation=90\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=triangle, rotation=180]\n[LEFT: patternId=?, rotation=0] [TOP: patternId=H, rotation=0] [RIGHT: patternId=?, rotation=0]\n  [FRONT: patternId=?, rotation=0]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=triangle, rotation=180\n- LEFT: patternId=?, rotation=0\n- TOP: patternId=H, rotation=0\n- RIGHT: patternId=?, rotation=0\n- FRONT: patternId=?, rotation=0\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C064.json

@@ -0,0 +1,190 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C064",
+  "name": "Goal Roll C064",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "O",
+          "rotation": 270
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "A",
+          "rotation": 270
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "W",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "O",
+        "rotation": 270
+      },
+      "FRONT": {
+        "patternId": "A",
+        "rotation": 270
+      },
+      "RIGHT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BACK": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "LEFT": {
+        "patternId": "W",
+        "rotation": 0
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 0,
+    "stepNumber": 1,
+    "patternId": "A",
+    "rotation": 0
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C064/initial_net.png",
+    "targetTopFaceImage": "../images/C064/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 1,
+    "tier": 1,
+    "targetStepNumber": 1,
+    "targetRotationOffset": 90,
+    "levelId": 64,
+    "moveCount": 3,
+    "sourceLevelPath": "levels/reconstruct/generated-064.json"
+  },
+  "rollSequence": [
+    "S",
+    "W",
+    "S"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "A",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "W",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "O",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "S",
+      "W",
+      "S"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "O",
+      "rotation": 270
+    },
+    "FRONT": {
+      "patternId": "A",
+      "rotation": 270
+    },
+    "RIGHT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BACK": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "LEFT": {
+      "patternId": "W",
+      "rotation": 0
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C064\n- task_type: roll_to_target_top_face\n- difficulty: 1\n- target_top_face: patternId=A, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=?, rotation=0]\n[LEFT: patternId=W, rotation=0] [TOP: patternId=O, rotation=270] [RIGHT: patternId=?, rotation=0]\n  [FRONT: patternId=A, rotation=270]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=?, rotation=0\n- LEFT: patternId=W, rotation=0\n- TOP: patternId=O, rotation=270\n- RIGHT: patternId=?, rotation=0\n- FRONT: patternId=A, rotation=270\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C065.json

@@ -0,0 +1,182 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C065",
+  "name": "Goal Roll C065",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "H",
+          "rotation": 90
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "Z",
+          "rotation": 180
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "H",
+        "rotation": 90
+      },
+      "FRONT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "RIGHT": {
+        "patternId": "Z",
+        "rotation": 180
+      },
+      "BACK": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "LEFT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 0,
+    "stepNumber": 1,
+    "patternId": "Z",
+    "rotation": 0
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C065/initial_net.png",
+    "targetTopFaceImage": "../images/C065/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 1,
+    "tier": 1,
+    "targetStepNumber": 1,
+    "targetRotationOffset": 270,
+    "levelId": 65,
+    "moveCount": 2,
+    "sourceLevelPath": "levels/reconstruct/generated-065.json"
+  },
+  "rollSequence": [
+    "E",
+    "E"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "Z",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "H",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "E",
+      "E"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "H",
+      "rotation": 90
+    },
+    "FRONT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "RIGHT": {
+      "patternId": "Z",
+      "rotation": 180
+    },
+    "BACK": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "LEFT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C065\n- task_type: roll_to_target_top_face\n- difficulty: 1\n- target_top_face: patternId=Z, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=?, rotation=0]\n[LEFT: patternId=?, rotation=0] [TOP: patternId=H, rotation=90] [RIGHT: patternId=Z, rotation=180]\n  [FRONT: patternId=?, rotation=0]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=?, rotation=0\n- LEFT: patternId=?, rotation=0\n- TOP: patternId=H, rotation=90\n- RIGHT: patternId=Z, rotation=180\n- FRONT: patternId=?, rotation=0\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C066.json

@@ -0,0 +1,190 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C066",
+  "name": "Goal Roll C066",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "R",
+          "rotation": 270
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "B",
+          "rotation": 270
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "V",
+          "rotation": 270
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "FRONT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "RIGHT": {
+        "patternId": "R",
+        "rotation": 270
+      },
+      "BACK": {
+        "patternId": "B",
+        "rotation": 270
+      },
+      "LEFT": {
+        "patternId": "V",
+        "rotation": 270
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 2,
+    "stepNumber": 3,
+    "patternId": "R",
+    "rotation": 90
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C066/initial_net.png",
+    "targetTopFaceImage": "../images/C066/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 1,
+    "tier": 1,
+    "targetStepNumber": 3,
+    "targetRotationOffset": 90,
+    "levelId": 66,
+    "moveCount": 3,
+    "sourceLevelPath": "levels/reconstruct/generated-066.json"
+  },
+  "rollSequence": [
+    "E",
+    "N",
+    "N"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "R",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "B",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "V",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "E",
+      "N",
+      "N"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "FRONT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "RIGHT": {
+      "patternId": "R",
+      "rotation": 270
+    },
+    "BACK": {
+      "patternId": "B",
+      "rotation": 270
+    },
+    "LEFT": {
+      "patternId": "V",
+      "rotation": 270
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C066\n- task_type: roll_to_target_top_face\n- difficulty: 1\n- target_top_face: patternId=R, rotation=90\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=B, rotation=270]\n[LEFT: patternId=V, rotation=270] [TOP: patternId=?, rotation=0] [RIGHT: patternId=R, rotation=270]\n  [FRONT: patternId=?, rotation=0]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=B, rotation=270\n- LEFT: patternId=V, rotation=270\n- TOP: patternId=?, rotation=0\n- RIGHT: patternId=R, rotation=270\n- FRONT: patternId=?, rotation=0\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C067.json

@@ -0,0 +1,190 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C067",
+  "name": "Goal Roll C067",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "9",
+          "rotation": 180
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "Y",
+          "rotation": 90
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "1",
+          "rotation": 90
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "9",
+        "rotation": 180
+      },
+      "FRONT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "RIGHT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BACK": {
+        "patternId": "Y",
+        "rotation": 90
+      },
+      "LEFT": {
+        "patternId": "1",
+        "rotation": 90
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 0,
+    "stepNumber": 1,
+    "patternId": "Y",
+    "rotation": 0
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C067/initial_net.png",
+    "targetTopFaceImage": "../images/C067/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 1,
+    "tier": 1,
+    "targetStepNumber": 1,
+    "targetRotationOffset": 90,
+    "levelId": 67,
+    "moveCount": 3,
+    "sourceLevelPath": "levels/reconstruct/generated-067.json"
+  },
+  "rollSequence": [
+    "N",
+    "W",
+    "N"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "Y",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "1",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "9",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "N",
+      "W",
+      "N"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "9",
+      "rotation": 180
+    },
+    "FRONT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "RIGHT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BACK": {
+      "patternId": "Y",
+      "rotation": 90
+    },
+    "LEFT": {
+      "patternId": "1",
+      "rotation": 90
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C067\n- task_type: roll_to_target_top_face\n- difficulty: 1\n- target_top_face: patternId=Y, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=Y, rotation=90]\n[LEFT: patternId=1, rotation=90] [TOP: patternId=9, rotation=180] [RIGHT: patternId=?, rotation=0]\n  [FRONT: patternId=?, rotation=0]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=Y, rotation=90\n- LEFT: patternId=1, rotation=90\n- TOP: patternId=9, rotation=180\n- RIGHT: patternId=?, rotation=0\n- FRONT: patternId=?, rotation=0\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C068.json

@@ -0,0 +1,182 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C068",
+  "name": "Goal Roll C068",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "7",
+          "rotation": 270
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "diamond",
+          "rotation": 270
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "7",
+        "rotation": 270
+      },
+      "FRONT": {
+        "patternId": "diamond",
+        "rotation": 270
+      },
+      "RIGHT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BACK": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "LEFT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 0,
+    "stepNumber": 1,
+    "patternId": "diamond",
+    "rotation": 0
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C068/initial_net.png",
+    "targetTopFaceImage": "../images/C068/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 1,
+    "tier": 1,
+    "targetStepNumber": 1,
+    "targetRotationOffset": 90,
+    "levelId": 68,
+    "moveCount": 2,
+    "sourceLevelPath": "levels/reconstruct/generated-068.json"
+  },
+  "rollSequence": [
+    "S",
+    "S"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "diamond",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "7",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "S",
+      "S"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "7",
+      "rotation": 270
+    },
+    "FRONT": {
+      "patternId": "diamond",
+      "rotation": 270
+    },
+    "RIGHT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BACK": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "LEFT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C068\n- task_type: roll_to_target_top_face\n- difficulty: 1\n- target_top_face: patternId=diamond, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=?, rotation=0]\n[LEFT: patternId=?, rotation=0] [TOP: patternId=7, rotation=270] [RIGHT: patternId=?, rotation=0]\n  [FRONT: patternId=diamond, rotation=270]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=?, rotation=0\n- LEFT: patternId=?, rotation=0\n- TOP: patternId=7, rotation=270\n- RIGHT: patternId=?, rotation=0\n- FRONT: patternId=diamond, rotation=270\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C069.json

@@ -0,0 +1,190 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C069",
+  "name": "Goal Roll C069",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "H",
+          "rotation": 270
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "V",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "square",
+          "rotation": 180
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "FRONT": {
+        "patternId": "H",
+        "rotation": 270
+      },
+      "RIGHT": {
+        "patternId": "V",
+        "rotation": 0
+      },
+      "BACK": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "LEFT": {
+        "patternId": "square",
+        "rotation": 180
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 0,
+    "stepNumber": 1,
+    "patternId": "square",
+    "rotation": 90
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C069/initial_net.png",
+    "targetTopFaceImage": "../images/C069/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 1,
+    "tier": 1,
+    "targetStepNumber": 1,
+    "targetRotationOffset": 180,
+    "levelId": 69,
+    "moveCount": 3,
+    "sourceLevelPath": "levels/reconstruct/generated-069.json"
+  },
+  "rollSequence": [
+    "E",
+    "S",
+    "S"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "V",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "H",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "square",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "E",
+      "S",
+      "S"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "FRONT": {
+      "patternId": "H",
+      "rotation": 270
+    },
+    "RIGHT": {
+      "patternId": "V",
+      "rotation": 0
+    },
+    "BACK": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "LEFT": {
+      "patternId": "square",
+      "rotation": 180
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C069\n- task_type: roll_to_target_top_face\n- difficulty: 1\n- target_top_face: patternId=square, rotation=90\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=?, rotation=0]\n[LEFT: patternId=square, rotation=180] [TOP: patternId=?, rotation=0] [RIGHT: patternId=V, rotation=0]\n  [FRONT: patternId=H, rotation=270]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=?, rotation=0\n- LEFT: patternId=square, rotation=180\n- TOP: patternId=?, rotation=0\n- RIGHT: patternId=V, rotation=0\n- FRONT: patternId=H, rotation=270\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C070.json

@@ -0,0 +1,190 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C070",
+  "name": "Goal Roll C070",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "N",
+          "rotation": 0
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "heart",
+          "rotation": 90
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "6",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "N",
+        "rotation": 0
+      },
+      "FRONT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "RIGHT": {
+        "patternId": "heart",
+        "rotation": 90
+      },
+      "BACK": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "LEFT": {
+        "patternId": "6",
+        "rotation": 0
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 2,
+    "stepNumber": 3,
+    "patternId": "6",
+    "rotation": 270
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C070/initial_net.png",
+    "targetTopFaceImage": "../images/C070/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 1,
+    "tier": 1,
+    "targetStepNumber": 3,
+    "targetRotationOffset": 180,
+    "levelId": 70,
+    "moveCount": 3,
+    "sourceLevelPath": "levels/reconstruct/generated-070.json"
+  },
+  "rollSequence": [
+    "W",
+    "W",
+    "W"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "6",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "N",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "heart",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "W",
+      "W",
+      "W"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "N",
+      "rotation": 0
+    },
+    "FRONT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "RIGHT": {
+      "patternId": "heart",
+      "rotation": 90
+    },
+    "BACK": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "LEFT": {
+      "patternId": "6",
+      "rotation": 0
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C070\n- task_type: roll_to_target_top_face\n- difficulty: 1\n- target_top_face: patternId=6, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=?, rotation=0]\n[LEFT: patternId=6, rotation=0] [TOP: patternId=N, rotation=0] [RIGHT: patternId=heart, rotation=90]\n  [FRONT: patternId=?, rotation=0]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=?, rotation=0\n- LEFT: patternId=6, rotation=0\n- TOP: patternId=N, rotation=0\n- RIGHT: patternId=heart, rotation=90\n- FRONT: patternId=?, rotation=0\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C071.json

@@ -0,0 +1,182 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C071",
+  "name": "Goal Roll C071",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "circle",
+          "rotation": 90
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "H",
+          "rotation": 0
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "circle",
+        "rotation": 90
+      },
+      "FRONT": {
+        "patternId": "H",
+        "rotation": 0
+      },
+      "RIGHT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BACK": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "LEFT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 0,
+    "stepNumber": 1,
+    "patternId": "H",
+    "rotation": 90
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C071/initial_net.png",
+    "targetTopFaceImage": "../images/C071/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 1,
+    "tier": 1,
+    "targetStepNumber": 1,
+    "targetRotationOffset": 90,
+    "levelId": 71,
+    "moveCount": 2,
+    "sourceLevelPath": "levels/reconstruct/generated-071.json"
+  },
+  "rollSequence": [
+    "S",
+    "S"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "H",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "circle",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "S",
+      "S"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "circle",
+      "rotation": 90
+    },
+    "FRONT": {
+      "patternId": "H",
+      "rotation": 0
+    },
+    "RIGHT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BACK": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "LEFT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C071\n- task_type: roll_to_target_top_face\n- difficulty: 1\n- target_top_face: patternId=H, rotation=90\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=?, rotation=0]\n[LEFT: patternId=?, rotation=0] [TOP: patternId=circle, rotation=90] [RIGHT: patternId=?, rotation=0]\n  [FRONT: patternId=H, rotation=0]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=?, rotation=0\n- LEFT: patternId=?, rotation=0\n- TOP: patternId=circle, rotation=90\n- RIGHT: patternId=?, rotation=0\n- FRONT: patternId=H, rotation=0\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C072.json

@@ -0,0 +1,190 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C072",
+  "name": "Goal Roll C072",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "6",
+          "rotation": 90
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "D",
+          "rotation": 270
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "arrow_left",
+          "rotation": 180
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "6",
+        "rotation": 90
+      },
+      "FRONT": {
+        "patternId": "D",
+        "rotation": 270
+      },
+      "RIGHT": {
+        "patternId": "arrow_left",
+        "rotation": 180
+      },
+      "BACK": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "LEFT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 0,
+    "stepNumber": 1,
+    "patternId": "D",
+    "rotation": 180
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C072/initial_net.png",
+    "targetTopFaceImage": "../images/C072/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 1,
+    "tier": 1,
+    "targetStepNumber": 1,
+    "targetRotationOffset": 270,
+    "levelId": 72,
+    "moveCount": 3,
+    "sourceLevelPath": "levels/reconstruct/generated-072.json"
+  },
+  "rollSequence": [
+    "E",
+    "S",
+    "E"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "arrow_left",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "D",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "6",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "E",
+      "S",
+      "E"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "6",
+      "rotation": 90
+    },
+    "FRONT": {
+      "patternId": "D",
+      "rotation": 270
+    },
+    "RIGHT": {
+      "patternId": "arrow_left",
+      "rotation": 180
+    },
+    "BACK": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "LEFT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C072\n- task_type: roll_to_target_top_face\n- difficulty: 1\n- target_top_face: patternId=D, rotation=180\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=?, rotation=0]\n[LEFT: patternId=?, rotation=0] [TOP: patternId=6, rotation=90] [RIGHT: patternId=arrow_left, rotation=180]\n  [FRONT: patternId=D, rotation=270]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=?, rotation=0\n- LEFT: patternId=?, rotation=0\n- TOP: patternId=6, rotation=90\n- RIGHT: patternId=arrow_left, rotation=180\n- FRONT: patternId=D, rotation=270\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C073.json

@@ -0,0 +1,182 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C073",
+  "name": "Goal Roll C073",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "X",
+          "rotation": 90
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "5",
+          "rotation": 90
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "FRONT": {
+        "patternId": "X",
+        "rotation": 90
+      },
+      "RIGHT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BACK": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "LEFT": {
+        "patternId": "5",
+        "rotation": 90
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 0,
+    "stepNumber": 1,
+    "patternId": "X",
+    "rotation": 0
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C073/initial_net.png",
+    "targetTopFaceImage": "../images/C073/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 1,
+    "tier": 1,
+    "targetStepNumber": 1,
+    "targetRotationOffset": 270,
+    "levelId": 73,
+    "moveCount": 2,
+    "sourceLevelPath": "levels/reconstruct/generated-073.json"
+  },
+  "rollSequence": [
+    "S",
+    "W"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "X",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "5",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "S",
+      "W"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "FRONT": {
+      "patternId": "X",
+      "rotation": 90
+    },
+    "RIGHT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BACK": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "LEFT": {
+      "patternId": "5",
+      "rotation": 90
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C073\n- task_type: roll_to_target_top_face\n- difficulty: 1\n- target_top_face: patternId=X, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=?, rotation=0]\n[LEFT: patternId=5, rotation=90] [TOP: patternId=?, rotation=0] [RIGHT: patternId=?, rotation=0]\n  [FRONT: patternId=X, rotation=90]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=?, rotation=0\n- LEFT: patternId=5, rotation=90\n- TOP: patternId=?, rotation=0\n- RIGHT: patternId=?, rotation=0\n- FRONT: patternId=X, rotation=90\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C074.json

@@ -0,0 +1,182 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C074",
+  "name": "Goal Roll C074",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "C",
+          "rotation": 0
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "S",
+          "rotation": 270
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "FRONT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "RIGHT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BACK": {
+        "patternId": "C",
+        "rotation": 0
+      },
+      "LEFT": {
+        "patternId": "S",
+        "rotation": 270
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 0,
+    "stepNumber": 1,
+    "patternId": "C",
+    "rotation": 90
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C074/initial_net.png",
+    "targetTopFaceImage": "../images/C074/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 1,
+    "tier": 1,
+    "targetStepNumber": 1,
+    "targetRotationOffset": 270,
+    "levelId": 74,
+    "moveCount": 2,
+    "sourceLevelPath": "levels/reconstruct/generated-074.json"
+  },
+  "rollSequence": [
+    "W",
+    "N"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "S",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "C",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "W",
+      "N"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "FRONT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "RIGHT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BACK": {
+      "patternId": "C",
+      "rotation": 0
+    },
+    "LEFT": {
+      "patternId": "S",
+      "rotation": 270
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C074\n- task_type: roll_to_target_top_face\n- difficulty: 1\n- target_top_face: patternId=C, rotation=90\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=C, rotation=0]\n[LEFT: patternId=S, rotation=270] [TOP: patternId=?, rotation=0] [RIGHT: patternId=?, rotation=0]\n  [FRONT: patternId=?, rotation=0]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=C, rotation=0\n- LEFT: patternId=S, rotation=270\n- TOP: patternId=?, rotation=0\n- RIGHT: patternId=?, rotation=0\n- FRONT: patternId=?, rotation=0\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C075.json

@@ -0,0 +1,190 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C075",
+  "name": "Goal Roll C075",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "6",
+          "rotation": 0
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "F",
+          "rotation": 180
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "6",
+          "rotation": 180
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "6",
+        "rotation": 0
+      },
+      "FRONT": {
+        "patternId": "F",
+        "rotation": 180
+      },
+      "RIGHT": {
+        "patternId": "6",
+        "rotation": 180
+      },
+      "BACK": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "LEFT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 0,
+    "stepNumber": 1,
+    "patternId": "F",
+    "rotation": 270
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C075/initial_net.png",
+    "targetTopFaceImage": "../images/C075/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 1,
+    "tier": 1,
+    "targetStepNumber": 1,
+    "targetRotationOffset": 90,
+    "levelId": 75,
+    "moveCount": 3,
+    "sourceLevelPath": "levels/reconstruct/generated-075.json"
+  },
+  "rollSequence": [
+    "E",
+    "S",
+    "E"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "6",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "F",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "6",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "E",
+      "S",
+      "E"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "6",
+      "rotation": 0
+    },
+    "FRONT": {
+      "patternId": "F",
+      "rotation": 180
+    },
+    "RIGHT": {
+      "patternId": "6",
+      "rotation": 180
+    },
+    "BACK": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "LEFT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C075\n- task_type: roll_to_target_top_face\n- difficulty: 1\n- target_top_face: patternId=F, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=?, rotation=0]\n[LEFT: patternId=?, rotation=0] [TOP: patternId=6, rotation=0] [RIGHT: patternId=6, rotation=180]\n  [FRONT: patternId=F, rotation=180]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=?, rotation=0\n- LEFT: patternId=?, rotation=0\n- TOP: patternId=6, rotation=0\n- RIGHT: patternId=6, rotation=180\n- FRONT: patternId=F, rotation=180\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C076.json

@@ -0,0 +1,182 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C076",
+  "name": "Goal Roll C076",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "star",
+          "rotation": 180
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "F",
+          "rotation": 270
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "FRONT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "RIGHT": {
+        "patternId": "star",
+        "rotation": 180
+      },
+      "BACK": {
+        "patternId": "F",
+        "rotation": 270
+      },
+      "LEFT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 0,
+    "stepNumber": 1,
+    "patternId": "F",
+    "rotation": 270
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C076/initial_net.png",
+    "targetTopFaceImage": "../images/C076/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 1,
+    "tier": 1,
+    "targetStepNumber": 1,
+    "targetRotationOffset": 180,
+    "levelId": 76,
+    "moveCount": 2,
+    "sourceLevelPath": "levels/reconstruct/generated-076.json"
+  },
+  "rollSequence": [
+    "E",
+    "N"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "star",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "F",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "E",
+      "N"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "FRONT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "RIGHT": {
+      "patternId": "star",
+      "rotation": 180
+    },
+    "BACK": {
+      "patternId": "F",
+      "rotation": 270
+    },
+    "LEFT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C076\n- task_type: roll_to_target_top_face\n- difficulty: 1\n- target_top_face: patternId=F, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=F, rotation=270]\n[LEFT: patternId=?, rotation=0] [TOP: patternId=?, rotation=0] [RIGHT: patternId=star, rotation=180]\n  [FRONT: patternId=?, rotation=0]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=F, rotation=270\n- LEFT: patternId=?, rotation=0\n- TOP: patternId=?, rotation=0\n- RIGHT: patternId=star, rotation=180\n- FRONT: patternId=?, rotation=0\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C077.json

@@ -0,0 +1,190 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C077",
+  "name": "Goal Roll C077",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "7",
+          "rotation": 180
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "J",
+          "rotation": 270
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "M",
+          "rotation": 90
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "7",
+        "rotation": 180
+      },
+      "FRONT": {
+        "patternId": "J",
+        "rotation": 270
+      },
+      "RIGHT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BACK": {
+        "patternId": "M",
+        "rotation": 90
+      },
+      "LEFT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 2,
+    "stepNumber": 3,
+    "patternId": "J",
+    "rotation": 90
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C077/initial_net.png",
+    "targetTopFaceImage": "../images/C077/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 1,
+    "tier": 1,
+    "targetStepNumber": 3,
+    "targetRotationOffset": 180,
+    "levelId": 77,
+    "moveCount": 3,
+    "sourceLevelPath": "levels/reconstruct/generated-077.json"
+  },
+  "rollSequence": [
+    "S",
+    "S",
+    "S"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "J",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "7",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "M",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "S",
+      "S",
+      "S"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "7",
+      "rotation": 180
+    },
+    "FRONT": {
+      "patternId": "J",
+      "rotation": 270
+    },
+    "RIGHT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BACK": {
+      "patternId": "M",
+      "rotation": 90
+    },
+    "LEFT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C077\n- task_type: roll_to_target_top_face\n- difficulty: 1\n- target_top_face: patternId=J, rotation=90\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=M, rotation=90]\n[LEFT: patternId=?, rotation=0] [TOP: patternId=7, rotation=180] [RIGHT: patternId=?, rotation=0]\n  [FRONT: patternId=J, rotation=270]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=M, rotation=90\n- LEFT: patternId=?, rotation=0\n- TOP: patternId=7, rotation=180\n- RIGHT: patternId=?, rotation=0\n- FRONT: patternId=J, rotation=270\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C178.json

@@ -0,0 +1,198 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C178",
+  "name": "Goal Roll C178",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "P",
+          "rotation": 90
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "arrow_down",
+          "rotation": 180
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "J",
+          "rotation": 180
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "5",
+          "rotation": 90
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "P",
+        "rotation": 90
+      },
+      "FRONT": {
+        "patternId": "arrow_down",
+        "rotation": 180
+      },
+      "RIGHT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BACK": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "LEFT": {
+        "patternId": "J",
+        "rotation": 180
+      },
+      "BOTTOM": {
+        "patternId": "5",
+        "rotation": 90
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 1,
+    "stepNumber": 2,
+    "patternId": "5",
+    "rotation": 180
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C178/initial_net.png",
+    "targetTopFaceImage": "../images/C178/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 2,
+    "tier": 2,
+    "targetStepNumber": 2,
+    "targetRotationOffset": 90,
+    "levelId": 178,
+    "moveCount": 4,
+    "sourceLevelPath": "levels/reconstruct/generated-178.json"
+  },
+  "rollSequence": [
+    "S",
+    "S",
+    "W",
+    "W"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "arrow_down",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "P",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "J",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "5",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "S",
+      "S",
+      "W",
+      "W"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "P",
+      "rotation": 90
+    },
+    "FRONT": {
+      "patternId": "arrow_down",
+      "rotation": 180
+    },
+    "RIGHT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BACK": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "LEFT": {
+      "patternId": "J",
+      "rotation": 180
+    },
+    "BOTTOM": {
+      "patternId": "5",
+      "rotation": 90
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C178\n- task_type: roll_to_target_top_face\n- difficulty: 2\n- target_top_face: patternId=5, rotation=180\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=?, rotation=0]\n[LEFT: patternId=J, rotation=180] [TOP: patternId=P, rotation=90] [RIGHT: patternId=?, rotation=0]\n  [FRONT: patternId=arrow_down, rotation=180]\n  [BOTTOM: patternId=5, rotation=90]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=?, rotation=0\n- LEFT: patternId=J, rotation=180\n- TOP: patternId=P, rotation=90\n- RIGHT: patternId=?, rotation=0\n- FRONT: patternId=arrow_down, rotation=180\n- BOTTOM: patternId=5, rotation=90\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C179.json

@@ -0,0 +1,206 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C179",
+  "name": "Goal Roll C179",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "L",
+          "rotation": 0
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "N",
+          "rotation": 270
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "J",
+          "rotation": 90
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "circle",
+          "rotation": 90
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "H",
+          "rotation": 270
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "L",
+        "rotation": 0
+      },
+      "FRONT": {
+        "patternId": "N",
+        "rotation": 270
+      },
+      "RIGHT": {
+        "patternId": "J",
+        "rotation": 90
+      },
+      "BACK": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "LEFT": {
+        "patternId": "circle",
+        "rotation": 90
+      },
+      "BOTTOM": {
+        "patternId": "H",
+        "rotation": 270
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 3,
+    "stepNumber": 4,
+    "patternId": "L",
+    "rotation": 0
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C179/initial_net.png",
+    "targetTopFaceImage": "../images/C179/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 2,
+    "tier": 2,
+    "targetStepNumber": 4,
+    "targetRotationOffset": 180,
+    "levelId": 179,
+    "moveCount": 5,
+    "sourceLevelPath": "levels/reconstruct/generated-179.json"
+  },
+  "rollSequence": [
+    "E",
+    "E",
+    "S",
+    "S",
+    "E"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "J",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "L",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "N",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "H",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "circle",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "E",
+      "E",
+      "S",
+      "S",
+      "E"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "L",
+      "rotation": 0
+    },
+    "FRONT": {
+      "patternId": "N",
+      "rotation": 270
+    },
+    "RIGHT": {
+      "patternId": "J",
+      "rotation": 90
+    },
+    "BACK": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "LEFT": {
+      "patternId": "circle",
+      "rotation": 90
+    },
+    "BOTTOM": {
+      "patternId": "H",
+      "rotation": 270
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C179\n- task_type: roll_to_target_top_face\n- difficulty: 2\n- target_top_face: patternId=L, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=?, rotation=0]\n[LEFT: patternId=circle, rotation=90] [TOP: patternId=L, rotation=0] [RIGHT: patternId=J, rotation=90]\n  [FRONT: patternId=N, rotation=270]\n  [BOTTOM: patternId=H, rotation=270]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=?, rotation=0\n- LEFT: patternId=circle, rotation=90\n- TOP: patternId=L, rotation=0\n- RIGHT: patternId=J, rotation=90\n- FRONT: patternId=N, rotation=270\n- BOTTOM: patternId=H, rotation=270\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C180.json

@@ -0,0 +1,198 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C180",
+  "name": "Goal Roll C180",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "arrow_up",
+          "rotation": 180
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "7",
+          "rotation": 270
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "W",
+          "rotation": 180
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "arrow_up",
+        "rotation": 180
+      },
+      "FRONT": {
+        "patternId": "7",
+        "rotation": 270
+      },
+      "RIGHT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BACK": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "LEFT": {
+        "patternId": "W",
+        "rotation": 180
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 0,
+    "stepNumber": 1,
+    "patternId": "7",
+    "rotation": 180
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C180/initial_net.png",
+    "targetTopFaceImage": "../images/C180/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 2,
+    "tier": 2,
+    "targetStepNumber": 1,
+    "targetRotationOffset": 270,
+    "levelId": 180,
+    "moveCount": 4,
+    "sourceLevelPath": "levels/reconstruct/generated-180.json"
+  },
+  "rollSequence": [
+    "W",
+    "S",
+    "W",
+    "N"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "W",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "7",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "arrow_up",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "W",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "W",
+      "S",
+      "W",
+      "N"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "arrow_up",
+      "rotation": 180
+    },
+    "FRONT": {
+      "patternId": "7",
+      "rotation": 270
+    },
+    "RIGHT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BACK": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "LEFT": {
+      "patternId": "W",
+      "rotation": 180
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C180\n- task_type: roll_to_target_top_face\n- difficulty: 2\n- target_top_face: patternId=7, rotation=180\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=?, rotation=0]\n[LEFT: patternId=W, rotation=180] [TOP: patternId=arrow_up, rotation=180] [RIGHT: patternId=?, rotation=0]\n  [FRONT: patternId=7, rotation=270]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=?, rotation=0\n- LEFT: patternId=W, rotation=180\n- TOP: patternId=arrow_up, rotation=180\n- RIGHT: patternId=?, rotation=0\n- FRONT: patternId=7, rotation=270\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C181.json

@@ -0,0 +1,206 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C181",
+  "name": "Goal Roll C181",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "J",
+          "rotation": 0
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "Z",
+          "rotation": 90
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "7",
+          "rotation": 0
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "diamond",
+          "rotation": 270
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "FRONT": {
+        "patternId": "J",
+        "rotation": 0
+      },
+      "RIGHT": {
+        "patternId": "Z",
+        "rotation": 90
+      },
+      "BACK": {
+        "patternId": "7",
+        "rotation": 0
+      },
+      "LEFT": {
+        "patternId": "diamond",
+        "rotation": 270
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 0,
+    "stepNumber": 1,
+    "patternId": "7",
+    "rotation": 0
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C181/initial_net.png",
+    "targetTopFaceImage": "../images/C181/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 2,
+    "tier": 2,
+    "targetStepNumber": 1,
+    "targetRotationOffset": 180,
+    "levelId": 181,
+    "moveCount": 5,
+    "sourceLevelPath": "levels/reconstruct/generated-181.json"
+  },
+  "rollSequence": [
+    "S",
+    "E",
+    "W",
+    "W",
+    "W"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "J",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "Z",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "J",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "diamond",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "7",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "S",
+      "E",
+      "W",
+      "W",
+      "W"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "FRONT": {
+      "patternId": "J",
+      "rotation": 0
+    },
+    "RIGHT": {
+      "patternId": "Z",
+      "rotation": 90
+    },
+    "BACK": {
+      "patternId": "7",
+      "rotation": 0
+    },
+    "LEFT": {
+      "patternId": "diamond",
+      "rotation": 270
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C181\n- task_type: roll_to_target_top_face\n- difficulty: 2\n- target_top_face: patternId=7, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=7, rotation=0]\n[LEFT: patternId=diamond, rotation=270] [TOP: patternId=?, rotation=0] [RIGHT: patternId=Z, rotation=90]\n  [FRONT: patternId=J, rotation=0]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=7, rotation=0\n- LEFT: patternId=diamond, rotation=270\n- TOP: patternId=?, rotation=0\n- RIGHT: patternId=Z, rotation=90\n- FRONT: patternId=J, rotation=0\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C182.json

@@ -0,0 +1,198 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C182",
+  "name": "Goal Roll C182",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "1",
+          "rotation": 180
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "4",
+          "rotation": 90
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "V",
+          "rotation": 270
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "FRONT": {
+        "patternId": "1",
+        "rotation": 180
+      },
+      "RIGHT": {
+        "patternId": "4",
+        "rotation": 90
+      },
+      "BACK": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "LEFT": {
+        "patternId": "V",
+        "rotation": 270
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 0,
+    "stepNumber": 1,
+    "patternId": "4",
+    "rotation": 270
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C182/initial_net.png",
+    "targetTopFaceImage": "../images/C182/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 2,
+    "tier": 2,
+    "targetStepNumber": 1,
+    "targetRotationOffset": 270,
+    "levelId": 182,
+    "moveCount": 4,
+    "sourceLevelPath": "levels/reconstruct/generated-182.json"
+  },
+  "rollSequence": [
+    "W",
+    "S",
+    "S",
+    "N"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "V",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "1",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "4",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "1",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "W",
+      "S",
+      "S",
+      "N"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "FRONT": {
+      "patternId": "1",
+      "rotation": 180
+    },
+    "RIGHT": {
+      "patternId": "4",
+      "rotation": 90
+    },
+    "BACK": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "LEFT": {
+      "patternId": "V",
+      "rotation": 270
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C182\n- task_type: roll_to_target_top_face\n- difficulty: 2\n- target_top_face: patternId=4, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=?, rotation=0]\n[LEFT: patternId=V, rotation=270] [TOP: patternId=?, rotation=0] [RIGHT: patternId=4, rotation=90]\n  [FRONT: patternId=1, rotation=180]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=?, rotation=0\n- LEFT: patternId=V, rotation=270\n- TOP: patternId=?, rotation=0\n- RIGHT: patternId=4, rotation=90\n- FRONT: patternId=1, rotation=180\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C183.json

@@ -0,0 +1,206 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C183",
+  "name": "Goal Roll C183",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "G",
+          "rotation": 180
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "smile",
+          "rotation": 270
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "D",
+          "rotation": 90
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "8",
+          "rotation": 180
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "FRONT": {
+        "patternId": "G",
+        "rotation": 180
+      },
+      "RIGHT": {
+        "patternId": "smile",
+        "rotation": 270
+      },
+      "BACK": {
+        "patternId": "D",
+        "rotation": 90
+      },
+      "LEFT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BOTTOM": {
+        "patternId": "8",
+        "rotation": 180
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 3,
+    "stepNumber": 4,
+    "patternId": "G",
+    "rotation": 270
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C183/initial_net.png",
+    "targetTopFaceImage": "../images/C183/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 2,
+    "tier": 2,
+    "targetStepNumber": 4,
+    "targetRotationOffset": 180,
+    "levelId": 183,
+    "moveCount": 5,
+    "sourceLevelPath": "levels/reconstruct/generated-183.json"
+  },
+  "rollSequence": [
+    "E",
+    "S",
+    "W",
+    "W",
+    "E"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "smile",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "G",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "8",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "D",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "8",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "E",
+      "S",
+      "W",
+      "W",
+      "E"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "FRONT": {
+      "patternId": "G",
+      "rotation": 180
+    },
+    "RIGHT": {
+      "patternId": "smile",
+      "rotation": 270
+    },
+    "BACK": {
+      "patternId": "D",
+      "rotation": 90
+    },
+    "LEFT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BOTTOM": {
+      "patternId": "8",
+      "rotation": 180
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C183\n- task_type: roll_to_target_top_face\n- difficulty: 2\n- target_top_face: patternId=G, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=D, rotation=90]\n[LEFT: patternId=?, rotation=0] [TOP: patternId=?, rotation=0] [RIGHT: patternId=smile, rotation=270]\n  [FRONT: patternId=G, rotation=180]\n  [BOTTOM: patternId=8, rotation=180]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=D, rotation=90\n- LEFT: patternId=?, rotation=0\n- TOP: patternId=?, rotation=0\n- RIGHT: patternId=smile, rotation=270\n- FRONT: patternId=G, rotation=180\n- BOTTOM: patternId=8, rotation=180\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C184.json

@@ -0,0 +1,198 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C184",
+  "name": "Goal Roll C184",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "T",
+          "rotation": 0
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "H",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "D",
+          "rotation": 180
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "W",
+          "rotation": 270
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "T",
+        "rotation": 0
+      },
+      "FRONT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "RIGHT": {
+        "patternId": "H",
+        "rotation": 0
+      },
+      "BACK": {
+        "patternId": "D",
+        "rotation": 180
+      },
+      "LEFT": {
+        "patternId": "W",
+        "rotation": 270
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 3,
+    "stepNumber": 4,
+    "patternId": "H",
+    "rotation": 270
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C184/initial_net.png",
+    "targetTopFaceImage": "../images/C184/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 2,
+    "tier": 2,
+    "targetStepNumber": 4,
+    "targetRotationOffset": 90,
+    "levelId": 184,
+    "moveCount": 4,
+    "sourceLevelPath": "levels/reconstruct/generated-184.json"
+  },
+  "rollSequence": [
+    "E",
+    "N",
+    "E",
+    "N"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "H",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "D",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "T",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "W",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "E",
+      "N",
+      "E",
+      "N"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "T",
+      "rotation": 0
+    },
+    "FRONT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "RIGHT": {
+      "patternId": "H",
+      "rotation": 0
+    },
+    "BACK": {
+      "patternId": "D",
+      "rotation": 180
+    },
+    "LEFT": {
+      "patternId": "W",
+      "rotation": 270
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C184\n- task_type: roll_to_target_top_face\n- difficulty: 2\n- target_top_face: patternId=H, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=D, rotation=180]\n[LEFT: patternId=W, rotation=270] [TOP: patternId=T, rotation=0] [RIGHT: patternId=H, rotation=0]\n  [FRONT: patternId=?, rotation=0]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=D, rotation=180\n- LEFT: patternId=W, rotation=270\n- TOP: patternId=T, rotation=0\n- RIGHT: patternId=H, rotation=0\n- FRONT: patternId=?, rotation=0\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C185.json

@@ -0,0 +1,198 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C185",
+  "name": "Goal Roll C185",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "3",
+          "rotation": 90
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "8",
+          "rotation": 180
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "C",
+          "rotation": 90
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "FRONT": {
+        "patternId": "3",
+        "rotation": 90
+      },
+      "RIGHT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BACK": {
+        "patternId": "8",
+        "rotation": 180
+      },
+      "LEFT": {
+        "patternId": "C",
+        "rotation": 90
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 2,
+    "stepNumber": 3,
+    "patternId": "8",
+    "rotation": 90
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C185/initial_net.png",
+    "targetTopFaceImage": "../images/C185/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 2,
+    "tier": 2,
+    "targetStepNumber": 3,
+    "targetRotationOffset": 270,
+    "levelId": 185,
+    "moveCount": 4,
+    "sourceLevelPath": "levels/reconstruct/generated-185.json"
+  },
+  "rollSequence": [
+    "N",
+    "W",
+    "W",
+    "E"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "8",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "C",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "3",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "C",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "N",
+      "W",
+      "W",
+      "E"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "FRONT": {
+      "patternId": "3",
+      "rotation": 90
+    },
+    "RIGHT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BACK": {
+      "patternId": "8",
+      "rotation": 180
+    },
+    "LEFT": {
+      "patternId": "C",
+      "rotation": 90
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C185\n- task_type: roll_to_target_top_face\n- difficulty: 2\n- target_top_face: patternId=8, rotation=90\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=8, rotation=180]\n[LEFT: patternId=C, rotation=90] [TOP: patternId=?, rotation=0] [RIGHT: patternId=?, rotation=0]\n  [FRONT: patternId=3, rotation=90]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=8, rotation=180\n- LEFT: patternId=C, rotation=90\n- TOP: patternId=?, rotation=0\n- RIGHT: patternId=?, rotation=0\n- FRONT: patternId=3, rotation=90\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C186.json

@@ -0,0 +1,206 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C186",
+  "name": "Goal Roll C186",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "G",
+          "rotation": 90
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "N",
+          "rotation": 0
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "arrow_down",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "arrow_left",
+          "rotation": 90
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "G",
+        "rotation": 90
+      },
+      "FRONT": {
+        "patternId": "N",
+        "rotation": 0
+      },
+      "RIGHT": {
+        "patternId": "arrow_down",
+        "rotation": 0
+      },
+      "BACK": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "LEFT": {
+        "patternId": "arrow_left",
+        "rotation": 90
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 2,
+    "stepNumber": 3,
+    "patternId": "arrow_left",
+    "rotation": 180
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C186/initial_net.png",
+    "targetTopFaceImage": "../images/C186/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 2,
+    "tier": 2,
+    "targetStepNumber": 3,
+    "targetRotationOffset": 180,
+    "levelId": 186,
+    "moveCount": 5,
+    "sourceLevelPath": "levels/reconstruct/generated-186.json"
+  },
+  "rollSequence": [
+    "W",
+    "S",
+    "S",
+    "W",
+    "W"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "arrow_left",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "N",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "arrow_down",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "G",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "arrow_left",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "W",
+      "S",
+      "S",
+      "W",
+      "W"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "G",
+      "rotation": 90
+    },
+    "FRONT": {
+      "patternId": "N",
+      "rotation": 0
+    },
+    "RIGHT": {
+      "patternId": "arrow_down",
+      "rotation": 0
+    },
+    "BACK": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "LEFT": {
+      "patternId": "arrow_left",
+      "rotation": 90
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C186\n- task_type: roll_to_target_top_face\n- difficulty: 2\n- target_top_face: patternId=arrow_left, rotation=180\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=?, rotation=0]\n[LEFT: patternId=arrow_left, rotation=90] [TOP: patternId=G, rotation=90] [RIGHT: patternId=arrow_down, rotation=0]\n  [FRONT: patternId=N, rotation=0]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=?, rotation=0\n- LEFT: patternId=arrow_left, rotation=90\n- TOP: patternId=G, rotation=90\n- RIGHT: patternId=arrow_down, rotation=0\n- FRONT: patternId=N, rotation=0\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C187.json

@@ -0,0 +1,206 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C187",
+  "name": "Goal Roll C187",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "1",
+          "rotation": 270
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "4",
+          "rotation": 180
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "O",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "U",
+          "rotation": 0
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "1",
+        "rotation": 270
+      },
+      "FRONT": {
+        "patternId": "4",
+        "rotation": 180
+      },
+      "RIGHT": {
+        "patternId": "O",
+        "rotation": 0
+      },
+      "BACK": {
+        "patternId": "U",
+        "rotation": 0
+      },
+      "LEFT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 3,
+    "stepNumber": 4,
+    "patternId": "4",
+    "rotation": 180
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C187/initial_net.png",
+    "targetTopFaceImage": "../images/C187/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 2,
+    "tier": 2,
+    "targetStepNumber": 4,
+    "targetRotationOffset": 90,
+    "levelId": 187,
+    "moveCount": 5,
+    "sourceLevelPath": "levels/reconstruct/generated-187.json"
+  },
+  "rollSequence": [
+    "E",
+    "S",
+    "E",
+    "E",
+    "N"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "O",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "4",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "1",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "U",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "O",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "E",
+      "S",
+      "E",
+      "E",
+      "N"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "1",
+      "rotation": 270
+    },
+    "FRONT": {
+      "patternId": "4",
+      "rotation": 180
+    },
+    "RIGHT": {
+      "patternId": "O",
+      "rotation": 0
+    },
+    "BACK": {
+      "patternId": "U",
+      "rotation": 0
+    },
+    "LEFT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C187\n- task_type: roll_to_target_top_face\n- difficulty: 2\n- target_top_face: patternId=4, rotation=180\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=U, rotation=0]\n[LEFT: patternId=?, rotation=0] [TOP: patternId=1, rotation=270] [RIGHT: patternId=O, rotation=0]\n  [FRONT: patternId=4, rotation=180]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=U, rotation=0\n- LEFT: patternId=?, rotation=0\n- TOP: patternId=1, rotation=270\n- RIGHT: patternId=O, rotation=0\n- FRONT: patternId=4, rotation=180\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C188.json

@@ -0,0 +1,206 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C188",
+  "name": "Goal Roll C188",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "J",
+          "rotation": 270
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "heart",
+          "rotation": 0
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "E",
+          "rotation": 270
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "1",
+          "rotation": 90
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "FRONT": {
+        "patternId": "J",
+        "rotation": 270
+      },
+      "RIGHT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BACK": {
+        "patternId": "heart",
+        "rotation": 0
+      },
+      "LEFT": {
+        "patternId": "E",
+        "rotation": 270
+      },
+      "BOTTOM": {
+        "patternId": "1",
+        "rotation": 90
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 1,
+    "stepNumber": 2,
+    "patternId": "J",
+    "rotation": 270
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C188/initial_net.png",
+    "targetTopFaceImage": "../images/C188/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 2,
+    "tier": 2,
+    "targetStepNumber": 2,
+    "targetRotationOffset": 90,
+    "levelId": 188,
+    "moveCount": 5,
+    "sourceLevelPath": "levels/reconstruct/generated-188.json"
+  },
+  "rollSequence": [
+    "W",
+    "N",
+    "E",
+    "S",
+    "E"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "E",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "heart",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "1",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "E",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "J",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "W",
+      "N",
+      "E",
+      "S",
+      "E"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "FRONT": {
+      "patternId": "J",
+      "rotation": 270
+    },
+    "RIGHT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BACK": {
+      "patternId": "heart",
+      "rotation": 0
+    },
+    "LEFT": {
+      "patternId": "E",
+      "rotation": 270
+    },
+    "BOTTOM": {
+      "patternId": "1",
+      "rotation": 90
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C188\n- task_type: roll_to_target_top_face\n- difficulty: 2\n- target_top_face: patternId=J, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=heart, rotation=0]\n[LEFT: patternId=E, rotation=270] [TOP: patternId=?, rotation=0] [RIGHT: patternId=?, rotation=0]\n  [FRONT: patternId=J, rotation=270]\n  [BOTTOM: patternId=1, rotation=90]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=heart, rotation=0\n- LEFT: patternId=E, rotation=270\n- TOP: patternId=?, rotation=0\n- RIGHT: patternId=?, rotation=0\n- FRONT: patternId=J, rotation=270\n- BOTTOM: patternId=1, rotation=90\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C189.json

@@ -0,0 +1,198 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C189",
+  "name": "Goal Roll C189",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "8",
+          "rotation": 180
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "heart",
+          "rotation": 270
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "C",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "FRONT": {
+        "patternId": "8",
+        "rotation": 180
+      },
+      "RIGHT": {
+        "patternId": "heart",
+        "rotation": 270
+      },
+      "BACK": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "LEFT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BOTTOM": {
+        "patternId": "C",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 0,
+    "stepNumber": 1,
+    "patternId": "8",
+    "rotation": 0
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C189/initial_net.png",
+    "targetTopFaceImage": "../images/C189/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 2,
+    "tier": 2,
+    "targetStepNumber": 1,
+    "targetRotationOffset": 180,
+    "levelId": 189,
+    "moveCount": 4,
+    "sourceLevelPath": "levels/reconstruct/generated-189.json"
+  },
+  "rollSequence": [
+    "S",
+    "N",
+    "E",
+    "S"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "8",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "C",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "heart",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "8",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "S",
+      "N",
+      "E",
+      "S"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "FRONT": {
+      "patternId": "8",
+      "rotation": 180
+    },
+    "RIGHT": {
+      "patternId": "heart",
+      "rotation": 270
+    },
+    "BACK": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "LEFT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BOTTOM": {
+      "patternId": "C",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C189\n- task_type: roll_to_target_top_face\n- difficulty: 2\n- target_top_face: patternId=8, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=?, rotation=0]\n[LEFT: patternId=?, rotation=0] [TOP: patternId=?, rotation=0] [RIGHT: patternId=heart, rotation=270]\n  [FRONT: patternId=8, rotation=180]\n  [BOTTOM: patternId=C, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=?, rotation=0\n- LEFT: patternId=?, rotation=0\n- TOP: patternId=?, rotation=0\n- RIGHT: patternId=heart, rotation=270\n- FRONT: patternId=8, rotation=180\n- BOTTOM: patternId=C, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C190.json

@@ -0,0 +1,198 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C190",
+  "name": "Goal Roll C190",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "7",
+          "rotation": 180
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "arrow_down",
+          "rotation": 90
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "Q",
+          "rotation": 90
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "7",
+        "rotation": 180
+      },
+      "FRONT": {
+        "patternId": "arrow_down",
+        "rotation": 90
+      },
+      "RIGHT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BACK": {
+        "patternId": "Q",
+        "rotation": 90
+      },
+      "LEFT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 2,
+    "stepNumber": 3,
+    "patternId": "Q",
+    "rotation": 0
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C190/initial_net.png",
+    "targetTopFaceImage": "../images/C190/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 2,
+    "tier": 2,
+    "targetStepNumber": 3,
+    "targetRotationOffset": 90,
+    "levelId": 190,
+    "moveCount": 4,
+    "sourceLevelPath": "levels/reconstruct/generated-190.json"
+  },
+  "rollSequence": [
+    "N",
+    "N",
+    "N",
+    "S"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "Q",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "7",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "arrow_down",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "7",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "N",
+      "N",
+      "N",
+      "S"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "7",
+      "rotation": 180
+    },
+    "FRONT": {
+      "patternId": "arrow_down",
+      "rotation": 90
+    },
+    "RIGHT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BACK": {
+      "patternId": "Q",
+      "rotation": 90
+    },
+    "LEFT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C190\n- task_type: roll_to_target_top_face\n- difficulty: 2\n- target_top_face: patternId=Q, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=Q, rotation=90]\n[LEFT: patternId=?, rotation=0] [TOP: patternId=7, rotation=180] [RIGHT: patternId=?, rotation=0]\n  [FRONT: patternId=arrow_down, rotation=90]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=Q, rotation=90\n- LEFT: patternId=?, rotation=0\n- TOP: patternId=7, rotation=180\n- RIGHT: patternId=?, rotation=0\n- FRONT: patternId=arrow_down, rotation=90\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C191.json

@@ -0,0 +1,198 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C191",
+  "name": "Goal Roll C191",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "arrow_left",
+          "rotation": 90
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "smile",
+          "rotation": 270
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "I",
+          "rotation": 180
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "M",
+          "rotation": 180
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "arrow_left",
+        "rotation": 90
+      },
+      "FRONT": {
+        "patternId": "smile",
+        "rotation": 270
+      },
+      "RIGHT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BACK": {
+        "patternId": "I",
+        "rotation": 180
+      },
+      "LEFT": {
+        "patternId": "M",
+        "rotation": 180
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 0,
+    "stepNumber": 1,
+    "patternId": "I",
+    "rotation": 180
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C191/initial_net.png",
+    "targetTopFaceImage": "../images/C191/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 2,
+    "tier": 2,
+    "targetStepNumber": 1,
+    "targetRotationOffset": 180,
+    "levelId": 191,
+    "moveCount": 4,
+    "sourceLevelPath": "levels/reconstruct/generated-191.json"
+  },
+  "rollSequence": [
+    "S",
+    "W",
+    "S",
+    "W"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "smile",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "M",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "arrow_left",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "I",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "S",
+      "W",
+      "S",
+      "W"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "arrow_left",
+      "rotation": 90
+    },
+    "FRONT": {
+      "patternId": "smile",
+      "rotation": 270
+    },
+    "RIGHT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BACK": {
+      "patternId": "I",
+      "rotation": 180
+    },
+    "LEFT": {
+      "patternId": "M",
+      "rotation": 180
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C191\n- task_type: roll_to_target_top_face\n- difficulty: 2\n- target_top_face: patternId=I, rotation=180\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=I, rotation=180]\n[LEFT: patternId=M, rotation=180] [TOP: patternId=arrow_left, rotation=90] [RIGHT: patternId=?, rotation=0]\n  [FRONT: patternId=smile, rotation=270]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=I, rotation=180\n- LEFT: patternId=M, rotation=180\n- TOP: patternId=arrow_left, rotation=90\n- RIGHT: patternId=?, rotation=0\n- FRONT: patternId=smile, rotation=270\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C192.json

@@ -0,0 +1,206 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C192",
+  "name": "Goal Roll C192",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "8",
+          "rotation": 270
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "P",
+          "rotation": 90
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "star",
+          "rotation": 180
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "8",
+          "rotation": 90
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "arrow_right",
+          "rotation": 90
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "8",
+        "rotation": 270
+      },
+      "FRONT": {
+        "patternId": "P",
+        "rotation": 90
+      },
+      "RIGHT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BACK": {
+        "patternId": "star",
+        "rotation": 180
+      },
+      "LEFT": {
+        "patternId": "8",
+        "rotation": 90
+      },
+      "BOTTOM": {
+        "patternId": "arrow_right",
+        "rotation": 90
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 4,
+    "stepNumber": 5,
+    "patternId": "star",
+    "rotation": 270
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C192/initial_net.png",
+    "targetTopFaceImage": "../images/C192/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 2,
+    "tier": 2,
+    "targetStepNumber": 5,
+    "targetRotationOffset": 90,
+    "levelId": 192,
+    "moveCount": 5,
+    "sourceLevelPath": "levels/reconstruct/generated-192.json"
+  },
+  "rollSequence": [
+    "W",
+    "W",
+    "N",
+    "N",
+    "N"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "8",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "8",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "star",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "arrow_right",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "P",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "W",
+      "W",
+      "N",
+      "N",
+      "N"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "8",
+      "rotation": 270
+    },
+    "FRONT": {
+      "patternId": "P",
+      "rotation": 90
+    },
+    "RIGHT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BACK": {
+      "patternId": "star",
+      "rotation": 180
+    },
+    "LEFT": {
+      "patternId": "8",
+      "rotation": 90
+    },
+    "BOTTOM": {
+      "patternId": "arrow_right",
+      "rotation": 90
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C192\n- task_type: roll_to_target_top_face\n- difficulty: 2\n- target_top_face: patternId=star, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=star, rotation=180]\n[LEFT: patternId=8, rotation=90] [TOP: patternId=8, rotation=270] [RIGHT: patternId=?, rotation=0]\n  [FRONT: patternId=P, rotation=90]\n  [BOTTOM: patternId=arrow_right, rotation=90]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=star, rotation=180\n- LEFT: patternId=8, rotation=90\n- TOP: patternId=8, rotation=270\n- RIGHT: patternId=?, rotation=0\n- FRONT: patternId=P, rotation=90\n- BOTTOM: patternId=arrow_right, rotation=90\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C193.json

@@ -0,0 +1,206 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C193",
+  "name": "Goal Roll C193",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "5",
+          "rotation": 90
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "I",
+          "rotation": 90
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "arrow_right",
+          "rotation": 90
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "I",
+          "rotation": 270
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "FRONT": {
+        "patternId": "5",
+        "rotation": 90
+      },
+      "RIGHT": {
+        "patternId": "I",
+        "rotation": 90
+      },
+      "BACK": {
+        "patternId": "arrow_right",
+        "rotation": 90
+      },
+      "LEFT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BOTTOM": {
+        "patternId": "I",
+        "rotation": 270
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 0,
+    "stepNumber": 1,
+    "patternId": "5",
+    "rotation": 270
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C193/initial_net.png",
+    "targetTopFaceImage": "../images/C193/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 2,
+    "tier": 2,
+    "targetStepNumber": 1,
+    "targetRotationOffset": 180,
+    "levelId": 193,
+    "moveCount": 5,
+    "sourceLevelPath": "levels/reconstruct/generated-193.json"
+  },
+  "rollSequence": [
+    "N",
+    "E",
+    "S",
+    "E",
+    "N"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "arrow_right",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "I",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "I",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "5",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "I",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "N",
+      "E",
+      "S",
+      "E",
+      "N"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "FRONT": {
+      "patternId": "5",
+      "rotation": 90
+    },
+    "RIGHT": {
+      "patternId": "I",
+      "rotation": 90
+    },
+    "BACK": {
+      "patternId": "arrow_right",
+      "rotation": 90
+    },
+    "LEFT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BOTTOM": {
+      "patternId": "I",
+      "rotation": 270
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C193\n- task_type: roll_to_target_top_face\n- difficulty: 2\n- target_top_face: patternId=5, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=arrow_right, rotation=90]\n[LEFT: patternId=?, rotation=0] [TOP: patternId=?, rotation=0] [RIGHT: patternId=I, rotation=90]\n  [FRONT: patternId=5, rotation=90]\n  [BOTTOM: patternId=I, rotation=270]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=arrow_right, rotation=90\n- LEFT: patternId=?, rotation=0\n- TOP: patternId=?, rotation=0\n- RIGHT: patternId=I, rotation=90\n- FRONT: patternId=5, rotation=90\n- BOTTOM: patternId=I, rotation=270\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C194.json

@@ -0,0 +1,198 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C194",
+  "name": "Goal Roll C194",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "G",
+          "rotation": 90
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "arrow_up",
+          "rotation": 180
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "arrow_right",
+          "rotation": 90
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "R",
+          "rotation": 180
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "FRONT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "RIGHT": {
+        "patternId": "G",
+        "rotation": 90
+      },
+      "BACK": {
+        "patternId": "arrow_up",
+        "rotation": 180
+      },
+      "LEFT": {
+        "patternId": "arrow_right",
+        "rotation": 90
+      },
+      "BOTTOM": {
+        "patternId": "R",
+        "rotation": 180
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 0,
+    "stepNumber": 1,
+    "patternId": "G",
+    "rotation": 270
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C194/initial_net.png",
+    "targetTopFaceImage": "../images/C194/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 2,
+    "tier": 2,
+    "targetStepNumber": 1,
+    "targetRotationOffset": 270,
+    "levelId": 194,
+    "moveCount": 4,
+    "sourceLevelPath": "levels/reconstruct/generated-194.json"
+  },
+  "rollSequence": [
+    "W",
+    "N",
+    "N",
+    "E"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "arrow_right",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "arrow_up",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "G",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "R",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "W",
+      "N",
+      "N",
+      "E"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "FRONT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "RIGHT": {
+      "patternId": "G",
+      "rotation": 90
+    },
+    "BACK": {
+      "patternId": "arrow_up",
+      "rotation": 180
+    },
+    "LEFT": {
+      "patternId": "arrow_right",
+      "rotation": 90
+    },
+    "BOTTOM": {
+      "patternId": "R",
+      "rotation": 180
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C194\n- task_type: roll_to_target_top_face\n- difficulty: 2\n- target_top_face: patternId=G, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=arrow_up, rotation=180]\n[LEFT: patternId=arrow_right, rotation=90] [TOP: patternId=?, rotation=0] [RIGHT: patternId=G, rotation=90]\n  [FRONT: patternId=?, rotation=0]\n  [BOTTOM: patternId=R, rotation=180]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=arrow_up, rotation=180\n- LEFT: patternId=arrow_right, rotation=90\n- TOP: patternId=?, rotation=0\n- RIGHT: patternId=G, rotation=90\n- FRONT: patternId=?, rotation=0\n- BOTTOM: patternId=R, rotation=180\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C195.json

@@ -0,0 +1,198 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C195",
+  "name": "Goal Roll C195",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "W",
+          "rotation": 0
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "plus",
+          "rotation": 270
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "G",
+          "rotation": 270
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "W",
+        "rotation": 0
+      },
+      "FRONT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "RIGHT": {
+        "patternId": "plus",
+        "rotation": 270
+      },
+      "BACK": {
+        "patternId": "G",
+        "rotation": 270
+      },
+      "LEFT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 0,
+    "stepNumber": 1,
+    "patternId": "G",
+    "rotation": 180
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C195/initial_net.png",
+    "targetTopFaceImage": "../images/C195/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 2,
+    "tier": 2,
+    "targetStepNumber": 1,
+    "targetRotationOffset": 90,
+    "levelId": 195,
+    "moveCount": 4,
+    "sourceLevelPath": "levels/reconstruct/generated-195.json"
+  },
+  "rollSequence": [
+    "N",
+    "N",
+    "E",
+    "S"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "G",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "W",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "plus",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "G",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "N",
+      "N",
+      "E",
+      "S"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "W",
+      "rotation": 0
+    },
+    "FRONT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "RIGHT": {
+      "patternId": "plus",
+      "rotation": 270
+    },
+    "BACK": {
+      "patternId": "G",
+      "rotation": 270
+    },
+    "LEFT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C195\n- task_type: roll_to_target_top_face\n- difficulty: 2\n- target_top_face: patternId=G, rotation=180\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=G, rotation=270]\n[LEFT: patternId=?, rotation=0] [TOP: patternId=W, rotation=0] [RIGHT: patternId=plus, rotation=270]\n  [FRONT: patternId=?, rotation=0]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=G, rotation=270\n- LEFT: patternId=?, rotation=0\n- TOP: patternId=W, rotation=0\n- RIGHT: patternId=plus, rotation=270\n- FRONT: patternId=?, rotation=0\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C196.json

@@ -0,0 +1,198 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C196",
+  "name": "Goal Roll C196",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "D",
+          "rotation": 90
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "Q",
+          "rotation": 90
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "X",
+          "rotation": 180
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "FRONT": {
+        "patternId": "D",
+        "rotation": 90
+      },
+      "RIGHT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BACK": {
+        "patternId": "Q",
+        "rotation": 90
+      },
+      "LEFT": {
+        "patternId": "X",
+        "rotation": 180
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 1,
+    "stepNumber": 2,
+    "patternId": "D",
+    "rotation": 90
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C196/initial_net.png",
+    "targetTopFaceImage": "../images/C196/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 2,
+    "tier": 2,
+    "targetStepNumber": 2,
+    "targetRotationOffset": 90,
+    "levelId": 196,
+    "moveCount": 4,
+    "sourceLevelPath": "levels/reconstruct/generated-196.json"
+  },
+  "rollSequence": [
+    "W",
+    "N",
+    "S",
+    "S"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "X",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "Q",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "X",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "D",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "W",
+      "N",
+      "S",
+      "S"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "FRONT": {
+      "patternId": "D",
+      "rotation": 90
+    },
+    "RIGHT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BACK": {
+      "patternId": "Q",
+      "rotation": 90
+    },
+    "LEFT": {
+      "patternId": "X",
+      "rotation": 180
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C196\n- task_type: roll_to_target_top_face\n- difficulty: 2\n- target_top_face: patternId=D, rotation=90\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=Q, rotation=90]\n[LEFT: patternId=X, rotation=180] [TOP: patternId=?, rotation=0] [RIGHT: patternId=?, rotation=0]\n  [FRONT: patternId=D, rotation=90]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=Q, rotation=90\n- LEFT: patternId=X, rotation=180\n- TOP: patternId=?, rotation=0\n- RIGHT: patternId=?, rotation=0\n- FRONT: patternId=D, rotation=90\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C197.json

@@ -0,0 +1,198 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C197",
+  "name": "Goal Roll C197",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "T",
+          "rotation": 90
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "7",
+          "rotation": 90
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "5",
+          "rotation": 270
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "3",
+          "rotation": 90
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "T",
+        "rotation": 90
+      },
+      "FRONT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "RIGHT": {
+        "patternId": "7",
+        "rotation": 90
+      },
+      "BACK": {
+        "patternId": "5",
+        "rotation": 270
+      },
+      "LEFT": {
+        "patternId": "3",
+        "rotation": 90
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 3,
+    "stepNumber": 4,
+    "patternId": "7",
+    "rotation": 180
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C197/initial_net.png",
+    "targetTopFaceImage": "../images/C197/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 2,
+    "tier": 2,
+    "targetStepNumber": 4,
+    "targetRotationOffset": 270,
+    "levelId": 197,
+    "moveCount": 4,
+    "sourceLevelPath": "levels/reconstruct/generated-197.json"
+  },
+  "rollSequence": [
+    "N",
+    "E",
+    "N",
+    "N"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "5",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "7",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "T",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "3",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "N",
+      "E",
+      "N",
+      "N"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "T",
+      "rotation": 90
+    },
+    "FRONT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "RIGHT": {
+      "patternId": "7",
+      "rotation": 90
+    },
+    "BACK": {
+      "patternId": "5",
+      "rotation": 270
+    },
+    "LEFT": {
+      "patternId": "3",
+      "rotation": 90
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C197\n- task_type: roll_to_target_top_face\n- difficulty: 2\n- target_top_face: patternId=7, rotation=180\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=5, rotation=270]\n[LEFT: patternId=3, rotation=90] [TOP: patternId=T, rotation=90] [RIGHT: patternId=7, rotation=90]\n  [FRONT: patternId=?, rotation=0]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=5, rotation=270\n- LEFT: patternId=3, rotation=90\n- TOP: patternId=T, rotation=90\n- RIGHT: patternId=7, rotation=90\n- FRONT: patternId=?, rotation=0\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C198.json

@@ -0,0 +1,206 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C198",
+  "name": "Goal Roll C198",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "square",
+          "rotation": 270
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "arrow_right",
+          "rotation": 180
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "F",
+          "rotation": 90
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "Z",
+          "rotation": 270
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "square",
+        "rotation": 270
+      },
+      "FRONT": {
+        "patternId": "arrow_right",
+        "rotation": 180
+      },
+      "RIGHT": {
+        "patternId": "F",
+        "rotation": 90
+      },
+      "BACK": {
+        "patternId": "Z",
+        "rotation": 270
+      },
+      "LEFT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BOTTOM": {
+        "patternId": "?",
+        "rotation": 0
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 1,
+    "stepNumber": 2,
+    "patternId": "arrow_right",
+    "rotation": 0
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C198/initial_net.png",
+    "targetTopFaceImage": "../images/C198/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 2,
+    "tier": 2,
+    "targetStepNumber": 2,
+    "targetRotationOffset": 90,
+    "levelId": 198,
+    "moveCount": 5,
+    "sourceLevelPath": "levels/reconstruct/generated-198.json"
+  },
+  "rollSequence": [
+    "E",
+    "N",
+    "S",
+    "E",
+    "S"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "F",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "Z",
+      "rotation": 180,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "F",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "square",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "arrow_right",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "E",
+      "N",
+      "S",
+      "E",
+      "S"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "square",
+      "rotation": 270
+    },
+    "FRONT": {
+      "patternId": "arrow_right",
+      "rotation": 180
+    },
+    "RIGHT": {
+      "patternId": "F",
+      "rotation": 90
+    },
+    "BACK": {
+      "patternId": "Z",
+      "rotation": 270
+    },
+    "LEFT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BOTTOM": {
+      "patternId": "?",
+      "rotation": 0
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C198\n- task_type: roll_to_target_top_face\n- difficulty: 2\n- target_top_face: patternId=arrow_right, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=Z, rotation=270]\n[LEFT: patternId=?, rotation=0] [TOP: patternId=square, rotation=270] [RIGHT: patternId=F, rotation=90]\n  [FRONT: patternId=arrow_right, rotation=180]\n  [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=Z, rotation=270\n- LEFT: patternId=?, rotation=0\n- TOP: patternId=square, rotation=270\n- RIGHT: patternId=F, rotation=90\n- FRONT: patternId=arrow_right, rotation=180\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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/data/C199.json

@@ -0,0 +1,198 @@
+{
+  "taskType": "roll_to_target_top_face",
+  "code": "C199",
+  "name": "Goal Roll C199",
+  "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.",
+  "instructions": {
+    "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.",
+    "directionVocabulary": {
+      "N": "Up",
+      "S": "Down",
+      "W": "Left",
+      "E": "Right"
+    }
+  },
+  "initialCube": {
+    "net": {
+      "layout": "reconstruction_cross",
+      "faceOrder": [
+        "TOP",
+        "FRONT",
+        "RIGHT",
+        "BACK",
+        "LEFT",
+        "BOTTOM"
+      ],
+      "cells": [
+        {
+          "faceKey": "TOP",
+          "faceLabelZh": "TOP",
+          "row": 1,
+          "col": 1,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "FRONT",
+          "faceLabelZh": "FRONT",
+          "row": 2,
+          "col": 1,
+          "patternId": "circle",
+          "rotation": 180
+        },
+        {
+          "faceKey": "RIGHT",
+          "faceLabelZh": "RIGHT",
+          "row": 1,
+          "col": 2,
+          "patternId": "heart",
+          "rotation": 270
+        },
+        {
+          "faceKey": "BACK",
+          "faceLabelZh": "BACK",
+          "row": 0,
+          "col": 1,
+          "patternId": "B",
+          "rotation": 0
+        },
+        {
+          "faceKey": "LEFT",
+          "faceLabelZh": "LEFT",
+          "row": 1,
+          "col": 0,
+          "patternId": "?",
+          "rotation": 0
+        },
+        {
+          "faceKey": "BOTTOM",
+          "faceLabelZh": "BOTTOM",
+          "row": 3,
+          "col": 1,
+          "patternId": "M",
+          "rotation": 270
+        }
+      ]
+    },
+    "solutionFaces": {
+      "TOP": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "FRONT": {
+        "patternId": "circle",
+        "rotation": 180
+      },
+      "RIGHT": {
+        "patternId": "heart",
+        "rotation": 270
+      },
+      "BACK": {
+        "patternId": "B",
+        "rotation": 0
+      },
+      "LEFT": {
+        "patternId": "?",
+        "rotation": 0
+      },
+      "BOTTOM": {
+        "patternId": "M",
+        "rotation": 270
+      }
+    }
+  },
+  "targetTopFace": {
+    "sourceObservationIndex": 3,
+    "stepNumber": 4,
+    "patternId": "circle",
+    "rotation": 0
+  },
+  "answers": {
+    "directions": [],
+    "moveCount": 0,
+    "referenceValid": false
+  },
+  "imagePaths": {
+    "initialNetImage": "../images/C199/initial_net.png",
+    "targetTopFaceImage": "../images/C199/target_top_face.png"
+  },
+  "metadata": {
+    "difficulty": 2,
+    "tier": 2,
+    "targetStepNumber": 4,
+    "targetRotationOffset": 270,
+    "levelId": 199,
+    "moveCount": 4,
+    "sourceLevelPath": "levels/reconstruct/generated-199.json"
+  },
+  "rollSequence": [
+    "E",
+    "S",
+    "W",
+    "W"
+  ],
+  "observedPathFaces": [
+    {
+      "patternId": "heart",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "circle",
+      "rotation": 270,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "M",
+      "rotation": 0,
+      "flipHorizontal": false,
+      "flipVertical": true
+    },
+    {
+      "patternId": "B",
+      "rotation": 90,
+      "flipHorizontal": false,
+      "flipVertical": true
+    }
+  ],
+  "answer": {
+    "directions": [
+      "E",
+      "S",
+      "W",
+      "W"
+    ]
+  },
+  "legacy_answer": {
+    "TOP": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "FRONT": {
+      "patternId": "circle",
+      "rotation": 180
+    },
+    "RIGHT": {
+      "patternId": "heart",
+      "rotation": 270
+    },
+    "BACK": {
+      "patternId": "B",
+      "rotation": 0
+    },
+    "LEFT": {
+      "patternId": "?",
+      "rotation": 0
+    },
+    "BOTTOM": {
+      "patternId": "M",
+      "rotation": 270
+    }
+  },
+  "prompt": {
+    "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\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 directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. 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 you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.",
+    "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C199\n- task_type: roll_to_target_top_face\n- difficulty: 2\n- target_top_face: patternId=circle, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n  [BACK: patternId=B, rotation=0]\n[LEFT: patternId=?, rotation=0] [TOP: patternId=?, rotation=0] [RIGHT: patternId=heart, rotation=270]\n  [FRONT: patternId=circle, rotation=180]\n  [BOTTOM: patternId=M, rotation=270]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=B, rotation=0\n- LEFT: patternId=?, rotation=0\n- TOP: patternId=?, rotation=0\n- RIGHT: patternId=heart, rotation=270\n- FRONT: patternId=circle, rotation=180\n- BOTTOM: patternId=M, rotation=270\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"<N|S|E|W>\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\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."
+  }
+}