Initial changes for ai-debugger

.gitignore

@@ -0,0 +1,10 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+.env
+.venv/
+venv/
+dist/
+build/
+*.log
+.DS_Store

Dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Install dependencies first 
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy project
+COPY . .
+
+# Default: run inference script across all 3 tasks
+CMD ["python", "inference.py"]

README copy.md

@@ -0,0 +1,211 @@
+# DebugOps: AI Incident Response Environment
+
+## Overview
+
+**DebugOps** is a reinforcement-learning environment that simulates real-world production incident response. An AI agent acts as an on-call Site Reliability Engineer (SRE), diagnosing system failures from noisy logs and degraded metrics, then executing the correct multi-step remediation sequence.
+
+The environment models real DevOps/SRE workflows from cloud infrastructure and distributed systems — unlike toy environments, fixes require correct *ordered* sequences and the agent must separate signal from noise in log data.
+
+Built with the [OpenEnv](https://github.com/raun/openenv-course) framework for the Meta × PyTorch Hackathon.
+
+---
+
+## Environment Description
+
+At each step the agent receives an **observation** containing:
+- **services** — per-service health (api, db, cache)
+- **logs** — system log lines, some of which are noisy red herrings
+- **metrics** — latency (ms), error_rate (0–1), cpu (%)
+- **time_step** — elapsed steps
+
+The agent must identify the hidden root cause and execute the correct multi-step fix sequence before the episode times out. System metrics degrade every step, creating real urgency.
+
+---
+
+### Observation Space
+
+| Field | Type | Description |
+|---|---|---|
+| `services` | `Dict[str, str]` | Service health: `healthy` or `degraded` |
+| `logs` | `List[str]` | System logs (may include noise/red herrings) |
+| `metrics.latency` | `float` | Current system latency (ms) |
+| `metrics.error_rate` | `float` | Error rate (0.0–1.0) |
+| `metrics.cpu` | `float` | CPU utilisation (%) |
+| `time_step` | `int` | Steps elapsed in this episode |
+
+---
+
+### Action Space (discrete, 5 actions)
+
+| Action | Description |
+|---|---|
+| `restart_api` | Restart the API service |
+| `restart_db` | Restart the database service |
+| `restart_cache` | Restart the cache service |
+| `scale_up` | Add compute capacity |
+| `noop` | Take no action |
+
+---
+
+### Root Causes & Fix Sequences
+
+| Root Cause | Fix Sequence | Affected Services |
+|---|---|---|
+| `api_timeout` | `scale_up → restart_api` | api |
+| `db_connection_leak` | `restart_db → scale_up` | db |
+| `cache_miss_storm` | `restart_cache → scale_up` | cache |
+| `memory_leak` | `restart_api → restart_db` | api, db |
+
+Actions must be performed **in order** — wrong steps degrade metrics further.
+
+---
+
+### Reward Function
+
+```
+reward =
+  +150   full resolution bonus
+  + 30   correct intermediate fix step
+  - 15   wrong action (no progress)
+  -0.04  × latency (ms) per step
+  - 25   × error_rate per step
+  -  2   time penalty per step (escalates after step 10)
+```
+
+The shaped reward provides dense signal throughout the episode, not just at termination.
+
+---
+
+## Tasks
+
+| Task | Module | Description | Max Steps | Difficulty |
+|---|---|---|---|---|
+| Simple | `tasks.task_simple` | Single-service failure | 15 | Low |
+| Multi-Service | `tasks.task_multi_service` | Two services degrade simultaneously | 12 | Medium |
+| Critical | `tasks.task_critical` | Memory-leak with misleading logs + SLA penalties | 10 | High |
+
+---
+
+## Setup
+
+```bash
+# Clone the repo
+git clone <your-repo-url>
+cd debugops
+
+# Install dependencies
+pip install -r requirements.txt
+```
+
+---
+
+## Running Inference (LLM Agent)
+
+```bash
+python inference.py
+```
+
+Expected output:
+
+```
+[START] task=simple env=debugops model=Qwen/Qwen2.5-72B-Instruct
+[STEP] step=0 action=scale_up reward=-18.4 done=false error=null
+[STEP] step=1 action=restart_api reward=145.3 done=true error=null
+[END] success=true steps=2 score=0.881 rewards=-18.4,145.3
+```
+
+If `HF_TOKEN` is not set, the heuristic fallback agent is used automatically — no API key required.
+
+---
+
+## Running the Baseline Agent
+
+```bash
+python app.py
+```
+
+---
+
+## Grader
+
+```bash
+python -m grader.grader
+```
+
+The grader scores each episode in `[0.0, 1.0]` using a weighted formula:
+
+| Component | Weight | Description |
+|---|---|---|
+| Resolution | 50% | Was the incident resolved? |
+| Efficiency | 30% | How quickly was it resolved? |
+| Quality | 20% | Normalised average reward |
+
+---
+
+## Pre-submission Validation
+
+```bash
+python scripts/validate_submission.py
+# or
+bash scripts/validate-submission.sh
+```
+
+---
+
+## Docker
+
+```bash
+# Build
+docker build -t debugops-env .
+
+# Run (heuristic agent, no key required)
+docker run debugops-env
+
+# Run with LLM agent
+docker run -e HF_TOKEN=your_token \
+           -e API_BASE_URL=https://router.huggingface.co/v1 \
+           -e MODEL_NAME=Qwen/Qwen2.5-72B-Instruct \
+           debugops-env
+```
+
+---
+
+## Project Structure
+
+```
+.
+├── inference.py              ← Main LLM inference script (required entry point)
+├── app.py                    ← Lightweight local runner (baseline agent)
+├── Dockerfile
+├── requirements.txt
+├── openenv.yaml              ← OpenEnv spec
+├── README.md
+├── env/
+│   ├── environment.py        ← DebugEnv class (reset/step/state)
+│   ├── dynamics.py           ← State transition logic
+│   ├── reward.py             ← Shaped reward function
+│   └── incident_generator.py ← Random incident sampling
+├── tasks/
+│   ├── task_simple.py
+│   ├── task_multi_service.py
+│   └── task_critical.py
+├── agent/
+│   └── baseline.py           ← Heuristic baseline agent
+├── grader/
+│   └── grader.py             ← Episode evaluator → score in [0, 1]
+└── scripts/
+    ├── validate_submission.py
+    └── validate-submission.sh
+```
+
+---
+
+## Design Decisions
+
+**Why multi-step fix sequences?** Single-action fixes are trivially solved by keyword matching. Requiring ordered sequences forces the agent to model state transitions, not just classify root causes.
+
+**Why noisy logs?** Real production systems always emit irrelevant log lines. An agent that cannot filter noise will be unreliable.
+
+**Why escalating time penalties?** Incident SLAs are real constraints — an agent that solves the issue in 10 steps is materially worse than one that solves it in 2.
+
+**Why shaped rewards?** Sparse rewards (terminal-only) are notoriously hard to learn from. Continuous metric penalties and partial-progress bonuses provide useful gradient signal at every step.

agent/__init__.py

@@ -0,0 +1 @@
+from agent.baseline import act, reset_history

agent/baseline.py

@@ -0,0 +1,103 @@
+#Baseline agent — heuristic rule-based agent for the DebugOps environment.
+
+# Strategy
+# --------
+# 1. Parse log keywords to identify the most likely root cause.
+# 2. Track own action history to avoid repeating wrong actions.
+# 3. Fall back to metric-based decisions when logs are ambiguous.
+# 4. Use the multi-step fix sequences documented in dynamics.py.
+from __future__ import annotations
+from typing import Dict, Any, List
+
+
+# Known fix sequences per root cause (mirrors dynamics.py FIX_MAP)
+_FIX_SEQUENCES: Dict[str, List[str]] = {
+    "api_timeout":        ["scale_up",    "restart_api"],
+    "db_connection_leak": ["restart_db",  "scale_up"],
+    "cache_miss_storm":   ["restart_cache", "scale_up"],
+    "memory_leak":        ["restart_api", "restart_db"],
+}
+
+# Log keywords → probable root cause
+_LOG_SIGNALS: Dict[str, str] = {
+    "timeout":      "api_timeout",
+    "upstream":     "api_timeout",
+    "connections":  "db_connection_leak",
+    "db pool":      "db_connection_leak",
+    "db":           "db_connection_leak",
+    "cache miss":   "cache_miss_storm",
+    "cache":        "cache_miss_storm",
+    "memory":       "memory_leak",
+    "oom":          "memory_leak",
+    "heap":         "memory_leak",
+}
+
+# Module-level action history (reset at the start of each episode call)
+_action_history: List[str] = []
+
+
+def reset_history() -> None:
+    """Call at the start of a new episode to clear action memory."""
+    global _action_history
+    _action_history = []
+
+
+def act(state: Dict[str, Any]) -> str:
+    """
+    Choose the next action given the current observation.
+
+    Parameters
+    ----------
+    state : dict with keys services, logs, metrics, time_step
+
+    Returns
+    -------
+    str : one of restart_api | restart_db | restart_cache | scale_up | noop
+    """
+    logs_text = " ".join(state.get("logs", [])).lower()
+    metrics   = state.get("metrics", {})
+
+    # Step 1: identify probable root cause from logs
+    cause = _infer_cause(logs_text)
+
+    if cause:
+        seq = _FIX_SEQUENCES[cause]
+        # Determine how many steps of this sequence we've already issued
+        progress = _count_progress(seq, _action_history)
+        if progress < len(seq):
+            action = seq[progress]
+            _action_history.append(action)
+            return action
+
+    # Step 2: metric-based fallback
+    if metrics.get("cpu", 0) > 80 and "scale_up" not in _action_history:
+        _action_history.append("scale_up")
+        return "scale_up"
+
+    if metrics.get("error_rate", 0) > 0.5 and "restart_api" not in _action_history:
+        _action_history.append("restart_api")
+        return "restart_api"
+
+    # Step 3: try any unused action (avoid noop loops) 
+    for a in ["restart_api", "restart_db", "restart_cache", "scale_up"]:
+        if _action_history.count(a) < 2:
+            _action_history.append(a)
+            return a
+
+    _action_history.append("noop")
+    return "noop"
+
+def _infer_cause(logs_text: str) -> str | None:
+    for keyword, cause in _LOG_SIGNALS.items():
+        if keyword in logs_text:
+            return cause
+    return None
+
+
+def _count_progress(seq: List[str], history: List[str]) -> int:
+    # Count how many leading actions of `seq` appear in `history` in order.
+    idx = 0
+    for action in history:
+        if idx < len(seq) and action == seq[idx]:
+            idx += 1
+    return idx

app.py

@@ -0,0 +1,56 @@
+"""
+app.py — quick local episode runner using the heuristic baseline agent.
+
+Usage
+    python app.py
+
+This runs a single episode of the Simple task using the rule-based agent
+and prints a per-step log. It is intentionally lightweight and dependency-free
+(no LLM API key required) so it works out of the box.
+"""
+from __future__ import annotations
+from typing import Any, Dict, List
+
+from tasks.task_simple import create_env
+from agent.baseline import act, reset_history
+
+
+def run_episode() -> List[Dict[str, Any]]:
+    env   = create_env()
+    state = env.reset()
+    reset_history()
+
+    logs: List[Dict[str, Any]] = []
+    done  = False
+    step  = 0
+
+    print("[app.py] Starting simple-task episode with heuristic baseline agent.")
+
+    while not done:
+        action = act(state)
+        next_state, reward, done, info = env.step(action)
+
+        logs.append({
+            "step":   step,
+            "state":  state,
+            "action": action,
+            "reward": round(reward, 3),
+            "info":   info,
+        })
+
+        print(
+            f"  step={step} action={action:<15} reward={round(reward, 3):>8.3f} "
+            f"resolved={str(info.get('resolved', False)).lower()}"
+        )
+
+        state = next_state
+        step += 1
+
+    success = any(e["info"].get("resolved", False) for e in logs)
+    print(f"\n[app.py] Episode finished — steps={step} success={str(success).lower()}")
+    return logs
+
+
+if __name__ == "__main__":
+    logs = run_episode()
+    print(f"Steps: {len(logs)}")

env/__init__.py

@@ -0,0 +1 @@
+from env.environment import DebugEnv

env/dynamics.py

@@ -0,0 +1,51 @@
+"""
+Dynamics - state transition logic for the DebugOps environment.
+The agent must perform the correct multi-step fix sequence to resolve
+an incident. Wrong actions degrade system metrics.
+"""
+from __future__ import annotations
+from typing import Dict, Any
+
+
+def apply_action(state: Dict[str, Any], action: str) -> Dict[str, Any]:
+    """
+    Mutate-and-return state after the agent takes `action`.
+
+    Resolution logic
+    ----------------
+    Each root cause has a `fix_sequence` list stored inside state.
+    The agent must perform each action in order:
+      - Correct step  → fix_progress += 1; metrics partially improve
+      - Wrong step    → metrics degrade further
+      - All steps done → resolved = True, metrics recover
+    """
+    seq = state["fix_sequence"]
+    prog = state["fix_progress"]
+
+    if prog < len(seq) and action == seq[prog]:
+        # Correct action
+        state["fix_progress"] += 1
+        prog += 1
+
+        state["metrics"]["latency"]    *= 0.85
+        state["metrics"]["error_rate"] *= 0.80
+        state["metrics"]["cpu"]        *= 0.90
+
+        if prog == len(seq):
+            state["resolved"] = True
+            state["metrics"]["latency"]    = max(state["metrics"]["latency"]    * 0.5, 30)
+            state["metrics"]["error_rate"] = max(state["metrics"]["error_rate"] * 0.1, 0.01)
+            state["metrics"]["cpu"]        = max(state["metrics"]["cpu"]        * 0.6, 20)
+
+            for svc in state["services"]:
+                state["services"][svc] = "healthy"
+    else:
+        state["metrics"]["latency"]    = min(state["metrics"]["latency"]    * 1.12, 2000)
+        state["metrics"]["error_rate"] = min(state["metrics"]["error_rate"] * 1.10, 1.0)
+        state["metrics"]["cpu"]        = min(state["metrics"]["cpu"]        * 1.05, 100)
+
+    if not state["resolved"]:
+        state["metrics"]["latency"] = min(state["metrics"]["latency"] * 1.03, 2000)
+        state["metrics"]["cpu"]     = min(state["metrics"]["cpu"]     * 1.01, 100)
+
+    return state

env/environment.py

@@ -0,0 +1,126 @@
+# DebugOps Environment — core RL environment for AI incident response.
+# Follows the OpenEnv step()/reset()/state() interface.
+from __future__ import annotations
+import copy
+from dataclasses import dataclass, field, asdict
+from typing import Dict, List, Tuple, Any
+
+from env.incident_generator import generate_incident
+from env.dynamics import apply_action
+from env.reward import compute_reward
+
+# Typed observation / state model
+@dataclass
+class Observation:
+    services: Dict[str, str]          # service_name -> "healthy" | "degraded"
+    logs: List[str]                   # ordered log lines (may be noisy)
+    metrics: Dict[str, float]         # latency, error_rate, cpu
+    time_step: int                    # steps elapsed in the current episode
+    fix_progress: int                 # number of correct steps completed so far
+    metric_trend: str                 # "improving" | "degrading" | "stable"
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+
+# Core environment
+class DebugEnv:
+    """
+    Single-episode production incident environment.
+
+    Observation space:
+        services    : Dict[str, str]   — per-service health status
+        logs        : List[str]        — system logs (may contain noise)
+        metrics     : Dict[str,float]  — latency (ms), error_rate (0-1), cpu (%)
+        time_step   : int
+
+    Action space (discrete, 5 actions):
+        restart_api | restart_db | restart_cache | scale_up | noop
+
+    Episode terminates when:
+        - state_data["resolved"] is True  (success)
+        - t >= max_steps                  (timeout / failure)
+    """
+
+    VALID_ACTIONS = ["restart_api", "restart_db", "restart_cache", "scale_up", "noop"]
+
+    def __init__(self, max_steps: int = 20):
+        self.max_steps = max_steps
+        self.t: int = 0
+        self.done: bool = False
+        self.success: bool = False
+        self.state_data: Dict[str, Any] = {}
+        self._prev_latency: float = 0.0
+
+    #---
+    def reset(self) -> Dict[str, Any]:
+        """Return fresh observation; episode counter reset."""
+        self.t = 0
+        self.done = False
+        self.success = False
+        self.state_data = generate_incident()
+        self._prev_latency = self.state_data["metrics"]["latency"]
+        return self._obs()
+
+    #---
+    def state(self) -> Dict[str, Any]:
+        """Return current observation (idempotent)."""
+        return self._obs()
+
+    
+    def step(self, action: str) -> Tuple[Dict[str, Any], float, bool, Dict[str, Any]]:
+        """
+        Apply action and advance one time-step.
+
+        Returns
+        -------
+        observation : Dict
+        reward      : float
+        done        : bool
+        info        : Dict   — latency, error_rate, progress, resolved, success
+        """
+        if self.done:
+            raise RuntimeError("Episode is finished. Call reset() before stepping.")
+
+        if action not in self.VALID_ACTIONS:
+            raise ValueError(f"Invalid action '{action}'. Must be one of {self.VALID_ACTIONS}")
+
+        prev_state = copy.deepcopy(self.state_data)
+        prev_latency = self.state_data["metrics"]["latency"]
+        self.state_data = apply_action(self.state_data, action)
+        reward, info = compute_reward(prev_state, self.state_data, action, self.t)
+        self._prev_latency = prev_latency
+
+        self.t += 1
+
+        if self.state_data["resolved"]:
+            self.done = True
+            self.success = True
+        elif self.t >= self.max_steps:
+            self.done = True
+            self.success = False
+
+        info["success"] = self.success
+        info["time_step"] = self.t
+
+        return self._obs(), reward, self.done, info
+
+    
+    def _obs(self) -> Dict[str, Any]:
+        curr_latency = self.state_data["metrics"]["latency"]
+        delta = curr_latency - self._prev_latency
+        if delta < -10:
+            trend = "improving"
+        elif delta > 10:
+            trend = "degrading"
+        else:
+            trend = "stable"
+
+        return Observation(
+            services=dict(self.state_data["services"]),
+            logs=list(self.state_data["logs"]),
+            metrics={k: round(v, 2) for k, v in self.state_data["metrics"].items()},
+            time_step=self.t,
+            fix_progress=self.state_data["fix_progress"],
+            metric_trend=trend,
+        ).to_dict()

env/incident_generator.py

@@ -0,0 +1,91 @@
+"""
+Incident generator - randomly samples a production incident scenario.
+Each incident has a hidden root cause that the agent must diagnose
+from noisy logs and degraded metrics.
+"""
+from __future__ import annotations
+import random
+from typing import Dict, List, Any
+
+ROOT_CAUSES: Dict[str, Dict[str, Any]] = {
+    "api_timeout": {
+        "affected": ["api"],
+        "fix_sequence": ["scale_up", "restart_api"],
+        "log_hints": ["timeout error", "upstream request failed", "connection refused"],
+    },
+    "db_connection_leak": {
+        "affected": ["db"],
+        "fix_sequence": ["restart_db", "scale_up"],
+        "log_hints": ["too many connections", "db pool exhausted", "connection refused to db"],
+    },
+    "cache_miss_storm": {
+        "affected": ["cache"],
+        "fix_sequence": ["restart_cache", "scale_up"],
+        "log_hints": ["cache miss spike", "high backend load", "cache key not found"],
+    },
+    "memory_leak": {
+        "affected": ["api", "db"],
+        "fix_sequence": ["restart_api", "restart_db"],
+        "log_hints": ["memory usage increasing", "OOM warning", "heap allocation failure"],
+    },
+}
+
+_NOISE_POOL: List[str] = [
+    "disk warning: 78% used",
+    "temporary network glitch resolved",
+    "unrelated service restarted (metrics-exporter)",
+    "certificate renewal scheduled",
+    "cron job completed",
+    "health check passed for load-balancer",
+    "rate limiter triggered on /api/v2/bulk",
+]
+
+
+def generate_incident() -> Dict[str, Any]:
+    """Return a fresh incident state dict."""
+    cause_key = random.choice(list(ROOT_CAUSES.keys()))
+    cause_cfg = ROOT_CAUSES[cause_key]
+
+    services = {s: "healthy" for s in ["api", "db", "cache"]}
+    for s in cause_cfg["affected"]:
+        services[s] = "degraded"
+
+    logs = _generate_logs(cause_key, cause_cfg["log_hints"])
+    metrics = _generate_metrics(cause_key)
+
+    return {
+        "services": services,
+        "logs": logs,
+        "metrics": metrics,
+        "root_cause": cause_key,
+        "fix_sequence": list(cause_cfg["fix_sequence"]),   # copy
+        "resolved": False,
+        "fix_progress": 0,
+    }
+
+def _generate_logs(cause: str, hints: List[str]) -> List[str]:
+    logs = list(hints)
+
+    # 20 % chance of a genuinely misleading entry
+    if random.random() < 0.2:
+        logs.append("corrupted log entry: [binary garbage]")
+
+    # Always add 2 noise entries
+    logs += random.sample(_NOISE_POOL, k=min(2, len(_NOISE_POOL)))
+    random.shuffle(logs)
+    return logs
+
+
+def _generate_metrics(cause: str) -> Dict[str, float]:
+    base = {
+        "api_timeout":        {"latency": 350, "error_rate": 0.55, "cpu": 75},
+        "db_connection_leak": {"latency": 280, "error_rate": 0.45, "cpu": 60},
+        "cache_miss_storm":   {"latency": 220, "error_rate": 0.35, "cpu": 85},
+        "memory_leak":        {"latency": 400, "error_rate": 0.65, "cpu": 92},
+    }[cause]
+
+    return {
+        "latency":    base["latency"]    + random.randint(-20, 20),
+        "error_rate": round(base["error_rate"] + random.uniform(-0.05, 0.05), 3),
+        "cpu":        base["cpu"]        + random.randint(-5, 5),
+    }

env/reward.py

@@ -0,0 +1,52 @@
+"""
+Reward function - provides dense, shaped signals to guide learning.
+
+Signal summary
+--------------
++150   full resolution bonus
++ 30   correct intermediate fix step
+- 15   wrong action (no progress)
+-0.04  per ms of latency  (continuous cost)
+- 25   per unit of error_rate (continuous cost)
+-  2   time penalty per step (urgency)
+"""
+from __future__ import annotations
+from typing import Dict, Any, Tuple
+
+
+def compute_reward(
+    prev: Dict[str, Any],
+    curr: Dict[str, Any],
+    action: str,
+    time_step: int = 0,
+) -> Tuple[float, Dict[str, Any]]:
+    reward = 0.0
+
+    # Resolution bonus
+    if curr["resolved"]:
+        reward += 150.0
+
+    # Partial progress
+    if curr["fix_progress"] > prev["fix_progress"]:
+        reward += 30.0
+    elif action != "noop":
+        # Wrong action (no progress, not a passive noop)
+        reward -= 15.0
+
+    # Continuous metric penalties
+    reward -= curr["metrics"]["latency"]    * 0.04
+    reward -= curr["metrics"]["error_rate"] * 25.0
+
+    # Time penalty (escalates after step 10 for urgency)
+    time_penalty = 2.0 + (0.5 * max(0, time_step - 10))
+    reward -= time_penalty
+
+    info = {
+        "latency":    round(curr["metrics"]["latency"], 2),
+        "error_rate": round(curr["metrics"]["error_rate"], 4),
+        "cpu":        round(curr["metrics"]["cpu"], 2),
+        "progress":   curr["fix_progress"],
+        "resolved":   curr["resolved"],
+    }
+
+    return reward, info

grader/__init__.py

@@ -0,0 +1 @@
+from grader.grader import evaluate_episode

grader/grader.py

@@ -0,0 +1,126 @@
+# Grader - evaluates a completed episode and returns a score in [0.0, 1.0].
+# Scoring formula: Base score is a weighted combination of:
+#   - Resolution bonus  (50 % weight)
+#   - Efficiency bonus  (30 % weight) - fewer steps = higher score
+#   - Quality bonus     (20 % weight) - average normalised reward
+
+# All components are clipped to [0, 1] before weighting.
+# Final score is also clipped to [0.0, 1.0].
+
+from __future__ import annotations
+from typing import List, Dict, Any
+
+_RESOLUTION_WEIGHT  = 0.50
+_EFFICIENCY_WEIGHT  = 0.30
+_QUALITY_WEIGHT     = 0.20
+
+_MAX_STEPS_SIMPLE       = 15
+_MAX_STEPS_MULTI        = 12
+_MAX_STEPS_CRITICAL     = 10
+
+# Reference reward range for normalisation (empirically determined)
+_REWARD_MIN = -200.0
+_REWARD_MAX =  200.0
+
+
+def evaluate_episode(
+    episode_logs: List[Dict[str, Any]],
+    max_steps: int = _MAX_STEPS_SIMPLE,
+) -> Dict[str, Any]:
+    """
+    Parameters
+    ----------
+    episode_logs : list of step dicts containing at minimum
+                   {"reward": float, "info": {"resolved": bool, ...}}
+    max_steps    : maximum allowed steps for this task (used in efficiency calc)
+
+    Returns
+    -------
+    dict with keys: score (float 0-1), resolved (bool), steps (int),
+                    total_reward (float), efficiency (float), quality (float)
+    """
+    if not episode_logs:
+        return {"score": 0.0, "resolved": False, "steps": 0,
+                "total_reward": 0.0, "efficiency": 0.0, "quality": 0.0}
+
+    steps        = len(episode_logs)
+    total_reward = sum(entry["reward"] for entry in episode_logs)
+    resolved     = any(entry["info"].get("resolved", False) for entry in episode_logs)
+
+    # Component 1: resolution (binary, but partial credit for progress) 
+    if resolved:
+        resolution_score = 1.0
+    else:
+        max_progress = max(
+            (entry["info"].get("progress", 0) for entry in episode_logs),
+            default=0,
+        )
+        # Guess fix sequence length ≈ 2 for all tasks
+        resolution_score = min(max_progress / 2.0, 0.49)
+
+    # Component 2: efficiency (resolved faster → higher score) 
+    if resolved:
+        efficiency_score = max(0.0, 1.0 - (steps - 1) / max(max_steps - 1, 1))
+    else:
+        efficiency_score = 0.0
+
+    # Component 3: quality (normalised average reward) 
+    avg_reward   = total_reward / steps
+    norm_reward  = (avg_reward - _REWARD_MIN) / (_REWARD_MAX - _REWARD_MIN)
+    quality_score = max(0.0, min(norm_reward, 1.0))
+
+    # Weighted combination 
+    score = (
+        _RESOLUTION_WEIGHT  * resolution_score +
+        _EFFICIENCY_WEIGHT  * efficiency_score +
+        _QUALITY_WEIGHT     * quality_score
+    )
+    score = round(max(0.0, min(score, 1.0)), 4)
+
+    return {
+        "score":        score,
+        "resolved":     resolved,
+        "steps":        steps,
+        "total_reward": round(total_reward, 3),
+        "efficiency":   round(efficiency_score, 4),
+        "quality":      round(quality_score, 4),
+    }
+
+if __name__ == "__main__":
+    import sys
+    import importlib
+
+    task_configs = [
+        ("simple",        "tasks.task_simple",        _MAX_STEPS_SIMPLE),
+        ("multi_service", "tasks.task_multi_service",  _MAX_STEPS_MULTI),
+        ("critical",      "tasks.task_critical",       _MAX_STEPS_CRITICAL),
+    ]
+
+    from agent.baseline import act
+
+    all_passed = True
+    for task_name, module_path, max_steps in task_configs:
+        mod = importlib.import_module(module_path)
+        env = mod.create_env()
+        state = env.reset()
+
+        logs = []
+        done = False
+        while not done:
+            action = act(state)
+            next_state, reward, done, info = env.step(action)
+            logs.append({"reward": reward, "info": info})
+            state = next_state
+
+        result = evaluate_episode(logs, max_steps=max_steps)
+        ok = 0.0 <= result["score"] <= 1.0
+        all_passed = all_passed and ok
+
+        status = "PASS" if ok else "FAIL"
+        print(
+            f"[GRADER] task={task_name:<15} score={result['score']:.4f} "
+            f"resolved={str(result['resolved']).lower():<5} "
+            f"steps={result['steps']:<3} status={status}"
+        )
+
+    sys.exit(0 if all_passed else 1)

inference.py

@@ -0,0 +1,224 @@
+"""
+DebugOps inference script
+=
+Runs the LLM agent (or heuristic fallback) against all three tasks and
+emits structured stdout logs in the exact required format:
+
+    [START] task=<name> env=debugops model=<model>
+    [STEP]  step=<n> action=<a> reward=<r> done=<bool> error=<null|err>
+    [END]   success=<bool> steps=<n> score=<s> rewards=<comma-list>
+
+Environment variables
+
+API_BASE_URL   LLM endpoint  (default: HuggingFace router)
+MODEL_NAME     Model ID      (default: Qwen/Qwen2.5-72B-Instruct)
+HF_TOKEN       API key (also checked as OPENAI_API_KEY or API_KEY)
+"""
+from __future__ import annotations
+import os
+import sys
+from typing import Any, Dict, List
+
+try:
+    from openai import OpenAI
+    _OPENAI_AVAILABLE = True
+except ImportError:
+    _OPENAI_AVAILABLE = False
+
+from grader.grader import evaluate_episode
+
+# Configuration
+API_KEY      = os.getenv("HF_TOKEN") or os.getenv("OPENAI_API_KEY") or os.getenv("API_KEY")
+API_BASE_URL = os.getenv("API_BASE_URL", "https://router.huggingface.co/v1")
+MODEL_NAME   = os.getenv("MODEL_NAME",   "Qwen/Qwen2.5-72B-Instruct")
+
+VALID_ACTIONS = ["restart_api", "restart_db", "restart_cache", "scale_up", "noop"]
+
+# OpenAI client (spec requires OpenAI client for all LLM calls)
+_client: Any = None
+if _OPENAI_AVAILABLE and API_KEY:
+    _client = OpenAI(api_key=API_KEY, base_url=API_BASE_URL)
+
+
+# Heuristic fallback agent (used when no LLM key or on API error)
+def _fallback_agent(state: Dict[str, Any], action_history: List[str]) -> str:
+    """
+    Rule-based agent driven by log keywords and fix_progress from state.
+    Uses fix_progress from the observation to know exactly which step to issue next.
+    """
+    logs = " ".join(state.get("logs", [])).lower()
+    metrics = state.get("metrics", {})
+    progress = state.get("fix_progress", 0)
+
+    # Known fix sequences keyed by log signal (ordered by specificity)
+    _log_to_seq = [
+        ("timeout",     ["scale_up",      "restart_api"]),
+        ("upstream",    ["scale_up",      "restart_api"]),
+        ("heap",        ["restart_api",   "restart_db"]),
+        ("oom",         ["restart_api",   "restart_db"]),
+        ("memory",      ["restart_api",   "restart_db"]),
+        ("db pool",     ["restart_db",    "scale_up"]),
+        ("connections", ["restart_db",    "scale_up"]),
+        ("cache miss",  ["restart_cache", "scale_up"]),
+        ("cache",       ["restart_cache", "scale_up"]),
+        ("db",          ["restart_db",    "scale_up"]),
+    ]
+
+    # Identify sequence from logs
+    seq = None
+    for keyword, candidate_seq in _log_to_seq:
+        if keyword in logs:
+            seq = candidate_seq
+            break
+
+    if seq and progress < len(seq):
+        # Issue the next step in the correct sequence
+        return seq[progress]
+
+    # Metric-based fallback
+    if metrics.get("cpu", 0) > 80 and "scale_up" not in action_history:
+        return "scale_up"
+    if metrics.get("error_rate", 0) > 0.5 and "restart_api" not in action_history:
+        return "restart_api"
+
+    # Try any action not yet used twice
+    for a in ["restart_api", "restart_db", "restart_cache", "scale_up"]:
+        if action_history.count(a) < 2:
+            return a
+
+    return "noop"
+
+# LLM call (OpenAI client as required)
+def _call_llm(
+    state: Dict[str, Any],
+    action_history: List[str],
+    reward_history: List[float],
+) -> str:
+    if _client is None:
+        return _fallback_agent(state, action_history)
+
+    # Build a human-readable step history with outcome signals
+    step_lines = []
+    for i, (a, r) in enumerate(zip(action_history, reward_history)):
+        outcome = "✓ progress made" if r > 20 else ("✗ wrong / no effect" if r < -5 else "~ neutral")
+        step_lines.append(f"  step {i}: {a:18s} reward={r:>8.1f}  [{outcome}]")
+    history_block = "\n".join(step_lines) if step_lines else "  (none yet)"
+
+    services_degraded = [s for s, h in state["services"].items() if h == "degraded"]
+    metrics = state["metrics"]
+
+    prompt = f"""You are an expert SRE triaging a production incident. Your goal is to resolve it in as few steps as possible.
+
+SYSTEM STATE (step {state['time_step']}) 
+Degraded services : {services_degraded if services_degraded else 'none'}
+Metrics           : latency={metrics.get('latency', 0):.0f}ms  error_rate={metrics.get('error_rate', 0):.2%}  cpu={metrics.get('cpu', 0):.0f}%
+Metric trend      : {state.get('metric_trend', 'unknown')}
+Fix progress      : {state.get('fix_progress', 0)} step(s) completed correctly so far
+
+SYSTEM LOGS 
+{chr(10).join('  ' + l for l in state['logs'])}
+
+ACTION HISTORY & OUTCOMES 
+{history_block}
+
+INSTRUCTIONS 
+Root causes have multi-step fix sequences that MUST be performed in order.
+A positive reward means the last action was a correct step — continue the sequence.
+A negative reward means the last action was wrong — try something different.
+Do NOT repeat an action that already got a negative reward.
+If fix_progress increased after your last action, continue to the NEXT step in the sequence.
+
+Choose ONE action from: restart_api, restart_db, restart_cache, scale_up, noop
+
+Respond with ONLY the action name."""
+
+    try:
+        response = _client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0,
+            max_tokens=20,
+            timeout=15,
+        )
+        action = response.choices[0].message.content.strip().lower()
+        action = action.split()[0] if action else "noop"
+        # strip any punctuation
+        action = "".join(c for c in action if c.isalnum() or c == "_")
+
+        if action not in VALID_ACTIONS:
+            return _fallback_agent(state, action_history)
+        return action
+
+    except Exception:
+        return _fallback_agent(state, action_history)
+
+
+def run_episode(task_name: str = "simple") -> None:
+    if task_name == "simple":
+        from tasks.task_simple import create_env
+        max_steps = 15
+    elif task_name == "multi_service":
+        from tasks.task_multi_service import create_env
+        max_steps = 12
+    elif task_name == "critical":
+        from tasks.task_critical import create_env
+        max_steps = 10
+    else:
+        raise ValueError(f"Unknown task: {task_name!r}")
+
+    env = create_env()
+    state = env.reset()
+
+    print(
+        f"[START] task={task_name} env=debugops model={MODEL_NAME}",
+        flush=True,
+    )
+
+    action_history: List[str] = []
+    reward_history: List[float] = []
+    episode_logs:   List[Dict[str, Any]] = []
+    done = False
+    step = 0
+
+    while not done and step < max_steps:
+        action = _call_llm(state, action_history, reward_history)
+
+        try:
+            next_state, reward, done, info = env.step(action)
+            error = "null"
+        except Exception as exc:
+            next_state, reward, done, info = state, 0.0, True, {}
+            error = type(exc).__name__
+
+        action_history.append(action)
+        reward_history.append(reward)
+        episode_logs.append({"reward": reward, "info": info})
+
+        print(
+            f"[STEP] step={step} action={action} reward={round(reward, 3)} "
+            f"done={str(done).lower()} error={error}",
+            flush=True,
+        )
+
+        # Early exit on explicit success flag
+        if info.get("success", False):
+            done = True
+
+        state = next_state
+        step += 1
+
+    result = evaluate_episode(episode_logs, max_steps=max_steps)
+    score   = result["score"]                    # already in [0, 1]
+    success = result["resolved"]
+
+    print(
+        f"[END] success={str(success).lower()} steps={step} "
+        f"score={round(score, 3)} "
+        f"rewards={','.join(str(round(e['reward'], 3)) for e in episode_logs)}",
+        flush=True,
+    )
+
+
+if __name__ == "__main__":
+    for task in ["simple", "multi_service", "critical"]:
+        run_episode(task)

