chore: Rename Dockerfile to fix HF Space deploy, and clean up AI slop

HANDOVER.md

@@ -1,211 +0,0 @@
-# AgentDebuggerEnv — Project Handover
-
-## What This Project Is
-A GRPO-trained LLM (Qwen2.5-Coder-7B-Instruct) that learns to debug Python code through
-structured hypothesis-driven reasoning. Submitted to the Meta + PyTorch + HuggingFace OpenEnv Hackathon.
-
----
-
-## Repo & Remotes
-
-| Remote | URL |
-|---|---|
-| GitHub (source of truth) | https://github.com/shasshaank/meta_hackthon.git |
-| HF Training Space | https://huggingface.co/spaces/shashaank0707/AgentDebugger-training-v2 |
-| HF Trained Model | https://huggingface.co/shashaank0707/AgentDebugger-trained |
-
-Push to GitHub first, then to HF Space if needed:
-```bash
-git push origin main
-git push space main --force   # space remote = HF training space
-```
-
-The `space` remote URL includes your HF token:
-```
-https://shashaank0707:YOUR_HF_TOKEN@huggingface.co/spaces/shashaank0707/AgentDebugger-training-v2
-```
-
----
-
-## Project Structure
-
-```
-meta_hackathon/
-├── app.py                      # Gradio training monitor — launched by HF Space SDK
-├── training/
-│   └── train_grpo.py           # Main training script (GRPO via TRL)
-├── server/
-│   ├── reward_calculator.py    # Multi-component reward (format, hypothesis, fix, semantic)
-│   ├── models.py               # parse_agent_output() — parses structured LLM output
-│   └── app.py                  # FastAPI server (for the inference/env Space, not training)
-├── data/
-│   ├── bugs_tier1.jsonl        # 9 easy bugs (used steps 0–150)
-│   ├── bugs_tier2.jsonl        # 31 medium bugs (added at step 150)
-│   ├── bugs_tier3.jsonl        # 21 hard bugs (added at step 350 → was 600)
-│   └── generate_bugs.py        # Script that generated the bug datasets
-├── requirements.txt            # HF Space deps (gradio[oauth,mcp]==6.13.0, cu121 torch)
-├── requirements_kaggle.txt     # Kaggle/RunPod deps (no torch pin, bitsandbytes==0.45.3)
-├── inference.py                # Inference wrapper for evaluation
-├── Dockerfile                  # For the inference/env Space (not the training space)
-└── README.md                   # HF Space config header (sdk: gradio, app_file: app.py)
-```
-
----
-
-## Dependency Versions (locked — do not change without testing)
-
-| Package | Version | Why pinned |
-|---|---|---|
-| `trl` | `0.14.0` | First version with `GRPOTrainer` + `GRPOConfig` |
-| `pydantic` | `2.12.5` | Only version satisfying both gradio base AND gradio[mcp] constraints |
-| `gradio` | `6.13.0[oauth,mcp]` | HF Space builder requires extras in one install pass |
-| `bitsandbytes` | `0.45.3` (Kaggle) / `0.43.3` (HF Space cu121) | 0.45.3 has CUDA 12.x binaries; 0.43.3 works with cu121 |
-| `transformers` | `4.46.3` | Tested with TRL 0.14.0 |
-| `torch` | `2.5.1+cu121` (HF Space) / pre-installed (Kaggle) | |
-
-**GRPOConfig param name:** `max_completion_length` (NOT `max_new_tokens` — that's the old name, breaks on 0.14.0)
-
----
-
-## Training Script — Key Design Decisions
-
-### GPU Auto-Detection (train_grpo.py ~line 260)
-The script detects GPU at runtime and sets all hyperparams automatically:
-
-| GPU | dtype | batch | grad_accum | num_gen | max_comp | lora_r |
-|---|---|---|---|---|---|---|
-| A100 40GB+ | bfloat16 | 2 | 4 | 8 | 256 | 16 |
-| V100 32GB | float16 | 1 | 8 | 6 | 220 | 12 |
-| T4 / ≤16GB | float16 | 1 | 8 | 4 | 160 | 8 |
-
-**Critical:** P100 is NOT supported — PyTorch 2.x dropped sm_60 support. Use T4 instead.
-
-### Curriculum
-- Steps 0–150: Tier 1 bugs only (9 bugs)
-- Steps 150–350: Tier 1 + Tier 2 (40 bugs)
-- Steps 350+: All tiers (61 bugs)
-
-### Reward Components (server/reward_calculator.py)
-| Component | Weight | What it measures |
-|---|---|---|
-| format_compliance | 0.10 | All 5 fields present (OBSERVATION/HYPOTHESIS/CONFIDENCE/ACTION/DETAIL) |
-| hypothesis_quality | 0.20 | Length + references specific variable names |
-| localization | 0.15 | Correct function/line identified |
-| fix_quality | 0.35 | Tests pass on proposed fix |
-| semantic_similarity | 0.10 | Similarity to canonical fix |
-| efficiency_potential | 0.10 | Potential-based shaping (Ibrahim et al. 2024) |
-
-### Required Output Format
-```
-OBSERVATION: [specific observations with line numbers]
-HYPOTHESIS: [2+ sentences explaining root cause with variable names]
-CONFIDENCE: [low | medium | high]
-ACTION: [inspect_lines | run_tests | propose_fix | request_context | give_up]
-DETAIL: [complete fixed function code if propose_fix, else details]
-```
-
----
-
-## Running Training
-
-### On Kaggle (T4 — free):
-```python
-# Cell 1 — install
-!pip install -q wandb==0.18.7 datasets==3.0.2 transformers==4.46.3 \
-    accelerate==1.0.1 trl==0.14.0 bitsandbytes==0.45.3 peft==0.13.2
-
-# Cell 2 — clone + secrets
-from kaggle_secrets import UserSecretsClient
-import os
-secrets = UserSecretsClient()
-os.environ["WANDB_API_KEY"] = secrets.get_secret("WANDB_API_KEY")
-os.environ["HF_TOKEN"]      = secrets.get_secret("HF_TOKEN")
-!git clone https://github.com/shasshaank/meta_hackthon.git /kaggle/working/repo
-%cd /kaggle/working/repo
-
-# Cell 3 — train (streams output live)
-import subprocess, sys
-proc = subprocess.Popen(
-    [sys.executable, "training/train_grpo.py"],
-    stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
-    text=True, bufsize=1, cwd="/kaggle/working/repo"
-)
-for line in proc.stdout:
-    print(line, end="", flush=True)
-proc.wait()
-
-# Cell 4 — save outputs after training
-import shutil
-shutil.copytree("/kaggle/working/repo/checkpoints", "/kaggle/working/checkpoints", dirs_exist_ok=True)
-```
-
-**Kaggle secrets needed:** `WANDB_API_KEY`, `HF_TOKEN`
-**Kaggle GPU:** T4 x1 (NOT P100 — incompatible with modern PyTorch)
-**Expected time:** ~8–10 hours for 500 steps (default max_steps=500)
-
-### On RunPod (A100 — ~$1.09/hr):
-```bash
-git clone https://github.com/shasshaank/meta_hackthon.git && cd meta_hackthon
-pip install -q wandb==0.18.7 datasets==3.0.2 transformers==4.46.3 \
-    accelerate==1.0.1 trl==0.14.0 bitsandbytes==0.45.3 peft==0.13.2
-WANDB_API_KEY=xxx HF_TOKEN=xxx python training/train_grpo.py
-```
-**Expected time:** ~3–4 hours for 1000 steps on A100 40GB
-
-### Resume from checkpoint:
-```bash
-python training/train_grpo.py --resume ./checkpoints/checkpoint-400
-```
-
-### Local sanity check (no GPU):
-```bash
-python training/train_grpo.py --test-local
-```
-
----
-
-## HF Space Setup (training monitor)
-
-The training Space (`AgentDebugger-training-v2`) is a Gradio app that:
-1. On startup, spawns `training/train_grpo.py` in a background thread
-2. Shows a live training log in the UI, auto-refreshing every 30s
-
-**Required Space secrets:**
-- `WANDB_API_KEY`
-- `HF_TOKEN`
-
-**Push to Space:**
-```bash
-git remote set-url space https://shashaank0707:YOUR_HF_TOKEN@huggingface.co/spaces/shashaank0707/AgentDebugger-training-v2
-git push space main --force
-```
-
----
-
-## Known Issues Fixed (do not revert)
-
-| Issue | Fix |
-|---|---|
-| `ImportError: cannot import name 'GRPOTrainer'` | `trl==0.12.2` → `trl==0.14.0` |
-| `TypeError: GRPOConfig got unexpected keyword 'max_new_tokens'` | renamed to `max_completion_length` |
-| `pydantic` conflict with `gradio[mcp]` | `pydantic==2.10.6` → `2.12.5` |
-| `P100 not supported by PyTorch 2.x` | Switch to T4 on Kaggle |
-| `bitsandbytes CUDA binary not found` | `bitsandbytes==0.43.3` → `0.45.3` on Kaggle |
-| `unsloth` CUDA driver crash on HF A100 | Replaced with `bitsandbytes + peft` |
-| `gradio every=` deprecation | Replaced with `gr.Timer(value=30)` |
-
----
-
-## W&B Dashboard
-https://wandb.ai/shashaankjain07-keshav-memorial-college-of-law/AgentDebuggerEnv
-
-Training runs appear here automatically when `WANDB_API_KEY` is set.
-
----
-
-## What's Left To Do
-
-- [ ] **Finish training** — 500–1000 steps, model pushes to HF Hub automatically on completion
-- [ ] **Verify trained model** — run `inference.py` against the trained model checkpoint
-- [ ] **Update HF Space README** — change curriculum description to match actual step boundaries (150/350)
-- [ ] **Submission** — ensure the inference/env Space (`AgentDebugger-env`) is live and healthy for judging

calibrate.py

@@ -15,9 +15,9 @@ def test_passes(code, func, inp, expected):
 try:
     r = {func}({args})
     expected = {repr(expected)}
-    print("PASS" if r == expected else f"FAIL: got {{r}}")
+    print("PASS" if r == expected else f"FAIL: got { r} ")
 except Exception as e:
-    print(f"ERROR: {{e}}")
+    print(f"ERROR: { e} ")
 """
     try:
         with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:

demo/gradio_app.py

@@ -1,9 +1,3 @@
-"""
-AgentDebuggerEnv — Interactive Gradio Demo
-==========================================
-Demonstrates the live debugging environment with a rule-based agent.
-Shows structured multi-turn reasoning, reward breakdown, and fix verification.
-"""
 
 import os
 import sys
@@ -18,7 +12,7 @@ import gradio as gr
 from env.models import parse_agent_output
 from server.reward_calculator import DebugRewardCalculator
 
-# ── Pre-loaded bug examples (one per bug type) ────────────────────────────────
+
 
 EXAMPLES = {
     "🔢 Off-by-One: binary_search": {
@@ -256,10 +250,9 @@ DETAIL: def fibonacci(n):
     },
 }
 
-# ── Test runner ───────────────────────────────────────────────────────────────
+
 
 def _run_tests(code: str, function_name: str, test_cases: list) -> dict:
-    """Run test cases against code in a subprocess. Returns pass/fail counts."""
     passed = 0
     python = shutil.which("python3") or shutil.which("python") or sys.executable
     for tc in test_cases:
@@ -270,9 +263,9 @@ def _run_tests(code: str, function_name: str, test_cases: list) -> dict:
             f"{code}\n"
             f"try:\n"
             f"    r = {function_name}({args_str})\n"
-            f"    print('PASS' if r == {repr(expected)} else f'FAIL: got {{r}}')\n"
+            f"    print('PASS' if r == {repr(expected)} else f'FAIL: got { r} ')\n"
             f"except Exception as e:\n"
-            f"    print(f'ERROR: {{e}}')\n"
+            f"    print(f'ERROR: { e} ')\n"
         )
         try:
             with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
@@ -288,16 +281,12 @@ def _run_tests(code: str, function_name: str, test_cases: list) -> dict:
     return {"passed": passed, "failed": total - passed, "total": total, "newly_broken": 0}
 
 
-# ── Rule-based agent runner ───────────────────────────────────────────────────
+
 
 def run_debug_session(example_name: str, custom_code: str) -> str:
-    """
-    Run the rule-based debug agent for 2 turns.
-    Returns a formatted string showing each turn's output and reward.
-    """
     calculator = DebugRewardCalculator()
 
-    # Determine which bug we're working with
+    
     if example_name and example_name in EXAMPLES:
         bug = EXAMPLES[example_name]
         code = bug["buggy_code"]
@@ -312,7 +301,7 @@ def run_debug_session(example_name: str, custom_code: str) -> str:
         function_name = bug["function_name"]
         initial_error = bug["initial_error"]
     else:
-        # Custom code — generic 2-turn agent
+        
         code = custom_code.strip() if custom_code.strip() else "# No code provided"
         agent_turns = [
             """\
@@ -336,7 +325,7 @@ DETAIL: """ + code,
         function_name = ""
         initial_error = "Unknown — paste your own code and observe the agent reasoning"
 
-    # ── Build output ──────────────────────────────────────────────────────────
+    
     lines = []
     lines.append("━" * 60)
     lines.append(f"🐛  BUGGY CODE")
@@ -356,12 +345,12 @@ DETAIL: """ + code,
 
         agent_output = parse_agent_output(raw_turn)
 
-        # Run tests if this is a fix proposal
+        
         test_results = {"passed": 0, "failed": 0, "total": len(test_cases), "newly_broken": 0}
         if agent_output.action == "propose_fix" and test_cases and function_name:
             test_results = _run_tests(agent_output.detail, function_name, test_cases)
 
-        # Compute reward
+        
         reward = calculator.compute_turn_reward(
             agent_output=agent_output,
             ground_truth=ground_truth,
@@ -370,7 +359,7 @@ DETAIL: """ + code,
         )
         total_episode_reward += reward.total
 
-        # Format the structured output
+        
         lines.append(f"OBSERVATION:  {agent_output.observation}")
         lines.append("")
         lines.append(f"HYPOTHESIS:   {agent_output.hypothesis}")
@@ -380,7 +369,7 @@ DETAIL: """ + code,
         lines.append(f"DETAIL:       {agent_output.detail[:120]}{'...' if len(agent_output.detail) > 120 else ''}")
         lines.append("")
 
-        # Reward breakdown table
+        
         lines.append("┌─────────────────────────────────────────────┐")
         lines.append("│  Reward Breakdown                           │")
         lines.append("├──────────────────────────┬──────────────────┤")
@@ -395,7 +384,7 @@ DETAIL: """ + code,
         lines.append(f"│  TURN REWARD             │  {reward.total:+.4f}          │")
         lines.append("└──────────────────────────┴──────────────────┘")
 
-        # Test results for fix turns
+        
         if agent_output.action == "propose_fix" and test_results["total"] > 0:
             p = test_results["passed"]
             t = test_results["total"]
@@ -409,7 +398,7 @@ DETAIL: """ + code,
 
         lines.append("")
 
-    # ── Episode summary ───────────────────────────────────────────────────────
+    
     lines.append("━" * 60)
     if solved:
         lines.append(f"  ✅  SOLVED in {len(agent_turns)} turns  |  Episode reward: {total_episode_reward:+.3f}")
@@ -424,10 +413,9 @@ DETAIL: """ + code,
     return "\n".join(lines)
 
 
-# ── Gradio interface ──────────────────────────────────────────────────────────
+
 
 def load_example(example_name: str) -> str:
-    """Return the buggy code for the selected example."""
     if example_name and example_name in EXAMPLES:
         return EXAMPLES[example_name]["buggy_code"]
     return ""
@@ -480,7 +468,7 @@ The environment scores every turn across 6 reward components grounded in two res
                     inputs=example_dropdown,
                     outputs=custom_code,
                 )
-                # Pre-load first example
+                
                 demo.load(
                     fn=lambda: load_example(example_names[0]),
                     outputs=custom_code,

eval_run.log

@@ -0,0 +1,12 @@
+W0707 11:06:09.884000 56937 .venv/lib/python3.13/site-packages/torch/distributed/elastic/multiprocessing/redirects.py:29] NOTE: Redirects are currently not supported in Windows or MacOs.
+`torch_dtype` is deprecated! Use `dtype` instead!
+Loading base model: Qwen/Qwen2.5-Coder-3B-Instruct...
+Using device: mps | dtype: torch.float16
+
+Loading LoRA adapter: shashaank0707/AgentDebugger-trained...
+Moving model to target device: mps...
+
+Initializing environment and loading bugs...
+
+Evaluating Tier 1 bugs...
+
  0%|          | 0/40 [00:00<?, ?it/s]The following generation flags are not valid and may be ignored: ['temperature', 'top_p', 'top_k']. Set `TRANSFORMERS_VERBOSITY=info` for more details.

evaluate_model.py

@@ -8,16 +8,16 @@ from dotenv import load_dotenv
 from transformers import AutoModelForCausalLM, AutoTokenizer
 from peft import PeftModel
 
-# Load environment variables
+
 load_dotenv()
 
-# Insert workspace root to path
+
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 from env.environment import DebuggerEnvironment
 from env.models import parse_agent_output
 from server.reward_calculator import DebugRewardCalculator
 
-# System prompt matching train_grpo.py
+
 SYSTEM_PROMPT = """You are an expert Python debugger. You reason through bugs systematically.
 
 You MUST respond in EXACTLY this format — no exceptions, no extra text:
@@ -51,7 +51,7 @@ def main():
     parser.add_argument("--base-model", type=str, default="Qwen/Qwen2.5-Coder-3B-Instruct", help="Base model identifier")
     args = parser.parse_args()
 
-    # Verify HF Token if repository is private
+    
     hf_token = os.environ.get("HF_TOKEN")
     if not hf_token:
         print("WARNING: HF_TOKEN environment variable not set. Loading a private repository might fail.")
@@ -80,7 +80,7 @@ def main():
             token=hf_token
         )
         
-        # Explicitly move to target device if using MPS or CPU
+        
         if device in ["mps", "cpu"]:
             print(f"Moving model to target device: {device}...")
             model = model.to(device)
@@ -125,12 +125,12 @@ def main():
         tier_solved = 0
 
         for bug in tqdm(bugs):
-            # Setup environment context for this bug
+            
             env.current_bug = bug
             env.current_episode_trajectory = []
             env.turn_number = 0
 
-            # Generate prompt
+            
             prompt = bug_to_prompt(bug)
             inputs = tokenizer(prompt, return_tensors="pt").to(device)
 
@@ -143,7 +143,7 @@ def main():
             
             completion = tokenizer.decode(out[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True)
 
-            # Step the environment with model's completion
+            
             step_result = env.step_curriculum(completion)
             info = step_result["info"]
             reward_breakdown = info["reward_breakdown"]
@@ -154,7 +154,7 @@ def main():
                 solved_bugs_count += 1
             total_bugs_count += 1
 
-            # Store details
+            
             bug_detail = {
                 "id": bug.get("id"),
                 "function_name": bug.get("function_name"),
@@ -190,7 +190,7 @@ def main():
         "solve_rate": solved_bugs_count / total_bugs_count if total_bugs_count else 0.0,
     }
 
-    # Save to file
+    
     output = {
         "summary": summary,
         "results": results

evaluation_results.json

@@ -41,9 +41,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -65,9 +68,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -89,9 +95,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -113,9 +122,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -137,9 +149,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -161,9 +176,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -185,9 +203,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -209,9 +230,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -233,9 +257,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -257,9 +284,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -281,9 +311,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -305,9 +338,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -329,9 +365,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -353,9 +392,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -377,9 +419,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -401,9 +446,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -425,9 +473,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -449,9 +500,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -473,9 +527,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -497,9 +554,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -521,9 +581,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -545,9 +608,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -569,9 +635,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -593,9 +662,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -617,9 +689,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -641,9 +716,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -665,9 +743,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -689,9 +770,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -713,9 +797,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -737,9 +824,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -761,9 +851,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -785,9 +878,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -809,9 +905,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -833,9 +932,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -857,9 +959,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -881,9 +986,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -905,9 +1013,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -929,9 +1040,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -953,9 +1067,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -977,9 +1094,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -1003,9 +1123,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 3,
@@ -1027,9 +1150,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -1051,9 +1177,12 @@
         },
         "reward": -0.5,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.0,
-          "functionality_reward": -0.7
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.0,
+          "localization": 0.0,
+          "fix_quality": 0.0,
+          "semantic_similarity": 0.0,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 0,
@@ -1075,9 +1204,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -1099,9 +1231,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -1123,9 +1258,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -1147,9 +1285,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -1171,9 +1312,12 @@
         },
         "reward": -0.5,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.0,
-          "functionality_reward": -0.7
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.0,
+          "localization": 0.0,
+          "fix_quality": 0.0,
+          "semantic_similarity": 0.0,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 0,
@@ -1195,9 +1339,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -1219,9 +1366,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -1243,9 +1393,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -1267,9 +1420,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -1291,9 +1447,12 @@
         },
         "reward": -0.5,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.0,
