Update app.py

app.py

@@ -1254,7 +1254,7 @@ If you find any "Code-Blocks" then,
     logger.info("Plan refinement and block relation analysis completed for all plans.")
     return state
 
-# Node: Node Optimizer node
+# Node2: Node Optimizer node
 def node_optimizer(state: GameState):
     logger.info("--- Running Node Optimizer Node ---")
     project_json = state["project_json"]
@@ -1302,820 +1302,820 @@ def node_optimizer(state: GameState):
         logger.error(f"Error in Node Optimizer Node: {e}")
 
 # Node 2: planner node
-def overall_planner_node(state: GameState):
-    """
-    Generates a comprehensive action plan for sprites, including detailed Scratch block information.
-    This node acts as an overall planner, leveraging knowledge of all block shapes and categories.
-    """
-    logger.info("--- Running OverallPlannerNode ---")
-
-    project_json = state["project_json"]
-    raw = state.get("pseudo_code", {})
-    refined_logic_data = raw.get("refined_logic", {})
-    sprite_name = refined_logic_data.get("name_variable", "<unknown>")
-    pseudo      = refined_logic_data.get("pseudocode", "")
-
-    # MODIFICATION 1: Include 'Stage' in the list of names to plan for.
-    # It's crucial to ensure 'Stage' is always present for its global role.
-    target_names = [t["name"] for t in project_json["targets"]]
-
-    # MODIFICATION 2: Get sprite positions, providing default for Stage as it doesn't have x,y
-    sprite_positions = {}
-    for target in project_json["targets"]:
-        if not target["isStage"]:
-            sprite_positions[target["name"]] = {"x": target.get("x", 0), "y": target.get("y", 0)}
-        else:
-            sprite_positions[target["name"]] = {"x": "N/A", "y": "N/A"} # Stage doesn't have positional coordinates
-
-    # declaration_plan = state["declaration_plan"]
-
-    planning_prompt = f"""
-Generate a detailed action plan for the game's sprites and stage based on the given pseudo-code and sprite details for the given sprite name and .
-
-Description: 
-    **Sprite_name**: {sprite_name} 
-    **and its corresponding Pseudo_code:** 
-    '{pseudo}'
-
-[Note: Make sure you just refine the pseudo code by correting mistake and adding the missing opcode if any and *Do not* generate any new logic]
-----
-**Targets in Game (Sprites and Stage) available in project_json:** {', '.join(target_names)}
-
---- Scratch 3.0 Block Reference ---
-This section provides a comprehensive reference of Scratch 3.0 blocks, categorized by shape, including their opcodes and functional descriptions. Use this to accurately identify block types and behavior.
-
-### Hat Blocks
-Description: {hat_description}
-Blocks:
-{hat_opcodes_functionalities}
-
-### Boolean Blocks
-Description: {boolean_description}
-Blocks:
-{boolean_opcodes_functionalities}
-
-### C Blocks
-Description: {c_description}
-Blocks:
-{c_opcodes_functionalities}
-
-### Cap Blocks
-Description: {cap_description}
-Blocks:
-{cap_opcodes_functionalities}
-
-### Reporter Blocks
-Description: {reporter_description}
-Blocks:
-{reporter_opcodes_functionalities}
-
-### Stack Blocks
-Description: {stack_description}
-Blocks:
-{stack_opcodes_functionalities}
-
------------------------------------
-
-Your task is to  use the `Sprite_name` given and `Pseudo_code` and add it to the specific target name and define the primary actions and movements.
-The output should be a JSON object with a single key 'action_overall_flow'. Each key inside this object should be a sprite or 'Stage' name (e.g., 'Player', 'Enemy', 'Stage'), and its value must include a 'description' and a list of 'plans'.
-The first plan in each stage must start with one Scratch Hat Block (e.g., event_whenflagclicked).
-Other plans may use any hat blocks (including duplicates) to represent different logics or events.
-Each plan must include a **single Scratch Hat Block** (e.g., 'event_whenflagclicked') to start scratch project and should contain:
-
-1. **'event'**: the exact `opcode` of the hat block that initiates the logic.
-[NOTE: INSTRUCTIONN TO FOLLOW IF PSEUDO_CODE HAVING PROBLEM ]
-2. **'logic'**: a natural language breakdown of each step taken after the event, formatted as a multi-line string representing pseudo-code. Ensure clarity and granularity—each described action should map closely to a Scratch block or tight sequence.
-    - Use 'forever: ...' or 'repeat(10): ...' to prefix repeating logic suitable taking reference from the C blocks.
-    - Use Scratch-consistent verbs: 'move', 'change', 'wait', 'hide', 'show', 'say', 'glide', etc.
-    - **Numeric values** `(e.g., 0, 5, 0.2, -130)` **must** be in parentheses: `(0)`, `(5)`, `(0.2)`, `(-130)`.
-   - **AlphaNumeric values** `(e.g., hello, say 5, 4, hi!)` **must** be in parentheses: `(hello)`, `(say 5)`, `(4)`, `(hi!)`.
-   - **Variables** must be in the form `[variable v]` (e.g., `[score v]`), even when used inside expressions two example use `set [score v] to (1)` or `show variable ([speed v])`.
-   - **Dropdown options** must be in the form `[option v]` (e.g., `[Game Start v]`, `[blue sky v]`). example use `when [space v] key pressed`.
-   - **Reporter blocks** used as inputs must be double‑wrapped: `((x position))`, `((y position))`. example use `if <((y position)) = (-130)> then` or `(((x position)) * (1))`.
-   - **Boolean blocks** in conditions must be inside `< >`, including nested ones: `<not <condition>>`, `<<cond1> and <cond2>>`,`<<cond1> or <cond2>>`.
-   - **Other Boolean blocks** in conditions must be inside `< >`, including nested ones or values or variables: `<(block/value/variable) * (block/value/variable)>`,`<(block/value/variable) < (block/value/variable)>`, and example of another variable`<[apple v] contains [a v]?>`.
-   - **Operator expressions** must use explicit Scratch operator blocks, e.g.:
-     ```
-     (([ballSpeed v]) * (1.1))
-     ```
-   - **Every hat block script must end** with a final `end` on its own line.
-   - **Indent nested blocks by 4 spaces under their parent (`forever`, `if`, etc.).This is a critical requirement.**
-3. **Opcode Lists**: include relevant Scratch opcodes grouped under `motion`, `control`, `operator`, `sensing`, `looks`, `sounds`, `events`, and `data`. List only the non-empty categories. Use exact opcodes.
-4. Few Example of content of logics inside for a specific plan as scratch pseudo-code:
-    - example 1[continues moving objects]:
-    ```
-    when green flag clicked
-        go to x: (240) y: (-100)
-        set [speed v] to (-5)
-        show variable [speed v]
-        forever
-            change x by ([speed v])
-            if <((x position)) < (-240)> then 
-                go to x: (240) y: (-100) 
-            end
-        end
-    end
-    ```
-    - example 2[jumping script of an plan]: 
-    ```    
-    when [space v] key pressed
-        if <((y position)) = (-100)> then 
-            repeat (5)
-                change y by (100) 
-                wait (0.1) seconds
-                change y by (-100) 
-                wait (0.1) seconds
-            end
-        end
-    end
-    ```
-   - example 3 [pattern for level up and increase difficulty]:
-   ```
-   when I receive [Level Up v]
-       change [level v] by (1)
-       set [ballSpeed v] to ((([ballSpeed v]) * (1.1)))
-   end
-   ```
-5. Use target names exactly as listed in `Targets in Game`. Do NOT rename or invent new targets.
-6. Ensure the plan reflects accurate opcode usage derived strictly from the block reference above.
-7. Few shot Example structure for 'action_overall_flow':
-```json
-{{
-    "action_overall_flow": {{
-        "Stage": {{
-            "description": "Background and global game state management, including broadcasts, rewards, and score.",
-            "plans": [
-                {{
-                    "event": "event_whenflagclicked",
-                    "logic": "when green flag clicked\n    switch backdrop to [backdrop1 v]\n    set [score v] to 0\n    show variable [score v]\n    broadcast [Game Start v]\nend",
-                    "motion": [],
-                    "control": [],
-                    "operator": [],
-                    "sensing": [],
-                    "looks": [
-                        "looks_switchbackdropto"
-                    ],
-                    "sounds": [],
-                    "events": [
-                        "event_broadcast"
-                    ],
-                    "data": [
-                        "data_setvariableto",
-                        "data_showvariable"
-                    ]
-                }},
-                {{
-                    "event": "event_whenbroadcastreceived",
-                    "logic": "when I receive [Game Over v]\n    if <(score) > (High Score)> then\n        set [High Score v] to (score)\n    end\n    switch backdrop to [HighScore v]\nend",
-                    "motion": [],
-                    "control": [
-                        "control_if"
-                    ],
-                    "operator": [
-                        "operator_gt"
-                    ],
-                    "sensing": [],
-                    "looks": [
-                        "looks_switchbackdropto"
-                    ],
-                    "sounds": [],
-                    "events": [],
-                    "data": [
-                        "data_setvariableto"
-                    ]
-                }}
-            ]
-        }},
-        "Sprite1": {{
-            "description": "Main character (cat) actions",
-            "plans": [
-                {{
-                    "event": "event_whenflagclicked",
-                    "logic": "when green flag clicked\n    go to x: 240 y: -100\nend",
-                    "motion": [
-                        "motion_gotoxy"
-                    ],
-                    "control": [],
-                    "operator": [],
-                    "sensing": [],
-                    "looks": [],
-                    "sounds": [],
-                    "events": [],
-                    "data": []
-                }},
-                {{
-                    "event": "event_whenkeypressed",
-                    "logic": "when [space v] key pressed\n    repeat (10)\n        change y by (20)\n        wait (0.1) seconds\n        change y by (-20)\n    end\nend",
-                    "motion": [
-                        "motion_changeyby"
-                    ],
-                    "control": [
-                        "control_repeat",
-                        "control_wait"
-                    ],
-                    "operator": [],
-                    "sensing": [],
-                    "looks": [],
-                    "sounds": [],
-                    "events": [],
-                    "data": []
-                }}
-            ]
-        }},
-        "soccer ball": {{
-            "description": "Obstacle movement and interaction",
-            "plans": [
-                {{
-                    "event": "event_whenflagclicked",
-                    "logic": "when green flag clicked\n    go to x: 240 y: -135\n    forever\n        glide 2 seconds to x: -240 y: -135\n        if <(x position) < -235> then\n            set x to 240\n        end\n        if <touching [Sprite1 v]?> then\n            broadcast [Game Over v]\n            stop [all v]\n        end\n    end\nend",
-                    "motion": [
-                        "motion_gotoxy",
-                        "motion_glidesecstoxy",
-                        "motion_xposition",
-                        "motion_setx"
-                    ],
-                    "control": [
-                        "control_forever",
-                        "control_if",
-                        "control_stop"
-                    ],
-                    "operator": [
-                        "operator_lt"
-                    ],
-                    "sensing": [
-                        "sensing_touchingobject",
-                        "sensing_touchingobjectmenu"
-                    ],
-                    "looks": [],
-                    "sounds": [],
-                    "events": [
-                        "event_broadcast"
-                    ],
-                    "data": []
-                }}
-            ]
-        }}
-
-    }}
-}}
-```
-8.  Based on the provided context, generate the `action_overall_flow`.
-    - Maintain the **exact JSON structure** shown above.
-    - All `logic` fields must be **clear and granular**.
-    - Only include opcode categories that contain relevant opcodes.
-    - Ensure that each opcode matches its intended Scratch functionality.
-    - If feedback suggests major change, **rethink the entire plan** for the affected sprite(s).
-    - If feedback is minor, make precise, minimal improvements only.
-"""
+# def overall_planner_node(state: GameState):
+#     """
+#     Generates a comprehensive action plan for sprites, including detailed Scratch block information.
+#     This node acts as an overall planner, leveraging knowledge of all block shapes and categories.
+#     """
+#     logger.info("--- Running OverallPlannerNode ---")
+
+#     project_json = state["project_json"]
+#     raw = state.get("pseudo_code", {})
+#     refined_logic_data = raw.get("refined_logic", {})
+#     sprite_name = refined_logic_data.get("name_variable", "<unknown>")
+#     pseudo      = refined_logic_data.get("pseudocode", "")
+
+#     # MODIFICATION 1: Include 'Stage' in the list of names to plan for.
+#     # It's crucial to ensure 'Stage' is always present for its global role.
+#     target_names = [t["name"] for t in project_json["targets"]]
+
+#     # MODIFICATION 2: Get sprite positions, providing default for Stage as it doesn't have x,y
+#     sprite_positions = {}
+#     for target in project_json["targets"]:
+#         if not target["isStage"]:
+#             sprite_positions[target["name"]] = {"x": target.get("x", 0), "y": target.get("y", 0)}
+#         else:
+#             sprite_positions[target["name"]] = {"x": "N/A", "y": "N/A"} # Stage doesn't have positional coordinates
+
+#     # declaration_plan = state["declaration_plan"]
+
+#     planning_prompt = f"""
+# Generate a detailed action plan for the game's sprites and stage based on the given pseudo-code and sprite details for the given sprite name and .
+
+# Description: 
+#     **Sprite_name**: {sprite_name} 
+#     **and its corresponding Pseudo_code:** 
+#     '{pseudo}'
+
+# [Note: Make sure you just refine the pseudo code by correting mistake and adding the missing opcode if any and *Do not* generate any new logic]
+# ----
+# **Targets in Game (Sprites and Stage) available in project_json:** {', '.join(target_names)}
+
+# --- Scratch 3.0 Block Reference ---
+# This section provides a comprehensive reference of Scratch 3.0 blocks, categorized by shape, including their opcodes and functional descriptions. Use this to accurately identify block types and behavior.
+
+# ### Hat Blocks
+# Description: {hat_description}
+# Blocks:
+# {hat_opcodes_functionalities}
+
+# ### Boolean Blocks
+# Description: {boolean_description}
+# Blocks:
+# {boolean_opcodes_functionalities}
+
+# ### C Blocks
+# Description: {c_description}
+# Blocks:
+# {c_opcodes_functionalities}
+
+# ### Cap Blocks
+# Description: {cap_description}
+# Blocks:
+# {cap_opcodes_functionalities}
+
+# ### Reporter Blocks
+# Description: {reporter_description}
+# Blocks:
+# {reporter_opcodes_functionalities}
+
+# ### Stack Blocks
+# Description: {stack_description}
+# Blocks:
+# {stack_opcodes_functionalities}
+
+# -----------------------------------
+
+# Your task is to  use the `Sprite_name` given and `Pseudo_code` and add it to the specific target name and define the primary actions and movements.
+# The output should be a JSON object with a single key 'action_overall_flow'. Each key inside this object should be a sprite or 'Stage' name (e.g., 'Player', 'Enemy', 'Stage'), and its value must include a 'description' and a list of 'plans'.
+# The first plan in each stage must start with one Scratch Hat Block (e.g., event_whenflagclicked).
+# Other plans may use any hat blocks (including duplicates) to represent different logics or events.
+# Each plan must include a **single Scratch Hat Block** (e.g., 'event_whenflagclicked') to start scratch project and should contain:
+
+# 1. **'event'**: the exact `opcode` of the hat block that initiates the logic.
+# [NOTE: INSTRUCTIONN TO FOLLOW IF PSEUDO_CODE HAVING PROBLEM ]
+# 2. **'logic'**: a natural language breakdown of each step taken after the event, formatted as a multi-line string representing pseudo-code. Ensure clarity and granularity—each described action should map closely to a Scratch block or tight sequence.
+#     - Use 'forever: ...' or 'repeat(10): ...' to prefix repeating logic suitable taking reference from the C blocks.
+#     - Use Scratch-consistent verbs: 'move', 'change', 'wait', 'hide', 'show', 'say', 'glide', etc.
+#     - **Numeric values** `(e.g., 0, 5, 0.2, -130)` **must** be in parentheses: `(0)`, `(5)`, `(0.2)`, `(-130)`.
+#    - **AlphaNumeric values** `(e.g., hello, say 5, 4, hi!)` **must** be in parentheses: `(hello)`, `(say 5)`, `(4)`, `(hi!)`.
+#    - **Variables** must be in the form `[variable v]` (e.g., `[score v]`), even when used inside expressions two example use `set [score v] to (1)` or `show variable ([speed v])`.
+#    - **Dropdown options** must be in the form `[option v]` (e.g., `[Game Start v]`, `[blue sky v]`). example use `when [space v] key pressed`.
+#    - **Reporter blocks** used as inputs must be double‑wrapped: `((x position))`, `((y position))`. example use `if <((y position)) = (-130)> then` or `(((x position)) * (1))`.
+#    - **Boolean blocks** in conditions must be inside `< >`, including nested ones: `<not <condition>>`, `<<cond1> and <cond2>>`,`<<cond1> or <cond2>>`.
+#    - **Other Boolean blocks** in conditions must be inside `< >`, including nested ones or values or variables: `<(block/value/variable) * (block/value/variable)>`,`<(block/value/variable) < (block/value/variable)>`, and example of another variable`<[apple v] contains [a v]?>`.
+#    - **Operator expressions** must use explicit Scratch operator blocks, e.g.:
+#      ```
+#      (([ballSpeed v]) * (1.1))
+#      ```
+#    - **Every hat block script must end** with a final `end` on its own line.
+#    - **Indent nested blocks by 4 spaces under their parent (`forever`, `if`, etc.).This is a critical requirement.**
+# 3. **Opcode Lists**: include relevant Scratch opcodes grouped under `motion`, `control`, `operator`, `sensing`, `looks`, `sounds`, `events`, and `data`. List only the non-empty categories. Use exact opcodes.
+# 4. Few Example of content of logics inside for a specific plan as scratch pseudo-code:
+#     - example 1[continues moving objects]:
+#     ```
+#     when green flag clicked
+#         go to x: (240) y: (-100)
+#         set [speed v] to (-5)
+#         show variable [speed v]
+#         forever
+#             change x by ([speed v])
+#             if <((x position)) < (-240)> then 
+#                 go to x: (240) y: (-100) 
+#             end
+#         end
+#     end
+#     ```
+#     - example 2[jumping script of an plan]: 
+#     ```    
+#     when [space v] key pressed
+#         if <((y position)) = (-100)> then 
+#             repeat (5)
+#                 change y by (100) 
+#                 wait (0.1) seconds
+#                 change y by (-100) 
+#                 wait (0.1) seconds
+#             end
+#         end
+#     end
+#     ```
+#    - example 3 [pattern for level up and increase difficulty]:
+#    ```
+#    when I receive [Level Up v]
+#        change [level v] by (1)
+#        set [ballSpeed v] to ((([ballSpeed v]) * (1.1)))
+#    end
+#    ```
+# 5. Use target names exactly as listed in `Targets in Game`. Do NOT rename or invent new targets.
+# 6. Ensure the plan reflects accurate opcode usage derived strictly from the block reference above.
+# 7. Few shot Example structure for 'action_overall_flow':
+# ```json
+# {{
+#     "action_overall_flow": {{
+#         "Stage": {{
+#             "description": "Background and global game state management, including broadcasts, rewards, and score.",
+#             "plans": [
+#                 {{
+#                     "event": "event_whenflagclicked",
+#                     "logic": "when green flag clicked\n    switch backdrop to [backdrop1 v]\n    set [score v] to 0\n    show variable [score v]\n    broadcast [Game Start v]\nend",
+#                     "motion": [],
+#                     "control": [],
+#                     "operator": [],
+#                     "sensing": [],
+#                     "looks": [
+#                         "looks_switchbackdropto"
+#                     ],
+#                     "sounds": [],
+#                     "events": [
+#                         "event_broadcast"
+#                     ],
+#                     "data": [
+#                         "data_setvariableto",
+#                         "data_showvariable"
+#                     ]
+#                 }},
+#                 {{
+#                     "event": "event_whenbroadcastreceived",
+#                     "logic": "when I receive [Game Over v]\n    if <(score) > (High Score)> then\n        set [High Score v] to (score)\n    end\n    switch backdrop to [HighScore v]\nend",
+#                     "motion": [],
+#                     "control": [
+#                         "control_if"
+#                     ],
+#                     "operator": [
+#                         "operator_gt"
+#                     ],
+#                     "sensing": [],
+#                     "looks": [
+#                         "looks_switchbackdropto"
+#                     ],
+#                     "sounds": [],
+#                     "events": [],
+#                     "data": [
+#                         "data_setvariableto"
+#                     ]
+#                 }}
+#             ]
+#         }},
+#         "Sprite1": {{
+#             "description": "Main character (cat) actions",
+#             "plans": [
+#                 {{
+#                     "event": "event_whenflagclicked",
+#                     "logic": "when green flag clicked\n    go to x: 240 y: -100\nend",
+#                     "motion": [
+#                         "motion_gotoxy"
+#                     ],
+#                     "control": [],
+#                     "operator": [],
+#                     "sensing": [],
+#                     "looks": [],
+#                     "sounds": [],
+#                     "events": [],
+#                     "data": []
+#                 }},
+#                 {{
+#                     "event": "event_whenkeypressed",
+#                     "logic": "when [space v] key pressed\n    repeat (10)\n        change y by (20)\n        wait (0.1) seconds\n        change y by (-20)\n    end\nend",
+#                     "motion": [
+#                         "motion_changeyby"
+#                     ],
+#                     "control": [
+#                         "control_repeat",
+#                         "control_wait"
+#                     ],
+#                     "operator": [],
+#                     "sensing": [],
+#                     "looks": [],
+#                     "sounds": [],
+#                     "events": [],
+#                     "data": []
+#                 }}
+#             ]
+#         }},
+#         "soccer ball": {{
+#             "description": "Obstacle movement and interaction",
+#             "plans": [
+#                 {{
+#                     "event": "event_whenflagclicked",
+#                     "logic": "when green flag clicked\n    go to x: 240 y: -135\n    forever\n        glide 2 seconds to x: -240 y: -135\n        if <(x position) < -235> then\n            set x to 240\n        end\n        if <touching [Sprite1 v]?> then\n            broadcast [Game Over v]\n            stop [all v]\n        end\n    end\nend",
+#                     "motion": [
+#                         "motion_gotoxy",
+#                         "motion_glidesecstoxy",
+#                         "motion_xposition",
+#                         "motion_setx"
+#                     ],
+#                     "control": [
+#                         "control_forever",
+#                         "control_if",
+#                         "control_stop"
+#                     ],
+#                     "operator": [
+#                         "operator_lt"
+#                     ],
+#                     "sensing": [
+#                         "sensing_touchingobject",
+#                         "sensing_touchingobjectmenu"
+#                     ],
+#                     "looks": [],
+#                     "sounds": [],
+#                     "events": [
+#                         "event_broadcast"
+#                     ],
+#                     "data": []
+#                 }}
+#             ]
+#         }}
+
+#     }}
+# }}
+# ```
+# 8.  Based on the provided context, generate the `action_overall_flow`.
+#     - Maintain the **exact JSON structure** shown above.
+#     - All `logic` fields must be **clear and granular**.
+#     - Only include opcode categories that contain relevant opcodes.
+#     - Ensure that each opcode matches its intended Scratch functionality.
+#     - If feedback suggests major change, **rethink the entire plan** for the affected sprite(s).
+#     - If feedback is minor, make precise, minimal improvements only.
+# """
 
