feat: ARIA Incident Generator — procedural incidents from seeds

api.py

@@ -4,14 +4,20 @@ from fastapi.responses import HTMLResponse
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
 from typing import Optional
+from curriculum import CurriculumEngine
 from env import DevOpsIncidentEnv
 from models import Action, ActionType, Observation, StepResult, State
 from collections import deque
 from datetime import datetime
 import uuid
 import statistics
+from generator import IncidentFactory
+from tasks.task_generated import GeneratedTask
 
+curriculum_engine = CurriculumEngine()
+episode_tracker: dict = {}  # tracks active episode task_id per session
 episode_history = deque(maxlen=1000)
+_factory = IncidentFactory()
 
 def track_episode(state_obj: State):
     from graders.grader import grade_episode
@@ -56,8 +62,9 @@ app = FastAPI(
     description=(
         "An OpenEnv-compliant RL environment where AI agents diagnose and remediate "
         "production software incidents across a simulated microservices architecture. "
-        "Four tasks: easy (OOM), medium (cascade), hard (silent corruption), "
-        "bonus (dual simultaneous failure)."
+        "Seven tasks of escalating difficulty: OOM crash-loop, cascading failure, "
+        "silent data corruption, dual simultaneous failure, DDoS attack, database "
+        "degradation, and multi-region failover."
     ),
     version="1.0.0",
 )
@@ -78,6 +85,11 @@ class ResetRequest(BaseModel):
     seed: Optional[int] = None
 
 
+class CurriculumRecordRequest(BaseModel):
+    task_id: str
+    score: float
+
+
 @app.get("/", response_class=HTMLResponse)
 def dashboard():
     env_state = None