-          "functionality_reward": -0.7
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.0,
+          "localization": 0.0,
+          "fix_quality": 0.0,
+          "semantic_similarity": 0.0,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 0,
@@ -1315,9 +1474,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -1339,9 +1501,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -1363,9 +1528,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -1387,9 +1555,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -1411,9 +1582,12 @@
         },
         "reward": -0.5,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.0,
-          "functionality_reward": -0.7
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.0,
+          "localization": 0.0,
+          "fix_quality": 0.0,
+          "semantic_similarity": 0.0,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 0,
@@ -1435,9 +1609,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -1459,9 +1636,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -1483,9 +1663,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -1507,9 +1690,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -1531,9 +1717,12 @@
         },
         "reward": -0.5,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.0,
-          "functionality_reward": -0.7
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.0,
+          "localization": 0.0,
+          "fix_quality": 0.0,
+          "semantic_similarity": 0.0,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 0,
@@ -1555,9 +1744,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -1579,9 +1771,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -1603,9 +1798,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -1627,9 +1825,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -1651,9 +1852,12 @@
         },
         "reward": -0.5,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.0,
-          "functionality_reward": -0.7
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.0,
+          "localization": 0.0,
+          "fix_quality": 0.0,
+          "semantic_similarity": 0.0,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 0,
@@ -1675,9 +1879,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -1699,9 +1906,12 @@
         },
         "reward": -0.5,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.0,