-    try:
-        response = agent.invoke({"messages": [{"role": "user", "content": planning_prompt}]})
-        print("Raw response from LLM [OverallPlannerNode 1]:",response)
-        raw_response = response["messages"][-1].content#strip_noise(response["messages"][-1].content)
-        print("Raw response from LLM [OverallPlannerNode 2]:", raw_response) # Uncomment for debugging
-        # json debugging and solving
-        try:
-            overall_plan = extract_json_from_llm_response(raw_response)
-        except json.JSONDecodeError as error_json:
-            logger.error("Failed to extract JSON from LLM response. Attempting to correct the response.")
-            # Use the JSON resolver agent to fix the response
-            correction_prompt = (
-                "Your task is to correct the provided JSON string to ensure it is **syntactically perfect and adheres strictly to JSON rules**.\n"
-                "Carefully review the JSON for any errors, especially focusing on the reported error at:\n"
-                f"- **Error Details**: {error_json}\n\n"
-                "**Strict Instructions for your response:**\n"
-                "1. **ONLY** output the corrected JSON. Do not include any other text, comments, or explanations outside the JSON.\n"
-                "2. Ensure all property names (keys) are enclosed in **double quotes**.\n"
-                "3. Ensure string values are correctly enclosed in **double quotes** and any internal special characters (like newlines `\\n`, tabs `\\t`, backslashes `\\\\`, or double quotes `\\`) are properly **escaped**.\n"
-                "4. Verify that there are **no extra commas**, especially between key-value pairs or after the last element in an object or array.\n"
-                "5. Ensure proper nesting and matching of curly braces `{}` and square brackets `[]`.\n"
-                "6. **Crucially, remove any extraneous characters or duplicate closing braces outside the main JSON object.**\n"
-                "7. The corrected JSON must be a **complete and valid** JSON object.\n\n"
-                "Here is the problematic JSON string to correct:\n"
-                "```json\n"
-                f"{raw_response}\n"
-                "```\n"
-                "Corrected JSON:\n"
-            )
-            correction_response = agent_json_resolver.invoke({"messages": [{"role": "user", "content": correction_prompt}]})
-            print(f"[JSON CORRECTOR RESPONSE AT OVERALLPLANNERNODE ]: {correction_response['messages'][-1].content}")
-            overall_plan= extract_json_from_llm_response(correction_response['messages'][-1].content)#strip_noise(correction_response["messages"][-1].content))
+#     try:
+#         response = agent.invoke({"messages": [{"role": "user", "content": planning_prompt}]})
+#         print("Raw response from LLM [OverallPlannerNode 1]:",response)
+#         raw_response = response["messages"][-1].content#strip_noise(response["messages"][-1].content)
+#         print("Raw response from LLM [OverallPlannerNode 2]:", raw_response) # Uncomment for debugging
+#         # json debugging and solving
+#         try:
+#             overall_plan = extract_json_from_llm_response(raw_response)
+#         except json.JSONDecodeError as error_json:
+#             logger.error("Failed to extract JSON from LLM response. Attempting to correct the response.")
+#             # Use the JSON resolver agent to fix the response
+#             correction_prompt = (
+#                 "Your task is to correct the provided JSON string to ensure it is **syntactically perfect and adheres strictly to JSON rules**.\n"
+#                 "Carefully review the JSON for any errors, especially focusing on the reported error at:\n"
+#                 f"- **Error Details**: {error_json}\n\n"
+#                 "**Strict Instructions for your response:**\n"
+#                 "1. **ONLY** output the corrected JSON. Do not include any other text, comments, or explanations outside the JSON.\n"
+#                 "2. Ensure all property names (keys) are enclosed in **double quotes**.\n"
+#                 "3. Ensure string values are correctly enclosed in **double quotes** and any internal special characters (like newlines `\\n`, tabs `\\t`, backslashes `\\\\`, or double quotes `\\`) are properly **escaped**.\n"
+#                 "4. Verify that there are **no extra commas**, especially between key-value pairs or after the last element in an object or array.\n"
+#                 "5. Ensure proper nesting and matching of curly braces `{}` and square brackets `[]`.\n"
+#                 "6. **Crucially, remove any extraneous characters or duplicate closing braces outside the main JSON object.**\n"
+#                 "7. The corrected JSON must be a **complete and valid** JSON object.\n\n"
+#                 "Here is the problematic JSON string to correct:\n"
+#                 "```json\n"
+#                 f"{raw_response}\n"
+#                 "```\n"
+#                 "Corrected JSON:\n"
+#             )
+#             correction_response = agent_json_resolver.invoke({"messages": [{"role": "user", "content": correction_prompt}]})
+#             print(f"[JSON CORRECTOR RESPONSE AT OVERALLPLANNERNODE ]: {correction_response['messages'][-1].content}")
+#             overall_plan= extract_json_from_llm_response(correction_response['messages'][-1].content)#strip_noise(correction_response["messages"][-1].content))
             
