major upgrade: 5 tasks, 7 faults, live HTML dashboard, richer reward shaping

api.py

@@ -4,6 +4,7 @@ FastAPI server — exposes OpenEnv standard endpoints + required hackathon endpo
 
 from fastapi import FastAPI, HTTPException, Request
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import HTMLResponse
 import uvicorn
 
 from models import Action, Observation
@@ -219,17 +220,271 @@ async def mcp(request: Request):
     }
 
 
-@app.get("/")
+@app.get("/", response_class=HTMLResponse)
 def root():
+    return HTMLResponse(content=DASHBOARD_HTML)
+
+
+@app.get("/api")
+def api_info():
     return {
         "name": "Dev Environment Debugger",
         "version": "1.0.0",
         "description": "OpenEnv environment for AI-powered dev environment debugging.",
+        "tasks": list(TASKS.keys()),
         "endpoints": ["/reset", "/step", "/state", "/tasks", "/grader",
                       "/baseline", "/health", "/metadata", "/schema", "/mcp"],
         "openenv": True,
     }
 
 
+DASHBOARD_HTML = """<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>Dev Environment Debugger — OpenEnv</title>
+<style>
+  * { box-sizing: border-box; margin: 0; padding: 0; }
+  body { font-family: 'Segoe UI', system-ui, sans-serif; background: #0d1117; color: #e6edf3; min-height: 100vh; }
+  header { background: linear-gradient(135deg, #161b22 0%, #1f2937 100%); border-bottom: 1px solid #30363d; padding: 24px 32px; display: flex; align-items: center; gap: 16px; }
+  header h1 { font-size: 1.5rem; font-weight: 700; }
+  header .badge { background: #238636; color: #fff; padding: 4px 10px; border-radius: 12px; font-size: 0.75rem; font-weight: 600; }
+  header .subtitle { color: #8b949e; font-size: 0.9rem; margin-top: 4px; }
+  main { max-width: 1100px; margin: 0 auto; padding: 32px; }
+  .grid { display: grid; grid-template-columns: 1fr 1fr; gap: 24px; margin-bottom: 32px; }
+  @media(max-width: 700px) { .grid { grid-template-columns: 1fr; } }
+  .card { background: #161b22; border: 1px solid #30363d; border-radius: 12px; padding: 24px; }
+  .card h2 { font-size: 1rem; font-weight: 600; color: #58a6ff; margin-bottom: 16px; display: flex; align-items: center; gap: 8px; }
+  .service { display: flex; justify-content: space-between; align-items: center; padding: 10px 14px; border-radius: 8px; margin-bottom: 8px; background: #0d1117; border: 1px solid #21262d; }
+  .service-name { font-weight: 600; font-size: 0.9rem; }
+  .status { padding: 3px 10px; border-radius: 10px; font-size: 0.78rem; font-weight: 700; }
+  .healthy { background: #1a4a2a; color: #3fb950; border: 1px solid #238636; }
+  .error { background: #4a1a1a; color: #f85149; border: 1px solid #da3633; }
+  .task-card { background: #161b22; border: 1px solid #30363d; border-radius: 12px; padding: 20px; margin-bottom: 16px; cursor: pointer; transition: border-color 0.2s; }
+  .task-card:hover { border-color: #58a6ff; }
+  .task-card.active { border-color: #58a6ff; background: #1c2433; }
+  .task-header { display: flex; justify-content: space-between; align-items: center; margin-bottom: 8px; }
+  .task-name { font-weight: 700; }
+  .diff { padding: 3px 10px; border-radius: 10px; font-size: 0.75rem; font-weight: 700; }
+  .easy { background: #1a4a2a; color: #3fb950; }
+  .medium { background: #4a3a1a; color: #d29922; }
+  .hard { background: #4a1a1a; color: #f85149; }
+  .expert { background: #2d1a4a; color: #bc8cff; }
+  .task-desc { color: #8b949e; font-size: 0.85rem; line-height: 1.5; }
+  .actions { display: flex; gap: 10px; flex-wrap: wrap; margin-top: 16px; }
+  button { padding: 9px 18px; border-radius: 8px; border: none; cursor: pointer; font-size: 0.85rem; font-weight: 600; transition: opacity 0.2s; }
+  button:hover { opacity: 0.85; }
+  .btn-primary { background: #238636; color: #fff; }
+  .btn-secondary { background: #21262d; color: #e6edf3; border: 1px solid #30363d; }
+  .btn-danger { background: #da3633; color: #fff; }
+  .log { background: #0d1117; border: 1px solid #21262d; border-radius: 8px; padding: 14px; font-family: 'Cascadia Code', 'Fira Code', monospace; font-size: 0.8rem; line-height: 1.6; max-height: 260px; overflow-y: auto; color: #8b949e; white-space: pre-wrap; word-break: break-all; }
+  .log .ok { color: #3fb950; }
+  .log .err { color: #f85149; }
+  .log .info { color: #58a6ff; }
+  .score-bar { height: 8px; border-radius: 4px; background: #21262d; margin-top: 8px; overflow: hidden; }
+  .score-fill { height: 100%; border-radius: 4px; background: linear-gradient(90deg, #238636, #3fb950); transition: width 0.5s; }
+  .step-counter { font-size: 2rem; font-weight: 800; color: #58a6ff; }
+  .stat-label { color: #8b949e; font-size: 0.8rem; margin-top: 4px; }
+  .stats { display: grid; grid-template-columns: repeat(3, 1fr); gap: 16px; margin-bottom: 16px; }
+  .stat { text-align: center; }
+  #action-panel { margin-top: 24px; }
+  select, input[type=text] { background: #0d1117; border: 1px solid #30363d; color: #e6edf3; border-radius: 6px; padding: 8px 12px; font-size: 0.85rem; width: 100%; margin-bottom: 8px; }
+  .full-width { grid-column: 1 / -1; }
+  .arch { display: flex; align-items: center; justify-content: center; gap: 8px; flex-wrap: wrap; padding: 16px 0; }
+  .svc-box { padding: 8px 16px; border-radius: 8px; font-size: 0.85rem; font-weight: 600; border: 2px solid; text-align: center; min-width: 80px; }
+  .arrow { color: #58a6ff; font-size: 1.2rem; }
+</style>
+</head>
+<body>
+<header>
+  <div>
+    <div style="display:flex;align-items:center;gap:12px">
+      <h1>🔧 Dev Environment Debugger</h1>
+      <span class="badge">OpenEnv</span>
+    </div>
+    <div class="subtitle">AI agent benchmark · 5 tasks · realistic multi-service debugging</div>
+  </div>
+</header>
+<main>
+  <div class="grid">
+    <!-- Services Panel -->
+    <div class="card">
+      <h2>⚙️ Service Status</h2>
+      <div id="arch" class="arch">
+        <div class="svc-box" id="box-proxy">proxy</div>
+        <div class="arrow">→</div>
+        <div class="svc-box" id="box-api">api</div>
+        <div class="arrow">→</div>
+        <div class="svc-box" id="box-database">database</div>
+      </div>
+      <div style="text-align:center;margin-bottom:16px">
+        <div class="arrow" style="font-size:1rem">↓</div>
+        <div class="svc-box" id="box-worker" style="display:inline-block;margin-top:4px">worker</div>
+      </div>
+      <div id="services-list"></div>
+      <div class="stats" style="margin-top:16px">
+        <div class="stat"><div class="step-counter" id="step-count">0</div><div class="stat-label">Steps</div></div>
+        <div class="stat"><div class="step-counter" id="fixed-count" style="color:#3fb950">0</div><div class="stat-label">Fixed</div></div>
+        <div class="stat"><div class="step-counter" id="score-val" style="color:#d29922">—</div><div class="stat-label">Score</div></div>
+      </div>
+    </div>
+
+    <!-- Action Panel -->
+    <div class="card">
+      <h2>🎮 Actions</h2>
+      <select id="action-type" onchange="updateActionFields()">
+        <option value="read_logs">read_logs</option>
+        <option value="inspect_env">inspect_env</option>
+        <option value="edit_env">edit_env</option>
+        <option value="restart_service">restart_service</option>
+        <option value="run_healthcheck">run_healthcheck</option>
+        <option value="submit">submit</option>
+      </select>
+      <div id="service-row">
+        <select id="action-service">
+          <option value="api">api</option>
+          <option value="worker">worker</option>
+          <option value="database">database</option>
+          <option value="proxy">proxy</option>
+        </select>
+      </div>
+      <div id="kv-row" style="display:none">
+        <input type="text" id="action-key" placeholder="env key (e.g. DB_PORT)" />
+        <input type="text" id="action-value" placeholder="new value (e.g. 5432)" />
+      </div>
+      <div class="actions">
+        <button class="btn-primary" onclick="doStep()">▶ Execute Action</button>
+        <button class="btn-secondary" onclick="doGrade()">📊 Grade</button>
+      </div>
+      <div class="log" id="action-log" style="margin-top:16px">No actions yet. Start an episode below.</div>
+    </div>
+
+    <!-- Tasks Panel -->
+    <div class="card full-width">
+      <h2>📋 Tasks</h2>
+      <div id="tasks-list"></div>
+    </div>
+  </div>
+</main>
+
+<script>
+let currentTask = 'task1';
+
+async function fetchTasks() {
+  const r = await fetch('/tasks');
+  const d = await r.json();
+  const el = document.getElementById('tasks-list');
+  el.innerHTML = d.tasks.map(t => `
+    <div class="task-card ${t.id === currentTask ? 'active' : ''}" id="tc-${t.id}" onclick="selectTask('${t.id}')">
+      <div class="task-header">
+        <span class="task-name">${t.id} — ${t.name}</span>
+        <span class="diff ${t.difficulty}">${t.difficulty}</span>
+      </div>
+      <div class="task-desc">${t.description}</div>
+      <div class="actions" style="margin-top:12px">
+        <button class="btn-primary" onclick="event.stopPropagation(); resetTask('${t.id}')">▶ Start Episode</button>
+        <span style="color:#8b949e;font-size:0.8rem;align-self:center">${t.faults_count} fault${t.faults_count>1?'s':''}</span>
+      </div>
+    </div>
+  `).join('');
+}
+
+function selectTask(id) {
+  currentTask = id;
+  document.querySelectorAll('.task-card').forEach(c => c.classList.remove('active'));
+  const el = document.getElementById('tc-' + id);
+  if (el) el.classList.add('active');
+}
+
+async function resetTask(taskId) {
+  selectTask(taskId);
+  const r = await fetch('/reset?task_id=' + taskId, {method:'POST'});
+  const obs = await r.json();
+  updateServices(obs.services);
+  log('info', 'Episode started: ' + taskId);
+  log('ok', obs.last_action_result.message);
+  document.getElementById('step-count').textContent = obs.step;
+  document.getElementById('fixed-count').textContent = '0';
+  document.getElementById('score-val').textContent = '—';
+}
+
+async function doStep() {
+  const type = document.getElementById('action-type').value;
+  const service = document.getElementById('action-service').value;
+  const key = document.getElementById('action-key').value;
+  const value = document.getElementById('action-value').value;
+  const action = {type};
+  if (type !== 'submit') action.service = service;
+  if (type === 'edit_env') { action.key = key; action.value = value; }
+
+  const r = await fetch('/step', {method:'POST', headers:{'Content-Type':'application/json'}, body:JSON.stringify(action)});
+  const d = await r.json();
+  const obs = d.observation;
+  updateServices(obs.services);
+  document.getElementById('step-count').textContent = obs.step;
+  const cls = d.reward > 0 ? 'ok' : d.reward < 0 ? 'err' : 'info';
+  log(cls, `[${type}${service && type!=='submit'?' → '+service:''}] reward=${d.reward > 0 ? '+' : ''}${d.reward.toFixed(2)}`);
+  log('info', obs.last_action_result.message.replace(/\\n/g, ' '));
+  if (d.done) { log('ok', '✓ Episode done!'); doGrade(); }
+}
+
+async function doGrade() {
+  const r = await fetch('/grader?task_id=' + currentTask);
+  const d = await r.json();
+  const gr = d.grader_result;
+  document.getElementById('score-val').textContent = (gr.score * 100).toFixed(1) + '%';
+  document.getElementById('fixed-count').textContent = gr.faults_fixed || 0;
+  log('ok', `Score: ${(gr.score*100).toFixed(1)}% — ${gr.reason}`);
+}
+
+function updateServices(services) {
+  const colors = {healthy: '#3fb950', error: '#f85149'};
+  const bg = {healthy: '#1a4a2a', error: '#4a1a1a'};
+  const border = {healthy: '#238636', error: '#da3633'};
+  const list = document.getElementById('services-list');
+  list.innerHTML = Object.entries(services).map(([name, s]) => `
+    <div class="service">
+      <span class="service-name">${name}</span>
+      <div style="display:flex;align-items:center;gap:8px">
+        ${s.port ? `<span style="color:#8b949e;font-size:0.8rem">:${s.port}</span>` : ''}
+        <span class="status ${s.status}">${s.status}</span>
+      </div>
+    </div>
+  `).join('');
+  ['proxy','api','database','worker'].forEach(name => {
+    const box = document.getElementById('box-' + name);
+    if (box && services[name]) {
+      const st = services[name].status;
+      box.style.borderColor = border[st] || '#30363d';
+      box.style.color = colors[st] || '#e6edf3';
+      box.style.background = bg[st] || '#21262d';
+    }
+  });
+}
+
+function log(cls, msg) {
+  const el = document.getElementById('action-log');
+  const line = document.createElement('div');
+  line.className = cls;
+  line.textContent = '› ' + msg;
+  el.appendChild(line);
+  el.scrollTop = el.scrollHeight;
+  if (el.children.length > 100) el.removeChild(el.firstChild);
+}
+
+function updateActionFields() {
+  const type = document.getElementById('action-type').value;
+  document.getElementById('service-row').style.display = type === 'submit' ? 'none' : 'block';
+  document.getElementById('kv-row').style.display = type === 'edit_env' ? 'block' : 'none';
+}
+
+fetchTasks();
+resetTask('task1');
+</script>
+</body>
+</html>"""
+
+
 if __name__ == "__main__":
     uvicorn.run("api:app", host="0.0.0.0", port=7860, reload=False)