openenv.yaml

@@ -0,0 +1,82 @@
+name: debugops
+version: "1.0.0"
+description: >
+  DebugOps — an AI Incident Response environment where an agent acts as an
+  on-call SRE to diagnose and resolve production system failures using
+  noisy logs, degraded metrics, and multi-step fix sequences.
+
+observation_space:
+  type: dict
+  fields:
+    services:
+      type: dict
+      description: "Per-service health status: api, db, cache → healthy | degraded"
+    logs:
+      type: list[str]
+      description: "System log lines (may contain noise and red herrings)"
+    metrics:
+      type: dict
+      fields:
+        latency:    { type: float, description: "Latency in ms" }
+        error_rate: { type: float, description: "Error rate 0.0–1.0" }
+        cpu:        { type: float, description: "CPU utilisation %" }
+    time_step:
+      type: int
+      description: "Steps elapsed in the current episode"
+
+action_space:
+  type: discrete
+  actions:
+    - restart_api
+    - restart_db
+    - restart_cache
+    - scale_up
+    - noop
+
+tasks:
+  - name: simple
+    description: "Single-service failure; 2-step fix; 15-step budget."
+    module: tasks.task_simple
+    max_steps: 15
+    difficulty: low
+
+  - name: multi_service
+    description: "Two services degrade simultaneously; 12-step budget; extra latency penalty."
+    module: tasks.task_multi_service
+    max_steps: 12
+    difficulty: medium
+
+  - name: critical
+    description: "Memory-leak root cause with misleading logs; SLA penalty; 10-step budget."
+    module: tasks.task_critical
+    max_steps: 10
+    difficulty: high
+
+grader:
+  module: grader.grader
+  function: evaluate_episode
+  score_range: [0.0, 1.0]
+  deterministic: true
+
+baseline:
+  module: agent.baseline
+  function: act
+  description: "Heuristic agent using log-keyword matching and metric thresholds."
+
+inference:
+  script: inference.py
+  env_vars:
+    - API_BASE_URL
+    - MODEL_NAME
+    - HF_TOKEN
+
+required_env:
+  - name: API_BASE_URL
+    description: "OpenAI-compatible LLM endpoint"
+    default: "https://router.huggingface.co/v1"
+  - name: MODEL_NAME
+    description: "Model identifier"
+    default: "Qwen/Qwen2.5-72B-Instruct"
+  - name: HF_TOKEN
+    description: "HuggingFace / OpenAI API key"
+    required: true