-        state["action_plan"] = overall_plan
-        logger.info("Overall plan generated by OverallPlannerNode.")
+#         state["action_plan"] = overall_plan
+#         logger.info("Overall plan generated by OverallPlannerNode.")
         
-        # with open("debug_state.json", "w", encoding="utf-8") as f:
-        #     json.dump(state, f, indent=2, ensure_ascii=False)
+#         # with open("debug_state.json", "w", encoding="utf-8") as f:
+#         #     json.dump(state, f, indent=2, ensure_ascii=False)
             
-        return state
+#         return state
             
-    except Exception as e:
-        logger.error(f"Error in OverallPlannerNode: {e}")
-        raise
-# Node 3: refiner node
-def refined_planner_node(state: GameState):
-    """
-    Refines the action plan based on validation feedback and game description.
-    """
-    logger.info("--- Running RefinedPlannerNode ---")
-    raw = state.get("pseudo_code", {})
-    refined_logic_data = raw.get("refined_logic", {})
-    sprite_name = refined_logic_data.get("name_variable", "<unknown>")
-    pseudo      = refined_logic_data.get("pseudocode", "")
-    #detailed_game_description = state.get("detailed_game_description", state.get("description", "A game."))
-    current_action_plan = state.get("action_plan", {})
-    print(f"[current_action_plan before refinement] on ({state.get('iteration_count', 0)}): {json.dumps(current_action_plan, indent=2)}")
-    plan_validation_feedback = state.get("plan_validation_feedback", "No specific feedback provided. Assume general refinement is needed.")
-    project_json = state["project_json"]
-    target_names = [t["name"] for t in project_json["targets"]]
-
-    # MODIFICATION 2: Get sprite positions, providing default for Stage as it doesn't have x,y
-    sprite_positions = {}
-    for target in project_json["targets"]:
-        if not target["isStage"]:
-            sprite_positions[target["name"]] = {"x": target.get("x", 0), "y": target.get("y", 0)}
-        else:
-            sprite_positions[target["name"]] = {"x": "N/A", "y": "N/A"} # Stage doesn't have positional coordinates
-
-    #declaration_plan = state["declaration_plan"]
-
-    refinement_prompt = f"""
-Refine and correct the JSON object `action_overall_flow` so that it fully aligns with the detailed game description, sprite positions, variable/broadcast declarations, and Scratch 3.0 block reference—while also validating for common formatting or opcode errors.
-
-Here is the overall script available:
-**Sprite name**: {sprite_name} 
-**and its corresponding Pseudo_code:** 
-'{pseudo}'
-
-[Note: Make sure you just refine the pseudo code by correting mistake and adding the missing opcode if any and *Do not* generate any new logic]
----
-**Targets in Game (Sprites and Stage):** {', '.join(target_names)}  
-**Current action plan:**  
-{current_action_plan}
-
-**Validation Feedback:**  
-'{plan_validation_feedback}'
-
---- Scratch 3.0 Block Reference ---
-### Hat Blocks
-{hat_opcodes_functionalities}
-
-### Boolean Blocks
-{boolean_opcodes_functionalities}
-
-### C Blocks
-{c_opcodes_functionalities}
-
-### Cap Blocks
-{cap_opcodes_functionalities}
-
-### Reporter Blocks
-{reporter_opcodes_functionalities}
-
-### Stack Blocks
-{stack_opcodes_functionalities}
-
------------------------------------
-
-* **Your task is to align to description, refine and correct the JSON object 'action_overall_flow'.**
-Use sprite names exactly as provided in `sprite_names` (e.g., 'Sprite1', 'soccer ball'); and also the stage, do **NOT** rename them.
-Other plans may use any hat blocks (including duplicates) to represent different logics or events.
-Each plan must include a **single Scratch Hat Block** (e.g., 'event_whenflagclicked') to start scratch project and should contain:
-1.  **'event'**: the exact `opcode` of the hat block that initiates the logic.
-2. **'logic'**: a natural language breakdown of each step taken after the event, formatted as a multi-line string representing pseudo-code. Ensure clarity and granularity—each described action should map closely to a Scratch block or tight sequence.
-    - Do **NOT** include any justification or comments—only the raw logic.
-    - Use 'forever: ...' or 'repeat(10): ...' to prefix repeating logic suitable taking reference from the C blocks.
-    - Use Scratch-consistent verbs: 'move', 'change', 'wait', 'hide', 'show', 'say', 'glide', etc.
-    - **Numeric values** `(e.g., 0, 5, 0.2, -130)` **must** be in parentheses: `(0)`, `(5)`, `(0.2)`, `(-130)`.
-   - **AlphaNumeric values** `(e.g., hello, say 5, 4, hi!)` **must** be in parentheses: `(hello)`, `(say 5)`, `(4)`, `(hi!)`.
-   - **Variables** must be in the form `[variable v]` (e.g., `[score v]`), even when used inside expressions two example use `set [score v] to (1)` or `show variable ([speed v])`.
-   - **Dropdown options** must be in the form `[option v]` (e.g., `[Game Start v]`, `[blue sky v]`). example use `when [space v] key pressed`.
-   - **Reporter blocks** used as inputs must be double‑wrapped: `((x position))`, `((y position))`. example use `if <((y position)) = (-130)> then` or `(((x position)) * (1))`.
-   - **Boolean blocks** in conditions must be inside `< >`, including nested ones: `<not <condition>>`, `<<cond1> and <cond2>>`,`<<cond1> or <cond2>>`.
-   - **Other Boolean blocks** in conditions must be inside `< >`, including nested ones or values or variables: `<(block/value/variable) * (block/value/variable)>`,`<(block/value/variable) < (block/value/variable)>`, and example of another variable`<[apple v] contains [a v]?>`.
-   - **Operator expressions** must use explicit Scratch operator blocks, e.g.:
-     ```
-     (([ballSpeed v]) * (1.1))
-     ```
-   - **Every hat block script must end** with a final `end` on its own line.
-3. **Validation & Formatting Checks**  
-   - **Opcode Coverage**: Ensure every action in `logic` has a matching opcode in the lists.  
-   - **Bracket Nesting**: Confirm every `(` has a matching `)`, e.g., `(pick random (100) to (-100))`.  
-   - **Operator Formatting**: Validate that operators use Scratch operator blocks, not inline math.  
-   - **Common Errors**:  
-     - `pick random (100,-100)` → `(pick random (100) to (-100))`  
-     - Missing `end` at script conclusion  
-     - Unwrapped reporter inputs or Boolean tests
-4. **Opcode Lists**: include relevant Scratch opcodes grouped under `motion`, `control`, `operator`, `sensing`, `looks`, `sounds`, `events`, and `data`. List only the non-empty categories. Use exact opcodes from the given Scratch 3.0 Block Reference.
-5. Few Example of content of logics inside for a specific plan as scratch pseudo-code:
-    - example 1[continues moving objects]:
-    ```
-    when green flag clicked
-        go to x: (240) y: (-100)
-        set [speed v] to (-5)
-        show variable [speed v]
-        forever
-            change x by ([speed v])
-            if <((x position)) < (-240)> then 
-                go to x: (240) y: (-100) 
-            end
-        end
-    end
-    ```
-    - example 2[jumping script of an plan]: 
-    ```    
-    when [space v] key pressed
-        if <((y position)) = (-100)> then 
-            repeat (5)
-                change y by (100) 
-                wait (0.1) seconds
-                change y by (-100) 
-                wait (0.1) seconds
-            end
-        end
-    end
-    ```
-   - example 3 [pattern for level up and increase difficulty]:
-   ```
-   when I receive [Level Up v]
-       change [level v] by (1)
-       set [ballSpeed v] to ((([ballSpeed v]) * (1.1)))
-   end
-   ```
-6. Use target names exactly as listed in `Targets in Game`. Do NOT rename or invent new targets.
-7. Ensure the plan reflects accurate opcode usage derived strictly from the block reference above.
-8. Few shot Example structure for 'action_overall_flow':
-```json
-    {{
-    "action_overall_flow": {{
-        "Stage": {{
-            "description": "Background and global game state management, including broadcasts, rewards, and score.",
-            "plans": [
-                {{
-                    "event": "event_whenflagclicked",
-                    "logic": "when green flag clicked\n    switch backdrop to [backdrop1 v]\n    set [score v] to 0\n    show variable [score v]\n    broadcast [Game Start v]\nend",
-                    "motion": [],
-                    "control": [],
-                    "operator": [],
-                    "sensing": [],
-                    "looks": [
-                        "looks_switchbackdropto"
-                    ],
-                    "sounds": [],
-                    "events": [
-                        "event_broadcast"
-                    ],
-                    "data": [
-                        "data_setvariableto",
-                        "data_showvariable"
-                    ]
-                }},
-                {{
-                    "event": "event_whenbroadcastreceived",
-                    "logic": "when I receive [Game Over v]\n    if <(score) > (High Score)> then\n        set [High Score v] to (score)\n    end\n    switch backdrop to [HighScore v]\nend",
-                    "motion": [],
-                    "control": [
-                        "control_if"
-                    ],
-                    "operator": [
-                        "operator_gt"
-                    ],
-                    "sensing": [],
-                    "looks": [
-                        "looks_switchbackdropto"
-                    ],
-                    "sounds": [],
-                    "events": [],
-                    "data": [
-                        "data_setvariableto"
-                    ]
-                }}
-            ]
-        }},
-        "Sprite1": {{
-            "description": "Main character (cat) actions",
-            "plans": [
-                {{
-                    "event": "event_whenflagclicked",
-                    "logic": "when green flag clicked\n    go to x: 240 y: -100\nend\n",
-                    "motion": [
-                        "motion_gotoxy"
-                    ],
-                    "control": [],
-                    "operator": [],
-                    "sensing": [],
-                    "looks": [],
-                    "sounds": [],
-                    "events": [],
-                    "data": []
-                }},
-                {{
-                    "event": "event_whenkeypressed",
-                    "logic": "when [space v] key pressed\n    repeat (10)\n        change y by (20)\n        wait (0.1) seconds\n        change y by (-20)\n    end\nend",
-                    "motion": [
-                        "motion_changeyby"
-                    ],
-                    "control": [
-                        "control_repeat",
-                        "control_wait"
-                    ],
-                    "operator": [],
-                    "sensing": [],
-                    "looks": [],
-                    "sounds": [],
-                    "events": [],
-                    "data": []
-                }}
-            ]
-        }},
-        "soccer ball": {{
-            "description": "Obstacle movement and interaction",
-            "plans": [
-                {{
-                    "event": "event_whenflagclicked",
-                    "logic": "when green flag clicked\n    go to x: 240 y: -135\n    forever\n        glide 2 seconds to x: -240 y: -135\n        if <(x position) < -235> then\n            set x to 240\n        end\n        if <touching [Sprite1 v]?> then\n            broadcast [Game Over v]\n            stop [all v]\n        end\n    end\nend",
-                    "motion": [
-                        "motion_gotoxy",
-                        "motion_glidesecstoxy",
-                        "motion_xposition",
-                        "motion_setx"
-                    ],
-                    "control": [
-                        "control_forever",
-                        "control_if",
-                        "control_stop"
-                    ],
-                    "operator": [
-                        "operator_lt"
-                    ],
-                    "sensing": [
-                        "sensing_touchingobject",
-                        "sensing_touchingobjectmenu"
-                    ],
-                    "looks": [],
-                    "sounds": [],
-                    "events": [
-                        "event_broadcast"
-                    ],
-                    "data": []
-                }}
-            ]
-        }}
-    }}
-}}
-```
-9. Use the validation feedback to address errors, fill in missing logic, or enhance clarity.
-    example of few possible improvements: 1.event_whenflagclicked is used to control sprite but its used for actual start scratch project and reset scratch. 2. looping like forever used where we should use iterative. 3. missing of for variable we used in the block
-    - Maintain the **exact JSON structure** shown above.
-    - All `logic` fields must be **clear and granular**.
-    - Only include opcode categories that contain relevant opcodes.
-    - Ensure that each opcode matches its intended Scratch functionality.
-    - If feedback suggests major change, **rethink the entire plan** for the affected sprite(s).
-    - If feedback is minor, make precise, minimal improvements only.
-"""
-    try:
-        response = agent.invoke({"messages": [{"role": "user", "content": refinement_prompt}]})
-        raw_response = response["messages"][-1].content#strip_noise(response["messages"][-1].content)
-        logger.info(f"Raw response from LLM [RefinedPlannerNode]: {raw_response[:500]}...")
-        # json debugging and solving
-        try:
-            refined_plan = extract_json_from_llm_response(raw_response)
-        except json.JSONDecodeError as error_json:
-            logger.error("Failed to extract JSON from LLM response. Attempting to correct the response.")
-            # Use the JSON resolver agent to fix the response
-            correction_prompt = (
-                "Your task is to correct the provided JSON string to ensure it is **syntactically perfect and adheres strictly to JSON rules**.\n"
-                "Carefully review the JSON for any errors, especially focusing on the reported error at:\n"
-                f"- **Error Details**: {error_json}\n\n"
-                "**Strict Instructions for your response:**\n"
-                "1. **ONLY** output the corrected JSON. Do not include any other text, comments, or explanations outside the JSON.\n"
-                "2. Ensure all property names (keys) are enclosed in **double quotes**.\n"
-                "3. Ensure string values are correctly enclosed in **double quotes** and any internal special characters (like newlines `\\n`, tabs `\\t`, backslashes `\\\\`, or double quotes `\\`) are properly **escaped**.\n"
-                "4. IN `logic` field make sure content enclosed in **double quotes** should not have invalid **double quotes**, **eliminate** all quotes inside the content if any. "
-                "4. Verify that there are **no extra commas**, especially between key-value pairs or after the last element in an object or array.\n"
-                "5. Ensure proper nesting and matching of curly braces `{}` and square brackets `[]`.\n"
-                "6. **Crucially, remove any extraneous characters or duplicate closing braces outside the main JSON object.**\n" # Added instruction
-                "7. The corrected JSON must be a **complete and valid** JSON object.\n\n"
-                "Here is the problematic JSON string to correct:\n"
-                "```json\n"
-                f"{raw_response}\n"
-                "```\n"
-                "Corrected JSON:\n"
-            )
-            correction_response = agent_json_resolver.invoke({"messages": [{"role": "user", "content": correction_prompt}]})
-            print(f"[JSON CORRECTOR RESPONSE AT REFINEPLANNER ]: {correction_response['messages'][-1].content}")
-            refined_plan = extract_json_from_llm_response(correction_response["messages"][-1].content)#strip_noise(correction_response["messages"][-1].content))
-            logger.info("Refined plan corrected by JSON resolver agent.")
+#     except Exception as e:
+#         logger.error(f"Error in OverallPlannerNode: {e}")
+#         raise
+# # Node 3: refiner node (scrape)
+# def refined_planner_node(state: GameState):
+#     """
+#     Refines the action plan based on validation feedback and game description.
+#     """
+#     logger.info("--- Running RefinedPlannerNode ---")
+#     raw = state.get("pseudo_code", {})
+#     refined_logic_data = raw.get("refined_logic", {})
+#     sprite_name = refined_logic_data.get("name_variable", "<unknown>")
+#     pseudo      = refined_logic_data.get("pseudocode", "")
+#     #detailed_game_description = state.get("detailed_game_description", state.get("description", "A game."))
+#     current_action_plan = state.get("action_plan", {})
+#     print(f"[current_action_plan before refinement] on ({state.get('iteration_count', 0)}): {json.dumps(current_action_plan, indent=2)}")
+#     plan_validation_feedback = state.get("plan_validation_feedback", "No specific feedback provided. Assume general refinement is needed.")
+#     project_json = state["project_json"]
+#     target_names = [t["name"] for t in project_json["targets"]]
+
+#     # MODIFICATION 2: Get sprite positions, providing default for Stage as it doesn't have x,y
+#     sprite_positions = {}
+#     for target in project_json["targets"]:
+#         if not target["isStage"]:
+#             sprite_positions[target["name"]] = {"x": target.get("x", 0), "y": target.get("y", 0)}
+#         else:
+#             sprite_positions[target["name"]] = {"x": "N/A", "y": "N/A"} # Stage doesn't have positional coordinates
+
+#     #declaration_plan = state["declaration_plan"]
+
+#     refinement_prompt = f"""
+# Refine and correct the JSON object `action_overall_flow` so that it fully aligns with the detailed game description, sprite positions, variable/broadcast declarations, and Scratch 3.0 block reference—while also validating for common formatting or opcode errors.
+
+# Here is the overall script available:
+# **Sprite name**: {sprite_name} 
+# **and its corresponding Pseudo_code:** 
+# '{pseudo}'
+
+# [Note: Make sure you just refine the pseudo code by correting mistake and adding the missing opcode if any and *Do not* generate any new logic]
+# ---
+# **Targets in Game (Sprites and Stage):** {', '.join(target_names)}  
+# **Current action plan:**  
+# {current_action_plan}
+
+# **Validation Feedback:**  
+# '{plan_validation_feedback}'
+
+# --- Scratch 3.0 Block Reference ---
+# ### Hat Blocks
+# {hat_opcodes_functionalities}
+
+# ### Boolean Blocks
+# {boolean_opcodes_functionalities}
+
+# ### C Blocks
+# {c_opcodes_functionalities}
+
+# ### Cap Blocks
+# {cap_opcodes_functionalities}
+
+# ### Reporter Blocks
+# {reporter_opcodes_functionalities}
+
+# ### Stack Blocks
+# {stack_opcodes_functionalities}
+
+# -----------------------------------
+
+# * **Your task is to align to description, refine and correct the JSON object 'action_overall_flow'.**
+# Use sprite names exactly as provided in `sprite_names` (e.g., 'Sprite1', 'soccer ball'); and also the stage, do **NOT** rename them.
+# Other plans may use any hat blocks (including duplicates) to represent different logics or events.
+# Each plan must include a **single Scratch Hat Block** (e.g., 'event_whenflagclicked') to start scratch project and should contain:
+# 1.  **'event'**: the exact `opcode` of the hat block that initiates the logic.
+# 2. **'logic'**: a natural language breakdown of each step taken after the event, formatted as a multi-line string representing pseudo-code. Ensure clarity and granularity—each described action should map closely to a Scratch block or tight sequence.
+#     - Do **NOT** include any justification or comments—only the raw logic.
+#     - Use 'forever: ...' or 'repeat(10): ...' to prefix repeating logic suitable taking reference from the C blocks.
+#     - Use Scratch-consistent verbs: 'move', 'change', 'wait', 'hide', 'show', 'say', 'glide', etc.
+#     - **Numeric values** `(e.g., 0, 5, 0.2, -130)` **must** be in parentheses: `(0)`, `(5)`, `(0.2)`, `(-130)`.
+#    - **AlphaNumeric values** `(e.g., hello, say 5, 4, hi!)` **must** be in parentheses: `(hello)`, `(say 5)`, `(4)`, `(hi!)`.
+#    - **Variables** must be in the form `[variable v]` (e.g., `[score v]`), even when used inside expressions two example use `set [score v] to (1)` or `show variable ([speed v])`.
+#    - **Dropdown options** must be in the form `[option v]` (e.g., `[Game Start v]`, `[blue sky v]`). example use `when [space v] key pressed`.
+#    - **Reporter blocks** used as inputs must be double‑wrapped: `((x position))`, `((y position))`. example use `if <((y position)) = (-130)> then` or `(((x position)) * (1))`.
+#    - **Boolean blocks** in conditions must be inside `< >`, including nested ones: `<not <condition>>`, `<<cond1> and <cond2>>`,`<<cond1> or <cond2>>`.
+#    - **Other Boolean blocks** in conditions must be inside `< >`, including nested ones or values or variables: `<(block/value/variable) * (block/value/variable)>`,`<(block/value/variable) < (block/value/variable)>`, and example of another variable`<[apple v] contains [a v]?>`.
+#    - **Operator expressions** must use explicit Scratch operator blocks, e.g.:
+#      ```
+#      (([ballSpeed v]) * (1.1))
+#      ```
+#    - **Every hat block script must end** with a final `end` on its own line.
+# 3. **Validation & Formatting Checks**  
+#    - **Opcode Coverage**: Ensure every action in `logic` has a matching opcode in the lists.  
+#    - **Bracket Nesting**: Confirm every `(` has a matching `)`, e.g., `(pick random (100) to (-100))`.  
+#    - **Operator Formatting**: Validate that operators use Scratch operator blocks, not inline math.  
+#    - **Common Errors**:  
+#      - `pick random (100,-100)` → `(pick random (100) to (-100))`  
+#      - Missing `end` at script conclusion  
+#      - Unwrapped reporter inputs or Boolean tests
+# 4. **Opcode Lists**: include relevant Scratch opcodes grouped under `motion`, `control`, `operator`, `sensing`, `looks`, `sounds`, `events`, and `data`. List only the non-empty categories. Use exact opcodes from the given Scratch 3.0 Block Reference.
+# 5. Few Example of content of logics inside for a specific plan as scratch pseudo-code:
+#     - example 1[continues moving objects]:
+#     ```
+#     when green flag clicked
+#         go to x: (240) y: (-100)
+#         set [speed v] to (-5)
+#         show variable [speed v]
+#         forever
+#             change x by ([speed v])
+#             if <((x position)) < (-240)> then 
+#                 go to x: (240) y: (-100) 
+#             end
+#         end
+#     end
+#     ```
+#     - example 2[jumping script of an plan]: 
+#     ```    
+#     when [space v] key pressed
+#         if <((y position)) = (-100)> then 
+#             repeat (5)
+#                 change y by (100) 
+#                 wait (0.1) seconds
+#                 change y by (-100) 
+#                 wait (0.1) seconds
+#             end
+#         end
+#     end
+#     ```
+#    - example 3 [pattern for level up and increase difficulty]:
+#    ```
+#    when I receive [Level Up v]
+#        change [level v] by (1)
+#        set [ballSpeed v] to ((([ballSpeed v]) * (1.1)))
+#    end
+#    ```
+# 6. Use target names exactly as listed in `Targets in Game`. Do NOT rename or invent new targets.
+# 7. Ensure the plan reflects accurate opcode usage derived strictly from the block reference above.
+# 8. Few shot Example structure for 'action_overall_flow':
+# ```json
+#     {{
+#     "action_overall_flow": {{
+#         "Stage": {{
+#             "description": "Background and global game state management, including broadcasts, rewards, and score.",
+#             "plans": [
+#                 {{
+#                     "event": "event_whenflagclicked",
+#                     "logic": "when green flag clicked\n    switch backdrop to [backdrop1 v]\n    set [score v] to 0\n    show variable [score v]\n    broadcast [Game Start v]\nend",
+#                     "motion": [],
+#                     "control": [],
+#                     "operator": [],
+#                     "sensing": [],
+#                     "looks": [
+#                         "looks_switchbackdropto"
+#                     ],
+#                     "sounds": [],
+#                     "events": [
+#                         "event_broadcast"
+#                     ],
+#                     "data": [
+#                         "data_setvariableto",
+#                         "data_showvariable"
+#                     ]
+#                 }},
+#                 {{
+#                     "event": "event_whenbroadcastreceived",
+#                     "logic": "when I receive [Game Over v]\n    if <(score) > (High Score)> then\n        set [High Score v] to (score)\n    end\n    switch backdrop to [HighScore v]\nend",
+#                     "motion": [],
+#                     "control": [
+#                         "control_if"
+#                     ],
+#                     "operator": [
+#                         "operator_gt"
+#                     ],
+#                     "sensing": [],
+#                     "looks": [
+#                         "looks_switchbackdropto"
+#                     ],
+#                     "sounds": [],
+#                     "events": [],
+#                     "data": [
+#                         "data_setvariableto"
+#                     ]
+#                 }}
+#             ]
+#         }},
+#         "Sprite1": {{
+#             "description": "Main character (cat) actions",
+#             "plans": [
+#                 {{
+#                     "event": "event_whenflagclicked",
+#                     "logic": "when green flag clicked\n    go to x: 240 y: -100\nend\n",
+#                     "motion": [
+#                         "motion_gotoxy"
+#                     ],
+#                     "control": [],
+#                     "operator": [],
+#                     "sensing": [],
+#                     "looks": [],
+#                     "sounds": [],
+#                     "events": [],
+#                     "data": []
+#                 }},
+#                 {{
+#                     "event": "event_whenkeypressed",
+#                     "logic": "when [space v] key pressed\n    repeat (10)\n        change y by (20)\n        wait (0.1) seconds\n        change y by (-20)\n    end\nend",
+#                     "motion": [
+#                         "motion_changeyby"
+#                     ],
+#                     "control": [
+#                         "control_repeat",
+#                         "control_wait"
+#                     ],
+#                     "operator": [],
+#                     "sensing": [],
+#                     "looks": [],
+#                     "sounds": [],
+#                     "events": [],
+#                     "data": []
+#                 }}
+#             ]
+#         }},
+#         "soccer ball": {{
+#             "description": "Obstacle movement and interaction",
+#             "plans": [
+#                 {{
+#                     "event": "event_whenflagclicked",
+#                     "logic": "when green flag clicked\n    go to x: 240 y: -135\n    forever\n        glide 2 seconds to x: -240 y: -135\n        if <(x position) < -235> then\n            set x to 240\n        end\n        if <touching [Sprite1 v]?> then\n            broadcast [Game Over v]\n            stop [all v]\n        end\n    end\nend",
+#                     "motion": [
+#                         "motion_gotoxy",
+#                         "motion_glidesecstoxy",
+#                         "motion_xposition",
+#                         "motion_setx"
+#                     ],
+#                     "control": [
+#                         "control_forever",
+#                         "control_if",
+#                         "control_stop"
+#                     ],
+#                     "operator": [
+#                         "operator_lt"
+#                     ],
+#                     "sensing": [
+#                         "sensing_touchingobject",
+#                         "sensing_touchingobjectmenu"
+#                     ],
+#                     "looks": [],
+#                     "sounds": [],
+#                     "events": [
+#                         "event_broadcast"
+#                     ],
+#                     "data": []
+#                 }}
+#             ]
+#         }}
+#     }}
+# }}
+# ```
+# 9. Use the validation feedback to address errors, fill in missing logic, or enhance clarity.
+#     example of few possible improvements: 1.event_whenflagclicked is used to control sprite but its used for actual start scratch project and reset scratch. 2. looping like forever used where we should use iterative. 3. missing of for variable we used in the block
+#     - Maintain the **exact JSON structure** shown above.
+#     - All `logic` fields must be **clear and granular**.
+#     - Only include opcode categories that contain relevant opcodes.
+#     - Ensure that each opcode matches its intended Scratch functionality.
+#     - If feedback suggests major change, **rethink the entire plan** for the affected sprite(s).
+#     - If feedback is minor, make precise, minimal improvements only.
+# """
+#     try:
+#         response = agent.invoke({"messages": [{"role": "user", "content": refinement_prompt}]})
+#         raw_response = response["messages"][-1].content#strip_noise(response["messages"][-1].content)
+#         logger.info(f"Raw response from LLM [RefinedPlannerNode]: {raw_response[:500]}...")
+#         # json debugging and solving
+#         try:
+#             refined_plan = extract_json_from_llm_response(raw_response)
+#         except json.JSONDecodeError as error_json:
+#             logger.error("Failed to extract JSON from LLM response. Attempting to correct the response.")
+#             # Use the JSON resolver agent to fix the response
+#             correction_prompt = (
+#                 "Your task is to correct the provided JSON string to ensure it is **syntactically perfect and adheres strictly to JSON rules**.\n"
+#                 "Carefully review the JSON for any errors, especially focusing on the reported error at:\n"
+#                 f"- **Error Details**: {error_json}\n\n"
+#                 "**Strict Instructions for your response:**\n"
+#                 "1. **ONLY** output the corrected JSON. Do not include any other text, comments, or explanations outside the JSON.\n"
+#                 "2. Ensure all property names (keys) are enclosed in **double quotes**.\n"
+#                 "3. Ensure string values are correctly enclosed in **double quotes** and any internal special characters (like newlines `\\n`, tabs `\\t`, backslashes `\\\\`, or double quotes `\\`) are properly **escaped**.\n"
+#                 "4. IN `logic` field make sure content enclosed in **double quotes** should not have invalid **double quotes**, **eliminate** all quotes inside the content if any. "
+#                 "4. Verify that there are **no extra commas**, especially between key-value pairs or after the last element in an object or array.\n"
+#                 "5. Ensure proper nesting and matching of curly braces `{}` and square brackets `[]`.\n"
+#                 "6. **Crucially, remove any extraneous characters or duplicate closing braces outside the main JSON object.**\n" # Added instruction
+#                 "7. The corrected JSON must be a **complete and valid** JSON object.\n\n"
+#                 "Here is the problematic JSON string to correct:\n"
+#                 "```json\n"
+#                 f"{raw_response}\n"
+#                 "```\n"
+#                 "Corrected JSON:\n"
+#             )
+#             correction_response = agent_json_resolver.invoke({"messages": [{"role": "user", "content": correction_prompt}]})
+#             print(f"[JSON CORRECTOR RESPONSE AT REFINEPLANNER ]: {correction_response['messages'][-1].content}")
+#             refined_plan = extract_json_from_llm_response(correction_response["messages"][-1].content)#strip_noise(correction_response["messages"][-1].content))
+#             logger.info("Refined plan corrected by JSON resolver agent.")
             