-          "functionality_reward": -0.7
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.0,
+          "localization": 0.0,
+          "fix_quality": 0.0,
+          "semantic_similarity": 0.0,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 0,
@@ -1725,9 +1935,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -1749,9 +1962,12 @@
         },
         "reward": -0.5,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.0,
-          "functionality_reward": -0.7
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.0,
+          "localization": 0.0,
+          "fix_quality": 0.0,
+          "semantic_similarity": 0.0,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 0,
@@ -1773,9 +1989,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -1797,9 +2016,12 @@
         },
         "reward": -0.5,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.0,
-          "functionality_reward": -0.7
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.0,
+          "localization": 0.0,
+          "fix_quality": 0.0,
+          "semantic_similarity": 0.0,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 0,
@@ -1821,9 +2043,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -1845,9 +2070,12 @@
         },
         "reward": -0.5,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.0,
-          "functionality_reward": -0.7
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.0,
+          "localization": 0.0,
+          "fix_quality": 0.0,
+          "semantic_similarity": 0.0,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 0,
@@ -1869,9 +2097,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -1893,9 +2124,12 @@
         },
         "reward": -0.5,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.0,
-          "functionality_reward": -0.7
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.0,
+          "localization": 0.0,
+          "fix_quality": 0.0,
+          "semantic_similarity": 0.0,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 0,
@@ -1917,9 +2151,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -1941,9 +2178,12 @@
         },
         "reward": -0.5,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.0,
-          "functionality_reward": -0.7
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.0,
+          "localization": 0.0,
+          "fix_quality": 0.0,
+          "semantic_similarity": 0.0,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 0,
@@ -1965,9 +2205,12 @@
         },
         "reward": -0.5,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.0,
-          "functionality_reward": -0.7
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.0,
+          "localization": 0.0,
+          "fix_quality": 0.0,
+          "semantic_similarity": 0.0,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 0,
@@ -1989,9 +2232,12 @@
         },
         "reward": -0.5,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.0,
-          "functionality_reward": -0.7
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.0,
+          "localization": 0.0,
+          "fix_quality": 0.0,
+          "semantic_similarity": 0.0,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 0,
@@ -2013,9 +2259,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -2037,9 +2286,12 @@
         },
         "reward": -0.5,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.0,
-          "functionality_reward": -0.7
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.0,
+          "localization": 0.0,
+          "fix_quality": 0.0,
+          "semantic_similarity": 0.0,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 0,
@@ -2061,9 +2313,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -2085,9 +2340,12 @@
         },
         "reward": -0.5,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.0,
-          "functionality_reward": -0.7
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.0,
+          "localization": 0.0,
+          "fix_quality": 0.0,
+          "semantic_similarity": 0.0,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 0,
@@ -2109,9 +2367,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -2133,9 +2394,12 @@
         },
         "reward": -0.5,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.0,
-          "functionality_reward": -0.7
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.0,
+          "localization": 0.0,
+          "fix_quality": 0.0,
+          "semantic_similarity": 0.0,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 0,
@@ -2157,9 +2421,12 @@
         },
         "reward": 1.0,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.2,