requirements.txt

@@ -0,0 +1,2 @@
+openai>=1.12.0
+pyyaml>=6.0

scripts/validate-submission.sh

@@ -0,0 +1,185 @@
+#!/usr/bin/env bash
+#
+# validate-submission.sh - OpenEnv Submission Validator
+#
+# Checks that your HF Space is live, Docker image builds, and openenv validate passes.
+#
+# Prerequisites:
+#   - Docker:       https://docs.docker.com/get-docker/
+#   - openenv-core: pip install openenv-core
+#   - curl (usually pre-installed)
+#
+# Run:
+#   curl -fsSL https://raw.githubusercontent.com/<owner>/<repo>/main/scripts/validate-submission.sh | bash -s -- <ping_url> [repo_dir]
+#
+#   Or download and run locally:
+#     chmod +x validate-submission.sh
+#     ./validate-submission.sh <ping_url> [repo_dir]
+#
+# Arguments:
+#   ping_url   Your HuggingFace Space URL (e.g. https://your-space.hf.space)
+#   repo_dir   Path to your repo (default: current directory)
+#
+# Examples:
+#   ./validate-submission.sh https://my-team.hf.space
+#   ./validate-submission.sh https://my-team.hf.space ./my-repo
+#
+
+set -uo pipefail
+
+DOCKER_BUILD_TIMEOUT=600
+if [ -t 1 ]; then
+  RED='\033[0;31m'
+  GREEN='\033[0;32m'
+  YELLOW='\033[1;33m'
+  BOLD='\033[1m'
+  NC='\033[0m'
+else
+  RED='' GREEN='' YELLOW='' BOLD='' NC=''
+fi
+
+run_with_timeout() {
+  local secs="$1"; shift
+  if command -v timeout &>/dev/null; then
+    timeout "$secs" "$@"
+  elif command -v gtimeout &>/dev/null; then
+    gtimeout "$secs" "$@"
+  else
+    "$@" &
+    local pid=$!
+    ( sleep "$secs" && kill "$pid" 2>/dev/null ) &
+    local watcher=$!
+    wait "$pid" 2>/dev/null
+    local rc=$?
+    kill "$watcher" 2>/dev/null
+    wait "$watcher" 2>/dev/null
+    return $rc
+  fi
+}
+
+portable_mktemp() {
+  local prefix="${1:-validate}"
+  mktemp "${TMPDIR:-/tmp}/${prefix}-XXXXXX" 2>/dev/null || mktemp
+}
+
+CLEANUP_FILES=()
+cleanup() { rm -f "${CLEANUP_FILES[@]+"${CLEANUP_FILES[@]}"}"; }
+trap cleanup EXIT
+
+PING_URL="${1:-}"
+REPO_DIR="${2:-.}"
+
+if [ -z "$PING_URL" ]; then
+  printf "Usage: %s <ping_url> [repo_dir]\n" "$0"
+  printf "\n"
+  printf "  ping_url   Your HuggingFace Space URL (e.g. https://your-space.hf.space)\n"
+  printf "  repo_dir   Path to your repo (default: current directory)\n"
+  exit 1
+fi
+
+if ! REPO_DIR="$(cd "$REPO_DIR" 2>/dev/null && pwd)"; then
+  printf "Error: directory '%s' not found\n" "${2:-.}"
+  exit 1
+fi
+PING_URL="${PING_URL%/}"
+export PING_URL
+PASS=0
+
+log()  { printf "[%s] %b\n" "$(date -u +%H:%M:%S)" "$*"; }
+pass() { log "${GREEN}PASSED${NC} -- $1"; PASS=$((PASS + 1)); }
+fail() { log "${RED}FAILED${NC} -- $1"; }
+hint() { printf "  ${YELLOW}Hint:${NC} %b\n" "$1"; }
+stop_at() {
+  printf "\n"
+  printf "${RED}${BOLD}Validation stopped at %s.${NC} Fix the above before continuing.\n" "$1"
+  exit 1
+}
+
+printf "\n"
+printf "${BOLD}========================================${NC}\n"
+printf "${BOLD}  OpenEnv Submission Validator${NC}\n"
+printf "${BOLD}========================================${NC}\n"
+log "Repo:     $REPO_DIR"
+log "Ping URL: $PING_URL"
+printf "\n"
+
+log "${BOLD}Step 1/3: Pinging HF Space${NC} ($PING_URL/reset) ..."
+
+CURL_OUTPUT=$(portable_mktemp "validate-curl")
+CLEANUP_FILES+=("$CURL_OUTPUT")
+HTTP_CODE=$(curl -s -o "$CURL_OUTPUT" -w "%{http_code}" -X POST \
+  -H "Content-Type: application/json" -d '{}' \
+  "$PING_URL/reset" --max-time 30 2>"$CURL_OUTPUT" || printf "000")
+
+if [ "$HTTP_CODE" = "200" ]; then
+  pass "HF Space is live and responds to /reset"
+elif [ "$HTTP_CODE" = "000" ]; then
+  fail "HF Space not reachable (connection failed or timed out)"
+  hint "Check your network connection and that the Space is running."
+  hint "Try: curl -s -o /dev/null -w '%%{http_code}' -X POST $PING_URL/reset"
+  stop_at "Step 1"
+else
+  fail "HF Space /reset returned HTTP $HTTP_CODE (expected 200)"
+  hint "Make sure your Space is running and the URL is correct."
+  hint "Try opening $PING_URL in your browser first."
+  stop_at "Step 1"
+fi
+
+log "${BOLD}Step 2/3: Running docker build${NC} ..."
+
+if ! command -v docker &>/dev/null; then
+  fail "docker command not found"
+  hint "Install Docker: https://docs.docker.com/get-docker/"
+  stop_at "Step 2"
+fi
+
+if [ -f "$REPO_DIR/Dockerfile" ]; then
+  DOCKER_CONTEXT="$REPO_DIR"
+elif [ -f "$REPO_DIR/server/Dockerfile" ]; then
+  DOCKER_CONTEXT="$REPO_DIR/server"
+else
+  fail "No Dockerfile found in repo root or server/ directory"
+  stop_at "Step 2"
+fi
+
+log "  Found Dockerfile in $DOCKER_CONTEXT"
+
+BUILD_OK=false
+BUILD_OUTPUT=$(run_with_timeout "$DOCKER_BUILD_TIMEOUT" docker build "$DOCKER_CONTEXT" 2>&1) && BUILD_OK=true
+
+if [ "$BUILD_OK" = true ]; then
+  pass "Docker build succeeded"
+else
+  fail "Docker build failed (timeout=${DOCKER_BUILD_TIMEOUT}s)"
+  printf "%s\n" "$BUILD_OUTPUT" | tail -20
+  stop_at "Step 2"
+fi
+
+log "${BOLD}Step 3/3: Running openenv validate${NC} ..."
+
+if ! command -v openenv &>/dev/null; then
+  fail "openenv command not found"
+  hint "Install it: pip install openenv-core"
+  stop_at "Step 3"
+fi
+
+VALIDATE_OK=false
+VALIDATE_OUTPUT=$(cd "$REPO_DIR" && openenv validate 2>&1) && VALIDATE_OK=true
+
+if [ "$VALIDATE_OK" = true ]; then
+  pass "openenv validate passed"
+  [ -n "$VALIDATE_OUTPUT" ] && log "  $VALIDATE_OUTPUT"
+else
+  fail "openenv validate failed"
+  printf "%s\n" "$VALIDATE_OUTPUT"
+  stop_at "Step 3"
+fi
+
+printf "\n"
+printf "${BOLD}========================================${NC}\n"
+printf "${GREEN}${BOLD}  All 3/3 checks passed!${NC}\n"
+printf "${GREEN}${BOLD}  Your submission is ready to submit.${NC}\n"
+printf "${BOLD}========================================${NC}\n"
+printf "\n"
+
+exit 0