-        if refined_plan:
-            #state["action_plan"] = refined_plan.get("action_overall_flow", {}) # Update to the key 'action_overall_flow' [error]
-            state["action_plan"] = refined_plan #.get("action_overall_flow", {})  # Update the main the prompt includes updated only
-            logger.info("Action plan refined by RefinedPlannerNode.")
-        else:
-            logger.warning("RefinedPlannerNode did not return a valid 'action_overall_flow' structure. Keeping previous plan.")
-        print("[Refined Action Plan]:", json.dumps(state["action_plan"], indent=2))
-        #print("[current state after refinement]:", json.dumps(state, indent=2))
+#         if refined_plan:
+#             #state["action_plan"] = refined_plan.get("action_overall_flow", {}) # Update to the key 'action_overall_flow' [error]
+#             state["action_plan"] = refined_plan #.get("action_overall_flow", {})  # Update the main the prompt includes updated only
+#             logger.info("Action plan refined by RefinedPlannerNode.")
+#         else:
+#             logger.warning("RefinedPlannerNode did not return a valid 'action_overall_flow' structure. Keeping previous plan.")
+#         print("[Refined Action Plan]:", json.dumps(state["action_plan"], indent=2))
+#         #print("[current state after refinement]:", json.dumps(state, indent=2))
         