environment.py

@@ -5,12 +5,11 @@ Agent must diagnose and fix faults to bring all services healthy.
 """
 
 import copy
-import random
 from typing import Any
 from models import Observation, Action, Reward, ServiceStatus, ActionResult
 
 # ---------------------------------------------------------------------------
-# Fault definitions
+# Fault catalog — injectable faults with realistic log messages
 # ---------------------------------------------------------------------------
 
 FAULT_CATALOG = {
@@ -21,8 +20,8 @@ FAULT_CATALOG = {
         "bad_value": "5433",
         "fix_key": "DB_PORT",
         "fix_value": "5432",
-        "log": "Error: cannot connect to database on port 5433. Connection refused.",
-        "requires_restart": ["api", "worker"],
+        "log": "Error: cannot connect to database on port 5433. Connection refused. Is the database running?",
+        "requires_restart": ["api"],
     },
     "missing_queue_url": {
         "service": "worker",
@@ -31,7 +30,7 @@ FAULT_CATALOG = {
         "bad_value": None,  # missing
         "fix_key": "WORKER_QUEUE_URL",
         "fix_value": "redis://localhost:6379",
-        "log": "Error: WORKER_QUEUE_URL is not set. Worker cannot connect to queue.",
+        "log": "Error: WORKER_QUEUE_URL is not set. Worker cannot connect to queue. Set WORKER_QUEUE_URL.",
         "requires_restart": ["worker"],
     },
     "wrong_api_port": {
@@ -41,7 +40,7 @@ FAULT_CATALOG = {
         "bad_value": "http://api:9999",
         "fix_key": "PROXY_UPSTREAM",
         "fix_value": "http://api:8000",
-        "log": "Error: upstream http://api:9999 unreachable. 502 Bad Gateway.",
+        "log": "Error: upstream http://api:9999 unreachable. 502 Bad Gateway. Check PROXY_UPSTREAM.",
         "requires_restart": ["proxy"],
     },
     "wrong_db_password": {
@@ -51,13 +50,43 @@ FAULT_CATALOG = {
         "bad_value": "wrongpassword",
         "fix_key": "DB_PASSWORD",
         "fix_value": "secret",
-        "log": "FATAL: password authentication failed for user 'app'. Check DB_PASSWORD.",
+        "log": "FATAL: password authentication failed for user 'app'. Check DB_PASSWORD env var.",
         "requires_restart": ["database", "api", "worker"],
     },
+    "wrong_db_host": {
+        "service": "api",
+        "description": "DB_HOST points to wrong hostname",
+        "env_key": "DB_HOST",
+        "bad_value": "db-prod-01.internal",
+        "fix_key": "DB_HOST",
+        "fix_value": "localhost",
+        "log": "Error: could not resolve host 'db-prod-01.internal'. Check DB_HOST. Is this a prod config?",
+        "requires_restart": ["api"],
+    },
+    "wrong_api_host": {
+        "service": "worker",
+        "description": "Worker API_HOST points to wrong address",
+        "env_key": "API_HOST",
+        "bad_value": "http://api:9000",
+        "fix_key": "API_HOST",
+        "fix_value": "http://api:8000",
+        "log": "Error: worker cannot reach API at http://api:9000. Connection refused. Check API_HOST.",
+        "requires_restart": ["worker"],
+    },
+    "missing_db_password": {
+        "service": "api",
+        "description": "DB_PASSWORD not set on API service",
+        "env_key": "DB_PASSWORD",
+        "bad_value": None,
+        "fix_key": "DB_PASSWORD",
+        "fix_value": "secret",
+        "log": "Error: DB_PASSWORD is not set. Database connection rejected (auth requires password).",
+        "requires_restart": ["api"],
+    },
 }
 
 # ---------------------------------------------------------------------------
-# Service dependency graph — which services depend on which
+# Service dependency graph
 # ---------------------------------------------------------------------------
 
 DEPENDENCIES = {
@@ -96,7 +125,7 @@ SERVICE_PORTS = {
     "proxy": 80,
 }
 
-MAX_STEPS = 25
+MAX_STEPS = 30
 
 
 # ---------------------------------------------------------------------------
@@ -124,12 +153,10 @@ class DevEnvEnvironment:
         self._fixed_faults = set()
         self._log_history = []
 
-        # Load task faults
         from tasks import TASKS
         task = TASKS[task_id]
         self._active_faults = list(task["faults"])
 
-        # Build initial service env state from defaults
         self._state = {
             "envs": copy.deepcopy(DEFAULT_ENV),
             "services": {},
@@ -141,16 +168,17 @@ class DevEnvEnvironment:
             svc = fault["service"]
             key = fault["env_key"]
             if fault["bad_value"] is None:
-                # Remove the key (missing env var)
                 self._state["envs"][svc].pop(key, None)
             else:
                 self._state["envs"][svc][key] = fault["bad_value"]
 
-        # Compute initial service statuses
         self._recompute_statuses()
 
         return self._build_observation(
-            last_action_result=ActionResult(success=True, message="Environment initialized. Services started.")
+            last_action_result=ActionResult(
+                success=True,
+                message="Environment initialized. Services started. Check service statuses and read logs."
+            )
         )
 
     def step(self, action: Action) -> tuple[Observation, float, bool, dict]:
@@ -162,9 +190,7 @@ class DevEnvEnvironment:
 
         self._step_count += 1
         reward = 0.0
-        result: ActionResult
 
-        # Dispatch action
         if action.type == "read_logs":
             result, r = self._handle_read_logs(action)
             reward += r
@@ -184,10 +210,9 @@ class DevEnvEnvironment:
             result, r, self._done = self._handle_submit()
             reward += r
         else:
-            result = ActionResult(success=False, message=f"Unknown action type: {action.type}")
+            result = ActionResult(success=False, message=f"Unknown action type: '{action.type}'. Valid: read_logs, inspect_env, edit_env, restart_service, run_healthcheck, submit")
             reward -= 0.05
 
-        # Penalty for exceeding steps
         if self._step_count >= MAX_STEPS and not self._done:
             self._done = True
             reward -= 0.2
@@ -196,7 +221,11 @@ class DevEnvEnvironment:
         self._log_history.append(f"Step {self._step_count}: {action.type} → {result.message}")
 
         obs = self._build_observation(result)
-        return obs, round(reward, 3), self._done, {"step": self._step_count}
+        return obs, round(reward, 3), self._done, {
+            "step": self._step_count,
+            "fixed_faults": list(self._fixed_faults),
+            "remaining_faults": [f for f in self._active_faults if f not in self._fixed_faults],
+        }
 
     def state(self) -> dict:
         return {
@@ -217,28 +246,27 @@ class DevEnvEnvironment:
     def _handle_read_logs(self, action: Action) -> tuple[ActionResult, float]:
         svc = action.service
         if svc not in self._state["services"]:
-            return ActionResult(success=False, message=f"Unknown service: {svc}"), -0.05
+            return ActionResult(success=False, message=f"Unknown service '{svc}'. Valid: api, worker, database, proxy"), -0.05
 
         status = self._state["services"][svc]
         reward = 0.0
 
         if status.status == "error":
-            # Find fault log for this service
             logs = []
             for fault_id in self._active_faults:
                 if fault_id not in self._fixed_faults:
                     fault = FAULT_CATALOG[fault_id]
                     if fault["service"] == svc:
-                        logs.append(fault["log"])
-            # Also add downstream symptom logs
+                        logs.append(f"[ERROR] {fault['log']}")
+            # Add downstream symptom logs for dependent failures
             for fault_id in self._active_faults:
                 if fault_id not in self._fixed_faults:
                     fault = FAULT_CATALOG[fault_id]
                     if svc in fault.get("requires_restart", []) and fault["service"] != svc:
-                        logs.append(f"[downstream] Service unavailable due to dependency failure.")
+                        logs.append(f"[ERROR] Service unavailable — upstream dependency '{fault['service']}' is failing.")
 
             log_text = "\n".join(logs) if logs else "No errors in log."
-            reward += 0.05  # reward for reading logs before acting
+            reward += 0.05
             return ActionResult(success=True, message=f"[{svc} logs]\n{log_text}"), reward
         else:
             return ActionResult(success=True, message=f"[{svc} logs]\nNo errors. Service running normally."), 0.0
@@ -246,22 +274,21 @@ class DevEnvEnvironment:
     def _handle_inspect_env(self, action: Action) -> tuple[ActionResult, float]:
         svc = action.service
         if svc not in self._state["envs"]:
-            return ActionResult(success=False, message=f"Unknown service: {svc}"), -0.05
+            return ActionResult(success=False, message=f"Unknown service '{svc}'. Valid: api, worker, database, proxy"), -0.05
 
         env = self._state["envs"][svc]
-        env_text = "\n".join(f"  {k}={v}" for k, v in env.items())
+        env_text = "\n".join(f"  {k}={v}" for k, v in sorted(env.items()))
         return ActionResult(success=True, message=f"[{svc} env]\n{env_text}"), 0.02
 
     def _handle_edit_env(self, action: Action) -> tuple[ActionResult, float]:
         svc = action.service
         if not action.key or action.value is None:
-            return ActionResult(success=False, message="edit_env requires 'key' and 'value' params."), -0.05
+            return ActionResult(success=False, message="edit_env requires 'key' and 'value'."), -0.05
         if svc not in self._state["envs"]:
-            return ActionResult(success=False, message=f"Unknown service: {svc}"), -0.05
+            return ActionResult(success=False, message=f"Unknown service '{svc}'."), -0.05
 
         self._state["envs"][svc][action.key] = action.value
 
-        # Check if this edit fixes a fault
         reward = 0.0
         for fault_id in self._active_faults:
             if fault_id in self._fixed_faults:
@@ -270,11 +297,10 @@ class DevEnvEnvironment:
             if (fault["service"] == svc and
                     fault["fix_key"] == action.key and
                     fault["fix_value"] == action.value):
-                # Correct fix applied — mark as pending restart
                 reward += 0.1
                 return ActionResult(
                     success=True,
-                    message=f"Updated {svc}.{action.key}={action.value}. Restart {svc} to apply."
+                    message=f"Updated {svc}.{action.key}={action.value}. Now restart {svc} to apply."
                 ), reward
 
         return ActionResult(
@@ -285,12 +311,11 @@ class DevEnvEnvironment:
     def _handle_restart_service(self, action: Action) -> tuple[ActionResult, float]:
         svc = action.service
         if svc not in self._state["services"]:
-            return ActionResult(success=False, message=f"Unknown service: {svc}"), -0.05
+            return ActionResult(success=False, message=f"Unknown service '{svc}'."), -0.05
 
         reward = 0.0
         prev_statuses = {s: self._state["services"][s].status for s in self._state["services"]}
 
-        # Check if fault is now fixed (env has correct value)
         for fault_id in self._active_faults:
             if fault_id in self._fixed_faults:
                 continue
@@ -302,25 +327,23 @@ class DevEnvEnvironment:
 
         self._recompute_statuses()
 
-        # Check improvements
         for s, status_obj in self._state["services"].items():
             if prev_statuses[s] != "healthy" and status_obj.status == "healthy":
-                reward += 0.3  # service recovered
+                reward += 0.3
 
-        # Penalty: restarted without fixing root cause
         if self._state["services"][svc].status == "error":
             reward -= 0.1
             return ActionResult(
                 success=True,
-                message=f"{svc} restarted but still in error state. Root cause not fixed."
+                message=f"{svc} restarted but still in error. Root cause not fixed yet."
             ), reward
 
-        return ActionResult(success=True, message=f"{svc} restarted successfully."), reward
+        return ActionResult(success=True, message=f"{svc} restarted successfully. Status: healthy."), reward
 
     def _handle_healthcheck(self, action: Action) -> tuple[ActionResult, float]:
         svc = action.service
         if svc not in self._state["services"]:
-            return ActionResult(success=False, message=f"Unknown service: {svc}"), -0.05
+            return ActionResult(success=False, message=f"Unknown service '{svc}'."), -0.05
 
         status = self._state["services"][svc]
         return ActionResult(
@@ -329,9 +352,7 @@ class DevEnvEnvironment:
         ), 0.01
 
     def _handle_submit(self) -> tuple[ActionResult, float, bool]:
-        all_healthy = all(
-            s.status == "healthy" for s in self._state["services"].values()
-        )
+        all_healthy = all(s.status == "healthy" for s in self._state["services"].values())
         if all_healthy:
             return ActionResult(
                 success=True,
@@ -341,7 +362,7 @@ class DevEnvEnvironment:
             unhealthy = [k for k, v in self._state["services"].items() if v.status != "healthy"]
             return ActionResult(
                 success=False,
-                message=f"Submit failed. Services still unhealthy: {unhealthy}"
+                message=f"Submit failed. Services still unhealthy: {unhealthy}. Fix all services before submitting."
             ), -0.3, True
 
     # ------------------------------------------------------------------
@@ -349,34 +370,25 @@ class DevEnvEnvironment:
     # ------------------------------------------------------------------
 
     def _recompute_statuses(self):
-        """Recompute service statuses based on active unfixed faults and dependencies."""
-        # Start all healthy
         statuses = {svc: "healthy" for svc in DEFAULT_ENV}
 
-        # Apply unfixed faults
-        remaining = [f for f in self._active_faults if f not in self._fixed_faults]
         directly_broken = set()
-        for fault_id in remaining:
-            fault = FAULT_CATALOG[fault_id]
-            directly_broken.add(fault["service"])
+        for fault_id in self._active_faults:
+            if fault_id not in self._fixed_faults:
+                fault = FAULT_CATALOG[fault_id]
+                directly_broken.add(fault["service"])
 
-        # Propagate through dependency graph
         for svc in ["database", "api", "worker", "proxy"]:
             if svc in directly_broken:
                 statuses[svc] = "error"
             else:
-                # Check if any dependency is broken
                 for dep in DEPENDENCIES.get(svc, []):
                     if statuses.get(dep) == "error":
                         statuses[svc] = "error"
                         break
 
         self._state["services"] = {
-            svc: ServiceStatus(
-                name=svc,
-                status=statuses[svc],
-                port=SERVICE_PORTS[svc]
-            )
+            svc: ServiceStatus(name=svc, status=statuses[svc], port=SERVICE_PORTS[svc])
             for svc in DEFAULT_ENV
         }
 

tasks.py

@@ -1,6 +1,6 @@
 """
 Task definitions and programmatic graders.