tasks/task_critical.py

@@ -0,0 +1,80 @@
+# Task: Critical — SLA-breach scenario with controlled randomness and realism.
+# Introduces noisy logs, metric variance, and slight ambiguity while preserving solvability.
+
+from __future__ import annotations
+from typing import Dict, Any, Tuple
+import random
+
+from env.environment import DebugEnv
+
+
+class CriticalEnv(DebugEnv):
+    """
+    High-stakes incident:
+      - Root cause: memory_leak (restart_api → restart_db)
+      - Noisy + misleading logs
+      - Randomized metrics per episode
+      - SLA penalties + time pressure
+      - Designed for score variance across runs
+    """
+
+    SLA_LATENCY_THRESHOLD = 250  # ms
+    SLA_PENALTY = 80.0
+    TIME_PRESSURE_START = 8
+    TIME_PRESSURE_PENALTY = 30.0
+
+    def reset(self) -> Dict[str, Any]:
+        state = super().reset()
+
+        self.state_data["root_cause"] = "memory_leak"
+        self.state_data["fix_sequence"] = ["restart_api", "restart_db"]
+
+        self.state_data["services"]["api"] = "degraded"
+        self.state_data["services"]["db"] = "degraded"
+
+        base_logs = [
+            "memory usage increasing",
+            "OOM warning",
+            "heap allocation failure",
+        ]
+
+        noise_logs = [
+            "network latency spike (transient)",
+            "disk almost full: /var/log 94%",
+            "temporary service restart: metrics-collector",
+            "cache eviction rate elevated",
+            "connection pool retry",
+            "upstream request timeout",
+        ]
+
+        # Randomly inject noise
+        selected_noise = random.sample(noise_logs, k=random.randint(2, 4))
+
+        logs = base_logs + selected_noise
+        random.shuffle(logs)
+
+        self.state_data["logs"] = logs
+        self.state_data["metrics"]["latency"] = random.randint(350, 500)
+        self.state_data["metrics"]["error_rate"] = round(random.uniform(0.6, 0.9), 2)
+        self.state_data["metrics"]["cpu"] = random.randint(85, 98)
+
+        self._prev_latency = self.state_data["metrics"]["latency"]
+
+        return self._obs()
+
+    def step(self, action: str) -> Tuple[Dict[str, Any], float, bool, Dict[str, Any]]:
+        obs, reward, done, info = super().step(action)
+
+        if info["latency"] > self.SLA_LATENCY_THRESHOLD:
+            reward -= self.SLA_PENALTY
+
+        if self.t > self.TIME_PRESSURE_START and not info["resolved"]:
+            reward -= self.TIME_PRESSURE_PENALTY
+
+        reward += random.uniform(-3, 3)
+
+        return obs, reward, done, info
+
+
+def create_env() -> CriticalEnv:
+    return CriticalEnv(max_steps=10)