-        # with open("debug_state.json", "w", encoding="utf-8") as f:
-        #     json.dump(state, f, indent=2, ensure_ascii=False)
+#         # with open("debug_state.json", "w", encoding="utf-8") as f:
+#         #     json.dump(state, f, indent=2, ensure_ascii=False)
         
-        return state
-    except Exception as e:
-        logger.error(f"Error in RefinedPlannerNode: {e}")
-        raise
-# Node 4: opcode counter node
-def plan_opcode_counter_node(state: Dict[str, Any]) -> Dict[str, Any]:
-    """
-    For each plan in state["action_plan"], calls the LLM agent
-    to analyze the `logic` string and return a list of {opcode, count} for each category.
-    """
-    logger.info("=== Running OPCODE COUTER LOGIC with LLM counts ===")
-    #game_description = state.get("description", "No game description provided.")
-    sprite_name = {}
-    project_json_targets = state.get("project_json", {}).get("targets", [])
-    for target in project_json_targets:
-        sprite_name[target["name"]] = target["name"]
+#         return state
+#     except Exception as e:
+#         logger.error(f"Error in RefinedPlannerNode: {e}")
+#         raise
+# # Node 4: opcode counter node (scrape)
+# def plan_opcode_counter_node(state: Dict[str, Any]) -> Dict[str, Any]:
+#     """
+#     For each plan in state["action_plan"], calls the LLM agent
+#     to analyze the `logic` string and return a list of {opcode, count} for each category.
+#     """
+#     logger.info("=== Running OPCODE COUTER LOGIC with LLM counts ===")
+#     #game_description = state.get("description", "No game description provided.")
+#     sprite_name = {}
+#     project_json_targets = state.get("project_json", {}).get("targets", [])
+#     for target in project_json_targets:
+#         sprite_name[target["name"]] = target["name"]
     
