feat: SRE Incident Response OpenEnv v1.0.0

.gitignore

@@ -0,0 +1,13 @@
+__pycache__/
+*.pyc
+*.pyo
+.env
+.venv/
+venv/
+*.egg-info/
+dist/
+build/
+.pytest_cache/
+*.log
+baseline_results.json
+.DS_Store

Dockerfile

@@ -0,0 +1,45 @@
+# SRE Incident Response — OpenEnv Environment
+# Dockerfile for Hugging Face Spaces
+# Build: docker build -t sre-incident-env .
+# Run:   docker run -p 7860:7860 sre-incident-env
+
+FROM python:3.11-slim
+
+LABEL maintainer="SRE Incident Response Environment"
+LABEL description="OpenEnv SRE Incident Response RL Environment"
+LABEL org.opencontainers.image.title="sre-incident-response"
+LABEL org.opencontainers.image.version="1.0.0"
+
+# System deps
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create non-root user (HF Spaces requirement)
+RUN useradd -m -u 1000 appuser
+
+WORKDIR /app
+
+# Install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY app/ ./app/
+COPY openenv.yaml .
+COPY baseline.py .
+
+# Ensure correct ownership
+RUN chown -R appuser:appuser /app
+
+USER appuser
+
+# HF Spaces uses port 7860
+EXPOSE 7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=15s --retries=3 \
+    CMD curl -f http://localhost:7860/health || exit 1
+
+# Start the server
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1"]

app/__init__.py

@@ -0,0 +1 @@
+# SRE Incident Response — OpenEnv Environment

app/environment.py

@@ -0,0 +1,216 @@
+"""
+Session manager for the SRE Incident Response environment.
+Manages per-session state, step processing, and reward accumulation.
+"""
+
+import uuid
+import copy
+from typing import Dict, Optional, Tuple
+from datetime import datetime, timezone
+
+from app.models import (
+    Observation, Action, Reward, StepResponse,
+    StateResponse, GraderResponse,
+)
+from app.tasks.base import AVAILABLE_ACTIONS
+from app.tasks import TASK_REGISTRY
+
+
+class Session:
+    """In-memory session state for one episode."""
+
+    def __init__(self, task_id: str, seed: int = 42):
+        self.session_id = str(uuid.uuid4())
+        self.task_id = task_id
+        self.step = 0
+        self.done = False
+        self.total_reward = 0.0
+        self.action_history: list = []
+        self.created_at = datetime.now(timezone.utc).isoformat()
+
+        task = TASK_REGISTRY[task_id]
+        self.world_state = task.initial_state(seed=seed)
+
+    def to_state_response(self, grader_score: Optional[float] = None) -> StateResponse:
+        return StateResponse(
+            session_id=self.session_id,
+            task_id=self.task_id,
+            step=self.step,
+            done=self.done,
+            total_reward=round(self.total_reward, 4),
+            world_state=_serialize_state(self.world_state),
+            action_history=self.action_history,
+            grader_score=grader_score,
+        )
+
+
+def _serialize_state(state: dict) -> dict:
+    """Make world_state JSON-serializable (convert sets, etc.)."""
+    result = {}
+    for k, v in state.items():
+        if k.startswith("_"):
+            continue  # hide internal fields
+        if isinstance(v, set):
+            result[k] = list(v)
+        elif isinstance(v, dict):
+            result[k] = _serialize_state(v)
+        else:
+            result[k] = v
+    return result
+
+
+class EnvironmentManager:
+    """Manages all active sessions."""
+
+    def __init__(self):
+        self._sessions: Dict[str, Session] = {}
+
+    def reset(self, task_id: str, seed: int = 42) -> Tuple[Observation, str]:
+        """Start a new episode. Returns (initial_observation, session_id)."""
+        if task_id not in TASK_REGISTRY:
+            raise ValueError(f"Unknown task_id '{task_id}'. Valid: {list(TASK_REGISTRY.keys())}")
+
+        session = Session(task_id=task_id, seed=seed)
+        self._sessions[session.session_id] = session
+
+        task = TASK_REGISTRY[task_id]
+        obs = task.get_observation(session.world_state, session.session_id, step=0)
+        obs.message = (
+            f"New episode started. Task: {task.name} (difficulty: {task.difficulty}). "
+            f"Max steps: {task.max_steps}. Investigate the incident and resolve it."
+        )
+        return obs, session.session_id
+
+    def step(self, session_id: str, action: Action) -> StepResponse:
+        """Process one action and return (observation, reward, done, info)."""
+        if session_id not in self._sessions:
+            raise KeyError(f"Session '{session_id}' not found. Call /reset first.")
+
+        session = self._sessions[session_id]
+
+        if session.done:
+            task = TASK_REGISTRY[session.task_id]
+            obs = task.get_observation(session.world_state, session_id, session.step)
+            obs.message = "Episode already complete. Call /reset to start a new episode."
+            return StepResponse(
+                observation=obs,
+                reward=Reward(value=0.0, cumulative=session.total_reward, breakdown={},
+                              message="Episode already complete."),
+                done=True,
+                info={"episode_complete": True},
+            )
+
+        task = TASK_REGISTRY[session.task_id]
+        session.step += 1
+
+        # Check max steps
+        if session.step > task.max_steps:
+            session.done = True
+            obs = task.get_observation(session.world_state, session_id, session.step)
+            obs.message = f"Episode ended: max steps ({task.max_steps}) reached without resolution."
+            timeout_reward = -0.10
+            session.total_reward += timeout_reward
+            return StepResponse(
+                observation=obs,
+                reward=Reward(
+                    value=timeout_reward,
+                    cumulative=round(session.total_reward, 4),
+                    breakdown={"timeout_penalty": timeout_reward},
+                    message="Max steps reached.",
+                ),
+                done=True,
+                info={"timeout": True, "steps": session.step},
+            )
+
+        # Process action
+        new_state, step_reward, done, message = task.process_action(
+            action.action_type,
+            action.parameters,
+            session.world_state,
+        )
+        session.world_state = new_state
+        session.done = done
+        session.total_reward += step_reward
+
+        # Record history
+        session.action_history.append({
+            "step": session.step,
+            "action_type": action.action_type,
+            "parameters": action.parameters,
+            "reward": round(step_reward, 4),
+            "message_preview": message[:120] if message else "",
+        })
+
+        # Build observation
+        obs = task.get_observation(session.world_state, session_id, session.step)
+        obs.message = message
+
+        # Grade for info
+        score, grade_breakdown = task.grade(session.world_state, session.action_history)
+
+        reward_obj = Reward(
+            value=round(step_reward, 4),
+            cumulative=round(session.total_reward, 4),
+            breakdown=_build_reward_breakdown(action.action_type, step_reward),
+            message=f"Step reward: {step_reward:+.3f} | Cumulative: {session.total_reward:+.3f}",
+        )
+
+        return StepResponse(
+            observation=obs,
+            reward=reward_obj,
+            done=done,
+            info={
+                "step": session.step,
+                "max_steps": task.max_steps,
+                "grader_score": score,
+                "episode_complete": done,
+            },
+        )
+
+    def get_state(self, session_id: str) -> StateResponse:
+        if session_id not in self._sessions:
+            raise KeyError(f"Session '{session_id}' not found.")
+        session = self._sessions[session_id]
+        task = TASK_REGISTRY[session.task_id]
+        score, _ = task.grade(session.world_state, session.action_history)
+        return session.to_state_response(grader_score=score)
+
+    def grade(self, session_id: str) -> GraderResponse:
+        if session_id not in self._sessions:
+            raise KeyError(f"Session '{session_id}' not found.")
+        session = self._sessions[session_id]
+        task = TASK_REGISTRY[session.task_id]
+        score, breakdown = task.grade(session.world_state, session.action_history)
+
+        passing = score >= task.passing_score
+        return GraderResponse(
+            session_id=session_id,
+            task_id=session.task_id,
+            score=score,
+            breakdown=breakdown,
+            episode_complete=session.done,
+            steps_taken=session.step,
+            message=(
+                f"Score: {score:.4f} | "
+                f"{'PASS' if passing else 'FAIL'} "
+                f"(threshold: {task.passing_score}) | "
+                f"Steps: {session.step}/{task.max_steps}"
+            ),
+        )
+
+    def cleanup_session(self, session_id: str) -> bool:
+        if session_id in self._sessions:
+            del self._sessions[session_id]
+            return True
+        return False
+
+    def active_sessions(self) -> int:
+        return len(self._sessions)
+
+
+def _build_reward_breakdown(action_type: str, value: float) -> Dict[str, float]:
+    if value > 0:
+        return {f"{action_type}_reward": round(value, 4)}
+    elif value < 0:
+        return {f"{action_type}_penalty": round(value, 4)}
+    return {}

app/main.py