tasks/task_multi_service.py

@@ -0,0 +1,37 @@
+# Task: Multi-Service: Forces two services into a degraded state simultaneously.
+# Agent must correctly sequence actions across both services.
+# Tighter step budget increases difficulty.
+
+from __future__ import annotations
+from typing import Dict, Any, Tuple
+
+from env.environment import DebugEnv
+
+class MultiServiceEnv(DebugEnv):
+    """Both API and DB start degraded regardless of sampled root cause."""
+
+    def reset(self) -> Dict[str, Any]:
+        state = super().reset()
+        self.state_data["services"]["api"] = "degraded"
+        self.state_data["services"]["db"]  = "degraded"
+        # Increase starting metric pressure
+        self.state_data["metrics"]["latency"]    = min(
+            self.state_data["metrics"]["latency"] * 1.3, 600
+        )
+        self.state_data["metrics"]["error_rate"] = min(
+            self.state_data["metrics"]["error_rate"] * 1.2, 0.95
+        )
+        return self._obs()
+
+    def step(self, action: str) -> Tuple[Dict[str, Any], float, bool, Dict[str, Any]]:
+        obs, reward, done, info = super().step(action)
+
+        # Additional latency penalty for multi-service SLA
+        if info["latency"] > 300:
+            reward -= 10.0
+
+        return obs, reward, done, info
+
+
+def create_env() -> MultiServiceEnv:
+    return MultiServiceEnv(max_steps=12)

tasks/task_simple.py

@@ -0,0 +1,6 @@
+#Task: Simple: A single-service failure with a 2-step fix sequence.
+#Entry-level task - low penalty, generous step budget.
+from env.environment import DebugEnv
+
+def create_env() -> DebugEnv:
+    return DebugEnv(max_steps=15)