-    action_flow = state.get("action_plan", {}) 
+#     action_flow = state.get("action_plan", {}) 
     
-    if action_flow.get("action_overall_flow", {}) == {}:
-        plan_data = action_flow.items()
-    else:
-        plan_data = action_flow.get("action_overall_flow", {}).items()
+#     if action_flow.get("action_overall_flow", {}) == {}:
+#         plan_data = action_flow.items()
+#     else:
+#         plan_data = action_flow.get("action_overall_flow", {}).items()
     
-    refined_flow: Dict[str, Any] = {}
-    for sprite, sprite_data in plan_data:
-        refined_plans = []
-        for plan in sprite_data.get("plans", []):
-            logic = plan.get("logic", "")
-            event = plan.get("event", "")
+#     refined_flow: Dict[str, Any] = {}
+#     for sprite, sprite_data in plan_data:
+#         refined_plans = []
+#         for plan in sprite_data.get("plans", []):
+#             logic = plan.get("logic", "")
+#             event = plan.get("event", "")
             
-            # These are for guiding the LLM, not for the final output format directly
-            opcodes_from_plan = {
-                "motion": plan.get("motion", []),
-                "control": plan.get("control", []),
-                "operator": plan.get("operator", []),
-                "sensing": plan.get("sensing", []),
-                "looks": plan.get("looks", []),
-                "sounds": plan.get("sounds", []),
-                "events": plan.get("events", []) + ([event] if isinstance(event, str) else []),
-                "data": plan.get("data", []),
-            }
-
-            refinement_prompt = f"""
-You are a Scratch 3.0 expert with deep knowledge of block types, nesting and stack relationships.
-Your job: read the plan logic below and decide exactly which blocks (and how many of each) are required to implement it.
-Review the following plan for '{sprite}' triggered by '{event}'.
---- Scratch 3.0 Block Reference ---
-    ### Hat Blocks
-    Description: {hat_description}
-    Blocks:
-    {hat_opcodes_functionalities}
-
-    ### Boolean Blocks
-    Description: {boolean_description}
-    Blocks:
-    {boolean_opcodes_functionalities}
-
-    ### C Blocks
-    Description: {c_description}
-    Blocks:
-    {c_opcodes_functionalities}
-
-    ### Cap Blocks
-    Description: {cap_description}
-    Blocks:
-    {cap_opcodes_functionalities}
-
-    ### Reporter Blocks
-    Description: {reporter_description}
-    Blocks:
-    {reporter_opcodes_functionalities}
-
-    ### Stack Blocks
-    Description: {stack_description}
-    Blocks:
-    {stack_opcodes_functionalities}
------------------------------------
-Current Plan Details:
-- Event (Hat Block Opcode): {event}
-- Associated Opcodes by Category: {json.dumps(opcodes_from_plan, indent=2)}
-
-── Game Context ──
-Sprite: "{sprite}"
-
-── Current Plan ──
-Event (hat block): {event}
-Logic (pseudo-Scratch): {logic}
-Plan : {plan}
-
-── Opcode Candidates ──
-Motion:   {opcodes_from_plan["motion"]}
-Control:  {opcodes_from_plan["control"]}
-Operator: {opcodes_from_plan["operator"]}
-Sensing:  {opcodes_from_plan["sensing"]}
-Looks:    {opcodes_from_plan["looks"]}
-Sounds:   {opcodes_from_plan["sounds"]}
-Events:   {opcodes_from_plan["events"]}
-Data:     {opcodes_from_plan["data"]}
-
-── Your Task ──
-1. Analyze the “Logic” steps and choose exactly which opcodes are needed. 
-2. Use exact opcodes from the given Scratch 3.0 Block Reference and verfiy the proper opcode are used available in the Scratch 3.0 Block Reference.
-3. Return a top-level JSON object with a single key: "opcode_counts".
-4. The value of "opcode_counts" should be a list of objects, where each object has "opcode": "<opcode_name>" and "count": <integer>.
-5. Ensure the list includes the hat block for this plan (e.g., event_whenflagclicked, event_whenkeypressed, event_whenbroadcastreceived) with a count of 1.
-6. The order of opcodes within the "opcode_counts" list does not matter.
-7. If any plan logic is None do not generate the opcode_counts for it.
-8. Use only double quotes and ensure valid JSON.
-
-Example output:
-**example 1**
-```json    
-{{
-"opcode_counts":[
-    {{"opcode":"motion_gotoxy","count":1}},
-    {{"opcode":"control_forever","count":1}},
-    {{"opcode":"control_if","count":1}},
-    {{"opcode":"looks_switchbackdropto","count":1}},
-    {{"opcode":"event_whenflagclicked","count":1}},
-    {{"opcode":"event_broadcast","count":1}},
-    {{"opcode":"data_setvariableto","count":2}},
-    {{"opcode":"data_showvariable","count":2}}
-    ]        
-}}    
-```
-**example 2**
-```json    
-{{        
-"opcode_counts":[
-    {{"opcode":"motion_gotoxy","count":1}},
-    {{"opcode":"motion_glidesecstoxy","count":1}},
-    {{"opcode":"motion_xposition","count":1}},
-    {{"opcode":"motion_setx","count":1}},
-    {{"opcode":"control_forever","count":1}},
-    {{"opcode":"control_if","count":2}},
-    {{"opcode":"operator_lt","count":1}},
-    {{"opcode":"sensing_touchingobject","count":1}},
-    {{"opcode":"event_whenflagclicked","count":1}},
-    {{"opcode":"event_broadcast","count":1}}
-    ]
-}}
-```
-"""                                    
-            try:
-                response = agent.invoke({"messages": [{"role": "user", "content": refinement_prompt}]})
-                llm_output = response["messages"][-1].content
-                llm_json = extract_json_from_llm_response(llm_output)                 
-                logger.info(f"Successfully analyze the opcode requirement for {sprite} - {event}.")
-
-            except json.JSONDecodeError as error_json:
-                logger.error(f"JSON Decode Error for {sprite} - {event}: {error_json}. Attempting correction.")
-                correction_prompt = (
-                    "Your task is to correct the provided JSON string to ensure it is **syntactically perfect and adheres strictly to JSON rules**.\n"
-                    "It must be a JSON object with a single key `opcode_counts` containing a list of objects like {{'opcode': '<opcode_name>', 'count': <integer>}}.\n"
-                    f"- **Error Details**: {error_json}\n\n"
-                    "**Strict Instructions for your response:**\n"
-                    "1. **ONLY** output the corrected JSON. Do not include any other text or explanations.\n"
-                    "2. Ensure all keys and string values are enclosed in **double quotes**. Escape internal quotes (`\\`).\n"
-                    "3. No trailing commas. Correct nesting.\n\n"
-                    "Here is the problematic JSON string to correct:\n"
-                    f"```json\n{llm_output}\n```\n"
-                    "Corrected JSON:\n"
-                )
-                try:
-                    correction_response = agent_json_resolver.invoke({"messages": [{"role": "user", "content": correction_prompt}]})
-                    llm_json = extract_json_from_llm_response(correction_response["messages"][-1].content)
-                    logger.info(f"Successfully corrected JSON output for {sprite} - {event}.")
-                except Exception as e_corr:
-                    logger.error(f"Failed to correct JSON output for {sprite} - {event} even after retry: {e_corr}")
-                    continue 
-
-            # Directly use the 'opcode_counts' list from the LLM's output
-            plan["opcode_counts"] = llm_json.get("opcode_counts", [])
-            plan["opcode_counts"] = validate_and_fix_opcodes(plan["opcode_counts"])
-            # Optionally, you can remove the individual category lists from the plan
-            # if they are no longer needed after the LLM provides the consolidated list.
-            # for key in ["motion", "control", "operator", "sensing", "looks", "sounds", "events", "data"]:
-            #     if key in plan:
-            #         del plan[key]
-
-            refined_plans.append(plan)
-
-        refined_flow[sprite] = {
-            "description": sprite_data.get("description", ""),
-            "plans": refined_plans
-        }
+#             # These are for guiding the LLM, not for the final output format directly
+#             opcodes_from_plan = {
+#                 "motion": plan.get("motion", []),
+#                 "control": plan.get("control", []),
+#                 "operator": plan.get("operator", []),
+#                 "sensing": plan.get("sensing", []),
+#                 "looks": plan.get("looks", []),
+#                 "sounds": plan.get("sounds", []),
+#                 "events": plan.get("events", []) + ([event] if isinstance(event, str) else []),
+#                 "data": plan.get("data", []),
+#             }
+
+#             refinement_prompt = f"""
+# You are a Scratch 3.0 expert with deep knowledge of block types, nesting and stack relationships.
+# Your job: read the plan logic below and decide exactly which blocks (and how many of each) are required to implement it.
+# Review the following plan for '{sprite}' triggered by '{event}'.
+# --- Scratch 3.0 Block Reference ---
+#     ### Hat Blocks
+#     Description: {hat_description}
+#     Blocks:
+#     {hat_opcodes_functionalities}
+
+#     ### Boolean Blocks
+#     Description: {boolean_description}
+#     Blocks:
+#     {boolean_opcodes_functionalities}
+
+#     ### C Blocks
+#     Description: {c_description}
+#     Blocks:
+#     {c_opcodes_functionalities}
+
+#     ### Cap Blocks
+#     Description: {cap_description}
+#     Blocks:
+#     {cap_opcodes_functionalities}
+
+#     ### Reporter Blocks
+#     Description: {reporter_description}
+#     Blocks:
+#     {reporter_opcodes_functionalities}
+
+#     ### Stack Blocks
+#     Description: {stack_description}
+#     Blocks:
+#     {stack_opcodes_functionalities}
+# -----------------------------------
+# Current Plan Details:
+# - Event (Hat Block Opcode): {event}
+# - Associated Opcodes by Category: {json.dumps(opcodes_from_plan, indent=2)}
+
+# ── Game Context ──
+# Sprite: "{sprite}"
+
+# ── Current Plan ──
+# Event (hat block): {event}
+# Logic (pseudo-Scratch): {logic}
+# Plan : {plan}
+
+# ── Opcode Candidates ──
+# Motion:   {opcodes_from_plan["motion"]}
+# Control:  {opcodes_from_plan["control"]}
+# Operator: {opcodes_from_plan["operator"]}
+# Sensing:  {opcodes_from_plan["sensing"]}
+# Looks:    {opcodes_from_plan["looks"]}
+# Sounds:   {opcodes_from_plan["sounds"]}
+# Events:   {opcodes_from_plan["events"]}
+# Data:     {opcodes_from_plan["data"]}
+
+# ── Your Task ──
+# 1. Analyze the “Logic” steps and choose exactly which opcodes are needed. 
+# 2. Use exact opcodes from the given Scratch 3.0 Block Reference and verfiy the proper opcode are used available in the Scratch 3.0 Block Reference.
+# 3. Return a top-level JSON object with a single key: "opcode_counts".
+# 4. The value of "opcode_counts" should be a list of objects, where each object has "opcode": "<opcode_name>" and "count": <integer>.
+# 5. Ensure the list includes the hat block for this plan (e.g., event_whenflagclicked, event_whenkeypressed, event_whenbroadcastreceived) with a count of 1.
+# 6. The order of opcodes within the "opcode_counts" list does not matter.
+# 7. If any plan logic is None do not generate the opcode_counts for it.
+# 8. Use only double quotes and ensure valid JSON.
+
+# Example output:
+# **example 1**
+# ```json    
+# {{
+# "opcode_counts":[
+#     {{"opcode":"motion_gotoxy","count":1}},
+#     {{"opcode":"control_forever","count":1}},
+#     {{"opcode":"control_if","count":1}},
+#     {{"opcode":"looks_switchbackdropto","count":1}},
+#     {{"opcode":"event_whenflagclicked","count":1}},
+#     {{"opcode":"event_broadcast","count":1}},
+#     {{"opcode":"data_setvariableto","count":2}},
+#     {{"opcode":"data_showvariable","count":2}}
+#     ]        
+# }}    
+# ```
+# **example 2**
+# ```json    
+# {{        
+# "opcode_counts":[
+#     {{"opcode":"motion_gotoxy","count":1}},
+#     {{"opcode":"motion_glidesecstoxy","count":1}},
+#     {{"opcode":"motion_xposition","count":1}},
+#     {{"opcode":"motion_setx","count":1}},
+#     {{"opcode":"control_forever","count":1}},
+#     {{"opcode":"control_if","count":2}},
+#     {{"opcode":"operator_lt","count":1}},
+#     {{"opcode":"sensing_touchingobject","count":1}},
+#     {{"opcode":"event_whenflagclicked","count":1}},
+#     {{"opcode":"event_broadcast","count":1}}
+#     ]
+# }}
+# ```
+# """                                    
+#             try:
+#                 response = agent.invoke({"messages": [{"role": "user", "content": refinement_prompt}]})
+#                 llm_output = response["messages"][-1].content
+#                 llm_json = extract_json_from_llm_response(llm_output)                 
+#                 logger.info(f"Successfully analyze the opcode requirement for {sprite} - {event}.")
+
+#             except json.JSONDecodeError as error_json:
+#                 logger.error(f"JSON Decode Error for {sprite} - {event}: {error_json}. Attempting correction.")
+#                 correction_prompt = (
+#                     "Your task is to correct the provided JSON string to ensure it is **syntactically perfect and adheres strictly to JSON rules**.\n"
+#                     "It must be a JSON object with a single key `opcode_counts` containing a list of objects like {{'opcode': '<opcode_name>', 'count': <integer>}}.\n"
+#                     f"- **Error Details**: {error_json}\n\n"
+#                     "**Strict Instructions for your response:**\n"
+#                     "1. **ONLY** output the corrected JSON. Do not include any other text or explanations.\n"
+#                     "2. Ensure all keys and string values are enclosed in **double quotes**. Escape internal quotes (`\\`).\n"
+#                     "3. No trailing commas. Correct nesting.\n\n"
+#                     "Here is the problematic JSON string to correct:\n"
+#                     f"```json\n{llm_output}\n```\n"
+#                     "Corrected JSON:\n"
+#                 )
+#                 try:
+#                     correction_response = agent_json_resolver.invoke({"messages": [{"role": "user", "content": correction_prompt}]})
+#                     llm_json = extract_json_from_llm_response(correction_response["messages"][-1].content)
+#                     logger.info(f"Successfully corrected JSON output for {sprite} - {event}.")
+#                 except Exception as e_corr:
+#                     logger.error(f"Failed to correct JSON output for {sprite} - {event} even after retry: {e_corr}")
+#                     continue 
+
+#             # Directly use the 'opcode_counts' list from the LLM's output
+#             plan["opcode_counts"] = llm_json.get("opcode_counts", [])
+#             plan["opcode_counts"] = validate_and_fix_opcodes(plan["opcode_counts"])
+#             # Optionally, you can remove the individual category lists from the plan
+#             # if they are no longer needed after the LLM provides the consolidated list.
+#             # for key in ["motion", "control", "operator", "sensing", "looks", "sounds", "events", "data"]:
+#             #     if key in plan:
+#             #         del plan[key]
+
+#             refined_plans.append(plan)
+
+#         refined_flow[sprite] = {
+#             "description": sprite_data.get("description", ""),
+#             "plans": refined_plans
+#         }
     
