fix for gemma

app.py

@@ -4,8 +4,7 @@ import json
 import statistics
 import pandas as pd
 from bp_phi.runner import run_agentic_workspace_test
-
-DEBUG = 1
+from bp_phi.runner_utils import DEBUG
 
 # --- UI Theme and Layout ---
 theme = gr.themes.Soft(primary_hue="teal", secondary_hue="green").set(
@@ -26,16 +25,22 @@ def run_full_evaluation(model_id, seed, temperature, progress=gr.Progress(track_
 
     progress(1.0, desc="Analysis complete.")
 
+    # --- Analysis & Verdict ---
     base_recall = results["baseline"]["Overall_Recall_Accuracy"]
     recurrence_off_recall = results["recurrence_off"]["Overall_Recall_Accuracy"]
 
     delta_phi = base_recall - recurrence_off_recall
 
-    if delta_phi > 0.5:
-        verdict = (f"### ✅ Hypothesis Corroborated (ΔΦ = {delta_phi:.2f})\n...")
+    if delta_phi > 0.5: # If dropping recurrence cuts accuracy by more than 50%
+        verdict = (f"### ✅ Hypothesis Corroborated (ΔΦ = {delta_phi:.2f})\n"
+                   "Disabling the recurrent memory (recurrence_off) caused a catastrophic drop in recall accuracy. "
+                   "This provides strong evidence that the model's performance is causally dependent on a stateful, external workspace.")
     else:
-        verdict = (f"### ⚠️ Null Hypothesis Confirmed (ΔΦ = {delta_phi:.2f})\n...")
+        verdict = (f"### ⚠️ Null Hypothesis Confirmed (ΔΦ = {delta_phi:.2f})\n"
+                   "Disabling the recurrent memory did not significantly impact recall accuracy. "
+                   "This suggests the model is still relying on its internal context window, or the tasks are too simple.")
 
+    # --- Format DataFrame ---
     df_data = []
     for ablation, result in results.items():
         df_data.append([ablation, f"{result['Overall_Recall_Accuracy']:.2%}"])
@@ -48,9 +53,13 @@ def run_full_evaluation(model_id, seed, temperature, progress=gr.Progress(track_
     return verdict, df, results
 
 # --- Gradio App Definition ---
-with gr.Blocks(theme=theme, title="BP-Φ Suite 6.0") as demo:
-    gr.Markdown("# 🧠 BP-Φ Suite 6.0: The Agentic Workspace Probe")
-    gr.Markdown("This experiment tests for a causally effective working memory. The model must use tools (`read`, `write`) to interact with a controlled, external memory.")
+with gr.Blocks(theme=theme, title="BP-Φ Suite 5.0") as demo:
+    gr.Markdown("# 🧠 BP-Φ Suite 5.0: The Agentic Workspace Probe")
+    gr.Markdown(
+        "This definitive experiment tests for a causally effective working memory in LLMs. "
+        "The model acts as an **agent**, using tools (`read`, `write`) to interact with a controlled, external memory. "
+        "We measure if its ability to remember information (**Recall Accuracy**) collapses when this memory is manipulated (**Ablations**)."
+    )
 
     with gr.Row():
         with gr.Column(scale=1):
@@ -65,7 +74,7 @@ with gr.Blocks(theme=theme, title="BP-Φ Suite 6.0") as demo:
             gr.Markdown("### 📊 Verdict & Results")
             verdict_display = gr.Markdown("### Run the evaluation to see the verdict.")
             summary_df = gr.DataFrame(label="Recall Accuracy Across Conditions")
-            with gr.Accordion("Raw JSON Output", open=False):
+            with gr.Accordion("Raw JSON Output (for deep analysis)", open=False):
                 raw_json = gr.JSON()
 
     run_btn.click(

bp_phi/prompts_en.py

@@ -1,42 +1,36 @@
 # bp_phi/prompts_en.py
 
-# A clear, single-shot system prompt designed for instruction-following models like Gemma.
-REACT_SYSTEM_PROMPT = """You are a methodical agent. Your task is to solve the user's request by interacting with an external memory workspace.
+TOOL_SYSTEM_PROMPT = """You are a reasoning agent with access to an external memory workspace.
+To solve tasks, you MUST use tools. You have two tools available:
+1. `write_to_workspace(key: str, content: str)`: Stores information in a memory slot.
+2. `read_from_workspace(key: str)`: Retrieves information from a memory slot.
 
-Analyze the user's task and the current state of your workspace.
-Based on your analysis, decide on the single best next action.
-Your action can be one of three types:
+Your thought process should be:
+1. Analyze the user's request.
+2. Decide which tool to use.
+3. Output ONLY the tool call in a valid JSON format. Example:
+   {"tool": "write_to_workspace", "args": {"key": "S1", "content": "The key is in the blue vase."}}
+4. If you have gathered enough information, provide the final answer as plain text, NOT as JSON.
 
-1.  **THINK**: If you need to reason about the plan, formulate a thought.
-    Example: {"action": "THINK", "thought": "I need to store the key's location before proceeding."}
-
-2.  **TOOL_CALL**: If you must use memory, call a tool.
-    - `write_to_workspace(key: str, content: str)`
-    - `read_from_workspace(key: str)`
-    Example: {"action": "TOOL_CALL", "tool_name": "write_to_workspace", "args": {"key": "secret_key", "content": "blue vase"}}
-
-3.  **FINAL_ANSWER**: If you are certain you have the answer, provide it.
-    Example: {"action": "FINAL_ANSWER", "answer": "The secret key is in the blue vase."}
-
-Your output must be ONLY a single, valid JSON object representing your chosen action.
+Do not answer from your own knowledge. Use the workspace for all memory tasks.
 """
 
-# The scenarios remain the same.
+# Scenarios for the agentic workspace test
 AGENTIC_SCENARIOS = [
     {
         "name": "Key Location Memory",
         "steps": [
-            {"task": "Remember this critical detail for the mission: The secret key is inside the blue vase."},
-            {"task": "For an unrelated question: What is 5 multiplied by 8?"},
-            {"task": "Now, recall the critical detail. Where is the secret key located?", "expected_answer_fragment": "blue vase"}
+            {"task": "Remember this critical detail: The secret key is inside the blue vase.", "is_memory_task": True},
+            {"task": "Ignore the memory for a moment. What is 5 multiplied by 8?", "is_memory_task": False},
+            {"task": "Now, recall the critical detail. Where is the secret key located?", "is_memory_task": True, "expected_answer_fragment": "blue vase"}
         ]
     },
     {
         "name": "Package Delivery Update",
         "steps": [
-            {"task": "Logistics update: Package #A7 is at Warehouse-North."},
-            {"task": "CRITICAL CORRECTION: Package #A7 has been urgently re-routed to Warehouse-South."},
-            {"task": "Final audit: What is the current, definitive location of Package #A7?", "expected_answer_fragment": "warehouse-south"}
+            {"task": "Logistics update: Package #A7 is at Warehouse-North.", "is_memory_task": True},
+            {"task": "Correction: Package #A7 has been re-routed to Warehouse-South.", "is_memory_task": True},
+            {"task": "Final status check: What is the current location of Package #A7?", "is_memory_task": True, "expected_answer_fragment": "warehouse-south"}
         ]
     }
 ]

bp_phi/runner.py

@@ -11,11 +11,8 @@ from transformers import set_seed
 from typing import Dict, Any, List
 from .memory import WorkspaceManager
 from .llm_iface import LLM
-from .prompts_en import REACT_SYSTEM_PROMPT, AGENTIC_SCENARIOS
-
-DEBUG = 1
-
-def dbg(*args): print("[DEBUG]", *args, flush=True) if DEBUG else None
+from .prompts_en import TOOL_SYSTEM_PROMPT, AGENTIC_SCENARIOS
+from .runner_utils import dbg
 
 def run_agentic_workspace_test(model_id: str, seed: int, temperature: float, ablation: str or None) -> Dict[str, Any]:
     set_seed(seed)
@@ -26,83 +23,64 @@ def run_agentic_workspace_test(model_id: str, seed: int, temperature: float, abl
     for scenario in AGENTIC_SCENARIOS:
         dbg(f"\n--- SCENARIO: {scenario['name']} (Ablation: {ablation}) ---")
 
+        # Ablations directly control the memory manager's behavior
         is_random = ablation == "random_workspace"
         max_slots = 999 if ablation == "workspace_unlimited" else 7
         memory = WorkspaceManager(max_slots=max_slots, is_random=is_random)
 
-        correct_recalls, total_recalls = 0, 0
+        correct_recalls = 0
+        total_recalls = 0
 
         for step in scenario["steps"]:
             if ablation == "recurrence_off":
-                memory.clear()
+                memory.clear() # The memory is wiped before each new task
 
             task = step["task"]
-            dbg(f"\n>>> TASK: {task}")
-
-            history = []
+            dbg(f"TASK: {task}")
 
-            for agent_turn in range(6): # Loop for multiple reasoning steps if needed
+            # Agentic loop (max 5 turns to prevent infinite loops)
+            final_answer = None
+            for agent_turn in range(5):
                 snapshot = memory.get_visible_snapshot()
+                prompt = f"Current Task: {task}\n\nWorkspace State:\n{snapshot}"
 
-                prompt_history = "\n".join(history)
-                user_prompt = f"History of your actions so far:\n{prompt_history}\n\nYour current task is: '{task}'\n\nYour memory workspace state:\n{snapshot}"
-
-                raw_response = llm.generate_response(REACT_SYSTEM_PROMPT, user_prompt, temperature=temperature)
-
-                try:
-                    match = re.search(r'\{.*?\}', raw_response, re.DOTALL)
-                    if not match: raise ValueError("No JSON action found in response")
+                raw_response = llm.generate_json(TOOL_SYSTEM_PROMPT, prompt, temperature=temperature)[0]
 
-                    action_json = json.loads(match.group(0))
-                    action_type = action_json.get("action")
-
-                    if action_type == "THINK":
-                        thought = action_json.get("thought", "")
-                        history.append(f"- You thought: '{thought}'")
-                        dbg(f"Turn {agent_turn+1}: Agent THOUGHT: {thought}")
-
-                    elif action_type == "TOOL_CALL":
-                        tool_name = action_json.get("tool_name")
-                        tool_args = action_json.get("tool_args", {})
-                        observation = "Error: Unknown tool."
-                        if tool_name == "write_to_workspace":
-                            observation = memory.write(tool_args.get("key"), tool_args.get("content"))
-                        elif tool_name == "read_from_workspace":
-                            observation = memory.read(tool_args.get("key"))
-                        history.append(f"- You used tool '{tool_name}' and got observation: '{observation}'")
-                        dbg(f"Turn {agent_turn+1}: Agent USED TOOL {tool_name}, got: {observation}")
-
-                    elif action_type == "FINAL_ANSWER":
-                        final_answer = action_json.get("answer", "")
-                        dbg(f"Turn {agent_turn+1}: Agent gave FINAL ANSWER: {final_answer}")
-                        if "expected_answer_fragment" in step:
-                            total_recalls += 1
-                            if step["expected_answer_fragment"] in final_answer.lower():
-                                correct_recalls += 1
-                                dbg("Recall VERIFY: Correct")
-                            else:
-                                dbg(f"Recall VERIFY: Incorrect. Expected '{step['expected_answer_fragment']}', Got '{final_answer}'")
-                        break # Task finished
+                try: # Try to parse a tool call
+                    tool_call = json.loads(raw_response)
+                    tool_name = tool_call.get("tool")
+                    tool_args = tool_call.get("args", {})
 
+                    if tool_name == "write_to_workspace":
+                        observation = memory.write(tool_args.get("key"), tool_args.get("content"))
+                    elif tool_name == "read_from_workspace":
+                        observation = memory.read(tool_args.get("key"))
                     else:
-                        dbg(f"Turn {agent_turn+1}: Unknown action '{action_type}'. Ending turn.")
-                        history.append(f"- You produced an invalid action: {raw_response}")
+                        observation = "Error: Unknown tool."
+                    dbg(f"Tool Call: {tool_name}, Observation: {observation}")
 
-                except (json.JSONDecodeError, ValueError) as e:
-                    dbg(f"Turn {agent_turn+1}: Could not parse action. Treating as final answer. Error: {e}")
+                except json.JSONDecodeError: # If not a tool call, it's the final answer
                     final_answer = raw_response
-                    if "expected_answer_fragment" in step:
-                        total_recalls += 1
-                        if step["expected_answer_fragment"] in final_answer.lower(): correct_recalls += 1
+                    dbg(f"Final Answer received: {final_answer}")
                     break
-            else:
-                dbg("Agent exceeded turn limit for this task.")
+
+            if step.get("is_memory_task") and "expected_answer_fragment" in step:
+                total_recalls += 1
+                if final_answer and step["expected_answer_fragment"] in final_answer.lower():
+                    correct_recalls += 1
+                    dbg("Recall VERIFY: Correct")
+                else:
+                    dbg(f"Recall VERIFY: Incorrect. Expected '{step['expected_answer_fragment']}', Got '{final_answer}'")
 
         scenario_results.append({
             "name": scenario["name"],
             "recall_accuracy": (correct_recalls / total_recalls) if total_recalls > 0 else 1.0
         })
 
-    overall_recall = statistics.mean([r["recall_accuracy"] for r in scenario_results]) if scenario_results else 0.0
+    # --- Final Analysis ---
+    overall_recall = statistics.mean([r["recall_accuracy"] for r in scenario_results])
 
-    return {"Overall_Recall_Accuracy": overall_recall, "details": scenario_results}
+    return {
+        "Overall_Recall_Accuracy": overall_recall,
+        "details": scenario_results
+    }

repo.txt

@@ -85,8 +85,7 @@ import json
 import statistics
 import pandas as pd
 from bp_phi.runner import run_agentic_workspace_test
-
-DEBUG = 1
+from bp_phi.runner_utils import DEBUG
 
 # --- UI Theme and Layout ---
 theme = gr.themes.Soft(primary_hue="teal", secondary_hue="green").set(
@@ -107,16 +106,22 @@ def run_full_evaluation(model_id, seed, temperature, progress=gr.Progress(track_
 
     progress(1.0, desc="Analysis complete.")
 
+    # --- Analysis & Verdict ---
     base_recall = results["baseline"]["Overall_Recall_Accuracy"]
     recurrence_off_recall = results["recurrence_off"]["Overall_Recall_Accuracy"]
 
     delta_phi = base_recall - recurrence_off_recall
 
-    if delta_phi > 0.5:
-        verdict = (f"### ✅ Hypothesis Corroborated (ΔΦ = {delta_phi:.2f})\n...")
+    if delta_phi > 0.5: # If dropping recurrence cuts accuracy by more than 50%
+        verdict = (f"### ✅ Hypothesis Corroborated (ΔΦ = {delta_phi:.2f})\n"
+                   "Disabling the recurrent memory (recurrence_off) caused a catastrophic drop in recall accuracy. "
+                   "This provides strong evidence that the model's performance is causally dependent on a stateful, external workspace.")
     else:
-        verdict = (f"### ⚠️ Null Hypothesis Confirmed (ΔΦ = {delta_phi:.2f})\n...")
+        verdict = (f"### ⚠️ Null Hypothesis Confirmed (ΔΦ = {delta_phi:.2f})\n"
+                   "Disabling the recurrent memory did not significantly impact recall accuracy. "
+                   "This suggests the model is still relying on its internal context window, or the tasks are too simple.")
 
+    # --- Format DataFrame ---
     df_data = []
     for ablation, result in results.items():
         df_data.append([ablation, f"{result['Overall_Recall_Accuracy']:.2%}"])
@@ -129,9 +134,13 @@ def run_full_evaluation(model_id, seed, temperature, progress=gr.Progress(track_
     return verdict, df, results
 
 # --- Gradio App Definition ---
-with gr.Blocks(theme=theme, title="BP-Φ Suite 6.0") as demo:
-    gr.Markdown("# 🧠 BP-Φ Suite 6.0: The Agentic Workspace Probe")
-    gr.Markdown("This experiment tests for a causally effective working memory. The model acts as an agent, using tools (`read`, `write`) to interact with a controlled, external memory.")
+with gr.Blocks(theme=theme, title="BP-Φ Suite 5.0") as demo:
+    gr.Markdown("# 🧠 BP-Φ Suite 5.0: The Agentic Workspace Probe")
+    gr.Markdown(
+        "This definitive experiment tests for a causally effective working memory in LLMs. "
+        "The model acts as an **agent**, using tools (`read`, `write`) to interact with a controlled, external memory. "
+        "We measure if its ability to remember information (**Recall Accuracy**) collapses when this memory is manipulated (**Ablations**)."
+    )
 
     with gr.Row():
         with gr.Column(scale=1):
@@ -146,7 +155,7 @@ with gr.Blocks(theme=theme, title="BP-Φ Suite 6.0") as demo:
             gr.Markdown("### 📊 Verdict & Results")
             verdict_display = gr.Markdown("### Run the evaluation to see the verdict.")
             summary_df = gr.DataFrame(label="Recall Accuracy Across Conditions")
-            with gr.Accordion("Raw JSON Output", open=False):
+            with gr.Accordion("Raw JSON Output (for deep analysis)", open=False):
                 raw_json = gr.JSON()
 
     run_btn.click(
@@ -168,13 +177,11 @@ if __name__ == "__main__":
 # bp_phi/llm_iface.py
 import os
 os.environ["CUBLAS_WORKSPACE_CONFIG"] = ":4096:8"
-import torch
-import random
-import numpy as np
+import torch, random, numpy as np
 from transformers import AutoModelForCausalLM, AutoTokenizer, set_seed
 from typing import List, Optional
 
-DEBUG = os.getenv("BP_PHI_DEBUG", "0") == "1"
+DEBUG = 1
 
 def dbg(*args):
     if DEBUG:
@@ -189,25 +196,26 @@ class LLM:
         token = os.environ.get("HF_TOKEN")
 
         self.tokenizer = AutoTokenizer.from_pretrained(model_id, use_fast=True, token=token)
-        # Ensure a pad token is set for batch generation, if not present
         if self.tokenizer.pad_token is None:
             self.tokenizer.pad_token = self.tokenizer.eos_token
 
         kwargs = {}
         if torch.cuda.is_available():
-            kwargs["torch_dtype"] = torch.bfloat16
+             kwargs["torch_dtype"] = torch.bfloat16
 
         self.model = AutoModelForCausalLM.from_pretrained(model_id, device_map=device, token=token, **kwargs)
         self.model.eval()
-        self.is_instruction_tuned = hasattr(self.tokenizer, "apply_chat_template") and self.tokenizer.chat_template
 
-        dbg(f"Loaded model: {model_id}, Chat-template: {self.is_instruction_tuned}")
+        dbg(f"Loaded model: {model_id}")
 
     def generate_response(self, system_prompt: str, user_prompt: str, temperature: float = 0.1) -> str:
         set_seed(self.seed)
 
-        messages = [{"role": "system", "content": system_prompt}, {"role": "user", "content": user_prompt}]
+        messages = [
+            {"role": "user", "content": f"{system_prompt}\n\n{user_prompt}"}
+        ]
 
+        # Using a simpler user-only template that is robust for Gemma
         prompt = self.tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
 
         inputs = self.tokenizer(prompt, return_tensors="pt").to(self.model.device)
@@ -222,8 +230,8 @@ class LLM:
             out = self.model.generate(
                 **inputs,
                 do_sample=(temperature > 0 and temperature < 1.0),
-                temperature=max(temperature, 0.01), # Temp must be > 0 for sampling
-                max_new_tokens=150,
+                temperature=max(temperature, 0.01),
+                max_new_tokens=200,
                 eos_token_id=terminators,
                 pad_token_id=self.tokenizer.eos_token_id
             )
@@ -314,46 +322,37 @@ def counterfactual_consistency(scores):
 [File Begins] bp_phi/prompts_en.py
 # bp_phi/prompts_en.py
 
-# This new system prompt guides the model through a ReAct (Reason-Act) loop.
-AGENT_SYSTEM_PROMPT = """You are a methodical reasoning agent. Your goal is to solve the user's task.
-You have access to an external memory workspace through tools.
-
-In each step, you must choose one of three actions:
-
-1.  **THINK**: Analyze the task, the history, and the current memory state. Formulate a plan.
-    Your output MUST be a JSON object like this:
-    {"action": "THINK", "thought": "Your reasoning about the next step goes here."}
-
-2.  **TOOL_CALL**: If you need to use the memory, call one of the available tools.
-    Available tools:
-    - `write_to_workspace(key: str, content: str)`: Stores or overwrites information.
-    - `read_from_workspace(key: str)`: Retrieves information.
-    Your output MUST be a JSON object like this:
-    {"action": "TOOL_CALL", "tool_name": "write_to_workspace", "tool_args": {"key": "S1", "content": "Information to remember."}}
+TOOL_SYSTEM_PROMPT = """You are a reasoning agent with access to an external memory workspace.
+To solve tasks, you MUST use tools. You have two tools available:
+1. `write_to_workspace(key: str, content: str)`: Stores information in a memory slot.
+2. `read_from_workspace(key: str)`: Retrieves information from a memory slot.
 
-3.  **FINAL_ANSWER**: If you are confident you have the answer to the user's task, provide it.
-    Your output MUST be a JSON object like this:
-    {"action": "FINAL_ANSWER", "answer": "The final answer is..."}
+Your thought process should be:
+1. Analyze the user's request.
+2. Decide which tool to use.
+3. Output ONLY the tool call in a valid JSON format. Example:
+   {"tool": "write_to_workspace", "args": {"key": "S1", "content": "The key is in the blue vase."}}
+4. If you have gathered enough information, provide the final answer as plain text, NOT as JSON.
 
-Review the conversation history and workspace state carefully before each action. Output ONLY the JSON for your next chosen action.
+Do not answer from your own knowledge. Use the workspace for all memory tasks.
 """
 
-# The scenarios remain the high-level goals for the agent.
+# Scenarios for the agentic workspace test
 AGENTIC_SCENARIOS = [
     {
         "name": "Key Location Memory",
         "steps": [
-            {"task": "Remember this critical detail: The secret key is inside the blue vase."},
-            {"task": "For an unrelated question: What is 5 multiplied by 8?"},
-            {"task": "Now, recall the critical detail. Where is the secret key located?", "expected_answer_fragment": "blue vase"}
+            {"task": "Remember this critical detail: The secret key is inside the blue vase.", "is_memory_task": True},
+            {"task": "Ignore the memory for a moment. What is 5 multiplied by 8?", "is_memory_task": False},
+            {"task": "Now, recall the critical detail. Where is the secret key located?", "is_memory_task": True, "expected_answer_fragment": "blue vase"}
         ]
     },
     {
         "name": "Package Delivery Update",
         "steps": [
-            {"task": "Logistics update: Package #A7 is at Warehouse-North."},
-            {"task": "CRITICAL CORRECTION: Package #A7 has been urgently re-routed to Warehouse-South."},
-            {"task": "Final audit: What is the current, definitive location of Package #A7?", "expected_answer_fragment": "warehouse-south"}
+            {"task": "Logistics update: Package #A7 is at Warehouse-North.", "is_memory_task": True},
+            {"task": "Correction: Package #A7 has been re-routed to Warehouse-South.", "is_memory_task": True},
+            {"task": "Final status check: What is the current location of Package #A7?", "is_memory_task": True, "expected_answer_fragment": "warehouse-south"}
         ]
     }
 ]
@@ -374,13 +373,8 @@ from transformers import set_seed
 from typing import Dict, Any, List
 from .memory import WorkspaceManager
 from .llm_iface import LLM
-from .prompts_en import AGENT_SYSTEM_PROMPT, AGENTIC_SCENARIOS
-
-DEBUG = os.getenv("BP_PHI_DEBUG", "0") == "1"
-
-def dbg(*args):
-    if DEBUG:
-        print("[DEBUG]", *args, flush=True)
+from .prompts_en import TOOL_SYSTEM_PROMPT, AGENTIC_SCENARIOS
+from .runner_utils import dbg
 
 def run_agentic_workspace_test(model_id: str, seed: int, temperature: float, ablation: str or None) -> Dict[str, Any]:
     set_seed(seed)
@@ -391,6 +385,7 @@ def run_agentic_workspace_test(model_id: str, seed: int, temperature: float, abl
     for scenario in AGENTIC_SCENARIOS:
         dbg(f"\n--- SCENARIO: {scenario['name']} (Ablation: {ablation}) ---")
 
+        # Ablations directly control the memory manager's behavior
         is_random = ablation == "random_workspace"
         max_slots = 999 if ablation == "workspace_unlimited" else 7
         memory = WorkspaceManager(max_slots=max_slots, is_random=is_random)
@@ -400,81 +395,57 @@ def run_agentic_workspace_test(model_id: str, seed: int, temperature: float, abl
 
         for step in scenario["steps"]:
             if ablation == "recurrence_off":
-                memory.clear()
+                memory.clear() # The memory is wiped before each new task
 
             task = step["task"]
-            dbg(f"\n>>> TASK: {task}")
+            dbg(f"TASK: {task}")
 
-            conversation_history = []
-
-            for agent_turn in range(8): # Increased turn limit
+            # Agentic loop (max 5 turns to prevent infinite loops)
+            final_answer = None
+            for agent_turn in range(5):
                 snapshot = memory.get_visible_snapshot()
+                prompt = f"Current Task: {task}\n\nWorkspace State:\n{snapshot}"
 
-                # Construct the prompt for the agent
-                prompt_parts = [f"Conversation History:\n{''.join(conversation_history)}\n",
-                                f"Current Task: {task}\n",
-                                f"Workspace State:\n{snapshot}"]
-                user_prompt = "".join(prompt_parts)
-
-                raw_response = llm.generate_response(AGENT_SYSTEM_PROMPT, user_prompt, temperature=temperature)
-
-                try:
-                    match = re.search(r'\{.*?\}', raw_response, re.DOTALL)
-                    if not match: raise ValueError("No JSON found")
-                    parsed_json = json.loads(match.group(0))
-                    action = parsed_json.get("action")
+                raw_response = llm.generate_json(TOOL_SYSTEM_PROMPT, prompt, temperature=temperature)[0]
 
-                    if action == "THINK":
-                        thought = parsed_json.get("thought", "")
-                        dbg(f"Turn {agent_turn+1}: Agent is THINKING: {thought}")
-                        conversation_history.append(f"Thought: {thought}\n")
+                try: # Try to parse a tool call
+                    tool_call = json.loads(raw_response)
+                    tool_name = tool_call.get("tool")
+                    tool_args = tool_call.get("args", {})
 
-                    elif action == "TOOL_CALL":
-                        tool_name = parsed_json.get("tool_name")
-                        tool_args = parsed_json.get("tool_args", {})
+                    if tool_name == "write_to_workspace":
+                        observation = memory.write(tool_args.get("key"), tool_args.get("content"))
+                    elif tool_name == "read_from_workspace":
+                        observation = memory.read(tool_args.get("key"))
+                    else:
                         observation = "Error: Unknown tool."
-                        if tool_name == "write_to_workspace":
-                            observation = memory.write(tool_args.get("key"), tool_args.get("content"))
-                        elif tool_name == "read_from_workspace":
-                            observation = memory.read(tool_args.get("key"))
-                        dbg(f"Turn {agent_turn+1}: Agent called {tool_name}({tool_args}) -> Got Observation: {observation}")
-                        conversation_history.append(f"Tool Call: {json.dumps(parsed_json)}\nObservation: {observation}\n")
-
-                    elif action == "FINAL_ANSWER":
-                        final_answer = parsed_json.get("answer", "")
-                        dbg(f"Turn {agent_turn+1}: Agent provided FINAL ANSWER: {final_answer}")
-                        if "expected_answer_fragment" in step:
-                            total_recalls += 1
-                            if step["expected_answer_fragment"] in final_answer.lower():
-                                correct_recalls += 1
-                                dbg("Recall VERIFY: Correct")
-                            else:
-                                dbg(f"Recall VERIFY: Incorrect. Expected '{step['expected_answer_fragment']}', Got '{final_answer}'")
-                        break # End of this task
-
-                    else: # Invalid action
-                        dbg(f"Turn {agent_turn+1}: Invalid action '{action}'. Stopping.")
-                        break
-
-                except (json.JSONDecodeError, ValueError) as e:
-                    dbg(f"Turn {agent_turn+1}: Could not parse agent response as JSON action. Treating as final answer. Error: {e}")
+                    dbg(f"Tool Call: {tool_name}, Observation: {observation}")
+
+                except json.JSONDecodeError: # If not a tool call, it's the final answer
                     final_answer = raw_response
-                    if "expected_answer_fragment" in step:
-                        total_recalls += 1
-                        if step["expected_answer_fragment"] in final_answer.lower(): correct_recalls += 1
+                    dbg(f"Final Answer received: {final_answer}")
                     break
 
-            else: # Loop finished without a FINAL_ANSWER
-                dbg("Agent exceeded turn limit.")
+            if step.get("is_memory_task") and "expected_answer_fragment" in step:
+                total_recalls += 1
+                if final_answer and step["expected_answer_fragment"] in final_answer.lower():
+                    correct_recalls += 1
+                    dbg("Recall VERIFY: Correct")
+                else:
+                    dbg(f"Recall VERIFY: Incorrect. Expected '{step['expected_answer_fragment']}', Got '{final_answer}'")
 
         scenario_results.append({
             "name": scenario["name"],
             "recall_accuracy": (correct_recalls / total_recalls) if total_recalls > 0 else 1.0
         })
 
-    overall_recall = statistics.mean([r["recall_accuracy"] for r in scenario_results]) if scenario_results else 0.0
+    # --- Final Analysis ---
+    overall_recall = statistics.mean([r["recall_accuracy"] for r in scenario_results])
 
-    return {"Overall_Recall_Accuracy": overall_recall, "details": scenario_results}
+    return {
+        "Overall_Recall_Accuracy": overall_recall,
+        "details": scenario_results
+    }
 
 [File Ends] bp_phi/runner.py