@@ -0,0 +1,436 @@
+"""
+SRE Incident Response — OpenEnv Environment
+============================================
+FastAPI application implementing the full OpenEnv spec.
+
+Endpoints:
+  POST /reset          — Start a new episode
+  POST /step           — Take one action
+  GET  /state          — Get current session state
+  GET  /tasks          — List tasks and action schema
+  POST /grader         — Get grader score for a session
+  POST /baseline       — Run baseline agent on all tasks
+  GET  /health         — Health check
+"""
+
+import os
+import json
+import asyncio
+from typing import Optional, List
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI, HTTPException, Query, Body
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+
+from app.models import (
+    Observation, Action, Reward, StepResponse, ResetRequest,
+    StateResponse, TaskInfo, GraderResponse, BaselineResult,
+)
+from app.environment import EnvironmentManager
+from app.tasks import TASK_REGISTRY
+from app.tasks.base import ACTION_SCHEMA, AVAILABLE_ACTIONS
+
+
+# ─── App Setup ───────────────────────────────────────────────────────────────
+
+env_manager = EnvironmentManager()
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    print("SRE Incident Response Environment starting up...")
+    yield
+    print("Shutting down...")
+
+
+app = FastAPI(
+    title="SRE Incident Response — OpenEnv Environment",
+    description=(
+        "An OpenEnv-compliant reinforcement learning environment where an AI agent "
+        "acts as an on-call Site Reliability Engineer. The agent receives production "
+        "incident alerts, investigates root causes using logs/metrics/configs, and "
+        "takes remediation actions to restore service health.\n\n"
+        "Three tasks of increasing difficulty: CPU spike investigation (easy), "
+        "database connection pool exhaustion (medium), and cascading service failure (hard)."
+    ),
+    version="1.0.0",
+    lifespan=lifespan,
+    docs_url="/docs",
+    redoc_url="/redoc",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# ─── Request/Response Models ─────────────────────────────────────────────────
+
+class StepRequest(BaseModel):
+    session_id: str
+    action: Action
+
+
+class GraderRequest(BaseModel):
+    session_id: str
+
+
+class BaselineRequest(BaseModel):
+    model: str = "gpt-4o-mini"
+    max_steps: int = 12
+    tasks: List[str] = ["task1", "task2", "task3"]
+
+
+# ─── OpenEnv Endpoints ───────────────────────────────────────────────────────
+
+@app.get("/health")
+async def health():
+    """Health check endpoint."""
+    return {
+        "status": "healthy",
+        "environment": "sre-incident-response",
+        "version": "1.0.0",
+        "active_sessions": env_manager.active_sessions(),
+    }
+
+
+@app.post("/reset", response_model=Observation, tags=["OpenEnv"])
+async def reset(request: ResetRequest = Body(...)):
+    """
+    Start a new episode.
+
+    Returns the initial observation for the specified task.
+    The session_id in the response must be passed to subsequent /step calls.
+
+    - **task_id**: One of `task1` (easy), `task2` (medium), `task3` (hard)
+    - **seed**: Optional random seed for reproducibility
+    """
+    try:
+        obs, session_id = env_manager.reset(
+            task_id=request.task_id,
+            seed=request.seed or 42,
+        )
+        return obs
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@app.post("/step", response_model=StepResponse, tags=["OpenEnv"])
+async def step(request: StepRequest = Body(...)):
+    """
+    Take one action in the environment.
+
+    Returns observation, reward, done flag, and info dict.
+
+    Action types: `query_logs`, `check_metrics`, `restart_service`,
+    `rollback_deployment`, `scale_service`, `kill_query`, `acknowledge_alert`,
+    `examine_trace`, `check_config`, `resolve_incident`
+    """
+    try:
+        return env_manager.step(request.session_id, request.action)
+    except KeyError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Step error: {str(e)}")
+
+
+@app.get("/state", response_model=StateResponse, tags=["OpenEnv"])
+async def state(session_id: str = Query(..., description="Session ID from /reset")):
+    """
+    Get the full current state of a session (for debugging/grading).
+
+    Returns internal world state including hidden state variables and
+    action history. The grader_score field shows current progress.
+    """
+    try:
+        return env_manager.get_state(session_id)
+    except KeyError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+
+
+# ─── Additional Required Endpoints ───────────────────────────────────────────
+
+@app.get("/tasks", tags=["Environment Info"])
+async def list_tasks():
+    """
+    List all available tasks with descriptions, difficulty levels,
+    and the full action schema.
+    """
+    tasks_info = []
+    for task_id, task in TASK_REGISTRY.items():
+        tasks_info.append({
+            "task_id": task.task_id,
+            "name": task.name,
+            "description": task.description,
+            "difficulty": task.difficulty,
+            "max_steps": task.max_steps,
+            "passing_score": task.passing_score,
+        })
+
+    return {
+        "tasks": tasks_info,
+        "action_schema": ACTION_SCHEMA,
+        "available_actions": AVAILABLE_ACTIONS,
+        "observation_fields": [
+            "session_id", "task_id", "step", "timestamp",
+            "alerts", "services", "logs", "metrics",
+            "available_actions", "incident_resolved", "message",
+            "recent_deployments", "runbook_hints",
+        ],
+        "reward_range": [-999.0, 1.0],
+    }
+
+
+@app.post("/grader", response_model=GraderResponse, tags=["Environment Info"])
+async def grader(request: GraderRequest = Body(...)):
+    """
+    Get the current grader score for a session.
+
+    Graders are deterministic and can be called mid-episode or after completion.
+    Score range: 0.0 (no progress) to 1.0 (perfect solution).
+    """
+    try:
+        return env_manager.grade(request.session_id)
+    except KeyError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+
+
+@app.post("/baseline", tags=["Evaluation"])
+async def baseline(request: BaselineRequest = Body(default=BaselineRequest())):
+    """
+    Run the baseline inference agent against all tasks.
+
+    Requires OPENAI_API_KEY environment variable.
+    Uses a ReAct-style prompting strategy with the specified model.
+    Returns per-task scores and episode logs.
+    """
+    api_key = os.environ.get("OPENAI_API_KEY")
+    if not api_key:
+        raise HTTPException(
+            status_code=400,
+            detail="OPENAI_API_KEY environment variable not set. "
+                   "Set it to run the baseline agent.",
+        )
+
+    try:
+        results = await run_baseline_agent(
+            api_key=api_key,
+            model=request.model,
+            max_steps=request.max_steps,
+            task_ids=request.tasks,
+        )
+        return {
+            "model": request.model,
+            "results": results,
+            "summary": {
+                "mean_score": round(
+                    sum(r["score"] for r in results) / len(results), 4
+                ) if results else 0.0,
+                "tasks_passed": sum(
+                    1 for r in results
+                    if r["score"] >= TASK_REGISTRY[r["task_id"]].passing_score
+                ),
+                "total_tasks": len(results),
+            },
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Baseline error: {str(e)}")
+
+
+# ─── Baseline Agent Logic ─────────────────────────────────────────────────────
+
+SYSTEM_PROMPT = """You are an expert Site Reliability Engineer (SRE) responding to a production incident.
+You will receive alerts, service statuses, and investigation results.
+Your goal is to identify the root cause and resolve the incident efficiently.
+
+At each step, respond with ONLY a valid JSON object in this exact format:
+{"action_type": "<action>", "parameters": {<params>}}
+
+Available actions:
+- query_logs: {"service": "<name>"} — fetch logs for a service
+- check_metrics: {"service": "<name>"} — get metrics for a service  
+- check_config: {"service": "<name>"} — inspect live config
+- restart_service: {"service": "<name>"} — restart a service
+- rollback_deployment: {"service": "<name>"} — roll back to previous version
+- kill_query: {"source": "<service>"} — kill long-running DB queries from a source
+- scale_service: {"service": "<name>", "replicas": <n>} — change replica count
+- examine_trace: {"trace_id": "<id>"} — examine a distributed trace
+- acknowledge_alert: {"alert_id": "<id>"} — acknowledge an alert
+- resolve_incident: {} — mark incident resolved (use only when services are healthy)
+
+Strategy:
+1. Assess the alerts and service statuses
+2. Investigate (query logs, check metrics) before acting
+3. Form a hypothesis about root cause
+4. Apply the minimal targeted fix
+5. Verify services recovered, then resolve_incident
+
+Respond ONLY with JSON. No explanation. No markdown."""
+
+
+def _format_observation(obs: dict) -> str:
+    """Format observation as a prompt string for the LLM."""
+    lines = [f"=== INCIDENT — Step {obs['step']} ===\n"]
+
+    # Alerts
+    lines.append("ACTIVE ALERTS:")
+    for alert in obs.get("alerts", []):
+        ack = " [ACK]" if alert.get("acknowledged") else ""
+        lines.append(f"  [{alert['severity'].upper()}]{ack} {alert['service']}: {alert['message']}")
+
+    # Service statuses
+    lines.append("\nSERVICE STATUS:")
+    for name, svc in obs.get("services", {}).items():
+        conn_info = ""
+        if svc.get("connections") is not None:
+            conn_info = f" | connections: {svc['connections']}/{svc.get('max_connections', '?')}"
+        lines.append(
+            f"  {name}: {svc['status'].upper()} | cpu: {svc['cpu_percent']:.1f}% | "
+            f"mem: {svc['memory_percent']:.1f}% | errors: {svc['error_rate']:.1f}/s | "
+            f"v{svc.get('version', '?')}{conn_info}"
+        )
+
+    # Recent deployments
+    if obs.get("recent_deployments"):
+        lines.append("\nRECENT DEPLOYMENTS:")
+        for dep in obs["recent_deployments"]:
+            lines.append(f"  {dep['service']}: v{dep.get('previous','?')} → v{dep['version']} at {dep['deployed_at']}")
+
+    # Last action result
+    if obs.get("message"):
+        lines.append(f"\nLAST ACTION RESULT:\n{obs['message']}")
+
+    # Hints
+    if obs.get("runbook_hints"):
+        lines.append("\nRUNBOOK HINTS:")
+        for hint in obs["runbook_hints"]:
+            lines.append(f"  • {hint}")
+
+    return "\n".join(lines)
+
+
+async def run_baseline_agent(
+    api_key: str, model: str, max_steps: int, task_ids: list
+) -> list:
+    """Run a ReAct-style baseline agent against specified tasks."""
+    import httpx
+
+    base_url = "http://localhost:7860"
+    results = []
+
+    for task_id in task_ids:
+        if task_id not in TASK_REGISTRY:
+            continue
+
+        task = TASK_REGISTRY[task_id]
+        episode_log = []
+        score = 0.0
+        steps_taken = 0
+
+        try:
+            async with httpx.AsyncClient(timeout=60.0) as client:
+                # Reset
+                reset_resp = await client.post(
+                    f"{base_url}/reset",
+                    json={"task_id": task_id, "seed": 42},
+                )
+                obs = reset_resp.json()
+                session_id = obs["session_id"]
+                conversation = []
+                done = False
+
+                for step_num in range(max_steps):
+                    obs_text = _format_observation(obs)
+                    conversation.append({"role": "user", "content": obs_text})
+
+                    # Call LLM
+                    llm_response = await client.post(
+                        "https://api.openai.com/v1/chat/completions",
+                        headers={"Authorization": f"Bearer {api_key}"},
+                        json={
+                            "model": model,
+                            "messages": [
+                                {"role": "system", "content": SYSTEM_PROMPT},
+                                *conversation[-6:],  # keep last 3 turns
+                            ],
+                            "max_tokens": 200,
+                            "temperature": 0.0,
+                        },
+                    )
+                    llm_data = llm_response.json()
+                    action_text = llm_data["choices"][0]["message"]["content"].strip()
+                    conversation.append({"role": "assistant", "content": action_text})
+
+                    # Parse action
+                    try:
+                        action_dict = json.loads(action_text)
+                    except json.JSONDecodeError:
+                        # Try to extract JSON from text
+                        import re
+                        match = re.search(r'\{.*\}', action_text, re.DOTALL)
+                        if match:
+                            action_dict = json.loads(match.group())
+                        else:
+                            action_dict = {"action_type": "acknowledge_alert",
+                                           "parameters": {"alert_id": "ALT-001"}}
+
+                    action_type = action_dict.get("action_type", "")
+                    parameters = action_dict.get("parameters", {})
+
+                    # Step
+                    step_resp = await client.post(
+                        f"{base_url}/step",
+                        json={
+                            "session_id": session_id,
+                            "action": {"action_type": action_type, "parameters": parameters},
+                        },
+                    )
+                    step_data = step_resp.json()
+                    obs = step_data["observation"]
+                    done = step_data["done"]
+                    steps_taken = step_num + 1
+
+                    episode_log.append({
+                        "step": step_num + 1,
+                        "action": {"action_type": action_type, "parameters": parameters},
+                        "reward": step_data["reward"]["value"],
+                        "message_preview": obs.get("message", "")[:100],
+                    })
+
+                    if done:
+                        break
+
+                # Get final grader score
+                grader_resp = await client.post(
+                    f"{base_url}/grader",
+                    json={"session_id": session_id},
+                )
+                grader_data = grader_resp.json()
+                score = grader_data["score"]
+
+        except Exception as e:
+            episode_log.append({"error": str(e)})
+
+        results.append({
+            "task_id": task_id,
+            "task_name": task.name,
+            "difficulty": task.difficulty,
+            "score": score,
+            "steps_taken": steps_taken,
+            "episode_log": episode_log,
+            "success": score >= task.passing_score,
+        })
+
+    return results
+
+
+# ─── Entry Point ──────────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("app.main:app", host="0.0.0.0", port=7860, reload=False)

app/models.py

@@ -0,0 +1,181 @@
+"""
+OpenEnv typed models for SRE Incident Response environment.
+Complies with OpenEnv spec: Observation, Action, Reward as Pydantic models.
+"""
+
+from pydantic import BaseModel, Field
+from typing import Dict, List, Optional, Any, Literal
+from datetime import datetime
+
+
+# ─── Core Domain Models ──────────────────────────────────────────────────────
+
+class ServiceStatus(BaseModel):
+    name: str
+    status: Literal["healthy", "degraded", "down", "unknown"]
+    cpu_percent: float = Field(..., ge=0.0, le=100.0)
+    memory_percent: float = Field(..., ge=0.0, le=100.0)
+    error_rate: float = Field(..., ge=0.0, description="Errors per second")
+    connections: Optional[int] = None
+    max_connections: Optional[int] = None
+    replicas: int = 1
+    version: str = "1.0.0"
+    tags: Dict[str, str] = {}
+
+
+class Alert(BaseModel):
+    alert_id: str
+    severity: Literal["critical", "warning", "info"]
+    service: str
+    message: str
+    triggered_at: str
+    acknowledged: bool = False
+
+
+class LogEntry(BaseModel):
+    timestamp: str
+    level: Literal["ERROR", "WARN", "INFO", "DEBUG"]
+    service: str
+    message: str
+    trace_id: Optional[str] = None
+
+
+class MetricPoint(BaseModel):
+    name: str
+    value: float
+    unit: str
+    service: str
+    timestamp: str
+
+
+# ─── OpenEnv Core Types ───────────────────────────────────────────────────────
+
+class Observation(BaseModel):
+    """
+    The agent's view of the environment at each step.
+    Implements OpenEnv Observation spec.
+    """
+    session_id: str
+    task_id: str
+    step: int
+    timestamp: str
+
+    # Incident data (always visible)
+    alerts: List[Alert]
+    services: Dict[str, ServiceStatus]
+
+    # Queried data (only populated after agent investigates)
+    logs: List[LogEntry] = []
+    metrics: List[MetricPoint] = []
+
+    # Episode state
+    available_actions: List[str]
+    incident_resolved: bool = False
+    message: str = ""
+
+    # Contextual hints
+    recent_deployments: List[Dict[str, Any]] = []
+    runbook_hints: List[str] = []
+
+
+class Action(BaseModel):
+    """
+    An action the agent can take in the environment.
+    Implements OpenEnv Action spec.
+
+    action_type options:
+      - query_logs: Fetch recent logs for a service
+      - check_metrics: Retrieve metrics for a service
+      - restart_service: Restart a named service
+      - rollback_deployment: Roll back a service to its previous version
+      - scale_service: Change replica count
+      - kill_query: Terminate a running database query from a named source
+      - acknowledge_alert: Acknowledge an alert by ID
+      - examine_trace: Examine a distributed trace by trace_id
+      - check_config: Inspect the live configuration of a service
+      - resolve_incident: Mark the incident as resolved (terminal action)
+    """
+    action_type: str = Field(
+        ...,
+        description="The type of action to perform",
+        examples=["query_logs", "restart_service", "resolve_incident"],
+    )
+    parameters: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Action-specific parameters. E.g., {'service': 'web-api'}",
+        examples=[{"service": "web-api"}, {"service": "db-primary", "source": "analytics-worker"}],
+    )
+
+
+class Reward(BaseModel):
+    """
+    Per-step reward with breakdown for interpretability.
+    Implements OpenEnv Reward spec.
+    """
+    value: float = Field(..., description="Reward for this step")
+    cumulative: float = Field(..., description="Total reward so far this episode")
+    breakdown: Dict[str, float] = Field(
+        default_factory=dict,
+        description="Named reward components for debugging",
+    )
+    message: str = Field("", description="Human-readable explanation of reward")
+
+
+class StepResponse(BaseModel):
+    """Full response from a step() call."""
+    observation: Observation
+    reward: Reward
+    done: bool
+    info: Dict[str, Any] = {}
+
+
+class ResetRequest(BaseModel):
+    """Request body for reset()."""
+    task_id: str = Field("task1", description="One of: task1, task2, task3")
+    seed: Optional[int] = Field(None, description="Random seed for reproducibility")
+
+
+class StateResponse(BaseModel):
+    """Full internal state (for grading/debugging)."""
+    session_id: str
+    task_id: str
+    step: int
+    done: bool
+    total_reward: float
+    world_state: Dict[str, Any]
+    action_history: List[Dict[str, Any]]
+    grader_score: Optional[float] = None
+
+
+class TaskInfo(BaseModel):
+    """Metadata about a task."""
+    task_id: str
+    name: str
+    description: str
+    difficulty: Literal["easy", "medium", "hard"]
+    max_steps: int
+    passing_score: float
+    action_schema: Dict[str, Any]
+    observation_schema: Dict[str, Any]
+
+
+class GraderResponse(BaseModel):
+    """Response from /grader endpoint."""
+    session_id: str
+    task_id: str
+    score: float = Field(..., ge=0.0, le=1.0)
+    breakdown: Dict[str, float]
+    episode_complete: bool
+    steps_taken: int
+    message: str
+
+
+class BaselineResult(BaseModel):
+    """Result from /baseline endpoint."""
+    task_id: str
+    task_name: str
+    difficulty: str
+    score: float
+    steps_taken: int
+    episode_log: List[Dict[str, Any]]
+    success: bool

app/tasks/__init__.py

@@ -0,0 +1,11 @@
+from app.tasks.task1 import CPUSpikeTask
+from app.tasks.task2 import DBConnectionPoolTask
+from app.tasks.task3 import CascadingFailureTask
+
+TASK_REGISTRY = {
+    "task1": CPUSpikeTask(),
+    "task2": DBConnectionPoolTask(),
+    "task3": CascadingFailureTask(),
+}
+
+__all__ = ["TASK_REGISTRY", "CPUSpikeTask", "DBConnectionPoolTask", "CascadingFailureTask"]

app/tasks/base.py

@@ -0,0 +1,137 @@
+"""Base class for all SRE incident tasks."""
+
+from abc import ABC, abstractmethod
+from typing import Dict, Any, Tuple, List
+from app.models import Observation, Alert, ServiceStatus, LogEntry, MetricPoint
+from datetime import datetime, timezone
+
+
+BASE_INCIDENT_TIME = "2024-11-15T09:47:00Z"
+
+AVAILABLE_ACTIONS = [
+    "query_logs",
+    "check_metrics",
+    "restart_service",
+    "rollback_deployment",
+    "scale_service",
+    "kill_query",
+    "acknowledge_alert",
+    "examine_trace",
+    "check_config",
+    "resolve_incident",
+]
+
+ACTION_SCHEMA = {
+    "query_logs": {
+        "description": "Fetch recent log entries for a service",
+        "parameters": {
+            "service": {"type": "string", "required": True, "description": "Service name"},
+            "lines": {"type": "integer", "required": False, "default": 50},
+        },
+    },
+    "check_metrics": {
+        "description": "Retrieve current metrics for a service",
+        "parameters": {
+            "service": {"type": "string", "required": True},
+        },
+    },
+    "restart_service": {
+        "description": "Restart a service (rolling restart, brief downtime)",
+        "parameters": {
+            "service": {"type": "string", "required": True},
+        },
+    },
+    "rollback_deployment": {
+        "description": "Roll back a service to its previous deployment version",
+        "parameters": {
+            "service": {"type": "string", "required": True},
+        },
+    },
+    "scale_service": {
+        "description": "Change the number of replicas for a service",
+        "parameters": {
+            "service": {"type": "string", "required": True},
+            "replicas": {"type": "integer", "required": True, "min": 1, "max": 20},
+        },
+    },
+    "kill_query": {
+        "description": "Kill long-running database queries from a specific source/application",
+        "parameters": {
+            "source": {"type": "string", "required": True, "description": "Application or service holding queries"},
+        },
+    },
+    "acknowledge_alert": {
+        "description": "Acknowledge an alert to stop paging",
+        "parameters": {
+            "alert_id": {"type": "string", "required": True},
+        },
+    },
+    "examine_trace": {
+        "description": "Examine a distributed trace to identify slow spans",
+        "parameters": {
+            "trace_id": {"type": "string", "required": True},
+        },
+    },
+    "check_config": {
+        "description": "Inspect the live runtime configuration of a service",
+        "parameters": {
+            "service": {"type": "string", "required": True},
+        },
+    },
+    "resolve_incident": {
+        "description": "Mark the incident as resolved. Terminal action — ends the episode.",
+        "parameters": {},
+    },
+}
+
+
+class BaseTask(ABC):
+    task_id: str
+    name: str
+    description: str
+    difficulty: str
+    max_steps: int
+    passing_score: float = 0.6
+
+    @abstractmethod
+    def initial_state(self, seed: int = 42) -> Dict[str, Any]:
+        """Return initial world state dict."""
+        ...
+
+    @abstractmethod
+    def process_action(
+        self, action_type: str, params: Dict[str, Any], state: Dict[str, Any]
+    ) -> Tuple[Dict[str, Any], float, bool, str]:
+        """
+        Apply action to state.
+        Returns: (new_state, step_reward, done, message)
+        """
+        ...
+
+    @abstractmethod
+    def get_observation(self, state: Dict[str, Any], session_id: str, step: int) -> Observation:
+        """Build Observation from state."""
+        ...
+
+    @abstractmethod
+    def grade(self, state: Dict[str, Any], history: List[Dict]) -> Tuple[float, Dict[str, float]]:
+        """
+        Grade the episode.
+        Returns: (score 0.0–1.0, breakdown dict)
+        """
+        ...
+
+    def _make_service(self, name: str, status: str, cpu: float, mem: float,
+                       err: float, **kwargs) -> ServiceStatus:
+        return ServiceStatus(
+            name=name, status=status,
+            cpu_percent=cpu, memory_percent=mem, error_rate=err,
+            **kwargs,
+        )
+
+    def _make_alert(self, alert_id: str, severity: str, service: str,
+                     message: str, ack: bool = False) -> Alert:
+        return Alert(
+            alert_id=alert_id, severity=severity, service=service,
+            message=message, triggered_at=BASE_INCIDENT_TIME, acknowledged=ack,
+        )

app/tasks/task1.py

@@ -0,0 +1,359 @@
+"""
+Task 1: CPU Spike Investigation (Easy)
+=======================================
+Scenario: The web-api service has been pegged at 95% CPU for 12 minutes,
+causing elevated latency. A memory leak in the request handler is causing
+a GC spin loop. The agent must investigate and restart the service.
+
+Optimal solution: query_logs(web-api) → restart_service(web-api) → resolve_incident()
+Max steps: 15  |  Passing score: 0.6
+"""
+
+from typing import Dict, Any, Tuple, List
+from app.models import Observation, Alert, ServiceStatus, LogEntry, MetricPoint
+from app.tasks.base import BaseTask, AVAILABLE_ACTIONS, BASE_INCIDENT_TIME
+
+
+class CPUSpikeTask(BaseTask):
+    task_id = "task1"
+    name = "CPU Spike Investigation"
+    description = (
+        "The web-api service is consuming 95% CPU. Investigate the root cause "
+        "using logs and metrics, then remediate the incident."
+    )
+    difficulty = "easy"
+    max_steps = 15
+    passing_score = 0.6
+
+    def initial_state(self, seed: int = 42) -> Dict[str, Any]:
+        return {
+            "services": {
+                "web-api": {
+                    "status": "degraded", "cpu": 95.2, "memory": 78.4,
+                    "error_rate": 3.1, "version": "2.3.1", "replicas": 2,
+                },
+                "db-primary": {
+                    "status": "healthy", "cpu": 14.0, "memory": 48.0,
+                    "error_rate": 0.0, "connections": 28, "max_connections": 100,
+                    "version": "14.5",
+                },
+                "cache": {
+                    "status": "healthy", "cpu": 6.0, "memory": 32.0,
+                    "error_rate": 0.0, "version": "7.2.0",
+                },
+                "load-balancer": {
+                    "status": "healthy", "cpu": 3.0, "memory": 15.0,
+                    "error_rate": 0.0, "version": "1.28.0",
+                },
+            },
+            "alerts": [
+                {"id": "ALT-001", "sev": "critical", "svc": "web-api",
+                 "msg": "CPU utilization at 95.2% — sustained for 12 minutes (threshold: 80%)",
+                 "ack": False},
+                {"id": "ALT-002", "sev": "warning", "svc": "web-api",
+                 "msg": "Request latency P99 = 8.4s (SLA threshold: 2s)",
+                 "ack": False},
+                {"id": "ALT-003", "sev": "info", "svc": "load-balancer",
+                 "msg": "Increased error routing to healthy upstream",
+                 "ack": False},
+            ],
+            "recent_deployments": [
+                {"service": "web-api", "version": "2.3.1", "previous": "2.3.0",
+                 "deployed_at": "2024-11-15T06:00:00Z", "deployer": "ci-pipeline"},
+                {"service": "cache", "version": "7.2.0", "previous": "7.1.9",
+                 "deployed_at": "2024-11-14T22:00:00Z", "deployer": "ci-pipeline"},
+            ],
+            # Tracking agent progress
+            "logs_queried": [],
+            "metrics_checked": [],
+            "configs_checked": [],
+            "traces_examined": [],
+            "web_api_restarted": False,
+            "wrong_actions": 0,
+            "incident_resolved": False,
+        }
+
+    def process_action(
+        self, action_type: str, params: Dict[str, Any], state: Dict[str, Any]
+    ) -> Tuple[Dict[str, Any], float, bool, str]:
+        reward = 0.0
+        done = False
+        message = ""
+        service = params.get("service", "").strip()
+
+        if action_type == "query_logs":
+            if not service:
+                return state, -0.02, False, "Parameter 'service' is required for query_logs."
+            if service in state["logs_queried"]:
+                reward = 0.0
+                message = f"[Cached] Logs for {service} already retrieved."
+            elif service == "web-api":
+                state["logs_queried"].append(service)
+                reward = 0.12
+                message = (
+                    "2024-11-15T09:34:11Z [ERROR] web-api RequestHandler: OutOfMemoryError "
+                    "caught, forcing GC — heap 98% full\n"
+                    "2024-11-15T09:35:02Z [ERROR] web-api RequestHandler: GC pause 1240ms, "
+                    "thread stalled — possible memory leak in connection pool\n"
+                    "2024-11-15T09:36:45Z [WARN]  web-api ConnectionPool: 512 leaked "
+                    "connections detected, pool not releasing objects\n"
+                    "2024-11-15T09:38:00Z [ERROR] web-api RequestHandler: CPU spin on GC "
+                    "collect() — recommend service restart\n"
+                    "2024-11-15T09:44:20Z [ERROR] web-api: request timeout after 8000ms "
+                    "(3 occurrences in last 60s)\n"
+                    "ROOT CAUSE HINT: Connection pool is leaking — GC is spinning trying "
+                    "to reclaim memory, causing CPU spike."
+                )
+            elif service == "db-primary":
+                state["logs_queried"].append(service)
+                reward = 0.02
+                message = (
+                    "2024-11-15T09:40:00Z [INFO] db-primary: checkpoint completed\n"
+                    "2024-11-15T09:45:00Z [INFO] db-primary: autovacuum finished on table users\n"
+                    "No anomalies in database logs."
+                )
+            elif service == "cache":
+                state["logs_queried"].append(service)
+                reward = 0.02
+                message = (
+                    "2024-11-15T09:30:00Z [INFO] cache: eviction rate 0.2%\n"
+                    "No anomalies in cache logs."
+                )
+            else:
+                state["logs_queried"].append(service)
+                reward = 0.01
+                message = f"No logs found for service '{service}'."
+
+        elif action_type == "check_metrics":
+            if not service:
+                return state, -0.02, False, "Parameter 'service' is required for check_metrics."
+            if service in state["metrics_checked"]:
+                message = f"[Cached] Metrics for {service} already retrieved."
+                reward = 0.0
+            elif service == "web-api":
+                state["metrics_checked"].append(service)
+                reward = 0.06
+                message = (
+                    "web-api metrics (last 15 min):\n"
+                    "  cpu_percent:       95.2% ↑ (was 12% before 09:30)\n"
+                    "  memory_percent:    78.4% ↑ (growing 1.2%/min)\n"
+                    "  heap_used_mb:      3840 / 4096\n"
+                    "  gc_pause_ms_avg:   950ms (normal: <50ms)\n"
+                    "  request_latency_p99: 8.4s\n"
+                    "  connections_leaked: 512 (normal: 0)\n"
+                    "INSIGHT: Memory growth is linear — classic leak pattern."
+                )
+            else:
+                state["metrics_checked"].append(service)
+                reward = 0.02
+                message = f"Metrics for {service}: All values within normal operating ranges."
+
+        elif action_type == "check_config":
+            if not service:
+                return state, -0.02, False, "Parameter 'service' is required for check_config."
+            state["configs_checked"].append(service)
+            if service == "web-api":
+                reward = 0.04
+                message = (
+                    "web-api live config:\n"
+                    "  connection_pool_max: 512\n"
+                    "  connection_pool_timeout: 30s\n"
+                    "  connection_pool_recycle: DISABLED  ← note: recycle was enabled in v2.3.0\n"
+                    "  heap_size: 4096m\n"
+                    "  gc_policy: G1GC\n"
+                    "Config change in v2.3.1: connection_pool_recycle was accidentally disabled."
+                )
+            else:
+                reward = 0.01
+                message = f"Config for {service}: No unusual settings detected."
+
+        elif action_type == "restart_service":
+            if not service:
+                return state, -0.02, False, "Parameter 'service' is required for restart_service."
+            if service == "web-api":
+                state["web_api_restarted"] = True
+                state["services"]["web-api"]["status"] = "healthy"
+                state["services"]["web-api"]["cpu"] = 11.0
+                state["services"]["web-api"]["memory"] = 34.0
+                state["services"]["web-api"]["error_rate"] = 0.0
+                reward = 0.40
+                message = (
+                    "✓ web-api restarted successfully (rolling restart, ~15s downtime).\n"
+                    "  CPU: 95.2% → 11.0%\n"
+                    "  Memory: 78.4% → 34.0%\n"
+                    "  Error rate: 3.1/s → 0.0/s\n"
+                    "  Status: healthy\n"
+                    "NOTE: Root cause (disabled connection pool recycle) is still present. "
+                    "CPU spike may recur without a permanent fix."
+                )
+            else:
+                state["wrong_actions"] += 1
+                reward = -0.08
+                message = (
+                    f"Restarted {service}, but this service is healthy and unrelated to "
+                    f"the incident. No improvement observed. Avoid unnecessary restarts."
+                )
+
+        elif action_type == "rollback_deployment":
+            if not service:
+                return state, -0.02, False, "Parameter 'service' is required for rollback_deployment."
+            if service == "web-api":
+                # Rollback also fixes it (alternative valid solution)
+                state["web_api_restarted"] = True  # treat as resolved
+                state["services"]["web-api"]["status"] = "healthy"
+                state["services"]["web-api"]["cpu"] = 10.0
+                state["services"]["web-api"]["memory"] = 32.0
+                state["services"]["web-api"]["error_rate"] = 0.0
+                reward = 0.45  # slightly better because it fixes root cause
+                message = (
+                    "✓ web-api rolled back to v2.3.0.\n"
+                    "  connection_pool_recycle re-enabled.\n"
+                    "  CPU: 95.2% → 10.0%\n"
+                    "  Memory: 78.4% → 32.0%\n"
+                    "  Status: healthy\n"
+                    "EXCELLENT: This addresses the root cause, not just the symptom."
+                )
+            else:
+                state["wrong_actions"] += 1
+                reward = -0.05
+                message = f"Rolled back {service}, but this is unrelated to the incident."
+
+        elif action_type == "scale_service":
+            if service == "web-api":
+                replicas = params.get("replicas", 2)
+                reward = 0.05
+                message = (
+                    f"Scaled web-api to {replicas} replicas. This distributes load but "
+                    f"does NOT fix the underlying memory leak. CPU per instance still high."
+                )
+            else:
+                reward = -0.03
+                message = f"Scaling {service} has no effect on the current incident."
+
+        elif action_type == "acknowledge_alert":
+            alert_id = params.get("alert_id", "")
+            for a in state["alerts"]:
+                if a["id"] == alert_id:
+                    a["ack"] = True
+            reward = 0.01
+            message = f"Alert {alert_id} acknowledged."
+
+        elif action_type == "examine_trace":
+            state["traces_examined"].append(params.get("trace_id", "unknown"))
+            reward = 0.03
+            message = (
+                "Trace analysis: Request span shows 7.8s blocked in GC pause within "
+                "web-api RequestHandler. All downstream services (db, cache) responding "
+                "normally. Bottleneck is exclusively in web-api."
+            )
+
+        elif action_type == "resolve_incident":
+            if state["web_api_restarted"]:
+                state["incident_resolved"] = True
+                done = True
+                reward = 0.30
+                message = (
+                    "✓ Incident resolved.\n"
+                    "Summary: web-api experienced a CPU spike due to a memory leak "
+                    "(connection pool not recycling in v2.3.1). Service was remediated."
+                )
+            else:
+                reward = -0.05
+                message = (
+                    "Cannot resolve: web-api is still degraded (CPU 95.2%). "
+                    "Investigate and fix the root cause before resolving."
+                )
+
+        else:
+            reward = -0.03
+            message = f"Unknown or inapplicable action: {action_type}."
+
+        return state, reward, done, message
+
+    def get_observation(self, state: Dict[str, Any], session_id: str, step: int) -> Observation:
+        services = {}
+        for name, s in state["services"].items():
+            services[name] = ServiceStatus(
+                name=name,
+                status=s["status"],
+                cpu_percent=s["cpu"],
+                memory_percent=s["memory"],
+                error_rate=s["error_rate"],
+                connections=s.get("connections"),
+                max_connections=s.get("max_connections"),
+                version=s.get("version", "1.0.0"),
+                replicas=s.get("replicas", 1),
+            )
+
+        alerts = [
+            Alert(
+                alert_id=a["id"], severity=a["sev"], service=a["svc"],
+                message=a["msg"], triggered_at=BASE_INCIDENT_TIME,
+                acknowledged=a["ack"],
+            )
+            for a in state["alerts"]
+        ]
+
+        return Observation(
+            session_id=session_id,
+            task_id=self.task_id,
+            step=step,
+            timestamp=BASE_INCIDENT_TIME,
+            alerts=alerts,
+            services=services,
+            logs=[],
+            metrics=[],
+            available_actions=AVAILABLE_ACTIONS,
+            incident_resolved=state["incident_resolved"],
+            message="",
+            recent_deployments=state["recent_deployments"],
+            runbook_hints=[
+                "High CPU often caused by: memory leaks, infinite loops, or hot code paths.",
+                "Check recent deployments for configuration changes.",
+                "query_logs and check_metrics before taking disruptive actions.",
+            ],
+        )
+
+    def grade(self, state: Dict[str, Any], history: List[Dict]) -> Tuple[float, Dict[str, float]]:
+        breakdown = {}
+        score = 0.0
+
+        # Root cause investigated?
+        if "web-api" in state.get("logs_queried", []) or \
+           "web-api" in state.get("metrics_checked", []) or \
+           "web-api" in state.get("configs_checked", []):
+            breakdown["investigated_root_service"] = 0.15
+            score += 0.15
+
+        # Service remediated?
+        if state.get("web_api_restarted", False):
+            breakdown["service_remediated"] = 0.45
+            score += 0.45
+
+        # Incident formally closed?
+        if state.get("incident_resolved", False):
+            breakdown["incident_resolved"] = 0.25
+            score += 0.25
+
+        # Efficiency bonus
+        steps = len(history)
+        if steps <= 4:
+            breakdown["efficiency_bonus"] = 0.15
+            score += 0.15
+        elif steps <= 7:
+            breakdown["efficiency_bonus"] = 0.10
+            score += 0.10
+        elif steps <= 10:
+            breakdown["efficiency_bonus"] = 0.05
+            score += 0.05
+        else:
+            breakdown["efficiency_bonus"] = 0.0
+
+        # Penalty for wrong actions
+        wrong = state.get("wrong_actions", 0)
+        if wrong > 0:
+            penalty = min(wrong * 0.08, 0.20)
+            breakdown["wrong_action_penalty"] = -penalty
+            score -= penalty
+
+        return round(min(max(score, 0.0), 1.0), 4), breakdown

app/tasks/task2.py

@@ -0,0 +1,445 @@
+"""
+Task 2: Database Connection Pool Exhaustion (Medium)
+=====================================================
+Scenario: The db-primary connection pool is fully exhausted (100/100 connections).
+Multiple dependent services (payment-api, user-service) are timing out.
+Root cause: analytics-worker is running unbounded full-table scans, holding 78
+long-running connections that never release.
+
+Trap: Restarting the DB makes things temporarily worse (all services lose their
+remaining connections during restart and have to reconnect).
+
+Optimal: check_metrics(db-primary) → query_logs(db-primary) →
+         kill_query(analytics-worker) → resolve_incident()
+Max steps: 18  |  Passing score: 0.6
+"""
+
+from typing import Dict, Any, Tuple, List
+from app.models import Observation, Alert, ServiceStatus, LogEntry, MetricPoint
+from app.tasks.base import BaseTask, AVAILABLE_ACTIONS, BASE_INCIDENT_TIME
+
+
+class DBConnectionPoolTask(BaseTask):
+    task_id = "task2"
+    name = "Database Connection Pool Exhaustion"
+    description = (
+        "The db-primary connection pool is exhausted (100/100). Multiple services "
+        "are timing out on DB calls. Identify which application is holding excess "
+        "connections and remediate without restarting the database."
+    )
+    difficulty = "medium"
+    max_steps = 18
+    passing_score = 0.6
+
+    def initial_state(self, seed: int = 42) -> Dict[str, Any]:
+        return {
+            "services": {
+                "db-primary": {
+                    "status": "degraded", "cpu": 31.0, "memory": 62.0,
+                    "error_rate": 8.2, "connections": 100, "max_connections": 100,
+                    "version": "14.8",
+                },
+                "payment-api": {
+                    "status": "degraded", "cpu": 45.0, "memory": 55.0,
+                    "error_rate": 12.4, "connections": 8, "max_connections": 20,
+                    "version": "3.1.2",
+                },
+                "user-service": {
+                    "status": "degraded", "cpu": 38.0, "memory": 50.0,
+                    "error_rate": 9.7, "connections": 6, "max_connections": 20,
+                    "version": "2.4.0",
+                },
+                "analytics-worker": {
+                    "status": "healthy", "cpu": 42.0, "memory": 70.0,
+                    "error_rate": 0.0, "connections": 78, "max_connections": 80,
+                    "version": "1.0.9",
+                },
+                "cache": {
+                    "status": "healthy", "cpu": 5.0, "memory": 28.0,
+                    "error_rate": 0.0, "version": "7.2.0",
+                },
+            },
+            "alerts": [
+                {"id": "ALT-010", "sev": "critical", "svc": "db-primary",
+                 "msg": "Connection pool exhausted: 100/100 connections in use",
+                 "ack": False},
+                {"id": "ALT-011", "sev": "critical", "svc": "payment-api",
+                 "msg": "High error rate 12.4/s — DB connection timeout after 30s",
+                 "ack": False},
+                {"id": "ALT-012", "sev": "critical", "svc": "user-service",
+                 "msg": "High error rate 9.7/s — DB connection timeout after 30s",
+                 "ack": False},
+                {"id": "ALT-013", "sev": "warning", "svc": "analytics-worker",
+                 "msg": "High memory usage 70% on analytics-worker",
+                 "ack": False},
+            ],
+            "recent_deployments": [
+                {"service": "analytics-worker", "version": "1.0.9", "previous": "1.0.8",
+                 "deployed_at": "2024-11-15T08:00:00Z", "deployer": "data-team"},
+                {"service": "payment-api", "version": "3.1.2", "previous": "3.1.1",
+                 "deployed_at": "2024-11-14T16:00:00Z", "deployer": "ci-pipeline"},
+            ],
+            # Tracking agent progress
+            "logs_queried": [],
+            "metrics_checked": [],
+            "configs_checked": [],
+            "queries_killed": [],
+            "db_restarted": False,
+            "analytics_worker_killed": False,
+            "wrong_actions": 0,
+            "incident_resolved": False,
+            # Hidden state — what's actually happening
+            "_analytics_holding_connections": True,
+            "_db_connections_freed": False,
+        }
+
+    def process_action(
+        self, action_type: str, params: Dict[str, Any], state: Dict[str, Any]
+    ) -> Tuple[Dict[str, Any], float, bool, str]:
+        reward = 0.0
+        done = False
+        message = ""
+        service = params.get("service", "").strip()
+
+        if action_type == "query_logs":
+            if not service:
+                return state, -0.02, False, "Parameter 'service' is required."
+            if service in state["logs_queried"]:
+                return state, 0.0, False, f"[Cached] Logs for {service} already retrieved."
+            state["logs_queried"].append(service)
+
+            if service == "db-primary":
+                reward = 0.14
+                message = (
+                    "2024-11-15T09:32:00Z [WARN]  db-primary: connection count 95/100\n"
+                    "2024-11-15T09:35:00Z [ERROR] db-primary: connection pool full, "
+                    "new connections queued\n"
+                    "2024-11-15T09:38:00Z [ERROR] db-primary: query from analytics-worker "
+                    "pid=28441 running 18min on table 'events' (full table scan, no index)\n"
+                    "2024-11-15T09:40:00Z [ERROR] db-primary: 78 long-running queries from "
+                    "analytics-worker — these are consuming all connections\n"
+                    "2024-11-15T09:44:00Z [ERROR] db-primary: payment-api cannot acquire "
+                    "connection — pool exhausted\n"
+                    "ROOT CAUSE: analytics-worker is running full table scans on 'events' "
+                    "table, holding 78 connections indefinitely."
+                )
+            elif service == "analytics-worker":
+                reward = 0.10
+                message = (
+                    "2024-11-15T08:01:00Z [INFO]  analytics-worker: v1.0.9 deployed\n"
+                    "2024-11-15T08:05:00Z [INFO]  analytics-worker: starting daily report job\n"
+                    "2024-11-15T08:05:10Z [WARN]  analytics-worker: query_timeout config "
+                    "missing — defaulting to no timeout\n"
+                    "2024-11-15T09:10:00Z [WARN]  analytics-worker: 78 concurrent queries "
+                    "running for >60min — possible misconfiguration\n"
+                    "BUG IN v1.0.9: query_timeout was removed from config, causing unbounded "
+                    "full-table scans that never terminate."
+                )
+            elif service == "payment-api":
+                reward = 0.06
+                message = (
+                    "2024-11-15T09:38:00Z [ERROR] payment-api: db connection timeout "
+                    "after 30s — pool exhausted upstream\n"
+                    "2024-11-15T09:39:00Z [ERROR] payment-api: 12 transaction failures "
+                    "due to DB unavailability\n"
+                    "payment-api is a victim, not the root cause."
+                )
+            elif service == "user-service":
+                reward = 0.05
+                message = (
+                    "2024-11-15T09:38:30Z [ERROR] user-service: DB connection timeout — "
+                    "pool exhausted upstream\n"
+                    "user-service is a victim, not the root cause."
+                )
+            else:
+                reward = 0.01
+                message = f"No relevant logs found for '{service}'."
+
+        elif action_type == "check_metrics":
+            if not service:
+                return state, -0.02, False, "Parameter 'service' is required."
+            if service in state["metrics_checked"]:
+                return state, 0.0, False, f"[Cached] Metrics for {service} already retrieved."
+            state["metrics_checked"].append(service)
+
+            if service == "db-primary":
+                reward = 0.12
+                message = (
+                    "db-primary metrics:\n"
+                    "  active_connections:    100 / 100  ← FULL\n"
+                    "  connections_by_client:\n"
+                    "    analytics-worker:    78  ← 78% of pool\n"
+                    "    payment-api:          8\n"
+                    "    user-service:         6\n"
+                    "    other:                8\n"
+                    "  longest_query_duration: 18m 42s (from analytics-worker)\n"
+                    "  queries_waiting_for_lock: 12\n"
+                    "  replication_lag:       0ms\n"
+                    "CRITICAL: analytics-worker holds 78/100 connections."
+                )
+            elif service == "analytics-worker":
+                reward = 0.06
+                message = (
+                    "analytics-worker metrics:\n"
+                    "  active_db_connections: 78\n"
+                    "  cpu_percent:           42.0%\n"
+                    "  memory_percent:        70.2%\n"
+                    "  rows_scanned_per_sec:  45000 (full table scan pattern)\n"
+                    "  queries_timed_out:     0  ← no query timeout configured!\n"
+                )
+            else:
+                reward = 0.02
+                message = f"Metrics for {service}: Elevated error rates due to DB connection failures."
+
+        elif action_type == "check_config":
+            state["configs_checked"].append(service)
+            if service == "analytics-worker":
+                reward = 0.08
+                message = (
+                    "analytics-worker config (v1.0.9):\n"
+                    "  db_connection_pool_size: 80\n"
+                    "  query_timeout:           (not set)  ← MISSING in v1.0.9\n"
+                    "  max_concurrent_queries:  (not set)\n"
+                    "  report_schedule:         0 8 * * *\n\n"
+                    "analytics-worker config (v1.0.8 — previous):\n"
+                    "  db_connection_pool_size: 20\n"
+                    "  query_timeout:           600  ← was 10 minutes\n"
+                    "  max_concurrent_queries:  5\n"
+                    "REGRESSION: v1.0.9 removed query_timeout and raised pool_size to 80."
+                )
+            elif service == "db-primary":
+                reward = 0.04
+                message = (
+                    "db-primary config:\n"
+                    "  max_connections: 100\n"
+                    "  statement_timeout: (not set at server level)\n"
+                    "  idle_in_transaction_session_timeout: 0 (disabled)\n"
+                )
+            else:
+                reward = 0.01
+                message = f"Config for {service}: No unusual settings."
+
+        elif action_type == "kill_query":
+            source = params.get("source", "").strip()
+            if source == "analytics-worker":
+                state["queries_killed"].append("analytics-worker")
+                state["analytics_worker_killed"] = True
+                state["_db_connections_freed"] = True
+                # Update db-primary state
+                state["services"]["db-primary"]["connections"] = 22
+                state["services"]["db-primary"]["status"] = "healthy"
+                state["services"]["db-primary"]["error_rate"] = 0.0
+                # Update dependent services
+                state["services"]["payment-api"]["status"] = "healthy"
+                state["services"]["payment-api"]["error_rate"] = 0.1
+                state["services"]["user-service"]["status"] = "healthy"
+                state["services"]["user-service"]["error_rate"] = 0.1
+                reward = 0.40
+                message = (
+                    "✓ Killed 78 long-running queries from analytics-worker.\n"
+                    "  db-primary connections: 100 → 22\n"
+                    "  db-primary status: degraded → healthy\n"
+                    "  payment-api: recovering (error rate dropping)\n"
+                    "  user-service: recovering (error rate dropping)\n"
+                    "NOTE: analytics-worker may restart the runaway queries on next job run. "
+                    "Consider also rolling back analytics-worker to v1.0.8."
+                )
+            else:
+                state["wrong_actions"] += 1
+                reward = -0.05
+                message = (
+                    f"No long-running queries found from '{source}'. "
+                    "Check db metrics to identify the actual source of connection exhaustion."
+                )
+
+        elif action_type == "restart_service":
+            if service == "db-primary":
+                state["db_restarted"] = True
+                state["wrong_actions"] += 1
+                # Restarting DB causes brief outage for all — connections drop but analytics-worker
+                # reconnects immediately and fills the pool again
+                reward = -0.15
+                message = (
+                    "⚠ db-primary restarted — ALL services lost their connections.\n"
+                    "  payment-api: connection errors spiking\n"
+                    "  user-service: connection errors spiking\n"
+                    "  analytics-worker: reconnected immediately, refilling pool with 78 queries\n"
+                    "RESULT: Restart did not fix the root cause. analytics-worker filled the "
+                    "pool again within 30 seconds. This approach is ineffective here."
+                )
+            elif service == "analytics-worker":
+                # Partial fix — stops current queries but doesn't prevent recurrence
+                state["queries_killed"].append("analytics-worker-restart")
+                state["services"]["db-primary"]["connections"] = 22
+                state["services"]["db-primary"]["status"] = "healthy"
+                state["services"]["payment-api"]["status"] = "healthy"
+                state["services"]["user-service"]["status"] = "healthy"
+                reward = 0.20  # partial credit — works but is heavy-handed
+                message = (
+                    "analytics-worker restarted. Current runaway queries terminated.\n"
+                    "  db-primary connections: 100 → 22 (analytics-worker queries cleared)\n"
+                    "  payment-api, user-service: recovering\n"
+                    "NOTE: This is a blunt fix. analytics-worker will restart its job and "
+                    "may cause the same issue again without a config fix."
+                )
+            else:
+                state["wrong_actions"] += 1
+                reward = -0.08
+                message = f"Restarting {service} does not affect the root cause."
+
+        elif action_type == "rollback_deployment":
+            if service == "analytics-worker":
+                if not state["analytics_worker_killed"] and not any("analytics-worker" in k for k in state["queries_killed"]):
+                    # Rollback also kills queries as part of restart
+                    state["services"]["db-primary"]["connections"] = 22
+                    state["services"]["db-primary"]["status"] = "healthy"
+                    state["services"]["payment-api"]["status"] = "healthy"
+                    state["services"]["user-service"]["status"] = "healthy"
+                reward = 0.35
+                message = (
+                    "✓ analytics-worker rolled back to v1.0.8.\n"
+                    "  query_timeout restored to 600s\n"
+                    "  max_concurrent_queries restored to 5\n"
+                    "  db_connection_pool_size reduced to 20\n"
+                    "  db-primary connections: dropping to 22\n"
+                    "This addresses the root cause AND prevents recurrence."
+                )
+            else:
+                state["wrong_actions"] += 1
+                reward = -0.05
+                message = f"Rolling back {service} does not address the connection pool issue."
+
+        elif action_type == "acknowledge_alert":
+            alert_id = params.get("alert_id", "")
+            for a in state["alerts"]:
+                if a["id"] == alert_id:
+                    a["ack"] = True
+            reward = 0.01
+            message = f"Alert {alert_id} acknowledged."
+
+        elif action_type == "resolve_incident":
+            db_ok = state["services"]["db-primary"]["connections"] < 80
+            if db_ok:
+                state["incident_resolved"] = True
+                done = True
+                reward = 0.25
+                message = (
+                    "✓ Incident resolved.\n"
+                    "Summary: analytics-worker v1.0.9 introduced unbounded DB queries "
+                    "(no query_timeout, large connection pool) causing pool exhaustion. "
+                    "Remediated by killing runaway queries and/or rolling back analytics-worker."
+                )
+            else:
+                reward = -0.05
+                message = (
+                    f"Cannot resolve: db-primary still at "
+                    f"{state['services']['db-primary']['connections']}/100 connections. "
+                    "Identify and fix the source of connection exhaustion first."
+                )
+
+        else:
+            reward = -0.03
+            message = f"Unknown or inapplicable action: {action_type}."
+
+        return state, reward, done, message
+
+    def get_observation(self, state: Dict[str, Any], session_id: str, step: int) -> Observation:
+        services = {}
+        for name, s in state["services"].items():
+            services[name] = ServiceStatus(
+                name=name, status=s["status"],
+                cpu_percent=s["cpu"], memory_percent=s["memory"],
+                error_rate=s["error_rate"],
+                connections=s.get("connections"),
+                max_connections=s.get("max_connections"),
+                version=s.get("version", "1.0.0"),
+                replicas=s.get("replicas", 1),
+            )
+
+        alerts = [
+            Alert(
+                alert_id=a["id"], severity=a["sev"], service=a["svc"],
+                message=a["msg"], triggered_at=BASE_INCIDENT_TIME,
+                acknowledged=a["ack"],
+            )
+            for a in state["alerts"]
+        ]
+
+        return Observation(
+            session_id=session_id,
+            task_id=self.task_id,
+            step=step,
+            timestamp=BASE_INCIDENT_TIME,
+            alerts=alerts,
+            services=services,
+            available_actions=AVAILABLE_ACTIONS,
+            incident_resolved=state["incident_resolved"],
+            message="",
+            recent_deployments=state["recent_deployments"],
+            runbook_hints=[
+                "check_metrics(db-primary) shows connections broken down by client.",
+                "Restarting the database during connection exhaustion can worsen the situation.",
+                "kill_query terminates long-running queries from a specific source application.",
+                "Recent deployments are often correlated with sudden incidents.",
+            ],
+        )
+
+    def grade(self, state: Dict[str, Any], history: List[Dict]) -> Tuple[float, Dict[str, float]]:
+        breakdown = {}
+        score = 0.0
+
+        # Root cause identified? (checked db metrics OR db logs which reveal analytics-worker)
+        root_cause_found = (
+            "db-primary" in state.get("metrics_checked", []) or
+            "db-primary" in state.get("logs_queried", []) or
+            "analytics-worker" in state.get("logs_queried", []) or
+            "analytics-worker" in state.get("configs_checked", [])
+        )
+        if root_cause_found:
+            breakdown["root_cause_identified"] = 0.20
+            score += 0.20
+
+        # Correct attribution? (analytics-worker named as source)
+        targeted_analytics = (
+            state.get("analytics_worker_killed", False) or
+            any("analytics-worker" in k for k in state.get("queries_killed", []))
+        )
+        if targeted_analytics:
+            breakdown["correct_attribution"] = 0.30
+            score += 0.30
+
+        # DB recovered (connections < 80)?
+        if state["services"]["db-primary"]["connections"] < 80:
+            breakdown["db_recovered"] = 0.20
+            score += 0.20
+
+        # Incident formally resolved?
+        if state.get("incident_resolved", False):
+            breakdown["incident_resolved"] = 0.20
+            score += 0.20
+
+        # Efficiency bonus
+        steps = len(history)
+        if steps <= 5:
+            breakdown["efficiency_bonus"] = 0.10
+            score += 0.10
+        elif steps <= 8:
+            breakdown["efficiency_bonus"] = 0.07
+            score += 0.07
+        elif steps <= 12:
+            breakdown["efficiency_bonus"] = 0.03
+            score += 0.03
+
+        # Penalty: restarted DB (bad practice)
+        if state.get("db_restarted", False):
+            breakdown["db_restart_penalty"] = -0.15
+            score -= 0.15
+
+        # Penalty: other wrong actions
+        wrong = state.get("wrong_actions", 0) - (1 if state.get("db_restarted", False) else 0)
+        if wrong > 0:
+            p = min(wrong * 0.07, 0.15)
+            breakdown["wrong_action_penalty"] = -p
+            score -= p
+
+        return round(min(max(score, 0.0), 1.0), 4), breakdown

app/tasks/task3.py

@@ -0,0 +1,487 @@
+"""
+Task 3: Cascading Service Failure (Hard)
+=========================================
+Scenario: Four production services are down simultaneously. A recent deployment
+of config-service v1.2.0 introduced a broken service-discovery URL, causing all
+services that depend on it to fail to resolve each other.
+
+Traps:
+  - user-service has an unrelated memory warning (red herring)
+  - order-service v2.1.0 was deployed 2h ago (not the cause)
+  - Restarting any individual service without fixing config-service makes no progress
+  - Need to investigate and identify config-service as the common dependency
+
+Optimal: check_config(config-service) OR query_logs(any-down-service) →
+         rollback_deployment(config-service) → resolve_incident()
+Max steps: 20  |  Passing score: 0.6
+"""
+
+from typing import Dict, Any, Tuple, List
+from app.models import Observation, Alert, ServiceStatus
+from app.tasks.base import BaseTask, AVAILABLE_ACTIONS, BASE_INCIDENT_TIME
+
+
+class CascadingFailureTask(BaseTask):
+    task_id = "task3"
+    name = "Cascading Service Failure"
+    description = (
+        "Four services (api-gateway, user-service, order-service, payment-service) "
+        "are simultaneously down. Identify the common root cause and remediate "
+        "the entire incident with minimal blast radius."
+    )
+    difficulty = "hard"
+    max_steps = 20
+    passing_score = 0.6
+
+    def initial_state(self, seed: int = 42) -> Dict[str, Any]:
+        return {
+            "services": {
+                "api-gateway": {
+                    "status": "down", "cpu": 0.5, "memory": 12.0,
+                    "error_rate": 100.0, "version": "1.4.2", "replicas": 3,
+                },
+                "user-service": {
+                    "status": "down", "cpu": 0.8, "memory": 88.0,
+                    "error_rate": 100.0, "version": "4.0.1", "replicas": 2,
+                },
+                "order-service": {
+                    "status": "down", "cpu": 0.3, "memory": 45.0,
+                    "error_rate": 100.0, "version": "2.1.0", "replicas": 2,
+                },
+                "payment-service": {
+                    "status": "down", "cpu": 0.2, "memory": 40.0,
+                    "error_rate": 100.0, "version": "5.2.3", "replicas": 2,
+                },
+                "config-service": {
+                    "status": "healthy", "cpu": 18.0, "memory": 35.0,
+                    "error_rate": 0.0, "version": "1.2.0", "replicas": 1,
+                },
+                "db-primary": {
+                    "status": "healthy", "cpu": 22.0, "memory": 55.0,
+                    "error_rate": 0.0, "connections": 15, "max_connections": 100,
+                    "version": "14.8",
+                },
+                "message-queue": {
+                    "status": "healthy", "cpu": 10.0, "memory": 42.0,
+                    "error_rate": 0.0, "version": "3.12.0",
+                },
+            },
+            "alerts": [
+                {"id": "ALT-020", "sev": "critical", "svc": "api-gateway",
+                 "msg": "api-gateway is DOWN — all requests returning 503",
+                 "ack": False},
+                {"id": "ALT-021", "sev": "critical", "svc": "user-service",
+                 "msg": "user-service is DOWN — health check failing for 8 minutes",
+                 "ack": False},
+                {"id": "ALT-022", "sev": "critical", "svc": "order-service",
+                 "msg": "order-service is DOWN — all replicas unhealthy",
+                 "ack": False},
+                {"id": "ALT-023", "sev": "critical", "svc": "payment-service",
+                 "msg": "payment-service is DOWN — cannot process transactions",
+                 "ack": False},
+                {"id": "ALT-024", "sev": "warning", "svc": "user-service",
+                 "msg": "user-service memory at 88% (elevated but not critical)",
+                 "ack": False},
+            ],
+            "recent_deployments": [
+                {"service": "config-service", "version": "1.2.0", "previous": "1.1.9",
+                 "deployed_at": "2024-11-15T09:30:00Z", "deployer": "platform-team",
+                 "change": "Updated service discovery URLs for new datacenter migration"},
+                {"service": "order-service", "version": "2.1.0", "previous": "2.0.8",
+                 "deployed_at": "2024-11-15T07:45:00Z", "deployer": "ci-pipeline",
+                 "change": "New checkout flow feature"},
+                {"service": "user-service", "version": "4.0.1", "previous": "4.0.0",
+                 "deployed_at": "2024-11-14T14:00:00Z", "deployer": "ci-pipeline",
+                 "change": "Bug fix for profile update endpoint"},
+            ],
+            # Tracking agent progress
+            "logs_queried": [],
+            "metrics_checked": [],
+            "configs_checked": [],
+            "services_restarted": [],
+            "rollbacks_attempted": {},
+            "wrong_rollbacks": 0,
+            "config_service_rolledback": False,
+            "services_recovered": [],
+            "incident_resolved": False,
+            "_all_services_down_due_to_config": True,
+        }
+
+    def _check_recovery(self, state: Dict[str, Any]) -> None:
+        """Update service statuses based on whether config-service was fixed."""
+        if state["config_service_rolledback"]:
+            for svc in ["api-gateway", "user-service", "order-service", "payment-service"]:
+                if svc not in state["services_recovered"]:
+                    state["services_recovered"].append(svc)
+                state["services"][svc]["status"] = "healthy"
+                state["services"][svc]["error_rate"] = 0.0
+                state["services"][svc]["cpu"] = float(
+                    {"api-gateway": 8.0, "user-service": 22.0,
+                     "order-service": 15.0, "payment-service": 12.0}[svc]
+                )
+
+    def process_action(
+        self, action_type: str, params: Dict[str, Any], state: Dict[str, Any]
+    ) -> Tuple[Dict[str, Any], float, bool, str]:
+        reward = 0.0
+        done = False
+        message = ""
+        service = params.get("service", "").strip()
+
+        if action_type == "query_logs":
+            if not service:
+                return state, -0.02, False, "Parameter 'service' is required."
+            if service in state["logs_queried"]:
+                return state, 0.0, False, f"[Cached] Logs for {service} already retrieved."
+            state["logs_queried"].append(service)
+
+            down_services = ["api-gateway", "user-service", "order-service", "payment-service"]
+
+            if service in down_services:
+                reward = 0.08
+                service_logs = {
+                    "api-gateway": (
+                        "2024-11-15T09:31:00Z [ERROR] api-gateway: failed to resolve "
+                        "user-service endpoint via config-service: "
+                        "GET http://config-service/discover/user-service → "
+                        "returned 'http://svc-mesh-BROKEN.internal:8080' (unreachable)\n"
+                        "2024-11-15T09:31:01Z [ERROR] api-gateway: failed to resolve "
+                        "order-service — same issue\n"
+                        "2024-11-15T09:31:05Z [FATAL] api-gateway: no healthy upstreams "
+                        "available — entering 503 mode\n"
+                        "PATTERN: All service discovery calls returning broken URLs from config-service."
+                    ),
+                    "user-service": (
+                        "2024-11-15T09:31:00Z [ERROR] user-service: startup failed — cannot "
+                        "resolve db endpoint via config-service: received 'db-BROKEN.internal' "
+                        "(expected 'db-primary.internal')\n"
+                        "2024-11-15T09:31:02Z [FATAL] user-service: health check failed — "
+                        "cannot connect to database\n"
+                        "PATTERN: config-service returning incorrect service discovery data."
+                    ),
+                    "order-service": (
+                        "2024-11-15T09:31:00Z [ERROR] order-service: failed to start — "
+                        "config-service returned broken payment-service URL\n"
+                        "2024-11-15T09:31:03Z [FATAL] order-service: dependency check failed, "
+                        "exiting\n"
+                        "NOTE: order-service v2.1.0 deployed at 07:45 ran fine until 09:30 "
+                        "when config-service was updated."
+                    ),
+                    "payment-service": (
+                        "2024-11-15T09:31:00Z [ERROR] payment-service: cannot resolve fraud-check "
+                        "service — config-service lookup returned null endpoint\n"
+                        "2024-11-15T09:31:05Z [FATAL] payment-service: aborting startup due to "
+                        "missing required service dependencies\n"
+                    ),
+                }
+                message = service_logs.get(service, "No logs found.")
+
+            elif service == "config-service":
+                reward = 0.12
+                message = (
+                    "2024-11-15T09:28:00Z [INFO]  config-service: v1.2.0 deployment started\n"
+                    "2024-11-15T09:29:50Z [INFO]  config-service: service discovery URLs updated "
+                    "for datacenter migration\n"
+                    "2024-11-15T09:30:00Z [INFO]  config-service: v1.2.0 deployment complete\n"
+                    "2024-11-15T09:30:05Z [WARN]  config-service: 4 downstream services "
+                    "reporting connection failures immediately after deploy\n"
+                    "2024-11-15T09:30:10Z [ERROR] config-service: config validation failed "
+                    "in post-deploy check — service_discovery_urls contain unreachable hosts\n"
+                    "ROOT CAUSE CONFIRMED: config-service v1.2.0 deployed broken service "
+                    "discovery URLs. All dependent services cannot resolve each other."
+                )
+            else:
+                reward = 0.02
+                message = f"No anomalies in logs for {service}."
+
+        elif action_type == "check_metrics":
+            if not service:
+                return state, -0.02, False, "Parameter 'service' is required."
+            if service in state["metrics_checked"]:
+                return state, 0.0, False, f"[Cached] Metrics for {service} already retrieved."
+            state["metrics_checked"].append(service)
+
+            if service in ["api-gateway", "user-service", "order-service", "payment-service"]:
+                reward = 0.06
+                message = (
+                    f"{service} metrics:\n"
+                    f"  status: DOWN\n"
+                    f"  error_rate: 100% (all requests failing)\n"
+                    f"  last_healthy: 2024-11-15T09:30:02Z\n"
+                    f"  restart_attempts: 3 (all failed)\n"
+                    f"  failure_reason: dependency resolution failure at startup\n"
+                    f"CORRELATES: All 4 services went down within 15 seconds of each other "
+                    f"at 09:30 — timing matches config-service v1.2.0 deployment."
+                )
+            elif service == "config-service":
+                reward = 0.08
+                message = (
+                    "config-service metrics:\n"
+                    "  status: healthy\n"
+                    "  cpu: 18%\n"
+                    "  requests_per_sec: 240\n"
+                    "  cache_hit_rate: 12%  ← very low (normal: 95%+)\n"
+                    "  discovery_errors_per_sec: 180  ← HIGH\n"
+                    "  version: 1.2.0  (deployed 17min ago)\n"
+                    "SUSPICIOUS: High discovery_errors and low cache_hit_rate after recent deploy."
+                )
+            else:
+                reward = 0.02
+                message = f"Metrics for {service}: Normal."
+
+        elif action_type == "check_config":
+            state["configs_checked"].append(service)
+            if service == "config-service":
+                reward = 0.15
+                message = (
+                    "config-service LIVE CONFIG (v1.2.0):\n"
+                    "  service_discovery:\n"
+                    "    user-service:    http://svc-mesh-BROKEN.dc2.internal:8080\n"
+                    "    order-service:   http://svc-mesh-BROKEN.dc2.internal:8081\n"
+                    "    payment-service: http://svc-mesh-BROKEN.dc2.internal:8082\n"
+                    "    db-primary:      http://db-BROKEN.dc2.internal:5432\n"
+                    "    api-gateway:     http://gw-BROKEN.dc2.internal:80\n\n"
+                    "config-service PREVIOUS CONFIG (v1.1.9):\n"
+                    "  service_discovery:\n"
+                    "    user-service:    http://user-service.svc.cluster.local:8080  ✓\n"
+                    "    order-service:   http://order-service.svc.cluster.local:8081  ✓\n"
+                    "    payment-service: http://payment-service.svc.cluster.local:8082 ✓\n"
+                    "    db-primary:      http://db-primary.svc.cluster.local:5432  ✓\n\n"
+                    "ROOT CAUSE CONFIRMED: v1.2.0 changed ALL service discovery URLs to "
+                    "non-existent dc2.internal addresses. Datacenter migration was incomplete."
+                )
+            elif service in ["api-gateway", "user-service", "order-service", "payment-service"]:
+                reward = 0.04
+                message = (
+                    f"{service} config appears normal. Service discovery endpoint "
+                    f"points to config-service (as expected). The issue is in what "
+                    f"config-service returns, not in {service}'s config itself."
+                )
+            else:
+                reward = 0.01
+                message = f"Config for {service}: Nothing unusual."
+
+        elif action_type == "examine_trace":
+            trace_id = params.get("trace_id", "unknown")
+            state["logs_queried"].append(f"trace:{trace_id}")
+            reward = 0.06
+            message = (
+                f"Trace {trace_id}:\n"
+                "  api-gateway → [service discovery lookup] → config-service (2ms)\n"
+                "  config-service → returned URL: http://svc-mesh-BROKEN.dc2.internal\n"
+                "  api-gateway → [connection attempt to broken URL] → TIMEOUT after 5000ms\n"
+                "  Root span: 100% of failures originate from bad service discovery response."
+            )
+
+        elif action_type == "restart_service":
+            if service in ["api-gateway", "user-service", "order-service", "payment-service"]:
+                if not state["config_service_rolledback"]:
+                    state["services_restarted"].append(service)
+                    # Restarting without fixing config does nothing
+                    reward = -0.05
+                    message = (
+                        f"Restarted {service}... but it failed to start again.\n"
+                        f"  Startup error: cannot resolve service dependencies via config-service\n"
+                        f"  Status: still DOWN\n"
+                        f"The underlying config-service issue must be fixed first."
+                    )
+                else:
+                    # After config fix, manual restart not needed (auto-recovery)
+                    reward = 0.0
+                    message = f"{service} already recovering after config-service rollback."
+            elif service == "config-service":
+                # Restarting config-service doesn't fix the bad config
+                state["services_restarted"].append(service)
+                reward = -0.08
+                message = (
+                    "config-service restarted — but it loaded the same broken v1.2.0 config.\n"
+                    "  All downstream services still failing.\n"
+                    "  A restart does not fix a misconfiguration. Use rollback_deployment."
+                )
+            else:
+                reward = 0.0
+                message = f"{service} is healthy and does not need a restart."
+
+        elif action_type == "rollback_deployment":
+            if service == "config-service":
+                state["config_service_rolledback"] = True
+                self._check_recovery(state)
+                reward = 0.45
+                message = (
+                    "✓ config-service rolled back from v1.2.0 → v1.1.9.\n"
+                    "  Service discovery URLs restored to cluster-internal addresses.\n"
+                    "  api-gateway:       DOWN → healthy (restarted automatically)\n"
+                    "  user-service:      DOWN → healthy (restarted automatically)\n"
+                    "  order-service:     DOWN → healthy (restarted automatically)\n"
+                    "  payment-service:   DOWN → healthy (restarted automatically)\n"
+                    "All 4 services recovered within 45 seconds of config-service rollback."
+                )
+            elif service == "order-service":
+                # Red herring — order-service v2.1.0 was NOT the cause
+                state["rollbacks_attempted"][service] = True
+                state["wrong_rollbacks"] += 1
+                reward = -0.08
+                message = (
+                    "Rolled back order-service to v2.0.8... but it immediately failed again.\n"
+                    "  Error: still cannot resolve service dependencies via config-service.\n"
+                    "  RESULT: order-service v2.1.0 was not the root cause. "
+                    "The issue is upstream."
+                )
+            elif service in ["api-gateway", "user-service", "payment-service"]:
+                state["rollbacks_attempted"][service] = True
+                state["wrong_rollbacks"] += 1
+                reward = -0.06
+                message = (
+                    f"Rolled back {service}... but it still cannot start.\n"
+                    f"  Error: service discovery failing — same as before.\n"
+                    f"  This service is not the root cause."
+                )
+            else:
+                reward = -0.02
+                message = f"Rolling back {service} has no effect on the current incident."
+
+        elif action_type == "scale_service":
+            reward = -0.05
+            message = (
+                "Scaling has no effect — services are failing due to misconfiguration, "
+                "not insufficient capacity."
+            )
+
+        elif action_type == "acknowledge_alert":
+            alert_id = params.get("alert_id", "")
+            for a in state["alerts"]:
+                if a["id"] == alert_id:
+                    a["ack"] = True
+            reward = 0.01
+            message = f"Alert {alert_id} acknowledged."
+
+        elif action_type == "resolve_incident":
+            all_healthy = all(
+                state["services"][svc]["status"] == "healthy"
+                for svc in ["api-gateway", "user-service", "order-service", "payment-service"]
+            )
+            if all_healthy:
+                state["incident_resolved"] = True
+                done = True
+                reward = 0.25
+                message = (
+                    "✓ Incident resolved.\n"
+                    "Post-mortem: config-service v1.2.0 was deployed with incorrect service "
+                    "discovery URLs targeting a non-existent dc2 datacenter. This caused all "
+                    "dependent services to fail at startup. Rollback to v1.1.9 restored service.\n"
+                    "Recommendation: Add config validation to deployment pipeline."
+                )
+            else:
+                still_down = [
+                    s for s in ["api-gateway", "user-service", "order-service", "payment-service"]
+                    if state["services"][s]["status"] != "healthy"
+                ]
+                reward = -0.05
+                message = (
+                    f"Cannot resolve: {len(still_down)} services still down: "
+                    f"{', '.join(still_down)}. Fix the root cause first."
+                )
+
+        else:
+            reward = -0.03
+            message = f"Unknown or inapplicable action: {action_type}."
+
+        return state, reward, done, message
+
+    def get_observation(self, state: Dict[str, Any], session_id: str, step: int) -> Observation:
+        services = {}
+        for name, s in state["services"].items():
+            services[name] = ServiceStatus(
+                name=name, status=s["status"],
+                cpu_percent=s["cpu"], memory_percent=s["memory"],
+                error_rate=s["error_rate"],
+                connections=s.get("connections"),
+                max_connections=s.get("max_connections"),
+                version=s.get("version", "1.0.0"),
+                replicas=s.get("replicas", 1),
+            )
+
+        alerts = [
+            Alert(
+                alert_id=a["id"], severity=a["sev"], service=a["svc"],
+                message=a["msg"], triggered_at=BASE_INCIDENT_TIME,
+                acknowledged=a["ack"],
+            )
+            for a in state["alerts"]
+        ]
+
+        return Observation(
+            session_id=session_id,
+            task_id=self.task_id,
+            step=step,
+            timestamp=BASE_INCIDENT_TIME,
+            alerts=alerts,
+            services=services,
+            available_actions=AVAILABLE_ACTIONS,
+            incident_resolved=state["incident_resolved"],
+            message="",
+            recent_deployments=state["recent_deployments"],
+            runbook_hints=[
+                "When multiple services fail simultaneously, look for a common dependency.",
+                "Check the timing: what changed just before the incident?",
+                "check_config reveals live runtime configuration values.",
+                "Restarting services without fixing the root cause will not help.",
+                "rollback_deployment reverts to the previous known-good version.",
+            ],
+        )
+
+    def grade(self, state: Dict[str, Any], history: List[Dict]) -> Tuple[float, Dict[str, float]]:
+        breakdown = {}
+        score = 0.0
+
+        # Root cause investigated?
+        root_investigated = (
+            "config-service" in state.get("configs_checked", []) or
+            "config-service" in state.get("logs_queried", []) or
+            "config-service" in state.get("metrics_checked", []) or
+            any(svc in state.get("logs_queried", [])
+                for svc in ["api-gateway", "user-service", "order-service", "payment-service"])
+        )
+        if root_investigated:
+            breakdown["investigated_root_cause"] = 0.15
+            score += 0.15
+
+        # config-service identified and rolled back?
+        if state.get("config_service_rolledback", False):
+            breakdown["correct_rollback"] = 0.40
+            score += 0.40
+
+        # All services recovered?
+        recovered = state.get("services_recovered", [])
+        if len(recovered) >= 4:
+            breakdown["full_recovery"] = 0.20
+            score += 0.20
+        elif len(recovered) >= 2:
+            breakdown["partial_recovery"] = 0.10
+            score += 0.10
+
+        # Incident formally resolved?
+        if state.get("incident_resolved", False):
+            breakdown["incident_resolved"] = 0.15
+            score += 0.15
+
+        # Efficiency bonus
+        steps = len(history)
+        if steps <= 4:
+            breakdown["efficiency_bonus"] = 0.10
+            score += 0.10
+        elif steps <= 7:
+            breakdown["efficiency_bonus"] = 0.07
+            score += 0.07
+        elif steps <= 12:
+            breakdown["efficiency_bonus"] = 0.03
+            score += 0.03
+
+        # Penalty for wrong rollbacks
+        wrong_rollbacks = state.get("wrong_rollbacks", 0)
+        if wrong_rollbacks > 0:
+            p = min(wrong_rollbacks * 0.08, 0.20)
+            breakdown["wrong_rollback_penalty"] = -p
+            score -= p
+
+        return round(min(max(score, 0.0), 1.0), 4), breakdown

baseline.py

@@ -0,0 +1,401 @@
+#!/usr/bin/env python3
+"""
+Baseline Inference Script — SRE Incident Response OpenEnv
+==========================================================
+Runs a ReAct-style OpenAI agent against all three tasks and
+reports reproducible baseline scores.
+
+Usage:
+    export OPENAI_API_KEY="sk-..."
+    export OPENENV_BASE_URL="http://localhost:7860"  # or your HF Space URL
+    python baseline.py
+
+    # Run specific tasks:
+    python baseline.py --tasks task1 task2
+
+    # Use a different model:
+    python baseline.py --model gpt-4o
+
+Requirements:
+    pip install openai httpx rich
+"""
+
+import os
+import sys
+import json
+import re
+import argparse
+import time
+from typing import Optional
+
+import httpx
+
+try:
+    from rich.console import Console
+    from rich.table import Table
+    from rich.panel import Panel
+    from rich import print as rprint
+    RICH = True
+except ImportError:
+    RICH = False
+    Console = None
+
+
+# ─── Config ──────────────────────────────────────────────────────────────────
+
+DEFAULT_MODEL = "gpt-4o-mini"
+DEFAULT_BASE_URL = os.environ.get("OPENENV_BASE_URL", "http://localhost:7860")
+OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY", "")
+
+SYSTEM_PROMPT = """You are an expert Site Reliability Engineer (SRE) responding to a production incident.
+You will receive alerts, service statuses, and investigation results.
+Your goal is to identify the root cause and resolve the incident efficiently.
+
+At each step, respond with ONLY a valid JSON object in this exact format:
+{"action_type": "<action>", "parameters": {<params>}}
+
+Available actions:
+- query_logs: {"service": "<name>"} — fetch recent logs for a service
+- check_metrics: {"service": "<name>"} — get current metrics for a service
+- check_config: {"service": "<name>"} — inspect live runtime configuration
+- restart_service: {"service": "<name>"} — restart a service (use carefully)
+- rollback_deployment: {"service": "<name>"} — roll back to previous version
+- kill_query: {"source": "<service>"} — terminate long-running DB queries from a source
+- scale_service: {"service": "<name>", "replicas": <int>} — change replica count
+- examine_trace: {"trace_id": "<id>"} — examine distributed trace
+- acknowledge_alert: {"alert_id": "<id>"} — acknowledge an alert
+- resolve_incident: {} — mark incident as resolved (only when services are healthy)
+
+SRE Investigation Strategy:
+1. Read ALL alerts and service statuses carefully
+2. Look at recent deployments — they are often correlated with incidents
+3. Use query_logs and check_metrics to gather evidence before acting
+4. Form a clear hypothesis about the root cause
+5. Apply the most targeted fix (prefer rollback over restart when deployment changed)
+6. Verify all affected services are healthy
+7. Call resolve_incident to complete the episode
+
+Respond ONLY with JSON. No markdown. No explanation."""
+
+
+# ─── Helpers ─────────────────────────────────────────────────────────────────
+
+def log(msg: str, level: str = "INFO"):
+    prefix = {"INFO": "ℹ", "OK": "✓", "WARN": "⚠", "ERR": "✗"}.get(level, "•")
+    print(f"  {prefix} {msg}")
+
+
+def format_observation(obs: dict) -> str:
+    """Format observation dict into a concise prompt string."""
+    lines = [f"=== INCIDENT — Step {obs.get('step', 0)} ===\n"]
+
+    lines.append("ACTIVE ALERTS:")
+    for alert in obs.get("alerts", []):
+        ack = " [ACK]" if alert.get("acknowledged") else ""
+        sev = alert.get("severity", "?").upper()
+        lines.append(f"  [{sev}]{ack} {alert.get('service')}: {alert.get('message')}")
+
+    lines.append("\nSERVICE STATUS:")
+    for name, svc in obs.get("services", {}).items():
+        conn = ""
+        if svc.get("connections") is not None:
+            conn = f" | conns: {svc['connections']}/{svc.get('max_connections', '?')}"
+        lines.append(
+            f"  {name}: {svc.get('status', '?').upper()} | "
+            f"cpu: {svc.get('cpu_percent', 0):.1f}% | "
+            f"mem: {svc.get('memory_percent', 0):.1f}% | "
+            f"errors: {svc.get('error_rate', 0):.1f}/s | "
+            f"v{svc.get('version', '?')}{conn}"
+        )
+
+    if obs.get("recent_deployments"):
+        lines.append("\nRECENT DEPLOYMENTS:")
+        for dep in obs["recent_deployments"]:
+            lines.append(
+                f"  {dep.get('service')}: v{dep.get('previous', '?')} → "
+                f"v{dep.get('version')} deployed at {dep.get('deployed_at')}"
+            )
+
+    if obs.get("message"):
+        lines.append(f"\nLAST ACTION RESULT:\n{obs['message']}")
+
+    if obs.get("runbook_hints"):
+        lines.append("\nRUNBOOK HINTS:")
+        for h in obs["runbook_hints"]:
+            lines.append(f"  • {h}")
+
+    return "\n".join(lines)
+
+
+def call_llm(client: httpx.Client, model: str, messages: list) -> str:
+    """Call OpenAI chat completions API."""
+    response = client.post(
+        "https://api.openai.com/v1/chat/completions",
+        headers={
+            "Authorization": f"Bearer {OPENAI_API_KEY}",
+            "Content-Type": "application/json",
+        },
+        json={
+            "model": model,
+            "messages": messages,
+            "max_tokens": 200,
+            "temperature": 0.0,
+        },
+        timeout=30.0,
+    )
+    response.raise_for_status()
+    return response.json()["choices"][0]["message"]["content"].strip()
+
+
+def parse_action(text: str) -> dict:
+    """Parse JSON action from LLM output, with fallback."""
+    text = text.strip()
+    # Remove markdown code blocks if present
+    text = re.sub(r"```(?:json)?\s*|\s*```", "", text).strip()
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        match = re.search(r'\{[^{}]*\}', text, re.DOTALL)
+        if match:
+            try:
+                return json.loads(match.group())
+            except json.JSONDecodeError:
+                pass
+    # Fallback: safe no-op
+    return {"action_type": "acknowledge_alert", "parameters": {"alert_id": "ALT-001"}}
+
+
+# ─── Core Runner ─────────────────────────────────────────────────────────────
+
+def run_task(
+    env_client: httpx.Client,
+    llm_client: httpx.Client,
+    task_id: str,
+    model: str,
+    max_steps: int,
+    verbose: bool = True,
+) -> dict:
+    """Run one complete episode for a task. Returns result dict."""
+
+    if verbose:
+        print(f"\n{'─'*60}")
+        print(f"  Task: {task_id.upper()}")
+        print(f"{'─'*60}")
+
+    episode_log = []
+    score = 0.0
+    steps_taken = 0
+    session_id = None
+
+    try:
+        # ── Reset ────────────────────────────────────────────────────
+        reset_resp = env_client.post("/reset", json={"task_id": task_id, "seed": 42})
+        reset_resp.raise_for_status()
+        obs = reset_resp.json()
+        session_id = obs["session_id"]
+
+        if verbose:
+            task_name = obs.get("message", "").split("Task:")[1].split("(")[0].strip() \
+                if "Task:" in obs.get("message", "") else task_id
+            log(f"Session: {session_id[:8]}...", "INFO")
+            log(obs.get("message", ""), "INFO")
+
+        conversation = []
+        done = False
+
+        # ── Episode Loop ─────────────────────────────────────────────
+        for step_num in range(max_steps):
+            obs_text = format_observation(obs)
+            conversation.append({"role": "user", "content": obs_text})
+
+            # Trim conversation to last 4 turns (keep it focused)
+            messages = [{"role": "system", "content": SYSTEM_PROMPT}]
+            messages += conversation[-8:]
+
+            # Get action from LLM
+            action_text = call_llm(llm_client, model, messages)
+            conversation.append({"role": "assistant", "content": action_text})
+
+            action_dict = parse_action(action_text)
+            action_type = action_dict.get("action_type", "unknown")
+            parameters = action_dict.get("parameters", {})
+
+            if verbose:
+                params_str = json.dumps(parameters) if parameters else "{}"
+                print(f"  Step {step_num+1:2d}: {action_type}({params_str})", end="")
+
+            # Take step
+            step_resp = env_client.post("/step", json={
+                "session_id": session_id,
+                "action": {"action_type": action_type, "parameters": parameters},
+            })
+            step_resp.raise_for_status()
+            step_data = step_resp.json()
+
+            obs = step_data["observation"]
+            reward_val = step_data["reward"]["value"]
+            done = step_data["done"]
+            steps_taken = step_num + 1
+
+            if verbose:
+                reward_str = f"{reward_val:+.3f}"
+                current_score = step_data["info"].get("grader_score", 0.0)
+                print(f" → reward: {reward_str} | score: {current_score:.3f}")
+
+            episode_log.append({
+                "step": step_num + 1,
+                "action_type": action_type,
+                "parameters": parameters,
+                "reward": reward_val,
+                "message_preview": obs.get("message", "")[:150],
+            })
+
+            if done:
+                break
+
+        # ── Get Final Grade ───────────────────────────────────────────
+        grader_resp = env_client.post("/grader", json={"session_id": session_id})
+        grader_resp.raise_for_status()
+        grader_data = grader_resp.json()
+        score = grader_data["score"]
+        breakdown = grader_data.get("breakdown", {})
+
+        if verbose:
+            print(f"\n  {'─'*30}")
+            log(f"Final score: {score:.4f}", "OK" if score >= 0.6 else "WARN")
+            log(f"Steps taken: {steps_taken}", "INFO")
+            if breakdown:
+                log("Breakdown:", "INFO")
+                for k, v in breakdown.items():
+                    print(f"      {k}: {v:+.4f}")
+
+    except Exception as e:
+        if verbose:
+            log(f"Error: {e}", "ERR")
+        episode_log.append({"error": str(e)})
+
+    # Get task info for name/difficulty
+    tasks_resp = env_client.get("/tasks")
+    task_info = {}
+    if tasks_resp.status_code == 200:
+        for t in tasks_resp.json().get("tasks", []):
+            if t["task_id"] == task_id:
+                task_info = t
+                break
+
+    return {
+        "task_id": task_id,
+        "task_name": task_info.get("name", task_id),
+        "difficulty": task_info.get("difficulty", "?"),
+        "score": score,
+        "steps_taken": steps_taken,
+        "success": score >= task_info.get("passing_score", 0.6),
+        "episode_log": episode_log,
+    }
+
+
+# ─── Main ─────────────────────────────────────────────────────────────────────
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Run baseline agent against SRE Incident Response environment"
+    )
+    parser.add_argument("--model", default=DEFAULT_MODEL, help="OpenAI model to use")
+    parser.add_argument("--base-url", default=DEFAULT_BASE_URL, help="Environment base URL")
+    parser.add_argument("--max-steps", type=int, default=12, help="Max steps per episode")
+    parser.add_argument("--tasks", nargs="+", default=["task1", "task2", "task3"],
+                        help="Tasks to run (task1, task2, task3)")
+    parser.add_argument("--quiet", action="store_true", help="Suppress step-by-step output")
+    parser.add_argument("--output", help="Save results to JSON file")
+    args = parser.parse_args()
+
+    if not OPENAI_API_KEY:
+        print("ERROR: OPENAI_API_KEY environment variable not set.")
+        sys.exit(1)
+
+    print(f"\n{'═'*60}")
+    print(f"  SRE Incident Response — Baseline Evaluation")
+    print(f"{'═'*60}")
+    print(f"  Model:    {args.model}")
+    print(f"  Env URL:  {args.base_url}")
+    print(f"  Tasks:    {', '.join(args.tasks)}")
+    print(f"  MaxSteps: {args.max_steps}")
+    print(f"{'═'*60}")
+
+    # Verify environment is reachable
+    with httpx.Client(base_url=args.base_url, timeout=30.0) as env_client:
+        try:
+            health = env_client.get("/health")
+            health.raise_for_status()
+            print(f"\n  ✓ Environment healthy: {health.json()}")
+        except Exception as e:
+            print(f"\n  ✗ Environment not reachable at {args.base_url}: {e}")
+            sys.exit(1)
+
+        results = []
+        start = time.time()
+
+        with httpx.Client(timeout=60.0) as llm_client:
+            for task_id in args.tasks:
+                result = run_task(
+                    env_client=env_client,
+                    llm_client=llm_client,
+                    task_id=task_id,
+                    model=args.model,
+                    max_steps=args.max_steps,
+                    verbose=not args.quiet,
+                )
+                results.append(result)
+                time.sleep(0.5)  # Rate limiting courtesy
+
+    # ── Summary ───────────────────────────────────────────────────────────────
+    elapsed = time.time() - start
+    mean_score = sum(r["score"] for r in results) / len(results) if results else 0.0
+    passed = sum(1 for r in results if r["success"])
+
+    print(f"\n{'═'*60}")
+    print(f"  BASELINE RESULTS SUMMARY")
+    print(f"{'═'*60}")
+    print(f"  {'Task':<35} {'Diff':<8} {'Score':<8} {'Steps':<7} {'Status'}")
+    print(f"  {'─'*55}")
+    for r in results:
+        status = "✓ PASS" if r["success"] else "✗ FAIL"
+        print(
+            f"  {r['task_name']:<35} {r['difficulty']:<8} "
+            f"{r['score']:.4f}  {r['steps_taken']:<7} {status}"
+        )
+    print(f"  {'─'*55}")
+    print(f"  {'Mean Score':<35} {'':8} {mean_score:.4f}")
+    print(f"  Tasks passed: {passed}/{len(results)}")
+    print(f"  Elapsed: {elapsed:.1f}s")
+    print(f"{'═'*60}\n")
+
+    # ── Save results ──────────────────────────────────────────────────────────
+    output = {
+        "model": args.model,
+        "environment": "sre-incident-response",
+        "results": results,
+        "summary": {
+            "mean_score": round(mean_score, 4),
+            "tasks_passed": passed,
+            "total_tasks": len(results),
+            "elapsed_seconds": round(elapsed, 1),
+        },
+    }
+
+    if args.output:
+        with open(args.output, "w") as f:
+            json.dump(output, f, indent=2)
+        print(f"  Results saved to {args.output}")
+    else:
+        # Always save a baseline_results.json for reproducibility
+        with open("baseline_results.json", "w") as f:
+            json.dump(output, f, indent=2)
+        print(f"  Results saved to baseline_results.json")
+
+    # Exit code: 0 if all tasks pass, 1 otherwise
+    sys.exit(0 if passed == len(results) else 1)
+
+
+if __name__ == "__main__":
+    main()