-    if refined_flow:
-        state["action_plan"] = refined_flow
-        logger.info("logic aligned by logic_aligner_Node.")
+#     if refined_flow:
+#         state["action_plan"] = refined_flow
+#         logger.info("logic aligned by logic_aligner_Node.")
         
-    state["temporary_node"] = refined_flow
-    #state["temporary_node"] = refined_flow
-    print(f"[OPCODE COUTER LOGIC]: {refined_flow}")
-    logger.info("=== OPCODE COUTER LOGIC completed ===")
-    return state
+#     state["temporary_node"] = refined_flow
+#     #state["temporary_node"] = refined_flow
+#     print(f"[OPCODE COUTER LOGIC]: {refined_flow}")
+#     logger.info("=== OPCODE COUTER LOGIC completed ===")
+#     return state
 
 # Node 5: block_builder_node
 def overall_block_builder_node_2(state: GameState):
@@ -2228,6 +2228,41 @@ def variable_adder_node(state: GameState):
         raise
 
 # Node 7: variable adder node
+def layer_order_correction(state: GameState):
+    """
+    Ensures that all sprites (isStage: false) have unique layerOrder values >= 1.
+    If duplicates are found, they are reassigned sequentially.
+    """
+    logger.info("--- Running Layer Order Correction Node ---")
+    try:
+        project_json = state.get("project_json", {})
+        targets = project_json.get("targets", [])
+
+        # Collect all sprites (ignore Stage)
+        sprites = [t for t in targets if not t.get("isStage", False)]
+
+        # Reassign layerOrder sequentially (starting from 1)
+        for idx, sprite in enumerate(sprites, start=1):
+            old_lo = sprite.get("layerOrder", None)
+            sprite["layerOrder"] = idx
+            logger.debug(f"Sprite '{sprite.get('name')}' layerOrder: {old_lo} -> {idx}")
+
+        # Stage always remains 0
+        for target in targets:
+            if target.get("isStage", False):
+                target["layerOrder"] = 0
+
+        # Update state
+        state["project_json"]["targets"] = targets
+        logger.info("Layer Order Correction completed successfully.")
+
+        return state
+
+    except Exception as e:
+        logger.error(f"Error in Layer Order Correction Node: {e}")
+        return state
+
+# Node 8: variable adder node
 def processed_page_node(state: GameState):
     logger.info("--- Processing the Pages Node ---")
     image = state.get("project_image", "")  