-          "functionality_reward": 0.6
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.2,
+          "localization": 0.2,
+          "fix_quality": 0.3,
+          "semantic_similarity": 0.1,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 4,
@@ -2181,9 +2448,12 @@
         },
         "reward": -0.5,
         "reward_breakdown": {
-          "format_match": 0.2,
-          "syntax_correctness": 0.0,
-          "functionality_reward": -0.7
+          "format_compliance": 0.2,
+          "hypothesis_quality": 0.0,
+          "localization": 0.0,
+          "fix_quality": 0.0,
+          "semantic_similarity": 0.0,
+          "efficiency_potential": 0.0
         },
         "test_results": {
           "passed": 0,

inference.py

@@ -1,14 +1,3 @@
-"""
-AgentDebuggerEnv Baseline Inference Script
-==========================================
-Baseline evaluation script for testing agent performance in the 
-AgentDebugger environment.
-
-System Configuration:
-- API_BASE_URL: LLM API endpoint
-- MODEL_NAME:   Model identifier for evaluation
-- HF_TOKEN:     Authentication token
-"""
 
 import os
 import json
@@ -18,7 +7,7 @@ import random
 from openai import OpenAI, APIError, RateLimitError, APIConnectionError, APITimeoutError
 import requests
 
-# ── Environment variables (never hardcode these) ──────────────────────────────
+
 API_BASE_URL = os.environ.get("API_BASE_URL", "https://router.huggingface.co/v1")
 MODEL_NAME   = os.environ.get("MODEL_NAME", "meta-llama/Llama-3.1-70B-Instruct")
 HF_TOKEN     = os.environ.get("HF_TOKEN") or os.environ.get("OPENAI_API_KEY", "")
@@ -66,10 +55,9 @@ Guidelines:
 - For concurrent tasks, ensure atomic operations and proper synchronization.
 """
 
-# ── Robust API Completion Helper ──────────────────────────────────────────────
+
 
 def get_completion(messages: list, model: str = MODEL_NAME, max_retries: int = 5) -> str:
-    """Gets LLM completion with exponential backoff and retry logic."""
     for attempt in range(max_retries):
         try:
             completion = client.chat.completions.create(
@@ -77,7 +65,7 @@ def get_completion(messages: list, model: str = MODEL_NAME, max_retries: int = 5
                 messages=messages,
                 max_tokens=1200,
                 temperature=0.2,
-                timeout=60.0  # Add a timeout to prevent hanging forever
+                timeout=60.0  
             )
             return completion.choices[0].message.content
         except (RateLimitError, APIConnectionError, APITimeoutError) as e:
@@ -87,7 +75,7 @@ def get_completion(messages: list, model: str = MODEL_NAME, max_retries: int = 5
             print(f"  [!] API Error ({type(e).__name__}). Retrying in {wait_time:.1f}s... (Attempt {attempt+1}/{max_retries})")
             time.sleep(wait_time)
         except APIError as e:
-            # For general API errors, log and potentially retry if it's a 5xx
+            
             print(f"  [!] OpenAI API Error: {e}")
             if attempt == max_retries - 1:
                 return ""
@@ -99,22 +87,21 @@ def get_completion(messages: list, model: str = MODEL_NAME, max_retries: int = 5
 
 
 def parse_action(raw: str) -> dict:
-    """Parse LLM response to action dict. Handle markdown code blocks."""
     raw = raw.strip()
-    # Strip markdown code blocks if present
+    
     raw = re.sub(r'^```(?:json)?\s*', '', raw, flags=re.MULTILINE)
     raw = re.sub(r'\s*```$', '', raw, flags=re.MULTILINE)
     try:
         return json.loads(raw)
     except json.JSONDecodeError:
-        # Try to extract first JSON object
+        
         match = re.search(r'\{.*\}', raw, re.DOTALL)
         if match:
             try:
                 return json.loads(match.group())
             except json.JSONDecodeError:
                 pass
-    # Fallback: give up
+    
     return {
         "action_type": "give_up",
         "final_diagnosis": f"Failed to parse response: {raw[:200]}"
@@ -149,7 +136,7 @@ def build_step_message(obs: dict, reward: dict, info: dict) -> str:
 
     if last_attempt and last_attempt.get("execution_output"):
         output = last_attempt["execution_output"]
-        # Truncate long outputs to stay within token budget
+        
         if len(output) > 1500:
             output = output[:750] + "\n...[truncated]...\n" + output[-750:]
         msg += f"\nNEW TEST OUTPUT:\n{output}\n"
@@ -163,14 +150,13 @@ def build_step_message(obs: dict, reward: dict, info: dict) -> str:
 
 
 def run_episode(task_id: str) -> dict:
-    """Run one complete debugging episode. Returns result dict."""
 
-    # Reset environment
+    
     reset_resp = requests.post(f"{ENV_BASE_URL}/reset", json={"task_id": task_id}, timeout=60)
     reset_resp.raise_for_status()
     obs = reset_resp.json()
 
-    # [START] task=NAME
+    
     print(f"\n[START] task={task_id}", flush=True)
     print(f"  Description: {obs['task_description'][:100]}...", flush=True)
 
@@ -197,14 +183,14 @@ def run_episode(task_id: str) -> dict:
             action = parse_action(raw)
         except Exception as e:
             print(f"  [✗] Failed to get response from LLM after retries: {e}")
-            # Fallback action to avoid crashing the whole episode
+            
             action = {
                 "action_type": "give_up",
                 "final_diagnosis": f"Inference system failure: {str(e)}"
             }
             raw = json.dumps(action)
 
-        # Submit action to environment
+        
         step_resp = requests.post(f"{ENV_BASE_URL}/step", json=action, timeout=60)
         step_resp.raise_for_status()
         result = step_resp.json()
@@ -215,10 +201,10 @@ def run_episode(task_id: str) -> dict:
         info   = result["info"]
         last_result = result
 
-        # [STEP] step=N reward=R
+        
         print(f"  [STEP {obs['step_number']}] Action: {action.get('action_type')} | Tests: {obs['tests_passed']}/{obs['tests_total']} | Reward: {reward['step_reward']:+.3f}", flush=True)
 
-        # Build context for next LLM call
+        
         step_msg = build_step_message(obs, reward, info)
         messages.append({"role": "assistant", "content": raw})
         messages.append({"role": "user",      "content": step_msg})
@@ -239,7 +225,7 @@ def run_episode(task_id: str) -> dict:
         "final_action_type":   action.get("action_type", "unknown")
     }
 
-    # [END] task=NAME score=S steps=N
+    
     print(f"[END] task={task_id} score={result['grader_score']} steps={result['steps_taken']}", flush=True)
 
     return result
@@ -248,7 +234,7 @@ def run_episode(task_id: str) -> dict:
 def main():
     print("AgentDebuggerEnv — Baseline Inference")
     
-    # ── Environment validation ────────────────────────────────────────────────
+    
     has_token = bool(HF_TOKEN and len(HF_TOKEN) > 5)
     masked_token = f"{HF_TOKEN[:4]}...{HF_TOKEN[-4:]}" if has_token else "MISSING"
     

scratch/data_tier2.py

@@ -1,5 +1,5 @@
 t2_bugs = [
-    # 7 bugs: wrong loop termination
+    
     {
         "id": "t2_004", "difficulty": 2, "bug_type": "wrong_loop_termination", "function_name": "find_first_positive",
         "buggy_code": "def find_first_positive(nums):\n    i = 0\n    while i < len(nums) - 1:\n        if nums[i] > 0:\n            return nums[i]\n        i += 1\n    return -1",
@@ -49,7 +49,7 @@ t2_bugs = [
         "initial_error": "AssertionError: expected [[1,2],[3]], got [[1,2]]", "bug_location": {"function": "get_chunks", "line_start": 4},
         "test_cases": [{"input": [[1, 2, 3], 2], "expected_output": [[1, 2], [3]]}, {"input": [[1, 2], 2], "expected_output": [[1, 2]]}, {"input": [[1, 2, 3, 4], 2], "expected_output": [[1, 2], [3, 4]]}, {"input": [[], 2], "expected_output": []}]
     },
-    # 7 bugs: incorrect accumulation
+    
     {
         "id": "t2_011", "difficulty": 2, "bug_type": "incorrect_accumulation", "function_name": "sum_even_numbers",
         "buggy_code": "def sum_even_numbers(nums):\n    total = 1\n    for n in nums:\n        if n % 2 == 0:\n            total += n\n    return total",
@@ -99,7 +99,7 @@ t2_bugs = [
         "initial_error": "AssertionError: expected 2, got 1", "bug_location": {"function": "count_negatives", "line_start": 2},
         "test_cases": [{"input": [[1, -1, 2, -2]], "expected_output": 2}, {"input": [[1, 2, 3]], "expected_output": 0}, {"input": [[-1, -2, -3]], "expected_output": 3}, {"input": [[]], "expected_output": 0}]
     },
-    # 7 bugs: wrong conditional branch
+    
     {
         "id": "t2_018", "difficulty": 2, "bug_type": "wrong_conditional_branch", "function_name": "classify_number",
         "buggy_code": "def classify_number(n):\n    if n > 0:\n        return 'positive'\n    elif n < 0:\n        return 'negative'\n    elif n == 0:\n        return 'negative'",
@@ -149,7 +149,7 @@ t2_bugs = [
         "initial_error": "AssertionError: expected 4, got 3", "bug_location": {"function": "get_quadrant", "line_start": 6},
         "test_cases": [{"input": [1, 1], "expected_output": 1}, {"input": [-1, 1], "expected_output": 2}, {"input": [-1, -1], "expected_output": 3}, {"input": [1, -1], "expected_output": 4}]
     },
-    # 6 bugs: wrong variable used in final step
+    
     {
         "id": "t2_025", "difficulty": 2, "bug_type": "wrong_variable", "function_name": "merge_arrays",
         "buggy_code": "def merge_arrays(a, b):\n    res = a + b\n    res.sort()\n    return a",

scratch/data_tier3.py

@@ -1,5 +1,5 @@
 t3_bugs = [
-    # 6 bugs: wrong argument order
+    
     {
         "id": "t3_003", "difficulty": 3, "bug_type": "wrong_argument_order", "function_name": "process_user",
         "buggy_code": "def format_name(first, last):\n    return f'{last}, {first}'\n\ndef process_user(first_name, last_name):\n    return format_name(last_name, first_name)",
@@ -42,7 +42,7 @@ t3_bugs = [
         "initial_error": "AssertionError: expected 8, got 9", "bug_location": {"function": "power_wrapper", "line_start": 5},
         "test_cases": [{"input": [2, 3], "expected_output": 8}, {"input": [3, 2], "expected_output": 9}, {"input": [5, 2], "expected_output": 25}, {"input": [2, 4], "expected_output": 16}]
     },
-    # 6 bugs: state not reset
+    
     {
         "id": "t3_009", "difficulty": 3, "bug_type": "state_not_reset", "function_name": "get_unique_items",
         "buggy_code": "seen = set()\ndef filter_unique(items):\n    res = []\n    for item in items:\n        if item not in seen:\n            seen.add(item)\n            res.append(item)\n    return res\n\ndef get_unique_items(items):\n    return filter_unique(items)",
@@ -85,7 +85,7 @@ t3_bugs = [
         "initial_error": "AssertionError: state leak between calls", "bug_location": {"function": "log_error", "line_start": 3},
         "test_cases": [{"input": [["e1"]], "expected_output": ["e1"]}, {"input": [["e2"]], "expected_output": ["e2"]}, {"input": [["e3", "e4"]], "expected_output": ["e3", "e4"]}, {"input": [["e5"]], "expected_output": ["e5"]}]
     },
-    # 6 bugs: missing edge case in helper
+    
     {
         "id": "t3_015", "difficulty": 3, "bug_type": "missing_edge_case", "function_name": "process_data",
         "buggy_code": "def get_first(lst):\n    return lst[0]\n\ndef process_data(data):\n    if not data:\n        return None\n    return [get_first(d) for d in data]",

scratch/fix_all.py

@@ -1,7 +1,7 @@
 import os
 import sys
 
-# ensure data is importable
+
 sys.path.append(os.path.abspath('.'))
 
 from data.generate_bugs import TIER1_BUGS, TIER2_BUGS, TIER3_BUGS
@@ -34,7 +34,7 @@ for b in TIER1_BUGS:
 for b in TIER2_BUGS:
     if b["id"] == "t2_003":
         for t in b["test_cases"]:
-            # If t["input"] is nested too deep, unpack it first.
+            
             while len(t["input"]) == 1 and isinstance(t["input"][0], list) and len(t["input"][0]) == 2:
                 t["input"] = t["input"][0]
             if len(t["input"]) == 2 and not isinstance(t["input"][0], list) and not isinstance(t["input"], tuple):
@@ -55,10 +55,10 @@ for b in TIER2_BUGS:
 for b in TIER3_BUGS:
     if b["id"] == "t3_002":
         for t in b["test_cases"]:
-            # Unpack completely
+            
             while len(t["input"]) == 1 and isinstance(t["input"][0], list):
                 t["input"] = t["input"][0]
-            # Wrap once
+            
             t["input"] = [t["input"]]
     elif b["id"] == "t3_007":
         b["buggy_code"] = b["buggy_code"].replace("calc_area(height, width)", "calc_area(height, height)")

scratch/gen_t1_base.py

@@ -80,7 +80,7 @@ funcs = [
     }
 ]
 
-# Create 2 bugs per function, plus 2 more for the first function = 32 bugs.
+
 bug_id_counter = 9
 for f in funcs:
     for i in range(2):
@@ -95,12 +95,12 @@ for f in funcs:
             "bug_location": {"function": f["name"], "line_start": 2}
         }
         
-        # We need to create a bug. Simple mutations based on function name and index.
-        # This will be done dynamically by the script we run.
+        
+        
         t1_bugs.append(bug)
         bug_id_counter += 1
 
-# Let's add 2 more to reach 32.
+
 for i in range(2):
     bug = {
         "id": f"t1_{bug_id_counter:03d}",

scratch/merge.py

@@ -1,7 +1,7 @@
 import sys
 import os
 
-# add parent dir to path so we can import data.generate_bugs
+
 sys.path.append(os.path.abspath('.'))
 
 from data.generate_bugs import TIER1_BUGS as T1_OLD
@@ -16,7 +16,7 @@ t1_all = T1_OLD + t1_bugs
 t2_all = T2_OLD + t2_bugs
 t3_all = T3_OLD + t3_bugs
 
-# Ensure we have the target numbers
+
 print(f"Tier 1: {len(t1_all)}")
 print(f"Tier 2: {len(t2_all)}")
 print(f"Tier 3: {len(t3_all)}")
@@ -32,12 +32,12 @@ def pretty_list(lst, name):
                     lines.append(f'        "{k}": (')
                     for line in v.split('\n'):
                         lines.append(f'            {repr(line + "\\n")}')
-                    lines[-1] = lines[-1][:-4] + "'" + lines[-1][-3:] # remove the trailing \n from the last line, wait, repr('...\\n') adds \n inside. Let's just use json dumps
-        # Actually json dumps is simpler!
-        # wait, we need to format code blocks nicely maybe?
+                    lines[-1] = lines[-1][:-4] + "'" + lines[-1][-3:] 
+        
+        
         pass
 
-# The best way to format Python code generating Python code is pprint or just repr.
+
 with open("data/generate_bugs.py", "w", encoding="utf-8") as f:
     f.write('"""\n')
     f.write('AgentDebuggerEnv — Bug Dataset Generator\n\n')
@@ -55,7 +55,7 @@ with open("data/generate_bugs.py", "w", encoding="utf-8") as f:
     f.write('import json\n')
     f.write('import os\n\n')
     
-    # write out variables
+    
     import pprint
     
     def dump_var(name, val):
@@ -71,9 +71,9 @@ with open("data/generate_bugs.py", "w", encoding="utf-8") as f:
     f.write('    with open(path, "w") as f:\n')
     f.write('        for bug in bugs:\n')
     f.write('            f.write(json.dumps(bug) + "\\n")\n')
-    f.write('    print(f"Tier {path[-12]}: {len(bugs)}")\n')  # to print Tier 1: 40 etc. wait, format is different
-    # wait, the prompt says "It should print: Tier 1: 40, Tier 2: 30, Tier 3: 20"
-    # let's change the output slightly.
+    f.write('    print(f"Tier {path[-12]}: {len(bugs)}")\n')  
+    
+    
     f.write('\n\n')
     f.write('if __name__ == "__main__":\n')
     f.write('    os.makedirs("data", exist_ok=True)\n')

server/__init__.py

@@ -1,2 +1,2 @@
-# server/__init__.py
-# Initializing the server package for OpenEnv validation.
+
+

server/app.py

@@ -1,14 +1,8 @@
-"""
-Server Entry Point for AgentDebuggerEnv
-========================================
-Main entry point to start the FastAPI server for the AgentDebugger environment.
-"""
 
 import uvicorn
 from env.server import app
 
 def main():
-    """Main execution function to run the FastAPI server."""
     uvicorn.run(app, host="0.0.0.0", port=8000, workers=1)
 
 if __name__ == "__main__":

server/models.py

@@ -1,10 +1,5 @@
-"""
-server/models.py — Re-exports structured agent types for training scripts.
-All core types live in env/models.py; this module exposes them under the
-`server` namespace so training/train_grpo.py can import without path changes.
-"""
 
-from env.models import (  # noqa: F401
+from env.models import (  
     StructuredAgentOutput,
     parse_agent_output,
     VALID_ACTIONS,

server/reward_calculator.py

@@ -1,17 +1,3 @@
-"""
-DebugRewardCalculator — Multi-component reward system for AgentDebuggerEnv.
-
-Reward taxonomy follows:
-  - Masud et al. (2026) "Reward Engineering for RL in Software Tasks"
-    → Uses their execution-based + process-based + semantic similarity taxonomy
-  - Ibrahim et al. (2024) "Comprehensive Overview of Reward Engineering and Shaping"
-    → Uses potential-based shaping for efficiency component to preserve policy invariance
-
-Design principle: GRPO learns by comparing completions WITHIN a group.
-Relative reward differences matter more than absolute values.
-Therefore: be generous with partial credit so the model gets differentiated signal
-even when nothing fully works.
-"""
 
 import difflib
 import re
@@ -22,34 +8,17 @@ from server.models import StructuredAgentOutput
 
 @dataclass
 class RewardBreakdown:
-    format_compliance: float     # fires every turn — gives early training signal
-    hypothesis_quality: float    # process-based reward (Paper 2 taxonomy)
-    localization: float          # execution-based proxy
-    fix_quality: float           # execution-based reward (primary terminal signal)
-    semantic_similarity: float   # semantic reward (Paper 2 taxonomy)
-    efficiency_potential: float  # potential-based shaping (Paper 1)
+    format_compliance: float     
+    hypothesis_quality: float    
+    localization: float          
+    fix_quality: float           
+    semantic_similarity: float   
+    efficiency_potential: float  
     penalties: float
     total: float
 
 
 class DebugRewardCalculator:
-    """
-    Reward weights (must sum to 1.0 excluding penalties):
-      format_compliance:    0.10  — fires every turn, drives early curve movement
-      hypothesis_quality:   0.20  — process-based, independent of fix success
-      localization:         0.15  — did agent find the right place?
-      fix_quality:          0.35  — execution-based, primary terminal signal (sparse)
-      semantic_similarity:  0.10  — how close to canonical fix?
-      efficiency_potential: 0.10  — potential-based shaping across turns
-
-    IMPORTANT NOTE ON SPARSITY vs DENSITY:
-    The fix_quality reward (0.35) is sparse — it only fires when tests pass.
-    The format, hypothesis, localization rewards are dense — they fire every turn.
-    This combination is intentional: dense rewards carry gradient signal while the
-    model is still learning to fix bugs; sparse rewards dominate once it gets good.
-    This directly implements Ibrahim et al.'s recommendation to combine reward
-    shaping with terminal rewards to solve the sparse reward problem.
-    """
 
     MAX_TURNS = 5
 
@@ -60,36 +29,14 @@ class DebugRewardCalculator:
         test_results: dict,
         turn_number: int,
     ) -> RewardBreakdown:
-        """
-        Compute reward for a single agent turn.
-
-        Args:
-            agent_output: parsed structured output from the agent
-            ground_truth: {
-                "bug_function": str,   # name of function containing the bug
-                "bug_line": int,       # line number of the bug
-                "bug_type": str,       # category of bug
-                "canonical_fix_code": str,  # the correct minimal fix
-            }
-            test_results: {
-                "passed": int,
-                "failed": int,
-                "total": int,
-                "newly_broken": int,   # tests that passed before but fail after fix
-            }
-            turn_number: 0-indexed turn number within the episode
-
-        Returns:
-            RewardBreakdown with total and all component scores
-        """
-
-        # ── COMPONENT 1: FORMAT COMPLIANCE ────────────────────────────────
-        # This fires EVERY turn. Gives the model early training signal before
-        # it learns to fix bugs. Drives curve movement in first 50-100 steps.
+
+        
+        
+        
         if agent_output.valid:
             format_score = 0.10
         else:
-            # Partial credit: how many fields were present?
+            
             fields_present = sum([
                 len(agent_output.observation) > 5,
                 len(agent_output.hypothesis) > 10,
@@ -98,48 +45,48 @@ class DebugRewardCalculator:
                                         "request_context", "give_up"},
                 len(agent_output.detail) > 0,
             ])
-            format_score = -0.25 + (fields_present * 0.04)  # -0.25 to -0.05
+            format_score = -0.25 + (fields_present * 0.04)  
 
-        # ── COMPONENT 2: HYPOTHESIS QUALITY (Process-based, Paper 2) ──────
-        # Score reasoning quality INDEPENDENTLY from whether the fix works.
-        # A correct diagnosis that leads to a wrong fix still gets rewarded here.
-        # This trains the model to reason carefully even when uncertain.
+        
+        
+        
+        
         hypothesis_score = 0.0
         hypothesis = agent_output.hypothesis
 
         if len(hypothesis.split()) >= 20:
-            hypothesis_score += 0.05   # not a one-liner
+            hypothesis_score += 0.05   
 
-        # References specific code elements (backticks, quotes, or operators)
+        
         if re.search(r'[`\'"<>!=+\-*/]', hypothesis):
             hypothesis_score += 0.05
 
-        # Mentions line numbers
+        
         if re.search(r'\bline\s+\d+\b|\b\d+\b', hypothesis):
             hypothesis_score += 0.05
 
-        # Logically consistent: OBSERVATION and HYPOTHESIS reference same code area
+        
         obs_words = set(agent_output.observation.lower().split())
         hyp_words = set(hypothesis.lower().split())
         overlap = len(obs_words & hyp_words) / max(len(obs_words), 1)
         if overlap > 0.15:
             hypothesis_score += 0.05
 
-        # Confidence calibration: rewards correct confidence, penalizes overconfidence
-        # High confidence + correct = bonus, High confidence + wrong = penalty
+        
+        
         if agent_output.action == "propose_fix":
             tests_pass = test_results.get("passed", 0) == test_results.get("total", 1)
             if agent_output.confidence == "high" and tests_pass:
-                hypothesis_score += 0.05   # well-calibrated
+                hypothesis_score += 0.05   
             elif agent_output.confidence == "high" and not tests_pass:
-                hypothesis_score -= 0.05   # overconfident
+                hypothesis_score -= 0.05   
             elif agent_output.confidence == "low" and tests_pass:
-                hypothesis_score += 0.02   # humble but correct
+                hypothesis_score += 0.02   
 
         hypothesis_score = max(0.0, min(hypothesis_score, 0.20))
 
-        # ── COMPONENT 3: LOCALIZATION (Execution-based proxy) ─────────────
-        # Did the agent identify WHERE the bug is, independently of fixing it?
+        
+        
         localization_score = 0.0
         bug_function = ground_truth.get("bug_function", "").lower()
         bug_line = str(ground_truth.get("bug_line", -1))
@@ -154,9 +101,9 @@ class DebugRewardCalculator:
 
         localization_score = min(localization_score, 0.15)
 
-        # ── COMPONENT 4: FIX QUALITY (Execution-based, Paper 2 primary) ───
-        # This is the dominant signal. Sparse but high value.
-        # Paper 1: combine with shaping (components 1-3) to solve sparse problem.
+        
+        
+        
         total_tests = test_results.get("total", 0)
         passed_tests = test_results.get("passed", 0)
         fix_score = 0.0
@@ -164,18 +111,18 @@ class DebugRewardCalculator:
         if total_tests > 0 and agent_output.action == "propose_fix":
             pass_rate = passed_tests / total_tests
             if pass_rate == 1.0:
-                fix_score = 0.35      # full solve — this is what we're training for
+                fix_score = 0.35      
             elif pass_rate >= 0.75:
-                fix_score = 0.20      # most tests pass
+                fix_score = 0.20      
             elif pass_rate >= 0.50:
-                fix_score = 0.12      # more than half pass
+                fix_score = 0.12      
             elif pass_rate > 0.0:
-                fix_score = 0.05      # at least something works
-            # 0.0 if nothing passes — no credit for non-fix actions
+                fix_score = 0.05      
+            
 
-        # ── COMPONENT 5: SEMANTIC SIMILARITY (Paper 2 taxonomy) ───────────
-        # How structurally close is the proposed fix to the canonical fix?
-        # Uses difflib — no heavy NLP dependencies needed.
+        
+        
+        
         semantic_score = 0.0
         proposed = agent_output.detail
         canonical = ground_truth.get("canonical_fix_code", "")
@@ -188,36 +135,36 @@ class DebugRewardCalculator:
                 semantic_score = 0.05
             elif similarity >= 0.40:
                 semantic_score = 0.02
-            # No reward below 0.40 similarity — prevents gaming with partial matches
+            
 
-        # ── COMPONENT 6: EFFICIENCY POTENTIAL (Potential-based, Paper 1) ──
-        # Implements potential-based reward shaping: F(s,a,s') = γΦ(s') - Φ(s)
-        # where Φ(state) = value of remaining turns
-        # This is PROVEN to not change the optimal policy (Ibrahim et al. Theorem 1)
-        # while still accelerating convergence.
+        
+        
+        
+        
+        
         remaining_turns = self.MAX_TURNS - turn_number
-        efficiency_potential = 0.02 * remaining_turns  # max 0.10 on turn 0
+        efficiency_potential = 0.02 * remaining_turns  
 
-        # ── PENALTIES ─────────────────────────────────────────────────────
+        
         penalties = 0.0
 
-        # Regression: fix breaks previously-passing tests — severe
+        
         if test_results.get("newly_broken", 0) > 0:
             penalties -= 0.20
 
-        # Give up: agent chose to give_up
+        
         if agent_output.action == "give_up":
             penalties -= 0.15
 
-        # Invalid action: not one of the 5 valid actions
+        
         if agent_output.action == "invalid":
             penalties -= 0.10
 
-        # Invalid format (already captured in format_score, add extra penalty)
+        
         if not agent_output.valid:
             penalties -= 0.10
 
-        # ── TOTAL ─────────────────────────────────────────────────────────
+        
         raw_total = (
             format_score
             + hypothesis_score
@@ -228,7 +175,7 @@ class DebugRewardCalculator:
             + penalties
         )
 
-        # Floor at -0.5 to prevent reward death spiral (Ibrahim et al.)
+        
         total = max(raw_total, -0.5)
 
         return RewardBreakdown(
@@ -243,11 +190,6 @@ class DebugRewardCalculator:
         )
 
     def compute_episode_reward(self, trajectory: list[dict]) -> float:
-        """
-        Aggregate turn rewards across an episode.
-        Uses 0.9 discount factor — later turns worth slightly less.
-        Adds solve bonus if bug was fixed before max turns.
-        """
         if not trajectory:
             return 0.0
 
@@ -258,7 +200,7 @@ class DebugRewardCalculator:
             total += discount * turn["reward"].total
             discount *= 0.9
 
-        # Solve bonus: incentivizes actually solving the bug
+        
         solved = any(t["reward"].fix_quality >= 0.35 for t in trajectory)
         if solved:
             total += 0.20
@@ -266,7 +208,6 @@ class DebugRewardCalculator:
         return round(total, 4)
 
     def get_reward_breakdown_for_logging(self, trajectory: list[dict]) -> dict:
-        """Returns per-component averages across episode for W&B logging."""
         if not trajectory:
             return {}
 

tests/__init__.py

@@ -1 +1 @@
-# AgentDebuggerEnv - Test suite
+

tests/test_environment.py

@@ -1,6 +1,3 @@
-"""
-Tests for the core environment — reset, step, state.
-"""
 
 import pytest
 from env.environment import DebuggerEnvironment
@@ -12,7 +9,7 @@ def env():
     return DebuggerEnvironment()
 
 
-# ── Reset Tests ──────────────────────────────────────────────────────────────
+
 
 def test_reset_easy_returns_observation(env):
     obs = env.reset("easy")
@@ -49,7 +46,7 @@ def test_reset_invalid_task_raises(env):
 
 def test_reset_clears_previous_state(env):
     env.reset("easy")
-    # Do a step
+    
     action = Action(
         action_type="submit_fix",
         fixed_code="def binary_search(arr, target): return -1",
@@ -57,14 +54,14 @@ def test_reset_clears_previous_state(env):
     )
     env.step(action)
 
-    # Reset should clear everything
+    
     obs = env.reset("easy")
     assert obs["step_number"] == 0
     assert obs["previous_attempts"] == []
     assert obs["attempts_remaining"] == 5
 
 
-# ── Step Tests ───────────────────────────────────────────────────────────────
+
 
 def test_step_submit_fix_without_hypothesis(env):
     env.reset("easy")
@@ -133,8 +130,8 @@ def test_step_query_context_second_costs(env):
         action_type="query_context",
         query_type="error_explanation",
     )