-Each task defines faults to inject and a grader that scores 0.0 - 1.0.
+Each task defines faults to inject and a grader that scores strictly in (0, 1).
 """
 
 TASKS = {
@@ -31,13 +31,37 @@ TASKS = {
         "name": "Cascading Failure Debug",
         "difficulty": "hard",
         "description": (
-            "The database has wrong credentials, causing the API to fail with a misleading "
-            "'connection timeout' error, which in turn causes the worker and proxy to fail. "
-            "Logs are misleading — the agent must trace the root cause (DB_PASSWORD) rather "
-            "than patching downstream symptoms."
+            "The database has wrong credentials, causing the API to log a misleading "
+            "'connection timeout' error, which cascades to the worker and proxy. "
+            "Logs are misleading — the agent must trace the root cause (DB_PASSWORD on the "
+            "database service) rather than patching downstream symptoms."
         ),
         "faults": ["wrong_db_password"],
     },
+    "task4": {
+        "id": "task4",
+        "name": "Triple Fault Storm",
+        "difficulty": "hard",
+        "description": (
+            "Three independent faults hit at once: wrong DB_HOST on the API, "
+            "wrong API_HOST on the worker, and wrong PROXY_UPSTREAM on the proxy. "
+            "Each service is broken for a different reason. Agent must diagnose and fix all three "
+            "without being misled by cascading errors."
+        ),
+        "faults": ["wrong_db_host", "wrong_api_host", "wrong_api_port"],
+    },
+    "task5": {
+        "id": "task5",
+        "name": "Silent Misconfiguration",
+        "difficulty": "expert",
+        "description": (
+            "Two subtle faults with no obvious error messages: DB_PASSWORD is missing on the API "
+            "(not wrong — missing entirely), and the worker's API_HOST points to the wrong port. "
+            "Services appear to start but immediately fail silently. "
+            "The agent must inspect env vars carefully rather than relying on logs alone."
+        ),
+        "faults": ["missing_db_password", "wrong_api_host"],
+    },
 }
 
 
@@ -53,12 +77,11 @@ def grade_episode(task_id: str, env_state: dict) -> dict:
     """
     task = TASKS.get(task_id)
     if not task:
-        return {"score": _clamp(0.0), "reason": f"Unknown task: {task_id}"}
+        return {"score": _clamp(0.001), "reason": f"Unknown task: {task_id}"}
 
     services = env_state.get("services", {})
     fixed_faults = set(env_state.get("fixed_faults", []))
     active_faults = set(env_state.get("active_faults", []))
-    remaining = active_faults - fixed_faults
     steps = env_state.get("step", 0)
 
     all_healthy = all(s["status"] == "healthy" for s in services.values())
@@ -66,13 +89,12 @@ def grade_episode(task_id: str, env_state: dict) -> dict:
     faults_fixed = len(fixed_faults)
 
     # ---------------------------------------------------------------
-    # Task 1 grader — single fault, binary but with partial for partial fix
+    # Task 1 — single fault, efficiency bonus
     # ---------------------------------------------------------------
     if task_id == "task1":
         if all_healthy and faults_fixed == total_faults:
-            # Efficiency bonus for doing it quickly
-            efficiency = max(0.0, 1.0 - (steps - 3) * 0.03)
-            score = min(1.0, 0.85 + efficiency * 0.15)
+            efficiency = max(0.0, 1.0 - max(0, steps - 4) * 0.04)
+            score = 0.75 + efficiency * 0.20
             return {
                 "score": _clamp(score),
                 "reason": f"All services healthy. Fixed in {steps} steps.",
@@ -81,55 +103,52 @@ def grade_episode(task_id: str, env_state: dict) -> dict:
             }
         elif faults_fixed > 0:
             return {
-                "score": _clamp(0.4),
-                "reason": "Fault fixed but service not restarted or submit not called.",
+                "score": _clamp(0.35),
+                "reason": "Fault fixed but episode not completed correctly.",
                 "faults_fixed": faults_fixed,
                 "total_faults": total_faults,
             }