@@ -3626,6 +3661,7 @@ workflow = StateGraph(GameState)
 workflow.add_node("pseudo_generator", pseudo_generator_node)
 #workflow.add_node("plan_generator", overall_planner_node)
 workflow.add_node("Node_optimizer", node_optimizer)
+workflow.add_node("layer_optimizer", layer_order_correction)
 #workflow.add_node("logic_alignment", plan_logic_aligner_node)
 #workflow.add_node("plan_verifier", plan_verification_node)
 #workflow.add_node("refined_planner", refined_planner_node) # Refines the action plan
@@ -3640,14 +3676,15 @@ def decide_next_step(state: GameState):
     if state.get("processing", False):
         return "pseudo_generator"
     else:
-        return END
+        return "layer_optimizer"#END
 
 workflow.add_conditional_edges(
     "page_processed",
     decide_next_step,
     {
         "pseudo_generator": "pseudo_generator",
-        str(END): END  # str(END) is '__end__'
+        "layer_optimizer": "layer_optimizer"
+        #str(END): END  # str(END) is '__end__'
     }
 )
 # Main chain
@@ -3660,9 +3697,9 @@ workflow.add_edge("pseudo_generator", "Node_optimizer")
 # workflow.add_edge("time_delay_3", "opcode_counter")
 workflow.add_edge("Node_optimizer", "block_builder")
 workflow.add_edge("block_builder", "variable_initializer")
-
 # After last node, check again
 workflow.add_edge("variable_initializer", "page_processed")
+workflow.add_edge("layer_optimizer", END)
 
 app_graph = workflow.compile()