-    env.step(action)  # First — free
-    result = env.step(action)  # Second — costs -0.05
+    env.step(action)  
+    result = env.step(action)  
     assert result["reward"]["step_reward"] == -0.05
 
 
@@ -173,7 +170,7 @@ def test_step_invalid_query_type(env):
     assert result["info"]["error"] is not None
 
 
-# ── State Tests ──────────────────────────────────────────────────────────────
+
 
 def test_state_before_reset(env):
     state = env.state()
@@ -203,7 +200,7 @@ def test_state_after_step(env):
     assert len(state["all_hypotheses"]) == 1
 
 
-# ── Attempts Exhaustion Tests ────────────────────────────────────────────────
+
 
 def test_attempts_exhausted(env):
     env.reset("easy")
@@ -215,10 +212,10 @@ def test_attempts_exhausted(env):
         )
         result = env.step(action)
 
-    # After 5 attempts, episode should be done (max_attempts=5)
+    
     assert result["done"] is True or result["observation"]["attempts_remaining"] == 0
 
-    # Trying another fix should either fail or episode is done
+    
     if not result["done"]:
         action = Action(
             action_type="submit_fix",

tests/test_graders.py

@@ -1,16 +1,12 @@
-"""
-Tests for graders — determinism and range validation.
-"""
 
 import pytest
 from env.graders import get_grader
 from env.tasks.registry import get_task
 
 
-# ── Determinism Tests ────────────────────────────────────────────────────────
+
 
 def _make_dummy_attempts(n=2, tests_passed=3, tests_total=8):
-    """Create dummy attempt data for testing."""
     return [
         {
             "attempt_number": i + 1,
@@ -27,7 +23,6 @@ def _make_dummy_attempts(n=2, tests_passed=3, tests_total=8):
 
 
 def test_easy_grader_deterministic():
-    """Same input to easy grader must produce same output."""
     grader = get_grader("easy")
     task = get_task("easy")
     attempts = _make_dummy_attempts(2, tests_passed=7, tests_total=8)
@@ -39,7 +34,6 @@ def test_easy_grader_deterministic():
 
 
 def test_medium_grader_deterministic():
-    """Same input to medium grader must produce same output."""
     grader = get_grader("medium")
     task = get_task("medium")
     attempts = _make_dummy_attempts(3, tests_passed=6, tests_total=10)
@@ -51,10 +45,9 @@ def test_medium_grader_deterministic():
 
 
 def test_hard_grader_deterministic():
-    """Same input to hard grader must produce same output (excluding concurrent test randomness)."""
     grader = get_grader("hard")
     task = get_task("hard")
-    # Use buggy code so concurrent test is deterministically failing
+    
     attempts = _make_dummy_attempts(2, tests_passed=8, tests_total=8)
     hypotheses = ["race condition in increment"]
 
@@ -63,11 +56,10 @@ def test_hard_grader_deterministic():
     assert score1 == score2, f"Hard grader not deterministic: {score1} != {score2}"
 
 
-# ── Range Tests ──────────────────────────────────────────────────────────────
+
 
 @pytest.mark.parametrize("task_id", ["easy", "medium", "hard"])
 def test_grader_range_with_zero_attempts(task_id):
-    """Grader with zero attempts should return a score in [0.0, 1.0]."""
     grader = get_grader(task_id)
     task = get_task(task_id)
     score = grader.score(task, [], 0, task["tests_total"], 0, task["max_attempts"], [])
@@ -76,7 +68,6 @@ def test_grader_range_with_zero_attempts(task_id):
 
 @pytest.mark.parametrize("task_id", ["easy", "medium", "hard"])
 def test_grader_range_with_perfect_score(task_id):
-    """Grader with all tests passing should return a score in [0.0, 1.0]."""
     grader = get_grader(task_id)
     task = get_task(task_id)
     tests_total = task["tests_total"]
@@ -89,7 +80,6 @@ def test_grader_range_with_perfect_score(task_id):
 
 @pytest.mark.parametrize("task_id", ["easy", "medium", "hard"])
 def test_grader_range_with_all_failures(task_id):
-    """Grader with no tests passing should return a score in [0.0, 1.0]."""
     grader = get_grader(task_id)
     task = get_task(task_id)
     tests_total = task["tests_total"]
@@ -99,10 +89,9 @@ def test_grader_range_with_all_failures(task_id):
     assert 0.0 <= score <= 1.0, f"{task_id} grader out of range: {score}"
 
 
-# ── Variance Tests (dummy vs perfect agents) ────────────────────────────────
+
 
 def test_easy_dummy_agent_low_score():
-    """A dummy agent submitting 'pass' should score < 0.15."""
     grader = get_grader("easy")
     task = get_task("easy")
     attempts = [
@@ -123,7 +112,6 @@ def test_easy_dummy_agent_low_score():
 
 
 def test_easy_perfect_agent_high_score():
-    """A perfect agent should score > 0.85 on easy."""
     grader = get_grader("easy")
     task = get_task("easy")
     attempts = [
@@ -143,7 +131,6 @@ def test_easy_perfect_agent_high_score():
 
 
 def test_medium_red_herring_low_score():
-    """Agent that only fixes authenticate_user should score < 0.30 on hypothesis."""
     grader = get_grader("medium")
     task = get_task("medium")
     attempts = _make_dummy_attempts(3, tests_passed=6, tests_total=10)
@@ -153,5 +140,5 @@ def test_medium_red_herring_low_score():
         "Fix authenticate_user to return True for valid users",
     ]
     score = grader.score(task, attempts, 6, 10, 3, 7, hypotheses)
-    # With only 6/10 tests and red herring hypotheses, score should be modest
+    
     assert score < 0.60, f"Red herring agent scored too high on medium: {score}"

tests/test_integration.py

@@ -1,27 +1,19 @@
-"""
-AgentDebuggerEnv — Integration Tests
-====================================
-Verifies the full episode lifecycle: reset -> step -> end.
-Assumes the server is available via the DebuggerEnvironment class directly
-(testing the logic, not the HTTP layer which is just a thin wrapper).
-"""
 
 import pytest
 from env.environment import DebuggerEnvironment
 from env.models import Action
 
 def test_full_episode_easy():
-    """Test a full successful episode on the 'easy' task."""
     env = DebuggerEnvironment()
     
-    # 1. Reset
+    
     obs = env.reset("easy")
     assert obs["task_id"] == "easy"
     assert obs["done"] is False
     assert obs["tests_passed"] < obs["tests_total"]
     
-    # 2. Submit a fix (using known ground truth)
-    # The easy task is binary search with 'left < right' instead of 'left <= right'
+    
+    
     ground_truth_code = """
 def binary_search(arr, target):
     left, right = 0, len(arr) - 1
@@ -43,13 +35,12 @@ def binary_search(arr, target):
     
     result = env.step(action)
     
-    # 3. Verify results
+    
     assert result["done"] is True
     assert result["observation"]["tests_passed"] == result["observation"]["tests_total"]
     assert result["reward"]["grader_score"] > 0.80
 
 def test_query_hint_system():
-    """Test the newly added hint system."""
     env = DebuggerEnvironment()
     env.reset("hard")
     
@@ -60,20 +51,16 @@ def test_query_hint_system():
     
     result = env.step(action)
     assert "concurrent threads" in result["info"]["query_result"]
-    assert result["reward"]["step_reward"] == 0.0  # First query is free
+    assert result["reward"]["step_reward"] == 0.0  
 
 def test_hard_grader_consensus():
-    """
-    Test that the hard grader runs multiple times.
-    (We mock execute_code to simulate flakiness).
-    """
     from unittest.mock import patch
     from env.graders.grader_hard import HardGrader
     
     grader = HardGrader()
     
-    # Mock execute_code to return success 3/5 times
-    # Sequence: PASS, FAIL, PASS, FAIL, PASS
+    
+    
     with patch("env.graders.grader_hard.execute_code") as mock_exec:
         mock_exec.side_effect = [
             ("CONCURRENT PASS", False, 100),
@@ -93,10 +80,10 @@ def test_hard_grader_consensus():
             hypotheses=["race condition"]
         )
         
-        # 3/5 passes → should get partial credit (0.15) for concurrency
-        # Sequential: 1.0 * 0.40 = 0.40
-        # Concurrency: 0.15
-        # Hypothesis: 1.0 * 0.20 = 0.20
-        # Efficiency: (concurrent_score == 0.30) is False -> 0.0
-        # Total: 0.75
+        
+        
+        
+        
+        
+        
         assert score == 0.75

tests/test_sandbox.py

@@ -1,14 +1,9 @@
-"""
-Tests for the code execution sandbox.
-All 5 tests are required by the hackathon spec.
-"""
 
 import pytest
 from env.sandbox import execute_code
 
 
 def test_timeout_enforcement():
-    """Code with infinite loop must return timed_out=True within ~11 seconds."""
     code = "while True: pass"
     output, timed_out, elapsed_ms = execute_code(code, "")
     assert timed_out is True
@@ -16,21 +11,18 @@ def test_timeout_enforcement():
 
 
 def test_os_import_blocked():
-    """os module must be blocked — cannot execute system commands."""
     code = "import os; os.system('echo pwned')"
     output, timed_out, _ = execute_code(code, "")
     assert "BLOCKED" in output or "blocked" in output.lower()
 
 
 def test_sys_import_blocked():
-    """sys module must be blocked."""
     code = "import sys; sys.exit(0)"
     output, _, _ = execute_code(code, "")
     assert "blocked" in output.lower() or "import" in output.lower()
 
 
 def test_clean_code_runs():
-    """Clean, safe code with tests must execute correctly."""
     code = "def add(a, b): return a + b"
     test = "assert add(2, 3) == 5\nprint('PASSED')"
     output, timed_out, _ = execute_code(code, test)
@@ -39,17 +31,15 @@ def test_clean_code_runs():
 
 
 def test_syntax_error_returns_output():
-    """Code with syntax errors should return the SyntaxError, not crash."""
     code = "def broken(: pass"
     output, timed_out, _ = execute_code(code, "")
     assert "SyntaxError" in output
     assert timed_out is False
 
 
-# ── Additional robustness tests ──────────────────────────────────────────────
+
 
 def test_subprocess_import_blocked():
-    """subprocess module must be blocked."""
     code = "import subprocess; subprocess.run(['echo', 'pw' + 'ned'])"
     output, _, _ = execute_code(code, "")
     assert "pwned" not in output
@@ -57,7 +47,6 @@ def test_subprocess_import_blocked():
 
 
 def test_threading_blocked_by_default():
-    """threading must be blocked unless allow_threading=True."""
     code = "import threading; print('thread ' + 'imported')"
     output, _, _ = execute_code(code, "")
     assert "thread imported" not in output
@@ -65,14 +54,12 @@ def test_threading_blocked_by_default():
 
 
 def test_threading_allowed_when_flagged():
-    """threading must be allowed when allow_threading=True."""
     code = "import threading; print('thread imported')"
     output, _, _ = execute_code(code, "", allow_threading=True)
     assert "thread imported" in output
 
 
 def test_from_import_blocked():
-    """'from os import path' style imports must also be blocked."""
     code = "from os import path; print('pw' + 'ned')"
     output, _, _ = execute_code(code, "")
     assert "pwned" not in output
@@ -80,14 +67,13 @@ def test_from_import_blocked():
 
 
 def test_no_state_leak_between_executions():
-    """Each execution must be completely isolated — no shared state."""
     code1 = "shared_var = 42"
     output1, _, _ = execute_code(code1, "print('set')")
     assert "set" in output1
 
     code2 = ""
     test2 = "try:\\n    print(shared_var)\\nexcept NameError:\\n    print('ISOLATED')"
-    # Fix: use actual newlines
+    
     code2_test = "try:\n    print(shared_var)\nexcept NameError:\n    print('ISOLATED')"
     output2, _, _ = execute_code("", code2_test)
     assert "ISOLATED" in output2

training/train_grpo.py

@@ -1,22 +1,3 @@
-"""
-AgentDebuggerEnv — GRPO Training Script
-Model: Qwen2.5-Coder-7B-Instruct (float16/bfloat16 + LoRA, no quantization)
-Algorithm: GRPO (Group Relative Policy Optimization) via HuggingFace TRL
-GPU: auto-detected at runtime (A100/H100 → bfloat16+large batch, T4/V100 → float16+small batch)
-
-Usage:
-  # Local reward sanity-check (no GPU, no model loading):
-  python training/train_grpo.py --test-local
-
-  # Test run (Colab/GPU, 10 steps):
-  python training/train_grpo.py --test
-
-  # Full training run:
-  python training/train_grpo.py
-
-  # Resume from checkpoint:
-  python training/train_grpo.py --resume ./checkpoints/checkpoint-400
-"""
 
 import os
 import sys
@@ -28,7 +9,7 @@ import tempfile
 import shutil
 from importlib import metadata
 
-# ── Parse args ────────────────────────────────────────────────────────────────
+
 parser = argparse.ArgumentParser()
 parser.add_argument("--test", action="store_true", help="Run 10 steps for testing (Colab/GPU)")
 parser.add_argument("--test-local", action="store_true", dest="test_local",
@@ -40,15 +21,15 @@ parser.add_argument("--max_steps", type=int, default=500)
 args = parser.parse_args()
 
 
-# ── Runtime dependency install ─────────────────────────────────────────────────
-# requirements.txt only has torch (too large to install at runtime).
-# Everything else is installed here, after gradio is already up.
-# NOTE: mergekit intentionally excluded — conflicts with accelerate/peft/trl.
+
+
+
+
 if not args.test_local:
-    # ── Ensure CUDA-enabled torch is present before anything else imports it ──
-    # The default PyPI torch wheel is CPU-only. We must install from the
-    # PyTorch CUDA index so that torch.cuda.is_available() returns True and
-    # device_map="auto" maps the model to GPU, not RAM.
+    
+    
+    
+    
     import importlib.util, importlib
     _needs_cuda_torch = True
     if importlib.util.find_spec("torch") is not None:
@@ -84,7 +65,7 @@ if not args.test_local:
         sys.exit(1)
     print("Dependencies installed.", flush=True)
 
-# ── GPU/training imports (skipped in --test-local mode) ───────────────────────
+
 if not args.test_local:
     import torch
     import wandb
@@ -115,13 +96,13 @@ sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from server.reward_calculator import DebugRewardCalculator
 from server.models import parse_agent_output
 
-# ── Configuration ─────────────────────────────────────────────────────────────
+
 MODEL_NAME = "Qwen/Qwen2.5-Coder-3B-Instruct"
 HF_REPO = "shashaank0707/AgentDebugger-trained"
 MAX_STEPS = (10 if args.test else args.max_steps) - args.step_offset
 CHECKPOINT_DIR = "./checkpoints"
 
-# W&B and HF Token
+
 WANDB_API_KEY = os.environ.get("WANDB_API_KEY", "") if not args.test_local else ""
 HF_TOKEN = os.environ.get("HF_TOKEN")
 
@@ -139,7 +120,7 @@ if WANDB_API_KEY:
         }
     )
 
-# ── System prompt ─────────────────────────────────────────────────────────────
+
 SYSTEM_PROMPT = """You are an expert Python debugger. You reason through bugs systematically.
 
 You MUST respond in EXACTLY this format — no exceptions, no extra text:
@@ -156,7 +137,7 @@ Rules:
 - If proposing a fix, DETAIL must contain the complete function, not just the changed line
 - Give up only if you have exhausted all reasonable hypotheses"""
 
-# ── Load bugs ─────────────────────────────────────────────────────────────────
+
 def load_bugs(tier: int) -> list[dict]:
     path = f"data/bugs_tier{tier}.jsonl"
     if not os.path.exists(path):
@@ -184,7 +165,6 @@ def bug_to_prompt(bug: dict) -> str:
     )
 
 def _run_fix(proposed_code: str, bug: dict) -> dict:
-    """Safely run proposed fix with subprocess timeout."""
     test_cases = bug.get("test_cases", [])
     func_name = bug.get("function_name", "")
     if not proposed_code or not test_cases or not func_name:
@@ -200,7 +180,7 @@ def _run_fix(proposed_code: str, bug: dict) -> dict:
             f"    r={func_name}({args_str})\n"
             f"    print('PASS' if r=={repr(test['expected_output'])} else 'FAIL')\n"
             f"except Exception as e:\n"
-            f"    print(f'ERROR: {{e}}')\n"
+            f"    print(f'ERROR: { e} ')\n"
         )
         try:
             with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
@@ -216,7 +196,7 @@ def _run_fix(proposed_code: str, bug: dict) -> dict:
 
     return {"passed": passed, "failed": len(test_cases) - passed, "total": len(test_cases), "newly_broken": 0}
 
-# ── Mock completions for --test-local ─────────────────────────────────────────
+
 MOCK_GOOD = """
 OBSERVATION: The loop condition on line 4 uses <= instead of 
 HYPOTHESIS: This causes an off-by-one error because Python lists are 
@@ -241,7 +221,7 @@ I think there might be a bug somewhere in the code.
 Let me try fixing it.
 """
 
-# ── --test-local: reward sanity-check without any model ───────────────────────
+
 if args.test_local:
     print("=" * 60)
     print("LOCAL TEST MODE — no model loaded, testing reward function only")
@@ -295,9 +275,9 @@ if args.test_local:
     print("\nLOCAL TEST PASSED")
     sys.exit(0)
 
-# ── Auto-detect GPU and set optimal config ────────────────────────────────────
+
 _gpu_vram_gb = 0
-_is_ampere_plus = False  # A100/H100 support bfloat16 natively (compute cap >= 8.0)
+_is_ampere_plus = False  
 if torch.cuda.is_available():
     _props = torch.cuda.get_device_properties(0)
     _gpu_vram_gb = _props.total_memory / 1e9
@@ -308,30 +288,30 @@ if torch.cuda.is_available():
 
 COMPUTE_DTYPE = torch.bfloat16 if _is_ampere_plus else torch.float16
 
-# Scale batch/generation config to available VRAM.
-# GRPO constraint: per_device_train_batch_size % num_generations == 0
-if _gpu_vram_gb >= 70:          # A100 80GB
+
+
+if _gpu_vram_gb >= 70:          
     _batch       = 8
-    _grad_accum  = 1            # effective batch = 8
-    _num_gen     = 8            # 8 % 8 == 0
+    _grad_accum  = 1            
+    _num_gen     = 8            
     _max_comp    = 256
     _lora_r      = 16
-elif _gpu_vram_gb >= 40:        # A100 40GB
+elif _gpu_vram_gb >= 40:        
     _batch       = 4
-    _grad_accum  = 2            # effective batch = 8
-    _num_gen     = 4            # 4 % 4 == 0
+    _grad_accum  = 2            
+    _num_gen     = 4            
     _max_comp    = 256
     _lora_r      = 16
-elif _gpu_vram_gb >= 20:        # A10G 24GB / V100 32GB
+elif _gpu_vram_gb >= 20:        
     _batch       = 2
     _grad_accum  = 4
-    _num_gen     = 2            # 2 % 2 == 0
+    _num_gen     = 2            
     _max_comp    = 192
     _lora_r      = 8
-else:                           # T4 15GB / anything smaller
+else:                           
     _batch       = 2
     _grad_accum  = 4
-    _num_gen     = 2            # 2 % 2 == 0
+    _num_gen     = 2            
     _max_comp    = 160
     _lora_r      = 8
 
@@ -339,9 +319,9 @@ print(f"Training config: batch={_batch} grad_accum={_grad_accum} "
       f"num_gen={_num_gen} max_comp={_max_comp} lora_r={_lora_r} "
       f"dtype={COMPUTE_DTYPE}")
 
-# ── Load model ────────────────────────────────────────────────────────────────
-# Load in native float16/bfloat16 — no bitsandbytes needed.
-# A10G (24GB) fits Qwen2.5-7B in float16 (~14GB) with room for LoRA + activations.
+
+
+
 print(f"Loading {MODEL_NAME} in {COMPUTE_DTYPE}...")
 tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, trust_remote_code=True)
 tokenizer.pad_token = tokenizer.eos_token
@@ -374,23 +354,20 @@ model.enable_input_require_grads()
 model.gradient_checkpointing_enable()
 print(f"Trainable params: {model.num_parameters(only_trainable=True):,}")
 
-# ── Runtime device selection ──────────────────────────────────────────────────
+
 def _select_runtime_device(model) -> str:
-    """
-    Pick the safest generation device without forcing CUDA init on broken drivers.
-    """
     def _cuda_usable() -> bool:
         try:
             if not torch.cuda.is_available():
                 return False
-            # Force lightweight CUDA init probe.
+            
             _ = torch.zeros(1, device="cuda")
             return True
         except Exception as e:
             print(f"WARNING: CUDA initialization failed ({e}). Falling back to CPU.")
             return False
 
-    # Prefer model's current device when available.
+    
     try:
         model_device = str(next(model.parameters()).device)
         if model_device.startswith("cuda") and not _cuda_usable():
@@ -399,7 +376,7 @@ def _select_runtime_device(model) -> str:
     except Exception:
         pass
 
-    # Fallback to torch capability checks.
+    
     if _cuda_usable():
         return "cuda"
     return "cpu"
@@ -408,14 +385,10 @@ def _select_runtime_device(model) -> str:
 RUNTIME_DEVICE = _select_runtime_device(model)
 print(f"Using generation/training runtime device: {RUNTIME_DEVICE}")
 
-# ── Reward function ───────────────────────────────────────────────────────────
+
 calculator = DebugRewardCalculator()
 
 def reward_fn(completions: list[str], prompts: list[str], **kwargs) -> list[float]:
-    """
-    GRPO reward function. Called on groups of completions for the same prompt.
-    GRPO learns from RELATIVE differences within each group.
-    """
     rewards = []
     bugs_raw = kwargs.get("bug_metadata", [{}] * len(completions))
     bugs = [json.loads(b) if isinstance(b, str) else b for b in bugs_raw]
@@ -424,7 +397,7 @@ def reward_fn(completions: list[str], prompts: list[str], **kwargs) -> list[floa
         try:
             agent_output = parse_agent_output(completion)
 
-            # Run fix if agent proposes one
+            
             test_results = {"passed": 0, "failed": 0, "total": 0, "newly_broken": 0}
             if agent_output.action == "propose_fix" and bug:
                 test_results = _run_fix(agent_output.detail, bug)
@@ -452,7 +425,7 @@ def reward_fn(completions: list[str], prompts: list[str], **kwargs) -> list[floa
 
     return rewards
 
-# ── Baseline evaluation (run BEFORE training) ─────────────────────────────────
+
 def run_baseline(n: int = 20) -> dict:
     print("\nRunning baseline evaluation on UNTRAINED model...")
     model.eval()
@@ -481,12 +454,12 @@ def run_baseline(n: int = 20) -> dict:
 baseline = run_baseline()
 model.train()
 
-# ── Build initial dataset ─────────────────────────────────────────────────────
+
 def make_dataset(step: int) -> Dataset:
     bugs = get_bugs_for_step(step)
     return Dataset.from_list([{"prompt": bug_to_prompt(b), "bug_metadata": json.dumps(b)} for b in bugs])
 
-# ── Training config ───────────────────────────────────────────────────────────
+
 config = GRPOConfig(
     output_dir=CHECKPOINT_DIR,
     max_steps=MAX_STEPS,
@@ -499,7 +472,7 @@ config = GRPOConfig(
     max_completion_length=_max_comp,
     temperature=0.9,
     logging_steps=5,
-    save_steps=25,               # Save to local disk every 25 steps
+    save_steps=25,               
     save_strategy="steps",
     report_to="wandb" if WANDB_API_KEY else "none",
 )
@@ -512,7 +485,7 @@ trainer = GRPOTrainer(
     processing_class=tokenizer,
 )
 
-# ── Curriculum callback ───────────────────────────────────────────────────────
+
 class CurriculumCallback(TrainerCallback):
     def on_step_end(self, callback_args, state, control, **kwargs):
         step = state.global_step + args.step_offset
@@ -524,15 +497,14 @@ class CurriculumCallback(TrainerCallback):
 
 trainer.add_callback(CurriculumCallback())
 
-# ── HF Hub checkpoint push callback (CRITICAL: survives container restarts) ────
-# Pushes LoRA adapter weights to HF Hub every HUB_PUSH_EVERY steps.
-# This is the fix for the original problem: ephemeral Space storage meant that
-# checkpoints saved to ./checkpoints/ were lost when the Space stopped.
-# Now even if training is interrupted, the latest adapter weights are on HF Hub.
-HUB_PUSH_EVERY = 50  # push every 50 steps — ~15min on T4, ~5min on A100
+
+
+
+
+
+HUB_PUSH_EVERY = 50  
 
 class CheckpointPushCallback(TrainerCallback):
-    """Push LoRA adapter to HF Hub every HUB_PUSH_EVERY steps."""
 
     def on_step_end(self, callback_args, state, control, **kwargs):
         step = state.global_step + args.step_offset
@@ -553,28 +525,28 @@ class CheckpointPushCallback(TrainerCallback):
                 private=True,
                 commit_message=f"tokenizer checkpoint-step-{step}",
             )
-            # Write a step marker file so we know the latest pushed step
+            
             with open("./last_hub_push.txt", "w") as _f:
                 _f.write(str(step))
             print(f"[HubPush] ✓ Step {step} pushed to HF Hub.", flush=True)
             if WANDB_API_KEY:
                 wandb.log({"hub/last_pushed_step": step})
         except Exception as e:
-            # Never crash training because of a push failure
+            
             print(f"[HubPush] WARNING: push failed at step {step}: {e}", flush=True)
 
-if not args.test:  # Don't push during 10-step test runs
+if not args.test:  
     trainer.add_callback(CheckpointPushCallback())
     print(f"HF Hub checkpoint push enabled every {HUB_PUSH_EVERY} steps → {HF_REPO}-checkpoints")
 else:
     print("[TEST MODE] Hub checkpoint push disabled.")
 
-# ── Train ─────────────────────────────────────────────────────────────────────
+
 print(f"\nStarting GRPO training. Max steps: {MAX_STEPS}")
 print(f"Baseline solve rate: {baseline['solve_rate']:.1%} — target: >60% after training")
 trainer.train(resume_from_checkpoint=args.resume)
 
-# ── Post-training evaluation ──────────────────────────────────────────────────
+
 model.eval()
 bugs = load_bugs(1)[:20]
 post_rewards = []
@@ -602,7 +574,7 @@ if WANDB_API_KEY:
     wandb.log({"final/solve_rate": post_solve_rate, "final/improvement": post_solve_rate - baseline["solve_rate"]})
     wandb.finish()
 
-# ── Save and push ─────────────────────────────────────────────────────────────
+
 model.save_pretrained("./final_model")
 tokenizer.save_pretrained("./final_model")
 

validator.py

@@ -1,14 +1,4 @@
-#!/usr/bin/env python3
-"""
-AgentDebuggerEnv — Pre-Submission Validator
-============================================
-Checks for all hard requirements of the Meta + HF Hackathon:
-- Mandatory Environment Variables
-- OpenEnv Spec Compliance (health, reset, step, state)
-- Inference Script Format & Logging
-- Dockerfile Correctness
-- openenv.yaml Presence
-"""
+
 
 import os
 import sys
@@ -17,7 +7,7 @@ import requests
 import yaml
 import re
 
-# ── Configuration ────────────────────────────────────────────────────────────
+
 ENV_BASE_URL = os.environ.get("ENV_BASE_URL", "http://localhost:8000")
 API_BASE_URL = os.environ.get("API_BASE_URL")
 MODEL_NAME = os.environ.get("MODEL_NAME")
@@ -74,7 +64,7 @@ def check_yaml():
 def check_endpoints():
     log_info(f"Checking Endpoints at {ENV_BASE_URL}...")
     
-    # 1. Health
+    
     try:
         resp = requests.get(f"{ENV_BASE_URL}/health", timeout=5)
         if resp.status_code == 200:
@@ -86,7 +76,7 @@ def check_endpoints():
         log_fail(f"Could not connect to /health: {e}")
         return False
     
-    # 2. Reset
+    
     try:
         resp = requests.post(f"{ENV_BASE_URL}/reset", json={"task_id": "easy"}, timeout=5)
         if resp.status_code == 200:
@@ -109,7 +99,7 @@ def check_inference_script():
     with open("inference.py", 'r') as f:
         content = f.read()
     
-    # Check for [START], [STEP], [END]
+    
     patterns = {
         "[START]": r"\[START\] task=",
         "[STEP]": r"\[STEP .+\] Action:",
@@ -137,7 +127,7 @@ def main():
     success &= check_yaml()
     success &= check_inference_script()
     
-    # Endpoints check is optional if server isn't running locally
+    
     try:
         if not check_endpoints():
             log_info("Skipping further endpoint checks as server is unreachable.")