-        else:
-            return {
-                "score": _clamp(0.0),
-                "reason": "No faults fixed.",
-                "faults_fixed": 0,
-                "total_faults": total_faults,
-            }
+        return {
+            "score": _clamp(0.05),
+            "reason": "No faults fixed.",
+            "faults_fixed": 0,
+            "total_faults": total_faults,
+        }
 
     # ---------------------------------------------------------------
-    # Task 2 grader — partial credit per fault fixed
+    # Task 2 — partial credit per fault fixed
     # ---------------------------------------------------------------
     if task_id == "task2":
         if all_healthy and faults_fixed == total_faults:
-            efficiency = max(0.0, 1.0 - (steps - 5) * 0.02)
-            score = min(1.0, 0.85 + efficiency * 0.15)
+            efficiency = max(0.0, 1.0 - max(0, steps - 6) * 0.03)
+            score = 0.70 + efficiency * 0.25
             return {
                 "score": _clamp(score),
-                "reason": f"All services healthy. Both faults fixed in {steps} steps.",
+                "reason": f"Both faults fixed. All services healthy in {steps} steps.",
                 "faults_fixed": faults_fixed,
                 "total_faults": total_faults,
             }
         elif faults_fixed == 1:
             return {
-                "score": _clamp(0.45),
-                "reason": f"One of two faults fixed. Partial credit.",
+                "score": _clamp(0.40),
+                "reason": "One of two faults fixed. Partial credit.",
                 "faults_fixed": faults_fixed,
                 "total_faults": total_faults,
             }