@@ -134,6 +146,29 @@ def dashboard():
         .task {{ background: #1a1d27; border: 1px solid #2d3148; border-radius: 8px; padding: 1.25rem; }}
         .task h3 {{ margin: 0 0 0.5rem; color: #ff6b35; font-size: 1rem; }}
         .task p {{ margin: 0; color: #aaa; font-size: 0.85rem; line-height: 1.5; }}
+        .curriculum-section {{ background: #121621; border: 1px solid #2d3148; border-radius: 10px; padding: 1.25rem; margin-bottom: 2rem; }}
+        .curriculum-section h3 {{ margin: 0 0 0.35rem; color: #fff; }}
+        .curriculum-section p {{ margin: 0 0 1rem; color: #7f8799; font-size: 0.85rem; }}
+        .curriculum-meta {{ color: #9aa4b2; font-size: 0.8rem; margin-bottom: 0.75rem; }}
+        .curriculum-table {{ display: flex; flex-direction: column; gap: 0.65rem; }}
+        .curriculum-header, .curriculum-row {{ display: grid; grid-template-columns: minmax(90px, 1fr) 110px minmax(180px, 1.4fr) minmax(160px, 1fr); gap: 1rem; align-items: center; }}
+        .curriculum-header {{ color: #7f8799; font-size: 0.72rem; text-transform: uppercase; letter-spacing: 0.08em; padding-bottom: 0.35rem; border-bottom: 1px solid #273042; }}
+        .curriculum-row {{ background: #171c29; border: 1px solid #242d40; border-radius: 8px; padding: 0.9rem 1rem; }}
+        .curriculum-task-name {{ font-weight: 600; color: #f5f7fa; text-transform: capitalize; }}
+        .curriculum-stars {{ font-size: 1rem; letter-spacing: 0.12em; color: #ffd166; }}
+        .curriculum-bar-wrap {{ display: flex; align-items: center; gap: 0.75rem; }}
+        .curriculum-bar {{ flex: 1; height: 0.7rem; background: #222a3b; border-radius: 999px; overflow: hidden; border: 1px solid #303a4f; }}
+        .curriculum-fill {{ height: 100%; border-radius: 999px; transition: width 0.3s ease; }}
+        .curriculum-score {{ min-width: 3rem; text-align: right; color: #d5dbe3; font-size: 0.8rem; font-variant-numeric: tabular-nums; }}
+        .curriculum-badges {{ display: flex; gap: 0.5rem; flex-wrap: wrap; justify-content: flex-start; }}
+        .curriculum-pill {{ display: inline-block; padding: 0.25rem 0.6rem; border-radius: 999px; font-size: 0.7rem; font-weight: 700; letter-spacing: 0.04em; }}
+        .scaffold-pill {{ background: rgba(239, 83, 80, 0.18); color: #ff8a80; border: 1px solid rgba(239, 83, 80, 0.35); }}
+        .recommended-pill {{ background: rgba(102, 187, 106, 0.18); color: #8de28f; border: 1px solid rgba(102, 187, 106, 0.35); }}
+        .curriculum-loading, .curriculum-error {{ color: #9aa4b2; font-size: 0.9rem; padding: 0.25rem 0; }}
+        @media (max-width: 900px) {{
+            .curriculum-header {{ display: none; }}
+            .curriculum-row {{ grid-template-columns: 1fr; gap: 0.7rem; }}
+        }}
         .badge {{ display: inline-block; padding: 0.2rem 0.6rem; border-radius: 4px; font-size: 0.7rem; font-weight: 600; margin-bottom: 0.5rem; }}
         .easy {{ background: #1a3a1a; color: #4caf50; }}
         .medium {{ background: #3a2a1a; color: #ff9800; }}
@@ -149,6 +184,12 @@ def dashboard():
         .path {{ color: #81c784; font-family: monospace; font-size: 0.85rem; }}
         .desc {{ color: #888; font-size: 0.8rem; }}
         .footer {{ color: #555; font-size: 0.8rem; text-align: center; margin-top: 2rem; }}
+        #incident-generator {{ background: #1a1d27; border: 1px solid #2d3148; border-radius: 8px; padding: 1.5rem; margin-bottom: 2rem; }}
+        #incident-result {{ margin-top: 1.5rem; padding: 1rem; background: #0f1117; border-radius: 6px; border-left: 4px solid #ff6b35; }}
+        .badge-mono {{ font-family: monospace; background: #333; padding: 0.1rem 0.4rem; border-radius: 3px; font-size: 0.85rem; }}
+        .difficulty-bar-container {{ height: 8px; background: #333; border-radius: 4px; margin: 10px 0; }}
+        .difficulty-bar {{ height: 100%; border-radius: 4px; transition: width 0.5s ease; }}
+        .tag {{ font-size: 0.75rem; color: #888; background: #222; padding: 0.1rem 0.4rem; border-radius: 10px; margin-right: 5px; }}
     </style>
 </head>
 <body>
@@ -196,6 +237,41 @@ def dashboard():
             <p>Partial region failure. Discriminate between services that support auto-failover and those that require human escalation. Max 25 steps.</p>
         </div>
     </div>
+
+    <div id="incident-generator">
+        <h3 style="margin-top:0; color:#ff6b35;">ARIA Incident Generator</h3>
+        <div style="display:flex; gap:10px; align-items:center;">
+            <input type="number" id="seed-input" min="0" max="99999" value="42" 
+                   style="background:#0f1117; color:#fff; border:1px solid #2d3148; padding:8px; border-radius:4px; width:100px;">
+            <button onclick="generateIncident()" 
+                    style="background:#ff6b35; color:#fff; border:none; padding:8px 16px; border-radius:4px; cursor:pointer; font-weight:600;">
+                Generate Incident
+            </button>
+        </div>
+        <div id="incident-result" style="display:none;">
+            <div style="display:flex; justify-content:space-between; align-items:center; margin-bottom:10px;">
+                <span id="res-id" class="badge-mono"></span>
+                <div id="res-badges"></div>
+            </div>
+            <p id="res-affected" style="margin:5px 0; font-weight:600;"></p>
+            <div class="difficulty-bar-container">
+                <div id="res-diff-bar" class="difficulty-bar"></div>
+            </div>
+            <p id="res-desc" style="margin:10px 0; line-height:1.4; color:#ccc;"></p>
+            <div id="res-noise" style="margin-bottom:15px;"></div>
+            <p style="font-size:0.75rem; color:#555; font-family:monospace; margin:0;">
+                Use with: POST /reset body {{"task_id":"generated","seed":<span id="res-seed-val"></span>}}
+            </p>
+        </div>
+    </div>
+
+    <div class="curriculum-section">
+        <h3>ARIA Curriculum Status</h3>
+        <p>Live mastery tracking across the seven incident types.</p>
+        <div id="curriculum-status">
+            <div class="curriculum-loading">Loading curriculum status...</div>
+        </div>
+    </div>
     
     <div class="endpoints">
         <h3>API Endpoints</h3>
@@ -222,7 +298,7 @@ def dashboard():
         <div class="endpoint">
             <span class="method">GET</span>
             <span class="path">/validate</span>
-            <span class="desc">Self-validation report for all 4 tasks</span>
+            <span class="desc">Self-validation report for all 7 tasks</span>
         </div>
         <div class="endpoint">
             <span class="method">GET</span>
@@ -239,6 +315,118 @@ def dashboard():
         <a href="/metrics" style="color:#ff6b35;">Metrics</a> &nbsp;|&nbsp;
         <a href="/leaderboard" style="color:#ff6b35;">Leaderboard</a>
     </div>
+    <script>
+        const curriculumContainer = document.getElementById("curriculum-status");
+
+        function masteryStars(level) {{
+            return "★".repeat(level) + "☆".repeat(3 - level);
+        }}
+
+        function avgColor(avg) {{
+            if (avg < 0.3) {{
+                return "#ef5350";
+            }}
+            if (avg < 0.6) {{
+                return "#ffd54f";
+            }}
+            return "#66bb6a";
+        }}
+
+        function renderCurriculumStatus(payload) {{
+            const tasks = payload.tasks || {{}};
+            const recommendedTask = payload.recommended_task;
+            const rows = Object.entries(tasks).map(([taskId, task]) => {{
+                const avg = Number(task.rolling_avg || 0);
+                const width = Math.max(0, Math.min(100, avg * 100));
+                const badges = [];
+                if (task.scaffold_needed) {{
+                    badges.push('<span class="curriculum-pill scaffold-pill">SCAFFOLD</span>');
+                }}
+                if (taskId === recommendedTask) {{
+                    badges.push('<span class="curriculum-pill recommended-pill">RECOMMENDED</span>');
+                }}
+
+                return `
+                    <div class="curriculum-row">
+                        <div class="curriculum-task-name">${{taskId}}</div>
+                        <div class="curriculum-stars" title="${{task.mastery_label}}">${{masteryStars(task.mastery_level)}}</div>
+                        <div class="curriculum-bar-wrap">
+                            <div class="curriculum-bar">
+                                <div class="curriculum-fill" style="width:${{width}}%; background:${{avgColor(avg)}};"></div>
+                            </div>
+                            <div class="curriculum-score">${{avg.toFixed(2)}}</div>
+                        </div>
+                        <div class="curriculum-badges">${{badges.join("")}}</div>
+                    </div>
+                `;
+            }}).join("");
+
+            curriculumContainer.innerHTML = `
+                <div class="curriculum-meta">Total episodes recorded: ${{payload.total_episodes_recorded}}</div>
+                <div class="curriculum-table">
+                    <div class="curriculum-header">
+                        <div>Task</div>
+                        <div>Mastery</div>
+                        <div>Rolling Avg</div>
+                        <div>Status</div>
+                    </div>
+                    ${{rows}}
+                </div>
+            `;
+        }}
+
+        async function refreshCurriculumStatus() {{
+            try {{
+                const response = await fetch("/curriculum/status");
+                if (!response.ok) {{
+                    throw new Error("Failed to load curriculum status");
+                }}
+                const payload = await response.json();
+                renderCurriculumStatus(payload);
+            }} catch (error) {{
+                curriculumContainer.innerHTML = '<div class="curriculum-error">Curriculum status unavailable.</div>';
+            }}
+        }}
+
+        refreshCurriculumStatus();
+        setInterval(refreshCurriculumStatus, 15000);
+
+        function generateIncident() {{
+            const seed = document.getElementById('seed-input').value;
+            fetch(`/generate/preview?seed=${{seed}}`)
+                .then(r => r.json())
+                .then(data => {{
+                    document.getElementById('res-id').innerText = data.incident_id;
+                    document.getElementById('res-seed-val').innerText = seed;
+                    document.getElementById('res-affected').innerText = "Affected: " + data.affected_service;
+                    document.getElementById('res-desc').innerText = data.description;
+                    
+                    const modeColors = {{
+                        oom: "#f44336", cascade: "#ff9800", corruption: "#9c27b0", 
+                        security: "#ffeb3b", database: "#4fc3f7", network_partition: "#009688"
+                    }};
+                    const sevColors = {{ sev1: "#f44336", sev2: "#ff9800", sev3: "#ffeb3b" }};
+                    
+                    document.getElementById('res-badges').innerHTML = `
+                        <span class="badge" style="background:${{modeColors[data.failure_mode]}}; color:#000; margin-right:5px;">${{data.failure_mode.toUpperCase()}}</span>
+                        <span class="badge" style="background:${{sevColors[data.severity]}}; color:#000;">${{data.severity.toUpperCase()}}</span>
+                    `;
+                    
+                    const diffBar = document.getElementById('res-diff-bar');
+                    diffBar.style.width = (data.difficulty_score * 100) + "%";
+                    diffBar.style.background = avgColor(data.difficulty_score);
+                    
+                    const noiseDiv = document.getElementById('res-noise');
+                    if (data.noise_alerts.length === 0) {{
+                        noiseDiv.innerHTML = '<span style="font-size:0.8rem; color:#555;">No noise alerts</span>';
+                    }} else {{
+                        noiseDiv.innerHTML = data.noise_alerts.map(n => `<span class="tag">${{n}}</span>`).join("");
+                    }}
+                    
+                    document.getElementById('incident-result').style.display = 'block';
+                }});
+        }}
+    </script>
 </body>
 </html>"""
     return html
@@ -249,18 +437,38 @@ def health():
     return {"status": "ok", "env": "devops-incident-response", "version": "1.0.0"}
 
 
+@app.get("/generate/preview")
+def preview_incident(seed: int = 42):
+    return _factory.generate(seed)
+
+
 @app.post("/reset", response_model=Observation)
 def reset(req: Optional[ResetRequest] = None):
     if req is None:
         req = ResetRequest()
     global _env
-    if req.task_id not in VALID_TASKS:
-        raise HTTPException(
-            status_code=400,
-            detail=f"task_id must be one of {VALID_TASKS}. Got: {req.task_id}",
-        )
-    _env = DevOpsIncidentEnv(task_id=req.task_id, seed=req.seed)
-    return _env.reset()
+    
+    if req.task_id == "generated":
+        seed = req.seed if req.seed is not None else 42
+        incident = _factory.generate(seed)
+        task = GeneratedTask(incident_dict=incident)
+        state = task.initialize()
+        _env = DevOpsIncidentEnv(task_id="easy", seed=seed)
+        _env.task_id = "generated"
+        _env._task = task
+        _env._internal_state = state
+        observation = state._build_observation()
+    else:
+        if req.task_id not in VALID_TASKS:
+            raise HTTPException(
+                status_code=400,
+                detail=f"task_id must be one of {VALID_TASKS}. Got: {req.task_id}",
+            )
+        _env = DevOpsIncidentEnv(task_id=req.task_id, seed=req.seed)
+        observation = _env.reset()
+    
+    episode_tracker[_env.state().episode_id] = req.task_id
+    return observation
 
 
 @app.post("/step", response_model=StepResult)
@@ -269,7 +477,21 @@ def step(action: Action):
         raise HTTPException(status_code=400, detail="Call /reset before /step")
     res = _env.step(action)
     if res.done:
-        track_episode(_env.state())
+        from graders.grader import grade_episode
+
+        current_state = _env.state()
+        current_task_id = episode_tracker.get(current_state.episode_id, current_state.task_id)
+        final_score = grade_episode(
+            task_id=current_task_id,
+            action_history=current_state.action_history,
+            ground_truth_root_cause=current_state.ground_truth_root_cause,
+            ground_truth_fix=current_state.ground_truth_fix,
+            incident_resolved=current_state.incident_resolved,
+            total_reward=current_state.total_reward,
+        )
+        curriculum_engine.record_episode(current_task_id, float(final_score))
+        episode_tracker.pop(current_state.episode_id, None)
+        track_episode(current_state)
     return res
 
 
@@ -352,10 +574,55 @@ def list_tasks():
                     "and which do not. Failing over the wrong services causes severe data inconsistency penalties."
                 ),
             },
+            {
+                "id": "generated",
+                "name": "Procedural Incident",
+                "difficulty": "variable",
+                "max_steps": 20,
+                "description": "Procedurally generated incident. Use with any seed 0-99999 for infinite unique scenarios.",
+            },
         ]
     }
 
 
+@app.get("/curriculum/status")
+def get_curriculum_status():
+    return curriculum_engine.get_status()
+
+
+@app.get("/curriculum/next")
+def get_next_curriculum_task():
+    return {
+        "recommended_task": curriculum_engine.get_next_curriculum_task(),
+        "reasoning": "Lowest rolling average among non-mastered tasks.",
+    }
+
+
+@app.post("/curriculum/record")
+def record_curriculum_episode(req: CurriculumRecordRequest):
+    try:
+        curriculum_engine.record_episode(req.task_id, req.score)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+    return {
+        "recorded": True,
+        "new_status": curriculum_engine.get_status()["tasks"][req.task_id],
+    }
+
+
+@app.get("/curriculum/hint/{task_id}")
+def get_curriculum_hint(task_id: str):
+    try:
+        return {
+            "task_id": task_id,
+            "hint": curriculum_engine.get_hint(task_id),
+            "scaffold_needed": curriculum_engine.should_scaffold(task_id),
+            "mastery_level": curriculum_engine.get_mastery(task_id),
+        }
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
+
 @app.get("/validate")
 def validate():
     """

curriculum/__init__.py

@@ -0,0 +1,3 @@
+from curriculum.engine import CurriculumEngine
+
+__all__ = ["CurriculumEngine"]

curriculum/engine.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+from collections import deque
+
+
+class CurriculumEngine:
+    def __init__(self):
+        self.tasks = ["easy", "medium", "hard", "bonus", "security", "database", "failover"]
+        self.scores: dict[str, deque] = {
+            task_id: deque(maxlen=5) for task_id in self.tasks
+        }
+        self.mastery: dict[str, int] = {task_id: 0 for task_id in self.tasks}
+        self._hints: dict[str, str] = {
+            "easy": "Focus on the service with highest memory_percent. Read its logs before acting.",
+            "medium": "Follow the dependency map backwards from the erroring service to find the root cause.",
+            "hard": "All services look green. Check WARN-level logs and business metrics, not error rates.",
+            "bonus": "There are two independent failures. Fix each one separately — do not conflate them.",
+            "security": "Look for repeated login failures from the same IP range in the access logs.",
+            "database": "Check for sequential scans in slow query logs. The fix is structural, not a restart.",
+            "failover": "Read the failover runbook first. Not all services are safe — check compliance constraints.",
+        }
+        self._rotation_index = 0
+        self._total_episodes_recorded = 0
+
+    def _ensure_task(self, task_id: str) -> None:
+        if task_id not in self.scores:
+            raise ValueError(f"Unknown task_id: {task_id}")
+
+    def record_episode(self, task_id: str, score: float) -> None:
+        self._ensure_task(task_id)
+        self.scores[task_id].append(float(score))
+        self._total_episodes_recorded += 1
+        self._update_mastery(task_id)
+
+    def _update_mastery(self, task_id: str) -> None:
+        self._ensure_task(task_id)
+        rolling_avg = self.get_rolling_avg(task_id)
+        if rolling_avg > 0.75 and self.mastery[task_id] < 3:
+            self.mastery[task_id] += 1
+        elif rolling_avg < 0.30 and self.mastery[task_id] > 0:
+            self.mastery[task_id] -= 1
+
+    def get_mastery(self, task_id: str) -> int:
+        self._ensure_task(task_id)
+        return self.mastery[task_id]
+
+    def get_rolling_avg(self, task_id: str) -> float:
+        self._ensure_task(task_id)
+        recent_scores = self.scores[task_id]
+        if not recent_scores:
+            return 0.0
+        return sum(recent_scores) / len(recent_scores)
+
+    def should_scaffold(self, task_id: str) -> bool:
+        self._ensure_task(task_id)
+        return len(self.scores[task_id]) >= 3 and self.get_rolling_avg(task_id) < 0.30
+
+    def get_hint(self, task_id: str) -> str:
+        self._ensure_task(task_id)
+        return self._hints[task_id]
+
+    def _get_non_mastered_tasks(self) -> list[str]:
+        return [task_id for task_id in self.tasks if self.mastery[task_id] < 3]
+
+    def _sorted_candidates(self) -> list[str]:
+        candidates = self._get_non_mastered_tasks()
+        return sorted(
+            candidates,
+            key=lambda task_id: (self.get_rolling_avg(task_id), self.tasks.index(task_id)),
+        )
+
+    def get_recommended_task(self) -> str:
+        candidates = self._sorted_candidates()
+        if not candidates:
+            return "bonus"
+        return candidates[0]
+
+    def get_next_curriculum_task(self) -> str:
+        candidates = self._sorted_candidates()
+        if not candidates:
+            return "bonus"
+        task_id = candidates[self._rotation_index % len(candidates)]
+        self._rotation_index = (self._rotation_index + 1) % len(candidates)
+        return task_id
+
+    def get_status(self) -> dict:
+        mastery_labels = {
+            0: "novice",
+            1: "intermediate",
+            2: "advanced",
+            3: "mastered",
+        }
+        tasks = {}
+        for task_id in self.tasks:
+            scaffold_needed = self.should_scaffold(task_id)
+            tasks[task_id] = {
+                "mastery_level": self.mastery[task_id],
+                "mastery_label": mastery_labels[self.mastery[task_id]],
+                "rolling_avg": self.get_rolling_avg(task_id),
+                "recent_scores": list(self.scores[task_id]),
+                "scaffold_needed": scaffold_needed,
+                "hint": self.get_hint(task_id) if scaffold_needed else None,
+            }
+        return {
+            "tasks": tasks,
+            "recommended_task": self.get_recommended_task(),
+            "total_episodes_recorded": self._total_episodes_recorded,
+        }

generator/__init__.py

@@ -0,0 +1,2 @@
+from generator.incident_factory import IncidentFactory
+__all__ = ["IncidentFactory"]

generator/incident_factory.py

@@ -0,0 +1,79 @@
+import random
+
+class IncidentFactory:
+    FAILURE_MODES = ["oom", "cascade", "corruption", "security", "database", "network_partition"]
+    SERVICES = ["payment-service", "order-service", "user-service", 
+                "inventory-service", "api-gateway", "notification-service", 
+                "data-pipeline", "ml-inference-service"]
+    SEVERITIES = ["sev1", "sev2", "sev3"]
+    NOISE_ALERTS = [
+        "Scheduled batch job running — high CPU expected",
+        "SSL certificate renewal in progress",
+        "Nightly analytics aggregation running",
+        "CDN cache warming after deployment",
+        "Routine health check latency spike"
+    ]
+
+    def generate(self, seed: int) -> dict:
+        rng = random.Random(seed)
+        failure_mode = rng.choice(self.FAILURE_MODES)
+        affected_service = rng.choice(self.SERVICES)
+        severity = rng.choice(self.SEVERITIES)
+        noise_count = rng.randint(0, 3)
+        noise_alerts = rng.sample(self.NOISE_ALERTS, min(noise_count, len(self.NOISE_ALERTS)))
+
+        # Templates for description
+        descriptions = {
+            "oom": f"{affected_service} is crash-looping due to memory exhaustion. Process memory exceeded limits.",
+            "cascade": f"{affected_service} bad deployment causing downstream connection pool exhaustion across dependent services.",
+            "corruption": f"Silent data corruption in {affected_service}. Invalid records being written. No error-rate alerts — signal buried in business metrics.",
+            "security": f"Credential stuffing botnet targeting {affected_service} from IP range 185.220.x.x.",
+            "database": f"Missing index on {affected_service} database after migration. Full table scans degrading all queries.",
+            "network_partition": f"Network partition isolating {affected_service} in us-east-1. Failover decision required."
+        }
+        description = descriptions[failure_mode]
+
+        # Templates for root cause
+        root_causes = {
+            "oom": f"Memory leak in {affected_service} causing OOM crash-loop",
+            "cascade": f"Bad deployment in {affected_service} causing cascading connection failures",
+            "corruption": f"Data corruption in {affected_service} writing invalid records",
+            "security": f"DDoS credential stuffing from 185.220.0.0/16 targeting {affected_service}",
+            "database": f"Missing index causing sequential scans on {affected_service}",
+            "network_partition": f"Network partition in us-east-1 affecting {affected_service}"
+        }
+        ground_truth_root_cause = root_causes[failure_mode]
+
+        # Templates for fix
+        fixes = {
+            "oom": "restart_service",
+            "cascade": "rollback",
+            "corruption": "rollback",
+            "security": "block_ip_range",
+            "database": "create_index",
+            "network_partition": "failover"
+        }
+        ground_truth_fix = fixes[failure_mode]
+
+        # Difficulty score
+        base_scores = {
+            "oom": 0.2, "cascade": 0.5, "corruption": 0.8,
+            "security": 0.6, "database": 0.6, "network_partition": 0.7
+        }
+        score = base_scores[failure_mode] + (noise_count * 0.05)
+        score = min(score, 1.0)
+
+        return {
+            "task_id": "generated",
+            "incident_id": f"INC-{seed:05d}",
+            "seed": seed,
+            "failure_mode": failure_mode,
+            "affected_service": affected_service,
+            "severity": severity,
+            "noise_alerts": noise_alerts,
+            "description": description,
+            "ground_truth_root_cause": ground_truth_root_cause,
+            "ground_truth_fix": ground_truth_fix,
+            "difficulty_score": round(score, 2),
+            "estimated_optimal_score": round(0.99 - score * 0.3, 2)
+        }

tasks/task_generated.py

@@ -0,0 +1,165 @@
+import random
+import uuid
+from datetime import datetime
+from tasks.base import BaseTask, InternalState, StepOutput
+from models import Action, StepResult, ServiceStatus, Alert, ActionType
+
+class GeneratedTask(BaseTask):
+    def __init__(self, incident_dict: dict):
+        self.incident = incident_dict
+        self.task_id = "generated"
+        self.max_steps = 20
+        # For compatibility with BaseTask which expects rng in __init__
+        super().__init__(random.Random(incident_dict.get("seed", 42)))
+
+    def initialize(self) -> InternalState:
+        affected = self.incident["affected_service"]
+        failure_mode = self.incident["failure_mode"]
+        
+        services_dict = {}
+        SERVICES = ["payment-service", "order-service", "user-service", 
+                    "inventory-service", "api-gateway", "notification-service", 
+                    "data-pipeline", "ml-inference-service"]
+        
+        for svc in SERVICES:
+            if svc == affected:
+                services_dict[svc] = {
+                    "name": svc,
+                    "status": "degraded",
+                    "cpu_percent": 85.0,
+                    "memory_percent": 92.0,
+                    "error_rate": 0.35,
+                    "latency_p99_ms": 2800.0,
+                    "replicas_running": 2,
+                    "replicas_desired": 3,
+                    "current_version": "v1.2.4",
+                    "last_deployed": (datetime.utcnow()).isoformat(),
+                    "minutes_degraded": 0,
+                    "sla_breach": False
+                }
+            else:
+                services_dict[svc] = {
+                    "name": svc,
+                    "status": "healthy",
+                    "cpu_percent": 25.0,
+                    "memory_percent": 40.0,
+                    "error_rate": 0.01,
+                    "latency_p99_ms": 120.0,
+                    "replicas_running": 3,
+                    "replicas_desired": 3,
+                    "current_version": "v1.2.3",
+                    "last_deployed": (datetime.utcnow()).isoformat(),
+                    "minutes_degraded": 0,
+                    "sla_breach": False
+                }
+
+        active_alerts = []
+        # One CRITICAL alert
+        active_alerts.append({
+            "id": str(uuid.uuid4())[:8],
+            "service": affected,
+            "severity": "critical",
+            "message": self.incident["description"],
+            "timestamp": datetime.utcnow().isoformat(),
+            "acknowledged": False
+        })
+        
+        # Noise alerts
+        for noise in self.incident["noise_alerts"]:
+            active_alerts.append({
+                "id": str(uuid.uuid4())[:8],
+                "service": "notification-service",
+                "severity": "warning",
+                "message": noise,
+                "timestamp": datetime.utcnow().isoformat(),
+                "acknowledged": False
+            })
+
+        log_lines = {
+            "oom": ["ERROR OutOfMemoryError: Java heap space", 
+                    "WARN Memory usage at 98%, GC overhead limit exceeded"],
+            "cascade": ["ERROR Connection pool exhausted: timeout after 30s",
+                        "ERROR Failed to acquire connection from pool"],
+            "corruption": ["WARN Price mismatch detected: expected 29.99 got 299.9",
+                           "WARN Data validation failed for 847 records"],
+            "security": ["WARN 1847 failed login attempts in 60s",
+                         "WARN Rate limit exceeded from 185.220.101.x"],
+            "database": ["WARN Slow query: seq_scan on orders (847ms)",
+                         "WARN Query planner chose sequential scan, missing index"],
+            "network_partition": ["ERROR Connection timeout to us-east-1",
+                                  "ERROR Health check failed: unreachable"]
+        }
+        
+        logs = {}
+        for svc in SERVICES:
+            if svc == affected:
+                logs[svc] = log_lines.get(failure_mode, ["INFO Service running normally"])
+            else:
+                logs[svc] = ["INFO Service running normally", "INFO Health check passed"]
+
+        state = InternalState(
+            episode_id=str(uuid.uuid4()),
+            task_id="generated",
+            step=0,
+            max_steps=self.max_steps,
+            services=services_dict,
+            alerts=active_alerts,
+            logs=logs,
+            action_history=[],
+            total_reward=0.0,
+            incident_resolved=False,
+            ground_truth_root_cause=self.incident["ground_truth_root_cause"],
+            ground_truth_fix=self.incident["ground_truth_fix"],
+            incident_start_time=datetime.utcnow().isoformat(),
+            rewards_given=set()
+        )
+        state._scenario = self.incident
+        return state
+
+    def step(self, state: InternalState, action: Action) -> StepOutput:
+        reward = 0.0
+        result_text, error_text = self._apply_action_to_logs(state, action)
+        
+        # ActionType can be enum or string
+        at = action.action_type
+        at_val = at.value if hasattr(at, "value") else str(at)
+        
+        if at_val == "read_logs":
+            if action.service == self.incident["affected_service"]:
+                if "read_logs" not in state.rewards_given:
+                    reward += 0.10
+                    state.rewards_given.add("read_logs")
+        
+        if at_val == "diagnose":
+            diagnosis = action.diagnosis or action.root_cause or ""
+            if state.ground_truth_root_cause.lower() in diagnosis.lower():
+                if "diagnose" not in state.rewards_given:
+                    reward += 0.30
+                    state.rewards_given.add("diagnose")
+        
+        if at_val == self.incident["ground_truth_fix"]:
+            if action.service == self.incident["affected_service"] and "fix" not in state.rewards_given:
+                reward += 0.45
+                state.rewards_given.add("fix")
+                state.incident_resolved = True
+                state.services[self.incident["affected_service"]]["status"] = "healthy"
+                state.services[self.incident["affected_service"]]["cpu_percent"] = 25.0
+                state.services[self.incident["affected_service"]]["memory_percent"] = 40.0
+                state.services[self.incident["affected_service"]]["error_rate"] = 0.01
+                state.services[self.incident["affected_service"]]["latency_p99_ms"] = 120.0
+        
+        state.step += 1
+        state.total_reward = self._clamp(state.total_reward + reward)
+        
+        done = state.incident_resolved or state.step >= self.max_steps
+        info = {}
+        if state.incident_resolved: info["resolution"] = "incident_resolved"
+        if state.step >= self.max_steps: info["reason"] = "max_steps_reached"
+        
+        state.action_history.append({
+            "step": state.step,
+            "action": action.model_dump(),
+            "reward": round(reward, 4)
+        })
+        
+        return StepOutput(next_state=state, reward=round(reward, 4), done=done, info=info)

validate.py

@@ -68,7 +68,7 @@ def main():
 
     def check_reset_all_tasks():
         from env import DevOpsIncidentEnv
-        for task_id in ["easy", "medium", "hard", "bonus"]:
+        for task_id in ["easy", "medium", "hard", "bonus", "security", "database", "failover"]:
             env = DevOpsIncidentEnv(task_id=task_id, seed=42)
             obs = env.reset()
             assert obs.task_id == task_id, f"task_id mismatch for {task_id}"
@@ -121,7 +121,7 @@ def main():
         from env import DevOpsIncidentEnv
         from models import Action, ActionType
         rng = random.Random(0)
-        for task_id in ["easy", "medium", "hard", "bonus"]:
+        for task_id in ["easy", "medium", "hard", "bonus", "security", "database", "failover"]:
             env = DevOpsIncidentEnv(task_id=task_id, seed=42)
             env.reset()
             done = False
@@ -177,7 +177,7 @@ def main():
         from models import Action, ActionType
         from graders.grader import grade_episode
         rng = random.Random(99)
-        for task_id in ["easy", "medium", "hard", "bonus"]:
+        for task_id in ["easy", "medium", "hard", "bonus", "security", "database", "failover"]:
             env = DevOpsIncidentEnv(task_id=task_id, seed=42)
             env.reset()
             done = False