Replace repo with updated config-debug files

.dockerignore

@@ -0,0 +1,5 @@
+__pycache__
+*.pyc
+.git
+test_*.py
+validate-submission.sh

.gitignore

@@ -0,0 +1,2 @@
+__pycache__/
+*.pyc

Dockerfile

@@ -0,0 +1,14 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+RUN useradd -m -u 1000 user
+COPY --chown=user . .
+USER user
+
+EXPOSE 7860
+
+CMD ["python", "-m", "uvicorn", "server.app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,226 @@
+---
+title: ConfigDebugEnv
+colorFrom: red
+colorTo: yellow
+sdk: docker
+app_port: 7860
+tags:
+  - openenv
+  - devops
+  - configuration
+  - debugging
+  - reinforcement-learning
+  - multi-task-rl
+pinned: false
+---
+
+# ConfigDebugEnv: Multi-Task RL Environment for Configuration Debugging
+
+> **Challenge**: Train AI agents to autonomously debug broken configuration files across 7 real-world DevOps formats. This is a **multi-step sequential decision-making problem** requiring iterative reasoning and progressive understanding.
+
+## Why This Matters
+
+**The Problem**: Configuration errors cause ~40% of production incidents and are among the hardest to debug manually because they require domain expertise across multiple technologies (JSON, YAML, Docker, Kubernetes, nginx, etc.).
+
+**Why RL?**: Static rule-based fixes fail because:
+- Bugs interact (fixing one reveals another)
+- Context matters (nginx syntax differs from Kubernetes)
+- Validation is semantic (type checker would pass some errors)
+
+**ConfigDebugEnv's Solution**: Train agents with **partial rewards** to discover multi-step fixes:
+- Agent attempts fix → gets 0.4 reward + error guidance
+- Agent iterates → gets 0.7 reward + next error guidance
+- Agent completes → gets 1.0 reward + advances to next task
+
+This mirrors real-world debugging where solutions emerge through iteration, not revelation.
+
+---
+
+## Environment Design
+
+### Action Space
+```
+ConfigDebugAction.fixed_config: str  # Corrected configuration
+```
+
+### Observation Space
+```
+{
+  "broken_config": str,           # Current broken config
+  "file_type": str,               # Format: json, yaml, dockerfile, etc
+  "error_message": str,           # Specific guidance (e.g., "replicas must be int")
+  "task_id": str,                 # Current task ID
+  "task_description": str,        # Human-readable task
+  "difficulty": str,              # easy, medium, hard, very_hard
+  "num_bugs": int,                # Total bugs in this config
+  "bugs_found_so_far": int,       # Bugs fixed in this attempt
+  "previous_reward": float,       # Last reward: [0.0, 1.0]
+}
+```
+
+### Reward Structure (Sequential Decision Making)
+
+Each task has **3 progressive levels**:
+
+| Level | Example (Kubernetes) | Reward | Guides Next Attempt |
+|-------|----------------------|--------|---------------------|
+| L1    | Fix replicas type    | 0.4    | "containerPort must be int" |
+| L2    | Fix port type too    | 0.7    | "cpu must include unit (m)" |
+| L3    | Fix all bugs         | 1.0    | ✅ Task complete, advance |
+
+**Why this works**: Agents learn to read error messages, make targeted fixes, and build on partial success—exactly like human debugging.
+
+**⚠️ Important**: Hard tasks (Kubernetes, Nginx) **require sequential reasoning and cannot be solved in a single step**. Perfect first-attempt solutions will not occur; agents must iterate based on error guidance.
+
+---
+
+## The 7 Tasks (Progressive Difficulty)
+
+| Task | Format | Difficulty | Bugs | Key Challenge |
+|------|--------|------------|------|----------------|
+| **task1_json** | JSON | Easy | 2 | Type detection |
+| **task2_yaml** | YAML | Easy | 2 | Indentation / structure |
+| **task3_dockerfile** | Dockerfile | Medium | 3 | Multi-stage builds |
+| **task4_compose** | docker-compose | Medium | 4 | Service networking |
+| **task5_k8s** | Kubernetes | Hard | 3* | Multi-step type/domain fixes |
+| **task6_github_actions** | GitHub Actions | Hard | 5 | Workflow triggers |
+| **task7_nginx** | Nginx config | Very Hard | 3* | Multi-step directive/routing fixes |
+
+*task5_k8s and task7_nginx optimized for multi-step learning with targeted error guidance
+
+---
+
+## Multi-Task Learning
+
+The environment progresses through all 7 tasks sequentially:
+1. Agent learns from task1 → task2 → ... → task7
+2. Each task builds on previous knowledge
+3. Harder tasks should show better reasoning (agents see more diverse error types)
+
+---
+
+## API Endpoints
+
+### Core OpenEnv Endpoints
+- `POST /reset` - Reset environment to task1
+- `POST /step` - Submit action (fixed config) → get reward + next observation
+- `GET /observation` - Get current observation
+- `GET /state` - Get full environment state
+
+### Utility Endpoints
+- `GET /metadata` - Environment specification (auto-generated by OpenEnv)
+- `GET /info` - Service info
+- `GET /health` - Health check
+- `GET /tasks` - List all tasks with metadata
+
+---
+
+## Example Session
+
+```python
+from server.config_debug_environment import ConfigDebugEnvironment
+from server.models import ConfigDebugAction
+
+env = ConfigDebugEnvironment()
+obs = env.reset()  # Start at task1_json
+
+# Attempt 1: Agent tries initial fix
+action = ConfigDebugAction(fixed_config='{"key": "value"}')
+obs = env.step(action)
+print(f"Reward: {obs.reward}")        # → 0.4 (partial credit)
+print(f"Error: {obs.error_message}")  # → Guides next attempt
+
+# Attempt 2: Agent learns and improves
+action = ConfigDebugAction(fixed_config='{"key": "value", "number": 42}')
+obs = env.step(action)
+print(f"Reward: {obs.reward}")        # → 0.7
+print(f"Error: {obs.error_message}")  # → Final hint
+
+# Attempt 3: Agent completes
+action = ConfigDebugAction(fixed_config='{"key": "value", "number": 42, "enabled": true}')
+obs = env.step(action)
+print(f"Reward: {obs.reward}")        # → 1.0 ✅
+print(f"Done: {obs.done}")            # → False (more tasks remain)
+obs = obs.task_id                     # → task2_yaml
+```
+
+---
+
+## Key Strengths
+
+✅ **True RL Problem**: Partial rewards with sequential decision-making  
+✅ **Multi-Step Reasoning**: Errors cascade; fixes must be iterative  
+✅ **Domain-Diverse**: 7 config formats = varied error types  
+✅ **Scalable Difficulty**: Easy tasks build foundation for hard tasks  
+✅ **Real-World Relevance**: Configuration bugs are a major DevOps pain point  
+
+---
+
+## Technical Stack
+
+- **Framework**: OpenEnv (FastAPI-based)
+- **Language**: Python 3.12+
+- **Graders**: Domain-specific validators (YAML, JSON, Docker, K8s, nginx)
+- **Deployment**: Docker + Hugging Face Spaces
+
+---
+
+## Getting Started
+
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Run tests
+python test_env.py
+
+# Start server
+uvicorn server.app:app --reload
+
+# Access at http://localhost:8000
+```
+
+---
+
+## Evaluation Criteria
+
+- ✅ **Correct Task Progression** - All 7 tasks with proper graders
+- ✅ **Multi-Step Learning** - Agents show iterative improvement  
+- ✅ **Error Guidance** - Clear feedback directs next fix
+- ✅ **Reward Semantics** - Partial credit enables intermediate learning
+
+---
+
+## For Judges
+
+This project demonstrates **advanced RL environment design**:
+
+1. **Problem Formulation**: Configuration debugging is inherently sequential and iterative
+2. **Reward Engineering**: Partial rewards guide exploration; not just binary pass/fail
+3. **Task Curriculum**: 7 tasks from easy→hard with consistent structure
+4. **Error Pedagogy**: Error messages teach agents what to fix next
+5. **Scalability**: Framework generalizes to any text-based debugging task
+
+ConfigDebugEnv isn't just a benchmark—it's a **learning tool** that teaches agents to think like human debuggers.
+
+---
+
+**Built for**: Meta PyTorch OpenEnv Hackathon x SST  
+**Version**: 1.0.0
+- GET /docs - Swagger API docs
+
+## Setup
+
+Run locally:
+
+    pip install fastapi uvicorn pydantic pyyaml httpx openai gradio
+    uvicorn server.env:app --host 0.0.0.0 --port 7860
+
+Run with Docker:
+
+    docker build -t config-debug-env .
+    docker run -p 7860:7860 config-debug-env
+
+## Baseline Results
+
+Qwen/Qwen2.5-72B-Instruct: 7/7 tasks, score = 1.000

__init__.py

@@ -0,0 +1,3 @@
+from server.models import ConfigDebugAction, ConfigDebugObservation, ConfigDebugState
+from server.config_debug_environment import ConfigDebugEnvironment
+from client import ConfigDebugEnv

client.py

@@ -0,0 +1,25 @@
+"""Client for ConfigDebugEnv - connects to the environment server."""
+from typing import Dict, Any
+
+from openenv.core.env_client import EnvClient
+from openenv.core.client_types import StepResult
+from server.models import ConfigDebugAction, ConfigDebugObservation, ConfigDebugState
+
+
+class ConfigDebugEnv(EnvClient[ConfigDebugAction, ConfigDebugObservation, ConfigDebugState]):
+    """Typed client for the ConfigDebugEnv environment."""
+
+    def _step_payload(self, action: ConfigDebugAction) -> Dict[str, Any]:
+        return {"fixed_config": action.fixed_config}
+
+    def _parse_result(self, payload: Dict[str, Any]) -> StepResult[ConfigDebugObservation]:
+        obs_data = payload.get("observation", {})
+        obs = ConfigDebugObservation(**obs_data)
+        return StepResult(
+            observation=obs,
+            reward=payload.get("reward"),
+            done=payload.get("done", False),
+        )
+
+    def _parse_state(self, payload: Dict[str, Any]) -> ConfigDebugState:
+        return ConfigDebugState(**payload)

inference.py

@@ -0,0 +1,217 @@
+"""
+Inference Script — ConfigDebugEnv
+===================================
+MANDATORY
+- Before submitting, ensure the following variables are defined in your environment configuration:
+    API_BASE_URL   The API endpoint for the LLM.
+    MODEL_NAME     The model identifier to use for inference.
+    HF_TOKEN       Your Hugging Face / API key.
+    IMAGE_NAME     The name of the local image to use for the environment if you are using
+                   from_docker_image() method
+
+STDOUT FORMAT
+- The script emits exactly three line types to stdout:
+    [START] task=<task_name> env=<benchmark> model=<model_name>
+    [STEP]  step=<n> action=<action_str> reward=<0.00> done=<true|false> error=<msg|null>
+    [END]   success=<true|false> steps=<n> score=<score> rewards=<r1,r2,...,rn>
+"""
+
+import asyncio
+import os
+import textwrap
+from typing import List, Optional
+
+from openai import OpenAI
+
+# Constants (not env-dependent)
+IMAGE_NAME = None  # Will be read at runtime
+TASK_NAME = "config-debug"  # Default
+BENCHMARK = "config_debug_env"  # Default
+MAX_STEPS = 35  # 7 tasks × 5 steps each
+TEMPERATURE = 0.1
+MAX_TOKENS = 2000
+SUCCESS_SCORE_THRESHOLD = 0.5  # normalized score in [0, 1]
+MAX_TOTAL_REWARD = 7.0  # 7 tasks, 1.0 max per task
+
+SYSTEM_PROMPT = textwrap.dedent(
+    """
+    You are an expert DevOps engineer specializing in configuration file debugging.
+    You will be given a broken configuration file and must fix ALL bugs in it.
+    Return ONLY the fixed configuration file content.
+    No explanations, no markdown formatting, no code blocks. Just the raw fixed configuration.
+    """
+).strip()
+
+
+def log_start(task: str, env: str, model: str) -> None:
+    print(f"[START] task={task} env={env} model={model}", flush=True)
+
+
+def log_step(step: int, action: str, reward: float, done: bool, error: Optional[str]) -> None:
+    error_val = error if error else "null"
+    done_val = str(done).lower()
+    print(
+        f"[STEP] step={step} action={action} reward={reward:.2f} done={done_val} error={error_val}",
+        flush=True,
+    )
+
+
+def log_end(success: bool, steps: int, score: float, rewards: List[float]) -> None:
+    rewards_str = ",".join(f"{r:.2f}" for r in rewards)
+    print(
+        f"[END] success={str(success).lower()} steps={steps} score={score:.3f} rewards={rewards_str}",
+        flush=True,
+    )
+
+
+def strip_code_blocks(text: str) -> str:
+    """Remove markdown code blocks if LLM wraps output in them."""
+    text = text.strip()
+    if text.startswith("```"):
+        lines = text.split("\n")
+        if lines[-1].strip() == "```":
+            lines = lines[1:-1]
+        else:
+            lines = lines[1:]
+        text = "\n".join(lines)
+    return text
+
+
+def build_user_prompt(obs: dict, step: int, history: List[str]) -> str:
+    history_block = "\n".join(history[-4:]) if history else "None"
+    return textwrap.dedent(
+        f"""
+        Fix the following broken {obs['file_type']} configuration file.
+
+        Task: {obs['task_description']}
+        Difficulty: {obs['difficulty']}
+        Number of bugs to find: {obs['num_bugs']}
+        Bugs fixed so far: {obs['bugs_found_so_far']}
+        Error message: {obs['error_message']}
+        Step: {step}
+
+        Previous attempts:
+        {history_block}
+
+        Broken configuration:
+        ```
+        {obs['broken_config']}
+        ```
+
+        Return ONLY the fixed configuration file content.
+        """
+    ).strip()
+
+
+def get_model_message(client: OpenAI, obs: dict, step: int, history: List[str], model_name: str) -> str:
+    user_prompt = build_user_prompt(obs, step, history)
+    try:
+        completion = client.chat.completions.create(
+            model=model_name,
+            messages=[
+                {"role": "system", "content": SYSTEM_PROMPT},
+                {"role": "user", "content": user_prompt},
+            ],
+            temperature=TEMPERATURE,
+            max_tokens=MAX_TOKENS,
+            stream=False,
+        )
+        text = (completion.choices[0].message.content or "").strip()
+        return strip_code_blocks(text) if text else ""
+    except Exception as exc:
+        print(f"[DEBUG] Model request failed: {exc}", flush=True)
+        return ""
+
+
+async def main() -> None:
+    # Re-read env vars at runtime (evaluator may inject after module import)
+    api_key = os.getenv("API_KEY") or os.getenv("HF_TOKEN")
+    api_base_url = os.getenv("API_BASE_URL", "https://router.huggingface.co/v1")
+    model_name = os.getenv("MODEL_NAME", "Qwen/Qwen2.5-72B-Instruct")
+    task_name = os.getenv("CONFIG_DEBUG_TASK", "config-debug")
+    benchmark = os.getenv("CONFIG_DEBUG_BENCHMARK", "config_debug_env")
+
+    client = OpenAI(base_url=api_base_url, api_key=api_key)
+
+    # Connect to the environment via HTTP
+    import httpx
+    import sys
+
+    class HTTPEnvClient:
+        """Simple HTTP client that mimics the OpenEnv SDK interface."""
+
+        def __init__(self, base_url: str):
+            self.base_url = base_url.rstrip("/")
+            self.http = httpx.AsyncClient(timeout=60.0)
+
+        async def reset(self):
+            resp = await self.http.post(f"{self.base_url}/reset")
+            resp.raise_for_status()
+            return resp.json()
+
+        async def step(self, action_data: dict):
+            resp = await self.http.post(f"{self.base_url}/step", json=action_data)
+            resp.raise_for_status()
+            return resp.json()
+
+        async def close(self):
+            await self.http.aclose()
+
+    env_url = sys.argv[1] if len(sys.argv) > 1 else "http://localhost:7860"
+    env = HTTPEnvClient(env_url)
+
+    history: List[str] = []
+    rewards: List[float] = []
+    steps_taken = 0
+    score = 0.0
+    success = False
+
+    log_start(task=task_name, env=benchmark, model=model_name)
+
+    try:
+        result = await env.reset()
+        obs = result["observation"]
+        state = result["state"]
+
+        step_num = 0
+        while not state["is_done"]:
+            step_num += 1
+
+            fixed_config = get_model_message(client, obs, step_num, history, model_name)
+
+            step_result = await env.step({"fixed_config": fixed_config})
+            obs = step_result["observation"]
+            state = step_result["state"]
+            reward = step_result.get("reward", 0.0)
+            done = state["is_done"]
+            info = step_result.get("info", {})
+            error = info.get("error_message") if info.get("error_message") != "All checks passed!" else None
+
+            rewards.append(reward)
+            steps_taken = step_num
+
+            action_summary = f"fix({info.get('task_id', 'unknown')})"
+            log_step(step=step_num, action=action_summary, reward=reward, done=done, error=error)
+
+            history.append(f"Step {step_num}: {action_summary} -> reward {reward:+.2f}")
+
+            if done:
+                break
+
+        score = sum(rewards) / MAX_TOTAL_REWARD if MAX_TOTAL_REWARD > 0 else 0.0
+        score = min(max(score, 0.0), 1.0)
+        success = score >= SUCCESS_SCORE_THRESHOLD
+
+    finally:
+        try:
+            await env.close()
+        except Exception as e:
+            print(f"[DEBUG] env.close() error: {e}", flush=True)
+        log_end(success=success, steps=steps_taken, score=score, rewards=rewards)
+
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except Exception as e:
+        print(f"[END] success=false error={str(e)}", flush=True)

openenv.yaml

@@ -0,0 +1,62 @@
+spec_version: 1
+name: config-debug-env
+type: space
+runtime: fastapi
+app: server.app:app
+port: 7860
+description: "An RL environment for training AI agents to debug broken configuration files"
+version: "1.0.0"
+author: "meta-hackathon-participant"
+tags:
+  - devops
+  - configuration
+  - debugging
+  - infrastructure
+
+action_model: server.models:ConfigDebugAction
+observation_model: server.models:ConfigDebugObservation
+state_model: server.models:ConfigDebugState
+
+tasks:
+  - id: task1_json
+    name: "JSON Config Debug"
+    difficulty: easy
+    num_bugs: 2
+    grader: server.graders.grader_api:grade_task1
+    has_grader: true
+  - id: task2_yaml
+    name: "YAML Config Debug"
+    difficulty: easy
+    num_bugs: 2
+    grader: server.graders.grader_api:grade_task2
+    has_grader: true
+  - id: task3_dockerfile
+    name: "Dockerfile Debug"
+    difficulty: medium
+    num_bugs: 3
+    grader: server.graders.grader_api:grade_task3
+    has_grader: true
+  - id: task4_compose
+    name: "Docker Compose Debug"
+    difficulty: medium
+    num_bugs: 4
+    grader: server.graders.grader_api:grade_task4
+    has_grader: true
+  - id: task5_k8s
+    name: "Kubernetes Config Debug"
+    difficulty: hard
+    num_bugs: 5
+    grader: server.graders.grader_api:grade_task5
+    has_grader: true
+  - id: task6_github_actions
+    name: "GitHub Actions Debug"
+    difficulty: hard
+    num_bugs: 5
+    grader: server.graders.grader_api:grade_task6
+    has_grader: true
+  - id: task7_nginx
+    name: "Nginx Config Debug"
+    difficulty: very_hard
+    num_bugs: 3
+    grader: server.graders.grader_api:grade_task7
+    has_grader: true

pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "config-debug-env"
+version = "1.0.0"
+description = "An RL environment for debugging broken configuration files"
+requires-python = ">=3.10"
+dependencies = [
+    "fastapi",
+    "uvicorn",
+    "pydantic",
+    "pyyaml",
+    "httpx",
+    "openai",
+    "gradio",
+    "openenv-core>=0.2.0",
+]
+
+[project.scripts]
+server = "server.app:main"
+
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.backends._legacy:_Backend"

requirements.txt

@@ -0,0 +1,8 @@
+fastapi
+uvicorn
+pydantic
+pyyaml
+httpx
+openai
+gradio
+openenv-core>=0.2.0

server/Dockerfile

@@ -0,0 +1,14 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+RUN useradd -m -u 1000 user
+COPY --chown=user . .
+USER user
+
+EXPOSE 7860
+
+CMD ["python", "-m", "uvicorn", "server.app:app", "--host", "0.0.0.0", "--port", "7860"]

server/app.py

@@ -0,0 +1,176 @@
+"""FastAPI application for ConfigDebugEnv.
+
+Uses OpenEnv's create_fastapi_app() for standard framework compatibility
+(WebSocket sessions, standard endpoints, grader discovery).
+"""
+import json
+import gradio as gr
+
+from openenv.core.env_server import create_fastapi_app
+from server.models import ConfigDebugAction, ConfigDebugObservation, ConfigDebugState
+from server.config_debug_environment import ConfigDebugEnvironment
+from server.tasks.task_registry import get_task, TASK_ORDER
+
+# ---- Create the standard OpenEnv FastAPI app ----
+# create_fastapi_app expects a callable (factory) that returns an Environment
+app = create_fastapi_app(
+    ConfigDebugEnvironment,       # factory / class — called per session
+    ConfigDebugAction,            # action model (inherits Action)
+    ConfigDebugObservation,       # observation model (inherits Observation)
+)
+
+
+
+
+# ---- Custom endpoints ----
+
+@app.get("/info")
+def info():
+    return {"name": "ConfigDebugEnv", "version": "1.0.0", "status": "running"}
+
+
+@app.get("/health")
+def health():
+    return {"status": "healthy"}
+
+
+
+
+
+@app.get("/tasks")
+def tasks():
+    return {
+        "tasks": [
+            {
+                "id": tid,
+                "name": get_task(tid).description,
+                "difficulty": get_task(tid).difficulty,
+                "file_type": get_task(tid).file_type,
+                "num_bugs": get_task(tid).num_bugs,
+                "has_grader": True,
+            }
+            for tid in TASK_ORDER
+        ],
+        "total_tasks": len(TASK_ORDER),
+        "tasks_with_graders": len(TASK_ORDER),
+    }
+
+
+# ---- Gradio Web UI ----
+
+_ui_env = ConfigDebugEnvironment()
+
+
+def format_state(env):
+    """Format environment state with progress bar and RL signals."""
+    state = env.state
+    progress_bar = "█" * int(state.progress_ratio * 10) + "░" * (10 - int(state.progress_ratio * 10))
+    
+    return f"""
+Task Progress: {len(state.tasks_completed)+1}/7
+Progress: {progress_bar} ({int(state.progress_ratio*100)}%)
+Total Reward: {state.total_reward:.2f}
+
+Current Task: {state.current_task_id}
+Difficulty: {state.current_difficulty}
+
+Bugs Found: {state.bugs_found_so_far}
+Error: {state.current_error_message or 'None'}
+
+Completed: {', '.join(state.tasks_completed) if state.tasks_completed else 'None'}
+Remaining: {', '.join(state.tasks_remaining[:3]) if state.tasks_remaining else 'None'}
+"""
+
+
+def ui_get_state():
+    """Get current environment state (inspectable state)."""
+    return format_state(_ui_env)
+
+
+def ui_reset():
+    _ui_env.reset()
+    obs = _ui_env._build_observation()
+    return (
+        f"Task: {obs.task_id} | Difficulty: {obs.difficulty} | Bugs: {obs.num_bugs}",
+        obs.task_description,
+        obs.broken_config,
+        obs.error_message,
+        format_state(_ui_env),
+        "Environment reset. Submit a fixed config to begin.",
+    )
+
+
+def ui_step(fixed_config):
+    if _ui_env._done:
+        return (
+            "All tasks completed!",
+            "",
+            "",
+            "Episode done. Click Reset to start again.",
+            format_state(_ui_env),
+            f"Final score: {_ui_env.total_reward:.1f} / {len(TASK_ORDER)}.0",
+        )
+
+    action = ConfigDebugAction(fixed_config=fixed_config)
+    obs = _ui_env.step(action)
+
+    history = f"Reward: {obs.reward:.2f} | Bugs found: {obs.bugs_found_so_far}/{obs.num_bugs}\nFeedback: {obs.error_message}"
+    return (
+        f"Task: {obs.task_id} | Difficulty: {obs.difficulty} | Bugs: {obs.num_bugs}",
+        obs.task_description,
+        obs.broken_config,
+        obs.error_message,
+        format_state(_ui_env),
+        history,
+    )
+
+
+with gr.Blocks(title="ConfigDebugEnv") as demo:
+    gr.Markdown("# ConfigDebugEnv")
+    gr.Markdown("An RL environment for debugging broken config files across 7 real-world formats.")
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### Agent Interface")
+            task_info = gr.Textbox(label="Current Task", interactive=False)
+            task_desc = gr.Textbox(label="Task Description", interactive=False, lines=2)
+            broken_config = gr.Textbox(label="Broken Config", interactive=False, lines=10)
+            error_msg = gr.Textbox(label="Error Message", interactive=False, lines=2)
+
+            gr.Markdown("### Take Action")
+            fixed_config_input = gr.Textbox(label="Your Fixed Config", placeholder="Paste your fixed configuration here...", lines=10)
+            with gr.Row():
+                reset_btn = gr.Button("Reset Environment", variant="secondary")
+                step_btn = gr.Button("Step", variant="primary")
+                state_btn = gr.Button("Get State", variant="secondary")
+
+        with gr.Column(scale=1):
+            gr.Markdown("### State Observer")
+            state_display = gr.Textbox(label="Current State (with RL Signals)", interactive=False, lines=14)
+            history_display = gr.Textbox(label="Action History / Reward", interactive=False, lines=4)
+
+    reset_btn.click(
+        fn=ui_reset,
+        outputs=[task_info, task_desc, broken_config, error_msg, state_display, history_display],
+    )
+    step_btn.click(
+        fn=ui_step,
+        inputs=[fixed_config_input],
+        outputs=[task_info, task_desc, broken_config, error_msg, state_display, history_display],
+    )
+    state_btn.click(
+        fn=ui_get_state,
+        outputs=[state_display],
+    )
+
+
+app = gr.mount_gradio_app(app, demo, path="/")
+
+
+def main(host: str = "0.0.0.0", port: int = 7860):
+    import uvicorn
+    uvicorn.run(app, host=host, port=port)
+
+
+if __name__ == "__main__":
+    main()

server/config_debug_environment.py

@@ -0,0 +1,145 @@
+"""ConfigDebugEnvironment - OpenEnv-compatible environment class.
+
+Inherits from openenv.core.env_server.Environment and implements
+the standard reset/step/state interface with multi-task logic.
+"""
+from typing import Optional, Any
+from uuid import uuid4
+
+from openenv.core.env_server import Environment
+from server.models import ConfigDebugAction, ConfigDebugObservation, ConfigDebugState
+from server.tasks.task_registry import get_task, TASK_ORDER
+
+MAX_STEPS_PER_TASK = 5
+
+
+class ConfigDebugEnvironment(Environment):
+    """Multi-task config debugging environment.
+
+    Manages 7 sequential tasks internally. Each WebSocket session
+    (via create_fastapi_app) gets its own instance with independent state.
+    """
+
+    SUPPORTS_CONCURRENT_SESSIONS = True
+
+    def __init__(self):
+        self._init_episode()
+
+    def _init_episode(self):
+        self.task_ids = list(TASK_ORDER)
+        self.current_task_index = 0
+        self.current_step = 0
+        self.total_reward = 0.0
+        self._done = False
+        self.tasks_completed: list = []
+        self.bugs_found_so_far = 0
+        self.previous_reward = 0.0
+        self.current_error_message: Optional[str] = None
+        self.current_broken_config: Optional[str] = None
+        self._episode_id = str(uuid4())
+        self._global_step = 0
+
+    # ---- OpenEnv interface methods ----
+
+    def reset(self, seed: Optional[int] = None, episode_id: Optional[str] = None, **kwargs: Any) -> ConfigDebugObservation:
+        """Reset environment to initial state (task 1)."""
+        self._init_episode()
+        if episode_id:
+            self._episode_id = episode_id
+        return self._build_observation()
+
+    def step(self, action: ConfigDebugAction, timeout_s: Optional[float] = None, **kwargs: Any) -> ConfigDebugObservation:
+        """Process an action: run the grader, advance tasks if done."""
+        if self._done:
+            return self._build_observation()
+
+        task_id = self._current_task_id()
+        task = get_task(task_id)
+
+        # Run the grader
+        reward, error_message, bugs_fixed = task.grader(action.fixed_config)
+        reward = max(0.0, min(1.0, reward))
+
+        self.current_step += 1
+        self._global_step += 1
+        self.bugs_found_so_far = len(bugs_fixed)
+        self.previous_reward = round(reward, 4)
+        self.current_error_message = error_message
+
+        # Check if task is complete
+        task_done = reward >= 0.99 or self.current_step >= MAX_STEPS_PER_TASK
+
+        if task_done:
+            self.total_reward += reward
+            self.tasks_completed.append(task_id)
+            self.current_task_index += 1
+            self.current_step = 0
+            self.bugs_found_so_far = 0
+            self.current_error_message = None
+            self.current_broken_config = None
+            if self.current_task_index >= len(self.task_ids):
+                self._done = True
+        else:
+            self.current_broken_config = action.fixed_config
+
+        obs = self._build_observation()
+        obs.done = self._done
+        obs.reward = round(reward, 4)
+        return obs
+
+    @property
+    def state(self) -> ConfigDebugState:
+        """Return current environment state with enhanced RL signals."""
+        tasks_remaining = self.task_ids[self.current_task_index:]
+        if self._done:
+            tasks_remaining = []
+
+        total_tasks = len(self.task_ids)
+        completed_tasks = len(self.tasks_completed)
+        progress_ratio = completed_tasks / total_tasks if total_tasks > 0 else 0.0
+
+        current_task = get_task(self._current_task_id())
+
+        return ConfigDebugState(
+            episode_id=self._episode_id,
+            step_count=self._global_step,
+            current_task_id=self._current_task_id(),
+            current_step=self.current_step,
+            max_steps=MAX_STEPS_PER_TASK,
+            total_reward=round(self.total_reward, 4),
+            is_done=self._done,
+            tasks_completed=list(self.tasks_completed),
+            tasks_remaining=tasks_remaining,
+            # Enhanced RL signals
+            bugs_found_so_far=self.bugs_found_so_far,
+            current_error_message=self.current_error_message,
+            progress_ratio=round(progress_ratio, 2),
+            current_difficulty=current_task.difficulty,
+        )
+
+    # ---- Internal helpers ----
+
+    def _current_task_id(self) -> str:
+        if self.current_task_index < len(self.task_ids):
+            return self.task_ids[self.current_task_index]
+        return self.task_ids[-1]
+
+    def _build_observation(self) -> ConfigDebugObservation:
+        task_id = self._current_task_id()
+        task = get_task(task_id)
+        broken = self.current_broken_config if self.current_broken_config is not None else task.broken_config
+        error = self.current_error_message if self.current_error_message is not None else task.error_message
+
+        return ConfigDebugObservation(
+            broken_config=broken,
+            file_type=task.file_type,
+            error_message=error,
+            task_id=task.task_id,
+            task_description=task.description,
+            difficulty=task.difficulty,
+            num_bugs=task.num_bugs,
+            bugs_found_so_far=self.bugs_found_so_far,
+            previous_reward=self.previous_reward,
+            done=self._done,
+            reward=self.previous_reward,
+        )

server/env.py

@@ -0,0 +1,362 @@
+from fastapi import FastAPI, HTTPException
+from typing import Optional
+import json
+import gradio as gr
+
+from server.models import ConfigDebugAction, ConfigDebugObservation, ConfigDebugState
+from server.tasks.task_registry import get_task, get_all_task_ids, TASK_ORDER
+
+app = FastAPI(title="ConfigDebugEnv", version="1.0.0")
+
+# --- Environment State ---
+MAX_STEPS_PER_TASK = 5
+
+
+class EnvironmentState:
+    """Mutable environment state that persists across requests."""
+
+    def __init__(self):
+        self.reset_state()
+
+    def reset_state(self):
+        self.task_ids = list(TASK_ORDER)
+        self.current_task_index = 0
+        self.current_step = 0
+        self.total_reward = 0.0
+        self.is_done = False
+        self.tasks_completed = []
+        self.bugs_found_so_far = 0
+        self.previous_reward = 0.0
+        self.current_error_message: Optional[str] = None
+        self.current_broken_config: Optional[str] = None
+
+
+env_state = EnvironmentState()
+
+
+def _get_current_task_id() -> str:
+    if env_state.current_task_index < len(env_state.task_ids):
+        return env_state.task_ids[env_state.current_task_index]
+    return env_state.task_ids[-1]
+
+
+def _build_observation() -> ConfigDebugObservation:
+    task_id = _get_current_task_id()
+    task = get_task(task_id)
+
+    broken_config = (
+        env_state.current_broken_config
+        if env_state.current_broken_config is not None
+        else task.broken_config
+    )
+    error_message = (
+        env_state.current_error_message
+        if env_state.current_error_message is not None
+        else task.error_message
+    )
+
+    return ConfigDebugObservation(
+        broken_config=broken_config,
+        file_type=task.file_type,
+        error_message=error_message,
+        task_id=task.task_id,
+        task_description=task.description,
+        difficulty=task.difficulty,
+        num_bugs=task.num_bugs,
+        bugs_found_so_far=env_state.bugs_found_so_far,
+        previous_reward=env_state.previous_reward,
+    )
+
+
+def _build_state() -> ConfigDebugState:
+    task_id = _get_current_task_id()
+    tasks_remaining = env_state.task_ids[env_state.current_task_index:]
+    if env_state.is_done:
+        tasks_remaining = []
+
+    return ConfigDebugState(
+        current_task_id=task_id,
+        current_step=env_state.current_step,
+        max_steps=MAX_STEPS_PER_TASK,
+        total_reward=round(env_state.total_reward, 4),
+        is_done=env_state.is_done,
+        tasks_completed=list(env_state.tasks_completed),
+        tasks_remaining=tasks_remaining,
+    )
+
+
+# --- API Endpoints ---
+
+
+@app.get("/health")
+def health():
+    return {"status": "healthy"}
+
+
+@app.get("/info")
+def info():
+    return {"name": "ConfigDebugEnv", "version": "1.0.0", "status": "running"}
+
+
+@app.post("/reset")
+def reset(task_id: str = None):
+    """Reset the environment to initial state, return first observation."""
+    env_state.reset_state()
+    if task_id and task_id in env_state.task_ids:
+        env_state.current_task_index = env_state.task_ids.index(task_id)
+
+    observation = _build_observation()
+    state = _build_state()
+
+    return {
+        "observation": observation.model_dump(),
+        "state": state.model_dump(),
+    }
+
+
+@app.post("/step")
+def step(action: ConfigDebugAction):
+    """
+    Take a step in the environment.
+    The agent submits a fixed config, the grader evaluates it.
+    """
+    if env_state.is_done:
+        raise HTTPException(
+            status_code=400,
+            detail="Environment is done. Call /reset to start a new episode.",
+        )
+
+    task_id = _get_current_task_id()
+    task = get_task(task_id)
+
+    # Run the grader
+    reward, error_message, bugs_fixed = task.grader(action.fixed_config)
+    reward = max(0.01, min(0.99, reward))
+
+    env_state.current_step += 1
+    env_state.bugs_found_so_far = len(bugs_fixed)
+    env_state.previous_reward = round(reward, 4)
+
+    # Update error message for feedback
+    env_state.current_error_message = error_message
+
+    # Check if task is complete (perfect score or max steps reached)
+    task_done = reward >= 0.99 or env_state.current_step >= MAX_STEPS_PER_TASK
+
+    task_reward = reward  # Reward for this step
+
+    if task_done:
+        # Record the best reward for this task
+        env_state.total_reward += reward
+        env_state.tasks_completed.append(task_id)
+        env_state.current_task_index += 1
+
+        # Reset per-task state
+        env_state.current_step = 0
+        env_state.bugs_found_so_far = 0
+        env_state.current_error_message = None
+        env_state.current_broken_config = None
+
+        # Check if all tasks are done
+        if env_state.current_task_index >= len(env_state.task_ids):
+            env_state.is_done = True
+    else:
+        # If the agent submitted something, use it as the new "broken" config
+        # so the agent can iterate
+        env_state.current_broken_config = action.fixed_config
+
+    observation = _build_observation()
+    state = _build_state()
+
+    return {
+        "observation": observation.model_dump(),
+        "reward": round(task_reward, 4),
+        "done": env_state.is_done,
+        "state": state.model_dump(),
+        "info": {
+            "task_id": task_id,
+            "bugs_fixed": bugs_fixed,
+            "error_message": error_message,
+            "task_done": task_done,
+        },
+    }
+
+
+@app.get("/state")
+def state():
+    """Return current environment state."""
+    return _build_state().model_dump()
+
+
+@app.get("/observation")
+def observation():
+    """Return current observation."""
+    if env_state.is_done:
+        raise HTTPException(
+            status_code=400,
+            detail="Environment is done. Call /reset to start a new episode.",
+        )
+    return _build_observation().model_dump()
+
+
+
+@app.get("/metadata")
+def metadata():
+    return {
+        "env_name": "config_debug_env",
+        "version": "1.0.0",
+        "description": "Config file debugging environment",
+        "tasks": [
+            {"id": "task1_json", "name": "JSON Config Debug", "difficulty": "easy", "num_bugs": 2, "has_grader": True, "grader": "server.graders.json_grader:grade_task1"},
+            {"id": "task2_yaml", "name": "YAML Config Debug", "difficulty": "easy", "num_bugs": 2, "has_grader": True, "grader": "server.graders.yaml_grader:grade_task2"},
+            {"id": "task3_dockerfile", "name": "Dockerfile Debug", "difficulty": "medium", "num_bugs": 3, "has_grader": True, "grader": "server.graders.dockerfile_grader:grade_task3"},
+            {"id": "task4_compose", "name": "Docker Compose Debug", "difficulty": "medium", "num_bugs": 4, "has_grader": True, "grader": "server.graders.compose_grader:grade_task4"},
+            {"id": "task5_k8s", "name": "Kubernetes Config Debug", "difficulty": "hard", "num_bugs": 5, "has_grader": True, "grader": "server.graders.k8s_grader:grade_task5"},
+            {"id": "task6_github_actions", "name": "GitHub Actions Debug", "difficulty": "hard", "num_bugs": 5, "has_grader": True, "grader": "server.graders.github_actions_grader:grade_task6"},
+            {"id": "task7_nginx", "name": "Nginx Config Debug", "difficulty": "very_hard", "num_bugs": 6, "has_grader": True, "grader": "server.graders.nginx_grader:grade_task7"},
+        ],
+        "action_model": "ConfigDebugAction",
+        "observation_model": "ConfigDebugObservation",
+        "state_model": "ConfigDebugState",
+    }
+
+
+@app.get("/tasks")
+def tasks():
+    """Return list of all tasks with grader information."""
+    return {
+        "tasks": [
+            {
+                "id": tid,
+                "name": get_task(tid).description,
+                "difficulty": get_task(tid).difficulty,
+                "file_type": get_task(tid).file_type,
+                "num_bugs": get_task(tid).num_bugs,
+                "has_grader": True,
+            }
+            for tid in TASK_ORDER
+        ],
+        "total_tasks": len(TASK_ORDER),
+        "tasks_with_graders": len(TASK_ORDER),
+    }
+
+@app.get("/schema")
+def schema():
+    return {
+        "action": ConfigDebugAction.model_json_schema(),
+        "observation": ConfigDebugObservation.model_json_schema(),
+        "state": ConfigDebugState.model_json_schema(),
+    }
+
+# --- Gradio Web UI ---
+
+
+def ui_reset():
+    env_state.reset_state()
+    obs = _build_observation()
+    st = _build_state()
+    return (
+        f"Task: {obs.task_id} | Difficulty: {obs.difficulty} | Bugs: {obs.num_bugs}",
+        obs.task_description,
+        obs.broken_config,
+        obs.error_message,
+        json.dumps(st.model_dump(), indent=2),
+        "Environment reset. Submit a fixed config to begin.",
+    )
+
+
+def ui_step(fixed_config):
+    if env_state.is_done:
+        st = _build_state()
+        return (
+            "All tasks completed!",
+            "",
+            "",
+            "Episode done. Click Reset to start again.",
+            json.dumps(st.model_dump(), indent=2),
+            f"Final score: {env_state.total_reward:.1f} / {len(TASK_ORDER)}.0",
+        )
+
+    task_id = _get_current_task_id()
+    task = get_task(task_id)
+    reward, error_message, bugs_fixed = task.grader(fixed_config)
+    reward = max(0.01, min(0.99, reward))
+
+    env_state.current_step += 1
+    env_state.bugs_found_so_far = len(bugs_fixed)
+    env_state.previous_reward = round(reward, 4)
+    env_state.current_error_message = error_message
+
+    task_done = reward >= 0.99 or env_state.current_step >= MAX_STEPS_PER_TASK
+
+    if task_done:
+        env_state.total_reward += reward
+        env_state.tasks_completed.append(task_id)
+        env_state.current_task_index += 1
+        env_state.current_step = 0
+        env_state.bugs_found_so_far = 0
+        env_state.current_error_message = None
+        env_state.current_broken_config = None
+        if env_state.current_task_index >= len(env_state.task_ids):
+            env_state.is_done = True
+    else:
+        env_state.current_broken_config = fixed_config
+
+    obs = _build_observation()
+    st = _build_state()
+    history = f"Reward: {reward:.2f} | Bugs fixed: {bugs_fixed} | Task done: {task_done}\nFeedback: {error_message}"
+
+    return (
+        f"Task: {obs.task_id} | Difficulty: {obs.difficulty} | Bugs: {obs.num_bugs}",
+        obs.task_description,
+        obs.broken_config,
+        obs.error_message,
+        json.dumps(st.model_dump(), indent=2),
+        history,
+    )
+
+
+def ui_get_state():
+    st = _build_state()
+    return json.dumps(st.model_dump(), indent=2)
+
+
+with gr.Blocks(title="ConfigDebugEnv", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# ConfigDebugEnv")
+    gr.Markdown("An RL environment for debugging broken config files across 7 real-world formats: JSON, YAML, Dockerfile, docker-compose, Kubernetes, GitHub Actions, nginx.")
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### HumanAgent Interface")
+            task_info = gr.Textbox(label="Current Task", interactive=False)
+            task_desc = gr.Textbox(label="Task Description", interactive=False, lines=2)
+            broken_config = gr.Textbox(label="Broken Config", interactive=False, lines=10)
+            error_msg = gr.Textbox(label="Error Message", interactive=False, lines=2)
+
+            gr.Markdown("### Take Action")
+            fixed_config_input = gr.Textbox(label="Your Fixed Config", placeholder="Paste your fixed configuration here...", lines=10)
+            with gr.Row():
+                reset_btn = gr.Button("Reset Environment", variant="secondary")
+                step_btn = gr.Button("Step", variant="primary")
+                state_btn = gr.Button("Get State", variant="secondary")
+
+        with gr.Column(scale=1):
+            gr.Markdown("### State Observer")
+            state_display = gr.Textbox(label="Current State", interactive=False, lines=12)
+            history_display = gr.Textbox(label="Action History / Reward", interactive=False, lines=4)
+
+    reset_btn.click(
+        fn=ui_reset,
+        outputs=[task_info, task_desc, broken_config, error_msg, state_display, history_display],
+    )
+    step_btn.click(
+        fn=ui_step,
+        inputs=[fixed_config_input],
+        outputs=[task_info, task_desc, broken_config, error_msg, state_display, history_display],
+    )
+    state_btn.click(
+        fn=ui_get_state,
+        outputs=[state_display],
+    )
+
+app = gr.mount_gradio_app(app, demo, path="/")

server/graders/compose_grader.py

@@ -0,0 +1,109 @@
+import yaml
+from typing import Tuple, List
+
+
+def grade_task4(submitted_config: str) -> Tuple[float, str, List[str]]:
+    """
+    Grade Task 4: Broken docker-compose.yml (4 bugs)
+    Bug 1 (Syntax): Wrong indentation on volumes key
+    Bug 2 (Semantic): Service references non-existent network name
+    Bug 3 (Runtime): Port mapping "8080:80" should be "8080:3000"
+    Bug 4 (Integration): depends_on references "postgres" but service is defined as "db"
+
+    Returns: (reward, error_message, bugs_fixed_list)
+    """
+    bugs_fixed = []
+    total_bugs = 4
+    error_messages = []
+
+    # Bug 1: Check if YAML parses (syntax layer)
+    try:
+        config = yaml.safe_load(submitted_config)
+        if not isinstance(config, dict):
+            error_messages.append("docker-compose config is not a valid mapping")
+            return 0.0, "; ".join(error_messages), bugs_fixed
+        bugs_fixed.append("syntax_valid_yaml")
+    except yaml.YAMLError as e:
+        error_messages.append(f"YAML parse error: {str(e)}")
+        return 0.0, "; ".join(error_messages), bugs_fixed
+
+    services = config.get("services", {})
+    if not isinstance(services, dict):
+        error_messages.append("'services' key is missing or not a mapping")
+        reward = len(bugs_fixed) / total_bugs
+        return reward, "; ".join(error_messages), bugs_fixed
+
+    defined_service_names = set(services.keys())
+    defined_networks = set(config.get("networks", {}).keys()) if isinstance(config.get("networks"), dict) else set()
+
+    # Bug 4: Check depends_on references valid service names
+    all_deps_valid = True
+    for svc_name, svc_config in services.items():
+        if not isinstance(svc_config, dict):
+            continue
+        deps = svc_config.get("depends_on", [])
+        if isinstance(deps, list):
+            for dep in deps:
+                if dep not in defined_service_names:
+                    all_deps_valid = False
+                    error_messages.append(
+                        f"Service '{svc_name}' depends_on '{dep}', "
+                        f"but no service named '{dep}' is defined. "
+                        f"Defined services: {sorted(defined_service_names)}"
+                    )
+
+    if all_deps_valid:
+        bugs_fixed.append("depends_on_valid")
+
+    # Bug 2: Check all referenced networks exist in top-level networks
+    all_nets_valid = True
+    for svc_name, svc_config in services.items():
+        if not isinstance(svc_config, dict):
+            continue
+        svc_networks = svc_config.get("networks", [])
+        if isinstance(svc_networks, list):
+            for net in svc_networks:
+                if net not in defined_networks:
+                    all_nets_valid = False
+                    error_messages.append(
+                        f"Service '{svc_name}' references network '{net}', "
+                        f"but it's not defined in top-level networks. "
+                        f"Defined networks: {sorted(defined_networks)}"
+                    )
+
+    if all_nets_valid:
+        bugs_fixed.append("networks_valid")
+
+    # Bug 3: Check port mapping - web service should map to 3000
+    web_svc = services.get("web", {})
+    if isinstance(web_svc, dict):
+        ports = web_svc.get("ports", [])
+        port_correct = False
+        for port_mapping in ports:
+            port_str = str(port_mapping)
+            # Check the container port (right side) is 3000
+            if ":3000" in port_str:
+                port_correct = True
+                break
+        if port_correct:
+            bugs_fixed.append("port_mapping_correct")
+        else:
+            error_messages.append(
+                "Web service port mapping is incorrect. "
+                "The application runs on port 3000, so the container port should be 3000."
+            )
+    else:
+        error_messages.append("Web service is missing or misconfigured")
+
+    # Calculate reward
+    reward = len(bugs_fixed) / total_bugs
+
+    # Bonus for parsing
+    if len(bugs_fixed) >= 1:
+        reward = min(1.0, reward + 0.1)
+
+    if len(bugs_fixed) == total_bugs:
+        reward = 1.0
+
+    error_msg = "; ".join(error_messages) if error_messages else "All checks passed!"
+    return reward, error_msg, bugs_fixed

server/graders/dockerfile_grader.py

@@ -0,0 +1,107 @@
+import re
+from typing import Tuple, List
+
+ALLOWED_BASE_IMAGES = [
+    "python:3.9-slim", "python:3.10-slim", "python:3.11-slim",
+    "python:3.9", "python:3.10", "python:3.11",
+    "python:3.9-alpine", "python:3.10-alpine", "python:3.11-alpine",
+    "python:3.9-slim-bullseye", "python:3.9-slim-bookworm",
+    "node:18", "node:20", "node:18-slim", "node:20-slim",
+    "ubuntu:22.04", "ubuntu:20.04", "debian:bullseye-slim",
+]
+
+
+def grade_task3(submitted_config: str) -> Tuple[float, str, List[str]]:
+    """
+    Grade Task 3: Broken Dockerfile (3 bugs)
+    Bug 1 (Syntax): RUN command with wrong escape character (^ instead of \\)
+    Bug 2 (Semantic): Wrong base image tag (python:3.9-slm instead of python:3.9-slim)
+    Bug 3 (Runtime): Missing EXPOSE directive
+
+    Returns: (reward, error_message, bugs_fixed_list)
+    """
+    bugs_fixed = []
+    total_bugs = 3
+    error_messages = []
+
+    lines = submitted_config.strip().split("\n")
+
+    # Bug 2: Check base image is valid
+    from_lines = [l for l in lines if l.strip().upper().startswith("FROM")]
+    if from_lines:
+        from_image = from_lines[0].strip().split()[1] if len(from_lines[0].strip().split()) > 1 else ""
+        if from_image in ALLOWED_BASE_IMAGES:
+            bugs_fixed.append("valid_base_image")
+        else:
+            error_messages.append(
+                f"Base image '{from_image}' is not a recognized valid image. "
+                f"Did you mean 'python:3.9-slim'?"
+            )
+    else:
+        error_messages.append("Missing FROM instruction in Dockerfile")
+
+    # Bug 1: Check RUN syntax - no ^ for line continuation
+    run_blocks = []
+    in_run = False
+    current_run = []
+    for line in lines:
+        stripped = line.strip()
+        if stripped.upper().startswith("RUN "):
+            in_run = True
+            current_run = [line]
+        elif in_run:
+            if current_run[-1].rstrip().endswith("\\"):
+                current_run.append(line)
+            else:
+                run_blocks.append("\n".join(current_run))
+                in_run = False
+                current_run = []
+                if stripped.upper().startswith("RUN "):
+                    in_run = True
+                    current_run = [line]
+        if not in_run and current_run:
+            run_blocks.append("\n".join(current_run))
+            current_run = []
+    if current_run:
+        run_blocks.append("\n".join(current_run))
+
+    has_caret = any("^" in line and not line.strip().startswith("#") for line in lines)
+    # Check if multi-line RUN uses proper backslash
+    has_proper_continuation = any(
+        line.rstrip().endswith("\\") for line in lines
+        if not line.strip().startswith("#")
+    )
+
+    if not has_caret:
+        bugs_fixed.append("run_syntax_correct")
+    else:
+        error_messages.append(
+            "RUN command uses '^' for line continuation. "
+            "Dockerfiles use '\\' for multi-line commands."
+        )
+
+    # Bug 3: Check EXPOSE directive present
+    expose_lines = [l for l in lines if l.strip().upper().startswith("EXPOSE")]
+    if expose_lines:
+        bugs_fixed.append("expose_present")
+    else:
+        error_messages.append(
+            "Missing EXPOSE directive. The application port should be exposed."
+        )
+
+    # Calculate reward
+    reward = len(bugs_fixed) / total_bugs
+
+    # Bonus for having a parseable Dockerfile structure
+    has_from = any(l.strip().upper().startswith("FROM") for l in lines)
+    has_cmd_or_entrypoint = any(
+        l.strip().upper().startswith(("CMD", "ENTRYPOINT")) for l in lines
+    )
+    if has_from and has_cmd_or_entrypoint:
+        reward = min(1.0, reward + 0.1)
+
+    if len(bugs_fixed) == total_bugs:
+        reward = 1.0
+
+    error_msg = "; ".join(error_messages) if error_messages else "All checks passed!"
+    return reward, error_msg, bugs_fixed

server/graders/github_actions_grader.py

@@ -0,0 +1,164 @@
+import yaml
+from typing import Tuple, List
+
+VALID_RUNNERS = [
+    "ubuntu-latest", "ubuntu-22.04", "ubuntu-20.04", "ubuntu-24.04",
+    "macos-latest", "macos-14", "macos-13", "macos-12",
+    "windows-latest", "windows-2022", "windows-2019",
+]
+
+VALID_CHECKOUT_PARAMS = [
+    "repository", "ref", "token", "ssh-key", "ssh-known-hosts", "ssh-strict",
+    "persist-credentials", "path", "clean", "filter", "sparse-checkout",
+    "sparse-checkout-cone-mode", "fetch-depth", "fetch-tags",
+    "show-progress", "lfs", "submodules", "set-safe-directory",
+]
+
+
+def grade_task6(submitted_config: str) -> Tuple[float, str, List[str]]:
+    """
+    Grade Task 6: Broken GitHub Actions Workflow (5 bugs)
+    Bug 1 (Syntax): Missing colon after 'on' trigger
+    Bug 2 (Semantic): runs-on uses "ubuntu-latets" (typo)
+    Bug 3 (Semantic): actions/checkout with invalid parameter name "fetch-deph"
+    Bug 4 (Runtime): env var references secrets but not defined in env block (acceptable)
+    Bug 5 (Integration): Upload artifact name "build-output" vs download "build-artifact"
+
+    Returns: (reward, error_message, bugs_fixed_list)
+    """
+    bugs_fixed = []
+    total_bugs = 5
+    error_messages = []
+
+    # Bug 1: Check if YAML parses (syntax layer - the missing colon after 'on')
+    try:
+        config = yaml.safe_load(submitted_config)
+        if not isinstance(config, dict):
+            error_messages.append("GitHub Actions workflow is not a valid mapping")
+            return 0.0, "; ".join(error_messages), bugs_fixed
+        bugs_fixed.append("syntax_valid_yaml")
+    except yaml.YAMLError as e:
+        error_messages.append(f"YAML parse error: {str(e)}")
+        return 0.0, "; ".join(error_messages), bugs_fixed
+
+    jobs = config.get("jobs", {})
+    if not isinstance(jobs, dict):
+        error_messages.append("'jobs' key is missing or not a mapping")
+        reward = len(bugs_fixed) / total_bugs
+        return reward, "; ".join(error_messages), bugs_fixed
+
+    # Bug 2: Check runner names
+    all_runners_valid = True
+    for job_name, job_config in jobs.items():
+        if not isinstance(job_config, dict):
+            continue
+        runner = job_config.get("runs-on", "")
+        if runner and runner not in VALID_RUNNERS:
+            all_runners_valid = False
+            error_messages.append(
+                f"Job '{job_name}' uses runner '{runner}' which is not valid. "
+                f"Did you mean 'ubuntu-latest'?"
+            )
+    if all_runners_valid:
+        bugs_fixed.append("valid_runners")
+
+    # Bug 3: Check checkout action parameters
+    checkout_params_valid = True
+    for job_name, job_config in jobs.items():
+        if not isinstance(job_config, dict):
+            continue
+        steps = job_config.get("steps", [])
+        if not isinstance(steps, list):
+            continue
+        for step in steps:
+            if not isinstance(step, dict):
+                continue
+            uses = step.get("uses", "")
+            if "actions/checkout" in str(uses):
+                with_params = step.get("with", {})
+                if isinstance(with_params, dict):
+                    for param_name in with_params.keys():
+                        if param_name not in VALID_CHECKOUT_PARAMS:
+                            checkout_params_valid = False
+                            error_messages.append(
+                                f"actions/checkout parameter '{param_name}' is invalid. "
+                                f"Did you mean 'fetch-depth'?"
+                            )
+    if checkout_params_valid:
+        bugs_fixed.append("checkout_params_valid")
+
+    # Bug 4: Check that env vars used with secrets are defined in env block
+    # This is more of a best-practice check - we'll check the env block exists on steps using secrets
+    env_usage_valid = True
+    for job_name, job_config in jobs.items():
+        if not isinstance(job_config, dict):
+            continue
+        steps = job_config.get("steps", [])
+        if not isinstance(steps, list):
+            continue
+        for step in steps:
+            if not isinstance(step, dict):
+                continue
+            step_env = step.get("env", {})
+            run_cmd = str(step.get("run", ""))
+            # Check if run uses env vars that aren't defined
+            if "${{" in run_cmd and "secrets." in run_cmd:
+                if not step_env:
+                    env_usage_valid = False
+                    error_messages.append(
+                        f"Step '{step.get('name', 'unnamed')}' references secrets "
+                        f"in run command but doesn't define them in env block."
+                    )
+    if env_usage_valid:
+        bugs_fixed.append("env_vars_defined")
+
+    # Bug 5: Check artifact name consistency between upload and download
+    upload_names = set()
+    download_names = set()
+    for job_name, job_config in jobs.items():
+        if not isinstance(job_config, dict):
+            continue
+        steps = job_config.get("steps", [])
+        if not isinstance(steps, list):
+            continue
+        for step in steps:
+            if not isinstance(step, dict):
+                continue
+            uses = str(step.get("uses", ""))
+            with_params = step.get("with", {})
+            if not isinstance(with_params, dict):
+                continue
+            if "upload-artifact" in uses:
+                name = with_params.get("name", "")
+                if name:
+                    upload_names.add(name)
+            elif "download-artifact" in uses:
+                name = with_params.get("name", "")
+                if name:
+                    download_names.add(name)
+
+    if download_names and upload_names:
+        if download_names.issubset(upload_names):
+            bugs_fixed.append("artifact_names_match")
+        else:
+            mismatched = download_names - upload_names
+            error_messages.append(
+                f"Artifact name mismatch: download references {sorted(mismatched)} "
+                f"but upload defines {sorted(upload_names)}. Names must match."
+            )
+    elif not download_names and not upload_names:
+        bugs_fixed.append("artifact_names_match")
+    else:
+        error_messages.append("Artifact upload/download configuration is incomplete")
+
+    # Calculate reward
+    reward = len(bugs_fixed) / total_bugs
+
+    if len(bugs_fixed) >= 1:
+        reward = min(1.0, reward + 0.1)
+
+    if len(bugs_fixed) == total_bugs:
+        reward = 1.0
+
+    error_msg = "; ".join(error_messages) if error_messages else "All checks passed!"
+    return reward, error_msg, bugs_fixed

server/graders/grader_api.py

@@ -0,0 +1,60 @@
+"""Grader API wrapper layer for OpenEnv validator compatibility.
+
+OpenEnv validator expects graders to:
+1. Be callable
+2. Return float only (not tuple)
+3. Return values in [0.0, 1.0] range
+
+Our graders return (reward, error_msg, bugs_fixed).
+This wrapper extracts just the float reward.
+"""
+
+from server.graders.json_grader import grade_task1 as _g1
+from server.graders.yaml_grader import grade_task2 as _g2
+from server.graders.dockerfile_grader import grade_task3 as _g3
+from server.graders.compose_grader import grade_task4 as _g4
+from server.graders.k8s_grader import grade_task5 as _g5
+from server.graders.github_actions_grader import grade_task6 as _g6
+from server.graders.nginx_grader import grade_task7 as _g7
+
+
+def _extract(result):
+    """Extract float reward from grader result tuple or return as-is if already float."""
+    if isinstance(result, tuple):
+        return float(result[0])
+    return float(result)
+
+
+def grade_task1(x):
+    """Task 1 (JSON) grader wrapper."""
+    return _extract(_g1(x))
+
+
+def grade_task2(x):
+    """Task 2 (YAML) grader wrapper."""
+    return _extract(_g2(x))
+
+
+def grade_task3(x):
+    """Task 3 (Dockerfile) grader wrapper."""
+    return _extract(_g3(x))
+
+
+def grade_task4(x):
+    """Task 4 (Docker Compose) grader wrapper."""
+    return _extract(_g4(x))
+
+
+def grade_task5(x):
+    """Task 5 (Kubernetes) grader wrapper."""
+    return _extract(_g5(x))
+
+
+def grade_task6(x):
+    """Task 6 (GitHub Actions) grader wrapper."""
+    return _extract(_g6(x))
+
+
+def grade_task7(x):
+    """Task 7 (Nginx) grader wrapper."""
+    return _extract(_g7(x))

server/graders/json_grader.py

@@ -0,0 +1,48 @@
+import json
+from typing import Tuple, List
+
+
+def grade_task1(submitted_config: str) -> Tuple[float, str, List[str]]:
+    """
+    Grade Task 1: Broken JSON Config (2 bugs)
+    Bug 1 (Syntax): Missing comma between key-value pairs
+    Bug 2 (Semantic): Wrong data type for "port" field (string instead of int)
+
+    Returns: (reward, error_message, bugs_fixed_list)
+    """
+    bugs_fixed = []
+    total_bugs = 2
+    error_messages = []
+
+    # Bug 1: Check if JSON parses (syntax layer)
+    try:
+        config = json.loads(submitted_config)
+        bugs_fixed.append("syntax_valid_json")
+    except json.JSONDecodeError as e:
+        error_messages.append(f"JSON parse error: {str(e)}")
+        reward = len(bugs_fixed) / total_bugs
+        return reward, "; ".join(error_messages), bugs_fixed
+
+    # Bug 2: Check port is integer (semantic layer)
+    if "port" in config:
+        if isinstance(config["port"], int):
+            bugs_fixed.append("port_is_integer")
+        else:
+            error_messages.append(
+                f"Field 'port' should be integer, got {type(config['port']).__name__}"
+            )
+    else:
+        error_messages.append("Missing required field: 'port'")
+
+    # Calculate reward
+    reward = len(bugs_fixed) / total_bugs
+
+    # Bonus for full parse
+    if len(bugs_fixed) >= 1:
+        reward = min(1.0, reward + 0.1)
+
+    if len(bugs_fixed) == total_bugs:
+        reward = 1.0
+
+    error_msg = "; ".join(error_messages) if error_messages else "All checks passed!"
+    return reward, error_msg, bugs_fixed

server/graders/k8s_grader.py

@@ -0,0 +1,64 @@
+import yaml
+from typing import Tuple, List
+
+
+def grade_task5(fixed_config: str) -> Tuple[float, str, List[str]]:
+    """
+    Grade Task 5: Multi-step Kubernetes Deployment YAML debugging.
+    
+    Bug 1: replicas = "three" (string, should be integer) → 0.4 reward
+    Bug 2: containerPort = "80" (string, should be integer) → +0.3 reward
+    Bug 3: cpu = "500" (missing 'm' suffix, should be "500m") → +0.3 reward
+    
+    Returns: (reward, error_message, bugs_fixed_list)
+    """
+    reward = 0.0
+    errors = []
+    fixed = []
+
+    # Parse YAML
+    try:
+        config = yaml.safe_load(fixed_config)
+    except Exception as e:
+        return 0.0, f"Invalid YAML format: {str(e)}", ["yaml"]
+
+    # --- STEP 1: replicas fix (0.0 → 0.4) ---
+    try:
+        replicas = config["spec"]["replicas"]
+        if isinstance(replicas, int):
+            reward += 0.4
+            fixed.append("replicas")
+        else:
+            errors.append("replicas must be an integer (not string)")
+    except Exception:
+        errors.append("missing or invalid replicas field")
+
+    # --- STEP 2: containerPort fix (0.4 → 0.7) ---
+    try:
+        port = config["spec"]["template"]["spec"]["containers"][0]["ports"][0]["containerPort"]
+        if isinstance(port, int):
+            reward += 0.3
+            fixed.append("port")
+        else:
+            errors.append("containerPort must be integer (not string)")
+    except Exception:
+        errors.append("missing or invalid containerPort")
+
+    # --- STEP 3: cpu resource unit fix (0.7 → 1.0) ---
+    try:
+        cpu = config["spec"]["template"]["spec"]["containers"][0]["resources"]["limits"]["cpu"]
+        if isinstance(cpu, str) and cpu.endswith("m"):
+            reward += 0.3
+            fixed.append("cpu")
+        else:
+            errors.append("cpu must be in millicores format (e.g., 500m, not plain integer)")
+    except Exception:
+        errors.append("missing or invalid cpu limit")
+
+    reward = round(min(reward, 1.0), 2)
+
+    if reward == 1.0:
+        return 1.0, "Deployment config is fully valid", fixed
+
+    error_msg = " ; ".join(errors) if errors else "Configuration has issues"
+    return reward, error_msg, fixed

server/graders/nginx_grader.py

@@ -0,0 +1,49 @@
+from typing import Tuple, List
+
+
+def grade_task7(fixed_config: str) -> Tuple[float, str, List[str]]:
+    """
+    Grade Task 7: Multi-step nginx config debugging.
+    
+    Bug 1: Missing semicolons in listen and error_log directives → 0.3 reward
+    Bug 2: Missing http:// prefix in proxy_pass directive → +0.3 reward
+    Bug 3: Improper routing with missing API endpoint headers → +0.4 reward
+    
+    Returns: (reward, error_message, bugs_fixed_list)
+    """
+    reward = 0.0
+    errors = []
+    fixed = []
+
+    config = fixed_config.strip()
+
+    # --- STEP 1: Syntax checks (semicolons) ---
+    if "listen 80;" in config and "error_log logs/error.log;" in config:
+        reward += 0.3
+        fixed.append("syntax")
+    else:
+        errors.append("Missing semicolon in listen or error_log directives")
+
+    # --- STEP 2: Directive correctness (proxy_pass protocol) ---
+    if "proxy_pass http://localhost:3000;" in config:
+        reward += 0.3
+        fixed.append("proxy_pass")
+    else:
+        errors.append("proxy_pass for / must include http:// protocol prefix (e.g., http://localhost:3000;)")
+
+    # --- STEP 3: Routing logic (API endpoint with headers) ---
+    if ("location /api/" in config or "location /api {" in config):
+        if "proxy_set_header Host" in config and "proxy_set_header X-Real-IP" in config:
+            reward += 0.4
+            fixed.append("routing")
+        else:
+            errors.append("API routing missing required proxy headers (Host and X-Real-IP)")
+    else:
+        errors.append("Improper API route configuration (use 'location /api/' with headers)")
+
+    reward = round(min(reward, 1.0), 2)
+
+    if reward == 1.0:
+        return 1.0, "Nginx config fully valid", fixed
+
+    return reward, " ; ".join(errors), fixed

server/graders/yaml_grader.py

@@ -0,0 +1,51 @@
+import yaml
+from typing import Tuple, List
+
+
+def grade_task2(submitted_config: str) -> Tuple[float, str, List[str]]:
+    """
+    Grade Task 2: Broken YAML Config (2 bugs)
+    Bug 1 (Syntax): Wrong indentation on nested key (3 spaces instead of 2)
+    Bug 2 (Semantic): Missing required field "version"
+
+    Returns: (reward, error_message, bugs_fixed_list)
+    """
+    bugs_fixed = []
+    total_bugs = 2
+    error_messages = []
+
+    # Bug 1: Check if YAML parses (syntax layer)
+    try:
+        config = yaml.safe_load(submitted_config)
+        if isinstance(config, dict):
+            bugs_fixed.append("syntax_valid_yaml")
+        else:
+            error_messages.append("YAML parsed but result is not a mapping/dictionary")
+            reward = len(bugs_fixed) / total_bugs
+            return reward, "; ".join(error_messages), bugs_fixed
+    except yaml.YAMLError as e:
+        error_messages.append(f"YAML parse error: {str(e)}")
+        reward = len(bugs_fixed) / total_bugs
+        return reward, "; ".join(error_messages), bugs_fixed
+
+    # Bug 2: Check required field "version" exists
+    service = config.get("service", config)
+    if isinstance(service, dict) and "version" in service:
+        bugs_fixed.append("version_field_present")
+    else:
+        error_messages.append(
+            "Missing required field: 'version' under 'service'"
+        )
+
+    # Calculate reward
+    reward = len(bugs_fixed) / total_bugs
+
+    # Bonus for full parse
+    if len(bugs_fixed) >= 1:
+        reward = min(1.0, reward + 0.1)
+
+    if len(bugs_fixed) == total_bugs:
+        reward = 1.0
+
+    error_msg = "; ".join(error_messages) if error_messages else "All checks passed!"
+    return reward, error_msg, bugs_fixed

server/models.py

@@ -0,0 +1,41 @@
+from typing import List, Optional
+from openenv.core.env_server import Action, Observation, State
+
+
+class ConfigDebugAction(Action):
+    """Action: the agent submits a fixed configuration file"""
+    fixed_config: str  # The corrected configuration file content
+
+
+class ConfigDebugObservation(Observation):
+    """Observation: what the agent sees.
+    Inherits done: bool, reward: Optional[float], metadata from Observation.
+    """
+    broken_config: str = ""
+    file_type: str = ""
+    error_message: str = ""
+    task_id: str = ""
+    task_description: str = ""
+    difficulty: str = ""
+    num_bugs: int = 0
+    bugs_found_so_far: int = 0
+    previous_reward: float = 0.0
+
+
+class ConfigDebugState(State):
+    """Full environment state.
+    Inherits episode_id: Optional[str], step_count: int from State.
+    """
+    current_task_id: str = ""
+    current_step: int = 0
+    max_steps: int = 5
+    total_reward: float = 0.0
+    is_done: bool = False
+    tasks_completed: List[str] = []
+    tasks_remaining: List[str] = []
+    
+    # Enhanced state fields for better RL signal
+    bugs_found_so_far: int = 0
+    current_error_message: Optional[str] = None
+    progress_ratio: float = 0.0
+    current_difficulty: Optional[str] = None

server/requirements.txt

@@ -0,0 +1,8 @@
+fastapi
+uvicorn
+pydantic
+pyyaml
+httpx
+openai
+gradio
+openenv-core>=0.2.0

server/tasks/task1_json.py

@@ -0,0 +1,31 @@
+TASK_ID = "task1_json"
+DIFFICULTY = "easy"
+FILE_TYPE = "json"
+NUM_BUGS = 2
+
+DESCRIPTION = (
+    "A simple application configuration file in JSON format. "
+    "It should define the app name, port (as integer), host, and debug mode."
+)
+
+# The broken config (what the agent sees)
+# Bug 1 (Syntax): Missing comma after "my-service"
+# Bug 2 (Semantic): port is string "8080" instead of integer 8080
+BROKEN_CONFIG = """{
+    "app_name": "my-service"
+    "port": "8080",
+    "host": "0.0.0.0",
+    "debug": true
+}"""
+
+ERROR_MESSAGE = (
+    "JSON parse error: Expecting ',' delimiter: line 3 column 5 (char 33). "
+    "Additionally, there may be type issues with some fields."
+)
+
+GROUND_TRUTH = """{
+    "app_name": "my-service",
+    "port": 8080,
+    "host": "0.0.0.0",
+    "debug": true
+}"""

server/tasks/task2_yaml.py

@@ -0,0 +1,43 @@
+TASK_ID = "task2_yaml"
+DIFFICULTY = "easy"
+FILE_TYPE = "yaml"
+NUM_BUGS = 2
+
+DESCRIPTION = (
+    "A service configuration file in YAML format. "
+    "It should define the service name, version, port, host, database settings, "
+    "and logging configuration with proper indentation and all required fields."
+)
+
+# The broken config (what the agent sees)
+# Bug 1 (Syntax): Wrong indentation on nested key (3 spaces instead of 2)
+# Bug 2 (Semantic): Missing required field "version"
+BROKEN_CONFIG = """service:
+  name: my-service
+  port: 8080
+  host: 0.0.0.0
+  database:
+     host: localhost
+     port: 5432
+   name: mydb
+  logging:
+    level: info
+    format: json"""
+
+ERROR_MESSAGE = (
+    "YAML parse error: mapping values are not allowed in this context. "
+    "Additionally, the configuration may be missing required fields."
+)
+
+GROUND_TRUTH = """service:
+  name: my-service
+  version: "1.0.0"
+  port: 8080
+  host: 0.0.0.0
+  database:
+    host: localhost
+    port: 5432
+    name: mydb
+  logging:
+    level: info
+    format: json"""

server/tasks/task3_dockerfile.py

@@ -0,0 +1,47 @@
+TASK_ID = "task3_dockerfile"
+DIFFICULTY = "medium"
+FILE_TYPE = "dockerfile"
+NUM_BUGS = 3
+
+DESCRIPTION = (
+    "A Dockerfile for a Python web application. It should use the python:3.9-slim "
+    "base image, install dependencies from requirements.txt, copy the application code, "
+    "expose port 8000, and run the application with uvicorn."
+)
+
+# Bug 1 (Syntax): Wrong escape character for multi-line RUN (using ^ instead of \)
+# Bug 2 (Semantic): Wrong base image tag (python:3.9-slm instead of python:3.9-slim)
+# Bug 3 (Runtime): Missing EXPOSE directive for the application port
+BROKEN_CONFIG = """FROM python:3.9-slm
+
+WORKDIR /app
+
+COPY requirements.txt .
+
+RUN pip install --no-cache-dir -r requirements.txt ^
+    && pip install uvicorn
+
+COPY . .
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]"""
+
+ERROR_MESSAGE = (
+    "Dockerfile build error: failed to resolve base image 'python:3.9-slm'. "
+    "Additionally, the RUN command may have syntax issues with multi-line continuation, "
+    "and the container may not be accessible on the expected port."
+)
+
+GROUND_TRUTH = """FROM python:3.9-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+
+RUN pip install --no-cache-dir -r requirements.txt \\
+    && pip install uvicorn
+
+COPY . .
+
+EXPOSE 8000
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]"""

server/tasks/task4_compose.py

@@ -0,0 +1,99 @@
+TASK_ID = "task4_compose"
+DIFFICULTY = "medium"
+FILE_TYPE = "docker-compose"
+NUM_BUGS = 4
+
+DESCRIPTION = (
+    "A docker-compose.yml file for a multi-service application with a web frontend "
+    "(Node.js app running on port 3000), a PostgreSQL database, and a Redis cache. "
+    "Services should be connected via a custom network and the web service should "
+    "depend on the database and cache services."
+)
+
+# Bug 1 (Syntax): Wrong indentation on volumes key
+# Bug 2 (Semantic): Service references non-existent network name
+# Bug 3 (Runtime): Port mapping "8080:80" should be "8080:3000" (app runs on 3000)
+# Bug 4 (Integration): depends_on references "postgres" but service is defined as "db"
+BROKEN_CONFIG = """version: "3.8"
+
+services:
+  web:
+    build: ./app
+    ports:
+      - "8080:80"
+    environment:
+      - DATABASE_URL=postgresql://user:pass@db:5432/mydb
+      - REDIS_URL=redis://cache:6379
+    depends_on:
+      - postgres
+      - cache
+    networks:
+      - frontend-net
+
+  db:
+    image: postgres:15
+    environment:
+      - POSTGRES_USER=user
+      - POSTGRES_PASSWORD=pass
+      - POSTGRES_DB=mydb
+  volumes:
+      - db-data:/var/lib/postgresql/data
+    networks:
+      - backend-net
+
+  cache:
+    image: redis:7-alpine
+    networks:
+      - backend-net
+
+networks:
+  app-network:
+    driver: bridge
+
+volumes:
+  db-data:"""
+
+ERROR_MESSAGE = (
+    "docker-compose config error: yaml parse error near 'volumes' key. "
+    "Additionally, there are issues with service references, network names, "
+    "and port mappings that need to be fixed."
+)
+
+GROUND_TRUTH = """version: "3.8"
+
+services:
+  web:
+    build: ./app
+    ports:
+      - "8080:3000"
+    environment:
+      - DATABASE_URL=postgresql://user:pass@db:5432/mydb
+      - REDIS_URL=redis://cache:6379
+    depends_on:
+      - db
+      - cache
+    networks:
+      - app-network
+
+  db:
+    image: postgres:15
+    environment:
+      - POSTGRES_USER=user
+      - POSTGRES_PASSWORD=pass
+      - POSTGRES_DB=mydb
+    volumes:
+      - db-data:/var/lib/postgresql/data
+    networks:
+      - app-network
+
+  cache:
+    image: redis:7-alpine
+    networks:
+      - app-network
+
+networks:
+  app-network:
+    driver: bridge
+
+volumes:
+  db-data:"""

server/tasks/task5_k8s.py

@@ -0,0 +1,66 @@
+TASK_ID = "task5_k8s"
+DIFFICULTY = "hard"
+FILE_TYPE = "kubernetes"
+NUM_BUGS = 3
+
+DESCRIPTION = (
+    "A Kubernetes Deployment manifest with multi-step bugs. Requires fixing replicas type, "
+    "containerPort type, and CPU resource units. Each fix provides intermediate feedback."
+)
+
+# Bug 1 (Type): replicas = "three" (string, should be integer)
+# Bug 2 (Type): containerPort = "80" (string, should be integer)
+# Bug 3 (Domain): cpu = "500" (missing 'm' suffix, should be "500m")
+BROKEN_CONFIG = """apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: my-app
+spec:
+  replicas: "three"
+  selector:
+    matchLabels:
+      app: my-app
+  template:
+    metadata:
+      labels:
+        app: my-app
+    spec:
+      containers:
+        - name: my-container
+          image: nginx
+          ports:
+            - containerPort: "80"
+          resources:
+            limits:
+              cpu: "500"
+"""
+
+ERROR_MESSAGE = (
+    "Kubernetes manifest has type and unit errors: replicas must be integer, "
+    "containerPort must be integer, and cpu must include millicores unit (e.g., 500m)."
+)
+
+GROUND_TRUTH = """apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: my-app
+spec:
+  replicas: 3
+  selector:
+    matchLabels:
+      app: my-app
+  template:
+    metadata:
+      labels:
+        app: my-app
+    spec:
+      containers:
+        - name: my-container
+          image: nginx
+          ports:
+            - containerPort: 80
+          resources:
+            limits:
+              cpu: "500m"
+"""
+

server/tasks/task6_github_actions.py

@@ -0,0 +1,124 @@
+TASK_ID = "task6_github_actions"
+DIFFICULTY = "hard"
+FILE_TYPE = "github-actions"
+NUM_BUGS = 5
+
+DESCRIPTION = (
+    "A GitHub Actions workflow that builds a Node.js application on push to main, "
+    "runs tests, uploads a build artifact, and deploys it. It should use ubuntu-latest "
+    "runner, checkout the code, setup Node.js, install deps, build, upload artifact as "
+    "'build-output', and download the same artifact in the deploy job."
+)
+
+# Bug 1 (Syntax): Missing colon after "on" trigger value (push should be on:\n  push:)
+# Bug 2 (Semantic): runs-on uses "ubuntu-latets" (typo, should be "ubuntu-latest")
+# Bug 3 (Semantic): Step uses actions/checkout@v2 but with has invalid parameter name
+# Bug 4 (Runtime): Environment variable referenced but not defined in env block
+# Bug 5 (Integration): Build step artifact name "build-output" but deploy references "build-artifact"
+BROKEN_CONFIG = """name: CI/CD Pipeline
+
+on
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  build:
+    runs-on: ubuntu-latets
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-deph: 0
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '18'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run tests
+        run: npm test
+        env:
+          API_ENDPOINT: ${{ secrets.API_KEY }}
+
+      - name: Build
+        run: npm run build
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: build-output
+          path: dist/
+
+  deploy:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: build-artifact
+
+      - name: Deploy
+        run: echo "Deploying..."
+"""
+
+ERROR_MESSAGE = (
+    "GitHub Actions workflow error: YAML parse error near 'on' key. "
+    "Additionally, the runner name may have a typo, an action parameter name is invalid, "
+    "environment variables may be misconfigured, and artifact names between jobs may not match."
+)
+
+GROUND_TRUTH = """name: CI/CD Pipeline
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '18'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run tests
+        run: npm test
+        env:
+          API_ENDPOINT: ${{ secrets.API_KEY }}
+
+      - name: Build
+        run: npm run build
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: build-output
+          path: dist/
+
+  deploy:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: build-output
+
+      - name: Deploy
+        run: echo "Deploying..."
+"""

server/tasks/task7_nginx.py

@@ -0,0 +1,57 @@
+TASK_ID = "task7_nginx"
+DIFFICULTY = "very_hard"
+FILE_TYPE = "nginx"
+NUM_BUGS = 3
+
+DESCRIPTION = (
+    "An nginx reverse proxy configuration with multi-step bugs. "
+    "Requires fixing syntax (semicolons), directives (protocol), and routing logic (headers)."
+)
+
+# Bug 1 (Syntax): Missing semicolons in listen and error_log directives
+# Bug 2 (Directive): proxy_pass missing http:// protocol prefix
+# Bug 3 (Logic): Improper routing with missing headers for API endpoint
+BROKEN_CONFIG = """events {}
+
+http {
+    server {
+        listen 80
+
+        location / {
+            proxy_pass localhost:3000
+        }
+
+        location /api {
+            proxy_pass http://localhost:5000
+            proxy_set_header Host $host
+            proxy_set_header X-Real-IP $remote_addr
+        }
+
+        error_log logs/error.log
+    }
+}"""
+
+ERROR_MESSAGE = (
+    "nginx configuration has syntax, directive, and routing errors: "
+    "missing semicolons, missing http:// prefix in proxy_pass, and improper API routing."
+)
+
+GROUND_TRUTH = """events {}
+
+http {
+    server {
+        listen 80;
+
+        location / {
+            proxy_pass http://localhost:3000;
+        }
+
+        location /api/ {
+            proxy_pass http://localhost:5000;
+            proxy_set_header Host $host;
+            proxy_set_header X-Real-IP $remote_addr;
+        }
+
+        error_log logs/error.log;
+    }
+}"""

server/tasks/task_registry.py

@@ -0,0 +1,53 @@
+from typing import Callable, Dict, Tuple, List
+
+from server.tasks import task1_json, task2_yaml, task3_dockerfile
+from server.tasks import task4_compose, task5_k8s, task6_github_actions, task7_nginx
+from server.graders.json_grader import grade_task1
+from server.graders.yaml_grader import grade_task2
+from server.graders.dockerfile_grader import grade_task3
+from server.graders.compose_grader import grade_task4
+from server.graders.k8s_grader import grade_task5
+from server.graders.github_actions_grader import grade_task6
+from server.graders.nginx_grader import grade_task7
+
+
+class TaskInfo:
+    def __init__(self, module, grader_func: Callable):
+        self.task_id: str = module.TASK_ID
+        self.difficulty: str = module.DIFFICULTY
+        self.file_type: str = module.FILE_TYPE
+        self.num_bugs: int = module.NUM_BUGS
+        self.description: str = module.DESCRIPTION
+        self.broken_config: str = module.BROKEN_CONFIG
+        self.error_message: str = module.ERROR_MESSAGE
+        self.ground_truth: str = module.GROUND_TRUTH
+        self.grader: Callable[[str], Tuple[float, str, List[str]]] = grader_func
+
+
+TASK_ORDER = [
+    "task1_json",
+    "task2_yaml",
+    "task3_dockerfile",
+    "task4_compose",
+    "task5_k8s",
+    "task6_github_actions",
+    "task7_nginx",
+]
+
+TASK_REGISTRY: Dict[str, TaskInfo] = {
+    "task1_json": TaskInfo(task1_json, grade_task1),
+    "task2_yaml": TaskInfo(task2_yaml, grade_task2),
+    "task3_dockerfile": TaskInfo(task3_dockerfile, grade_task3),
+    "task4_compose": TaskInfo(task4_compose, grade_task4),
+    "task5_k8s": TaskInfo(task5_k8s, grade_task5),
+    "task6_github_actions": TaskInfo(task6_github_actions, grade_task6),
+    "task7_nginx": TaskInfo(task7_nginx, grade_task7),
+}
+
+
+def get_task(task_id: str) -> TaskInfo:
+    return TASK_REGISTRY[task_id]
+
+
+def get_all_task_ids() -> List[str]:
+    return list(TASK_ORDER)

test_env.py

@@ -0,0 +1,21 @@
+from server.config_debug_environment import ConfigDebugEnvironment
+from server.models import ConfigDebugAction
+from server.tasks.task_registry import get_task
+
+env = ConfigDebugEnvironment()
+
+# ONLY ONE RESET
+obs = env.reset()
+
+for i in range(3):
+    print(f"\n--- Step {i+1} ---")
+
+    task = get_task(obs.task_id)
+    correct_output = task.ground_truth
+
+    action = ConfigDebugAction(fixed_config=correct_output)
+    obs = env.step(action)
+
+    print("Task ID:", obs.task_id)
+    print("Reward:", obs.reward)
+    print("Done:", obs.done)

test_k8s_multistep.py

@@ -0,0 +1,88 @@
+from server.graders.k8s_grader import grade_task5
+
+# Test 1: Only fix replicas
+config1 = """apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: my-app
+spec:
+  replicas: 3
+  selector:
+    matchLabels:
+      app: my-app
+  template:
+    metadata:
+      labels:
+        app: my-app
+    spec:
+      containers:
+        - name: my-container
+          image: nginx
+          ports:
+            - containerPort: "80"
+          resources:
+            limits:
+              cpu: "500"
+"""
+
+reward1, msg1, fixed1 = grade_task5(config1)
+print(f'Step 1 (replicas fixed): Reward={reward1}, Fixed={fixed1}')
+print(f'  Error: {msg1}\n')
+
+# Test 2: Fix replicas + port
+config2 = """apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: my-app
+spec:
+  replicas: 3
+  selector:
+    matchLabels:
+      app: my-app
+  template:
+    metadata:
+      labels:
+        app: my-app
+    spec:
+      containers:
+        - name: my-container
+          image: nginx
+          ports:
+            - containerPort: 80
+          resources:
+            limits:
+              cpu: "500"
+"""
+
+reward2, msg2, fixed2 = grade_task5(config2)
+print(f'Step 2 (replicas + port fixed): Reward={reward2}, Fixed={fixed2}')
+print(f'  Error: {msg2}\n')
+
+# Test 3: Fix everything
+config3 = """apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: my-app
+spec:
+  replicas: 3
+  selector:
+    matchLabels:
+      app: my-app
+  template:
+    metadata:
+      labels:
+        app: my-app
+    spec:
+      containers:
+        - name: my-container
+          image: nginx
+          ports:
+            - containerPort: 80
+          resources:
+            limits:
+              cpu: "500m"
+"""
+
+reward3, msg3, fixed3 = grade_task5(config3)
+print(f'Step 3 (all fixed): Reward={reward3}, Fixed={fixed3}')
+print(f'  Message: {msg3}')

test_nginx_multistep.py

@@ -0,0 +1,72 @@
+from server.graders.nginx_grader import grade_task7
+
+# Test 1: Only fix syntax (listen and error_log semicolons)
+config1 = """events {}
+
+http {
+    server {
+        listen 80;
+
+        location / {
+            proxy_pass localhost:3000
+        }
+
+        location /api {
+            proxy_pass http://localhost:5000
+        }
+
+        error_log logs/error.log;
+    }
+}"""
+
+reward1, msg1, fixed1 = grade_task7(config1)
+print(f'Step 1 (syntax fixed): Reward={reward1}, Fixed={fixed1}')
+print(f'  Error: {msg1}\n')
+
+# Test 2: Fix syntax + proxy_pass (add http://)
+config2 = """events {}
+
+http {
+    server {
+        listen 80;
+
+        location / {
+            proxy_pass http://localhost:3000;
+        }
+
+        location /api {
+            proxy_pass http://localhost:5000
+        }
+
+        error_log logs/error.log;
+    }
+}"""
+
+reward2, msg2, fixed2 = grade_task7(config2)
+print(f'Step 2 (syntax + proxy_pass fixed): Reward={reward2}, Fixed={fixed2}')
+print(f'  Error: {msg2}\n')
+
+# Test 3: Fix everything (add /api/ and headers)
+config3 = """events {}
+
+http {
+    server {
+        listen 80;
+
+        location / {
+            proxy_pass http://localhost:3000;
+        }
+
+        location /api/ {
+            proxy_pass http://localhost:5000;
+            proxy_set_header Host $host;
+            proxy_set_header X-Real-IP $remote_addr;
+        }
+
+        error_log logs/error.log;
+    }
+}"""
+
+reward3, msg3, fixed3 = grade_task7(config3)
+print(f'Step 3 (all fixed): Reward={reward3}, Fixed={fixed3}')
+print(f'  Message: {msg3}')