-        else:
-            return {
-                "score": _clamp(0.0),
-                "reason": "No faults fixed.",
-                "faults_fixed": 0,
-                "total_faults": total_faults,
-            }
+        return {
+            "score": _clamp(0.05),
+            "reason": "No faults fixed.",
+            "faults_fixed": 0,
+            "total_faults": total_faults,
+        }
 
     # ---------------------------------------------------------------
-    # Task 3 grader — penalizes symptom-patching, rewards root cause fix
+    # Task 3 — cascading root cause
     # ---------------------------------------------------------------
     if task_id == "task3":
         if all_healthy and faults_fixed == total_faults:
-            # Reward fewer steps heavily (cascading fix is fast if root cause found)
-            efficiency = max(0.0, 1.0 - (steps - 4) * 0.04)
-            score = min(1.0, 0.80 + efficiency * 0.20)
+            efficiency = max(0.0, 1.0 - max(0, steps - 5) * 0.04)
+            score = 0.70 + efficiency * 0.25
             return {
                 "score": _clamp(score),
                 "reason": f"Root cause found and fixed. All services recovered in {steps} steps.",
@@ -137,19 +156,78 @@ def grade_episode(task_id: str, env_state: dict) -> dict:
                 "total_faults": total_faults,
             }
         elif faults_fixed > 0:
-            # Fixed something but not all healthy — partial
             return {
-                "score": _clamp(0.3),
-                "reason": "Partial fix. Root cause addressed but services not fully recovered.",
+                "score": _clamp(0.30),
+                "reason": "Root cause addressed but services not fully recovered.",
+                "faults_fixed": faults_fixed,
+                "total_faults": total_faults,
+            }
+        return {
+            "score": _clamp(0.05),
+            "reason": "Root cause not identified.",
+            "faults_fixed": 0,
+            "total_faults": total_faults,
+        }
+
+    # ---------------------------------------------------------------
+    # Task 4 — triple fault storm (partial credit per fault)
+    # ---------------------------------------------------------------
+    if task_id == "task4":
+        if all_healthy and faults_fixed == total_faults:
+            efficiency = max(0.0, 1.0 - max(0, steps - 10) * 0.025)
+            score = 0.65 + efficiency * 0.30
+            return {
+                "score": _clamp(score),
+                "reason": f"All 3 faults fixed. All services healthy in {steps} steps.",
+                "faults_fixed": faults_fixed,
+                "total_faults": total_faults,
+            }
+        elif faults_fixed == 2:
+            return {
+                "score": _clamp(0.55),
+                "reason": "2 of 3 faults fixed.",
                 "faults_fixed": faults_fixed,
                 "total_faults": total_faults,
             }