openenv.yaml

@@ -0,0 +1,191 @@
+name: sre-incident-response
+version: "1.0.0"
+description: >
+  An OpenEnv environment where an AI agent acts as an on-call Site Reliability Engineer.
+  The agent receives production incident alerts, investigates root causes through logs,
+  metrics, and configuration inspection, then applies targeted remediation actions to
+  restore service health. Three tasks of increasing difficulty model real SRE workflows.
+
+author: SRE Incident Response Environment
+license: MIT
+tags:
+  - openenv
+  - sre
+  - incident-response
+  - devops
+  - real-world
+  - multi-step
+
+environment:
+  type: text-based
+  episodic: true
+  deterministic: true
+  observable: partial  # agent must investigate to reveal full state
+
+observation_space:
+  type: structured
+  description: >
+    JSON object containing active alerts, service health metrics (CPU, memory,
+    error rate, connection counts), investigation results (logs, metrics, configs),
+    recent deployment history, available actions, and contextual runbook hints.
+  fields:
+    session_id: string
+    task_id: string
+    step: integer
+    timestamp: string (ISO 8601)
+    alerts:
+      type: array
+      items:
+        alert_id: string
+        severity: critical or warning or info
+        service: string
+        message: string
+        triggered_at: string
+        acknowledged: boolean
+    services:
+      type: object
+      description: "Map of service_name → ServiceStatus"
+      value_fields:
+        status: healthy or degraded or down or unknown
+        cpu_percent: float [0, 100]
+        memory_percent: float [0, 100]
+        error_rate: float (errors/second)
+        connections: integer | null
+        max_connections: integer | null
+        version: string
+        replicas: integer
+    logs: array of LogEntry (populated after query_logs action)
+    metrics: array of MetricPoint (populated after check_metrics action)
+    available_actions: array of strings
+    incident_resolved: boolean
+    message: string (result of last action)
+    recent_deployments: array
+    runbook_hints: array of strings
+
+action_space:
+  type: discrete+parametric
+  description: >
+    Categorical action type with optional typed parameters. The agent selects
+    an action_type and provides relevant parameters.
+  actions:
+    query_logs:
+      description: Fetch recent log entries for a service
+      parameters:
+        service: {type: string, required: true}
+    check_metrics:
+      description: Retrieve current metrics for a service
+      parameters:
+        service: {type: string, required: true}
+    check_config:
+      description: Inspect live runtime configuration of a service
+      parameters:
+        service: {type: string, required: true}
+    restart_service:
+      description: Restart a service with rolling restart
+      parameters:
+        service: {type: string, required: true}
+    rollback_deployment:
+      description: Roll back service to previous deployment version
+      parameters:
+        service: {type: string, required: true}
+    kill_query:
+      description: Terminate long-running DB queries from a specific source
+      parameters:
+        source: {type: string, required: true, description: "Application holding the queries"}
+    scale_service:
+      description: Change the number of replicas for a service
+      parameters:
+        service: {type: string, required: true}
+        replicas: {type: integer, required: true, min: 1, max: 20}
+    examine_trace:
+      description: Examine a distributed trace to identify slow spans
+      parameters:
+        trace_id: {type: string, required: true}
+    acknowledge_alert:
+      description: Acknowledge an alert to stop paging
+      parameters:
+        alert_id: {type: string, required: true}
+    resolve_incident:
+      description: Mark incident as resolved (terminal action)
+      parameters: {}
+
+reward:
+  type: dense
+  range: [-inf, 1.0]
+  description: >
+    Per-step shaped rewards guide investigation and remediation. Positive rewards
+    for relevant investigation (+0.06–0.15) and correct fixes (+0.20–0.45).
+    Negative rewards for destructive or irrelevant actions (-0.05–-0.15).
+    Terminal reward on correct resolution (+0.25–0.30). Efficiency bonus for
+    fewer steps. Penalty for max-step timeout.
+
+tasks:
+  - id: task1
+    name: "CPU Spike Investigation"
+    description: >
+      The web-api service is consuming 95% CPU due to a memory leak in v2.3.1
+      (connection pool recycling disabled). Agent must investigate logs/metrics
+      and restart or roll back the service.
+    difficulty: easy
+    max_steps: 15
+    passing_score: 0.60
+    optimal_steps: 3
+    grader:
+      investigated_root_service: 0.15
+      service_remediated: 0.45
+      incident_resolved: 0.25
+      efficiency_bonus: 0.15
+
+  - id: task2
+    name: "Database Connection Pool Exhaustion"
+    description: >
+      db-primary connection pool is exhausted (100/100). analytics-worker v1.0.9
+      introduced unbounded full-table scans with no query timeout, holding 78/100
+      connections. Dependent services (payment-api, user-service) are timing out.
+      Restarting the DB worsens the situation.
+    difficulty: medium
+    max_steps: 18
+    passing_score: 0.60
+    optimal_steps: 4
+    grader:
+      root_cause_identified: 0.20
+      correct_attribution: 0.30
+      db_recovered: 0.20
+      incident_resolved: 0.20
+      efficiency_bonus: 0.10
+
+  - id: task3
+    name: "Cascading Service Failure"
+    description: >
+      Four services (api-gateway, user-service, order-service, payment-service)
+      are simultaneously down. config-service v1.2.0 was deployed 17 minutes ago
+      with broken service discovery URLs. All downstream services fail to resolve
+      each other. Red herrings: user-service memory warning, order-service recent
+      deployment. Restarting individual services has no effect.
+    difficulty: hard
+    max_steps: 20
+    passing_score: 0.60
+    optimal_steps: 3
+    grader:
+      investigated_root_cause: 0.15
+      correct_rollback: 0.40
+      full_recovery: 0.20
+      incident_resolved: 0.15
+      efficiency_bonus: 0.10
+
+endpoints:
+  reset: "POST /reset"
+  step: "POST /step"
+  state: "GET /state"
+  tasks: "GET /tasks"
+  grader: "POST /grader"
+  baseline: "POST /baseline"
+  health: "GET /health"
+
+baseline:
+  model: gpt-4o-mini
+  seed: 42
+  expected_scores:
+    task1: 0.85
+    task2: 0.65
+    task3: 0.55

requirements.txt

@@ -0,0 +1,6 @@
+fastapi==0.115.5
+uvicorn[standard]==0.32.1
+pydantic==2.10.3
+httpx==0.28.1
+python-multipart==0.0.19
+pyyaml==6.0.2