-        else:
+        elif faults_fixed == 1:
             return {
-                "score": _clamp(0.0),
-                "reason": "Root cause not identified. All services still broken.",
-                "faults_fixed": 0,
+                "score": _clamp(0.28),
+                "reason": "1 of 3 faults fixed.",
+                "faults_fixed": faults_fixed,
+                "total_faults": total_faults,
+            }
+        return {
+            "score": _clamp(0.05),
+            "reason": "No faults fixed.",
+            "faults_fixed": 0,
+            "total_faults": total_faults,
+        }
+
+    # ---------------------------------------------------------------
+    # Task 5 — silent misconfiguration (expert)
+    # ---------------------------------------------------------------
+    if task_id == "task5":
+        if all_healthy and faults_fixed == total_faults:
+            efficiency = max(0.0, 1.0 - max(0, steps - 8) * 0.03)
+            score = 0.65 + efficiency * 0.30
+            return {
+                "score": _clamp(score),
+                "reason": f"Both silent faults found and fixed in {steps} steps. Expert diagnosis.",
+                "faults_fixed": faults_fixed,
+                "total_faults": total_faults,
+            }
+        elif faults_fixed == 1:
+            return {
+                "score": _clamp(0.38),
+                "reason": "One silent fault found. Second still undetected.",
+                "faults_fixed": faults_fixed,
                 "total_faults": total_faults,
             }
+        return {
+            "score": _clamp(0.05),
+            "reason": "No faults found. Agent must inspect env vars, not just logs.",
+            "faults_fixed": 0,
+            "total_faults": total_faults,
+        }
 
-    return {"score": _clamp(0.0), "reason": "Unhandled task."}
+    return {"score": _clamp(0.05), "reason": "Unhandled task."}