Merge wave1/story-assets: README rewrite, BLOG, VIDEO_SCRIPT, asset templates

BLOG.md

@@ -0,0 +1,72 @@
+# SevZero: from simulator to a trainable SRE war-room (Round 2)
+
+*HF blog draft — no inline hosted images; upload plots separately and replace the placeholders below.*
+
+## The autopsy (hook)
+
+At step fourteen, an untrained 8B model panicked and restarted the primary database, turning a minor latency spike into a regional outage. 300 steps later, it learned to throttle background jobs instead. This is SevZero.
+
+That failure was not a toy bug hunt. In production, the damage lives in a few irreversible actions taken under pressure: wrong service restarted, change applied without a rollback plan, a primary store touched when a leaf service was the root cause. SevZero is built to make those mistakes *expensive* in simulation so policy learning can make them *rare* in policy.
+
+In Round 1 we shipped a deterministic, OpenEnv-native incident simulator: queues, breakers, SLOs, and eight failure types with distinct log signatures. In Round 2 the product is not “more of the same environment.” It is a **self-evolving SRE war-room** — non-stationary observations, an oversight channel for the riskiest tool calls, a curriculum that tightens the incident as the agent’s rolling reward improves, and reward components dense enough for GRPO to see gradients instead of a flat line.
+
+## The environment: what is novel
+
+**Core:** partial observability, delayed effects, and propagation along a service DAG. The agent never sees a labeled root cause. It can only use the same surfaces a human on-call has—metrics, logs, traces—and the same *classes* of actions: `inspect_*` diagnostics, `restart_service`, `rollback_service`, `scale_service`, `tune_config`, `clear_cache`, `rebalance_traffic`, and a few more. That matters: failures propagate through a dependency graph; circuit breakers open and close with delay; a bad restart on an upstream can look like a downstream cache miss until you read the trace.
+
+The scalar score is a blend of SLO recovery, action efficiency, and time under budget. The simulator is **deterministic for a given seed**—`random.Random(seed)` throughout—so a GRPO run that misbehaves is debuggable, and held-out eval seeds are true generalization over topology and failure mix, not replay of the same micro-incident in disguise.
+
+**Round 2 upgrades (implementation-level):**
+
+- **Schema drift** — a middleware path mutates the shapes and keys of `inspect_metrics` and `inspect_logs` responses while exposing a small change log in the observation. Rigid string parsing fails; semantic parsing survives. This tracks real production reality: your dashboards change version without your pager updating first.
+- **Oversight** — a virtual SRE manager gates high-blast-radius actions (e.g. touching a primary data plane or draining a region at the wrong time). The model must learn *when* to request approval, not only *what* to type. That maps directly to the “weaker supervisor, stronger worker” story enterprises already run in shadow mode.
+- **Adversarial curriculum (lite)** — as rolling performance crosses thresholds, the environment increases failure count, service count, and tightens the step budget. It is a performance-linked escalator, not a long table of hand-authored levels: the *distribution* of incidents shifts as the policy improves.
+- **Fine-grained sub-rewards** — early GRPO runs hit a pattern we should own in public: the policy occasionally spammed `inspect_logs` to stay inside dense shaping and avoid committing to a fix. Tightening sub-reward structure—without hiding the real terminal SLO—restored non-zero group variance so GRPO had something to backpropagate.
+
+## The training pipeline: SFT, then GRPO
+
+**Collect:** 100–150 expert-style trajectories from frontier chat models, filtered to a minimum episode score (we used ≥ `__FILL__`).
+
+**SFT:** LoRA on Llama-3.1-8B-Instruct to lock in valid function-call JSON, incident vocabulary, and a “read before you break glass” inductive bias. Approximate run: `__FILL__` steps, effective batch `__FILL__`, LR `1e-5` (see repository training config for the exact file).
+
+**GRPO:** *K* completions per prompt, group-relative advantages, and rollouts that hit the *same* HTTP OpenEnv the judges can open from a Space. The trainer does not get a hand-wavy stub reward: the FastAPI app runs the full tick engine, the grader, and the R2 modules. In TRL, wire custom rollouts through `rollout_func`—`environment_factory` is the legacy path that breaks silent on recent releases.
+
+**Infra in practice:** vLLM (or a compatible server) for fast multi-completion sampling, LoRA on attention and MLP blocks for 8B, cosine LR schedule, and a 30–45 minute *health* window where we watch entropy, KL, and the fraction of steps with near-zero advantage standard deviation. If the curve is flat, the bug is usually integration—not “RL doesn’t work.”
+
+High-level config that matched the GPU hours we had: rank `__FILL__`, LR in the `7e-6`–`1e-5` band, *K* of `4` or `8`, temperature `0.85`, β `0.04`, 300–400 steps. The exact job JSON and dependency pins live next to `train_grpo.py` in the repository.
+
+**Why GRPO, not DPO?** DPO needs a static preference set over pairs; the failure modes here are multi-turn and path-dependent. GRPO’s per-group normalization lets the same prompt explore multiple remediation strategies and learn from the one that actually moves SLO under delayed physics.
+
+**Why 8B?** A 70B API can score near the 0.929 frontier on aggregate benchmarks, but the deployment story for a regulated network is a local policy with auditable weights. The hackathon ask is to show a believable *lift* on that 8B class, not to pretend 8B equals Gemini on every seed.
+
+## Results
+
+**What a judge should see in 10 seconds** — a line that starts near the *measured* untrained-8B floor, steps upward with visible slope changes, and approaches—but may not need to meet—the frontier at **0.929** (Gemini-3.1-Pro, aggregate of 28 reference runs on our protocol). A shaded band between the floor and the curve is the *learning delta* in points, not a decoration.
+
+![GRPO mean reward vs step](path/to/reward_curve.png)
+
+- **Frontier line:** **0.929** (reference aggregate above).
+- **Pre-GRPO 8B floor:** `__FILL__` (measured zero-shot on held-out seeds **13, 99, 777** — we deliberately avoid 42/123/7 that appeared in early baselines).
+- **Post-GRPO:** `__FILL__` at step `__FILL__` (from `metrics.jsonl`); learning delta `+__FILL__` points in the figure above. Inflection captions are drafted from `assets/reward_curve.py` heuristics and edited against the run log for the final asset.
+
+**Per-tier bars** are more legible to humans than a single scalar. Easy should look boring (everyone is high); *Hard* is where a weak policy collapses. That is the column we expect improvement to show up first if anything does.
+
+![Easy / medium / hard bars](path/to/scores_bar.png)
+
+**Before/after** (same task and seed) is the human-readable twin of the curve: one JSONL line per step with action and observation text. The repository’s `assets/before_after.md` is the working template; the final post will include one medium and one hard excerpt once eval lands.
+
+## Lessons and failure modes (honest)
+
+- **Reward hacking (inspect loop):** a short run spiked by spamming `inspect_logs` to farm dense shaping without remediating. We addressed it with repetition-style penalties in the sub-reward terms and a stronger terminal SLO term so “busy work” could not outscore a resolved incident.
+- **Zero-advantage batches:** if every completion in a group gets the same return, GRPO has nothing to differentiate. The fine-grained sub-rewards and curriculum variance exist partly to keep group standard deviation alive.
+- **What still breaks:** `__FILL__` (e.g. multi-region + simultaneous independent root causes in the Hard tier) — the honest answer in Q&A is that this is the next curriculum axis, not a reason to hand-wave the current metrics.
+
+## Reuse
+
+- `pip install` / `uv sync` and Docker as in the GitHub `README.md`.
+- OpenEnv schema and validation: the Space exposes the same routes evaluators expect.
+- **Main Hub links (when live):** [`mist-ic/sevzero-env`](https://huggingface.co/spaces/mist-ic/sevzero-env) · [`mist-ic/sevzero-trackio`](https://huggingface.co/spaces/mist-ic/sevzero-trackio) · [`mist-ic/sevzero-llama3-8b-grpo`](https://huggingface.co/mist-ic/sevzero-llama3-8b-grpo) · [`mist-ic/sevzero-expert-trajectories`](https://huggingface.co/datasets/mist-ic/sevzero-expert-trajectories)
+
+---
+
+Thanks to the OpenEnv team, Hugging Face TRL, and Unsloth for the post-training stack this round actually shipped on.

README.md

@@ -1,363 +1,172 @@
----
-title: SevZero
-emoji: 🔥
-colorFrom: red
-colorTo: indigo
-sdk: docker
-pinned: false
----
+# SevZero
 
-# SevZero - SRE Incident Response Environment
+**A self-evolving SRE war-room for training on-call AI agents.**
 
-**An RL environment where your agent is the on-call engineer: diagnose and fix cascading cloud failures before the system collapses.**
+> At step fourteen, an untrained 8B model panicked and restarted the primary database, turning a minor latency spike into a regional outage. 300 steps later, it learned to throttle background jobs instead. This is SevZero.
 
-A reinforcement learning benchmark where AI agents must act as autonomous Site Reliability Engineers (SREs) -- the people responsible for keeping production systems running. The agent observes a live microservice cluster, reads alerts and logs, and issues remediation commands to restore service health before the incident escalates.
-
-Built with [OpenEnv](https://github.com/meta-pytorch/OpenEnv) for the **OpenEnv AI Hackathon 2026**.
+In R1 we built the foundation; in R2 we turned it into a self-evolving SRE war-room: live curriculum pressure, schema drift, oversight for risky actions, and a training stack that shows up in reward curves, not just pull requests.
 
 ---
 
-## Why This Exists
-
-Most RL benchmarks (Atari, MuJoCo, MiniGrid) train agents on perception and motor control. They do not train agents to reason causally under partial observability, manage multi-step diagnostic workflows, or handle high-stakes irreversible actions with delayed consequences.
+## Live artifacts (main hosting)
 
-SRE incident response requires all of these things simultaneously:
-
-- **Partial observability**: The agent cannot see root causes directly -- only noisy symptoms (error rates, latency spikes, memory graphs, log lines)
-- **Causal reasoning**: Fixing the wrong service first can cascade into a wider outage
-- **Delayed consequences**: A service restart takes multiple simulation ticks to take effect
-- **Time pressure**: The scoring penalty for slow resolution compounds every step
-
-This directly mirrors the skills needed to deploy autonomous agents in real infrastructure. SRE agents are already being built and deployed in production by major cloud providers -- SevZero provides a safe, reproducible simulation environment to develop and benchmark them.
-
-| Property | Games (Atari, MuJoCo) | SevZero |
-|---|---|---|
-| Observability | Full or structured | Genuinely partial (logs, metrics, alerts only) |
-| Action consequences | Immediate (next frame) | Delayed (restarts take multiple ticks) |
-| Causal structure | Fixed physics | Dynamic service dependency graphs |
-| Reward signal | Synthetic game score | SLO compliance, MTTR, action efficiency |
-| Procedural diversity | Fixed levels | Infinite graph topologies from seed |
-| Domain transfer | Game-only | Maps directly to production systems |
+| | |
+|:--|:--|
+| **HF Space (environment)** | [`huggingface.co/spaces/mist-ic/sevzero-env`](https://huggingface.co/spaces/mist-ic/sevzero-env) |
+| **HF Space (Trackio / metrics)** | [`huggingface.co/spaces/mist-ic/sevzero-trackio`](https://huggingface.co/spaces/mist-ic/sevzero-trackio) |
+| **HF Model (8B GRPO adapter)** | [`huggingface.co/mist-ic/sevzero-llama3-8b-grpo`](https://huggingface.co/mist-ic/sevzero-llama3-8b-grpo) |
+| **HF Dataset (SFT / trajectories)** | [`huggingface.co/datasets/mist-ic/sevzero-expert-trajectories`](https://huggingface.co/datasets/mist-ic/sevzero-expert-trajectories) |
+| **Blog (HF)** | `__BLOG_URL__` |
+| **Video** | `__VIDEO_URL__` |
 
 ---
 
-## Quick Start
-
-```bash
-git clone https://github.com/mist-ic/SevZero.git
-cd SevZero
-uv sync  # or: pip install -e .
-uv run uvicorn server.app:app --host 0.0.0.0 --port 7860
-```
-
-Then interact via the HTTP API:
-
-```python
-import httpx
+## What’s new in R2
 
-# Start a new episode
-resp = httpx.post("http://localhost:7860/reset", json={"task_id": "easy", "seed": 42})
-obs = resp.json()["observation"]
-print(f"SLO: {obs['global_slo_score']:.0%} | Summary: {obs['observation_summary']}")
-
-# Take an action
-resp = httpx.post("http://localhost:7860/step", json={
-    "action": {"action_type": "inspect_logs", "params": {"service_id": "order-service"}}
-})
-print(resp.json()["observation"]["logs"])
-```
-
-Or connect using the Python client:
-
-```python
-from client import SevZeroEnv
-from models import SevZeroAction
-
-with SevZeroEnv(base_url="http://localhost:7860") as env:
-    result = env.reset(task_id="medium", seed=123)
-    action = SevZeroAction(action_type="inspect_logs", params={"service_id": "auth-service"})
-    result = env.step(action)
-    print(result.observation.logs)
-```
+| Upgrade | What it does (one line) |
+|--------|-------------------------|
+| **Schema drift** | `inspect_metrics` / `inspect_logs` payloads and keys can change mid-episode; a change log keeps it fair. |
+| **Oversight** | High-impact actions (e.g. primary DB, traffic drain) go through a virtual SRE manager: approve, deny, or ask for a safer plan. |
+| **Adversarial curriculum** | As rolling reward crosses thresholds, the simulator adds failures, tightens the step budget, and scales topology difficulty. |
+| **Fine-grained sub-rewards** | Dense step-wise signals so GRPO does not collapse into zero-advantage groups when SLO movement is small. |
 
 ---
 
-## Tasks
-
-| Task | Services | Steps | Simultaneous Failures | Description |
-|------|----------|-------|-----------------------|-------------|
-| **easy** | 3-5 | 10 | 1 | Single service outage in a linear chain. One root cause, straightforward diagnosis. |
-| **medium** | 8-15 | 20 | 2-3 | Cascading failure through a branching dependency graph. Fixing the wrong service first makes things worse. |
-| **hard** | 15-30 | 50 | 4-6 | Multi-region incident with simultaneous independent root causes. Requires correctly prioritizing across regions while managing propagation. |
-
-All scenarios are procedurally generated from a seed. Same seed always produces the same incident. Different seeds produce structurally distinct topologies.
+## Architecture (conceptual)
+
+```mermaid
+flowchart LR
+  subgraph Agent
+    A[Policy LLM]
+  end
+  subgraph HTTP
+    H[OpenEnv / FastAPI]
+  end
+  subgraph Environment
+    S[Simulator + grader]
+    C[Curriculum + adversary]
+    O[Oversight / governance]
+    D[Schema drift]
+  end
+  A <--> H
+  H <--> S
+  H <--> C
+  H <--> O
+  H <--> D
+```
+
+*Source: [`assets/architecture.md`](assets/architecture.md) (mermaid for editing).*
 
 ---
 
-## Episode Trace
+## Training pipeline
 
-A concrete walkthrough of one medium-difficulty episode (seed=123):
-
-```
-EPISODE START  |  Task: medium  |  Max Steps: 20  |  Seed: 123
-SLO: 50%  |  Services: auth-service [CRITICAL], api-gateway [DEGRADED], 6 healthy
-
-Step 0 - Observation
-  Alerts:
-    [CRITICAL] auth-service: error_rate=94%, p99=4800ms
-    [WARNING]  api-gateway: error_rate=28%, p99=1200ms (downstream effect)
-  Recent deploys: auth-service -> v2.1.3 (2 ticks ago)
-
-Step 1 - Action: inspect_logs(service_id="auth-service")
-  Logs reveal: "NullPointerException in UserSessionManager.validate()"
-               "Caused by: incompatible schema in v2.1.3 migration"
-  Reward: 0.0 (diagnostic step, free)
-
-Step 2 - Action: rollback_service(service_id="auth-service")
-  Effect queued: auth-service rollback to v2.1.2 (resolves in 2 ticks)
-  Reward: +0.35 (correct root cause action)
-
-Step 4 - auth-service rollback completes
-  auth-service: CRITICAL -> HEALTHY (error_rate: 94% -> 1%)
-  api-gateway: DEGRADED -> HEALTHY (upstream dependency restored)
-  SLO: 50% -> 100%
-
-Step 4 - Action: inspect_logs(service_id="api-gateway")
-  Logs: nominal, confirming recovery
-  Reward: +0.10 (verification)
-
-EPISODE END  |  Score: 0.9325  |  SLO Recovery: 100%  |  Steps: 4/20
-Termination: resolved
+```mermaid
+flowchart LR
+  T[Collect expert trajectories\nGemini / Claude / GPT] --> F[SFT\nLlama-3.1-8B-Instruct + LoRA]
+  F --> G[GRPO\nremote SevZero / TRL + vLLM]
+  G --> M[Model + eval on held-out seeds]
 ```
 
-The key dynamic: `api-gateway` was degraded not because of its own failure, but because `auth-service` (a dependency) was down. A naive agent that restarts `api-gateway` first wastes steps, gets penalized on action efficiency, and delays resolution.
+*Source: [`assets/training_pipeline.md`](assets/training_pipeline.md).*
 
 ---
 
-## Action Space
+## Results
 
-The agent issues one action per step as `{"action_type": "...", "params": {...}}`:
+**Scores** (held-out eval seeds: **13, 99, 777** — not 42/123/7 from baseline). Replace `__FILL__` when eval lands.
 
-| Action | Parameters | Description |
-|--------|-----------|-------------|
-| `inspect_logs` | `service_id` | Read recent log lines for a service (diagnostic, no tick cost) |
-| `inspect_metrics` | `service_id` | View metric history: CPU, memory, error rate, latency over last 10 ticks |
-| `inspect_traces` | `service_id` | View distributed traces showing call paths and error spans |
-| `restart_service` | `service_id` | Restart a crashed or leaking service (resolves in 1-2 ticks) |
-| `rollback_service` | `service_id` | Roll back to previous version (resolves in 2-3 ticks) |
-| `scale_service` | `service_id`, `replicas` | Scale replicas horizontally (helps with overload, resolves in 1 tick) |
-| `tune_config` | `service_id`, `key`, `value` | Fix a misconfigured key (resolves in 1 tick) |
-| `clear_cache` | `cache_name` | Flush a cache (resolves in 1 tick) |
-| `rebalance_traffic` | `from_region`, `to_region`, `pct` | Shift traffic between regions |
-| `pause_job` | `job_name` | Pause a background job consuming resources |
-| `noop` | (none) | Advance one tick without acting |
+| Task | Baseline 8B | SFT | GRPO | Frontier (Gemini-3.1-Pro) |
+|------|------------|-----|------|----------------------------|
+| Easy | `__FILL__` | `__FILL__` | `__FILL__` | 0.930 |
+| Medium | `__FILL__` | `__FILL__` | `__FILL__` | 0.970 |
+| Hard | `__FILL__` | `__FILL__` | `__FILL__` | 0.887 |
+| **Mean** | `__FILL__` | `__FILL__` | `__FILL__` | **0.929** |
 
-Inspect actions are free (they add information without consuming a remediation step). Remediation actions have 1-4 tick delays before effects appear.
-
----
+**Reward curve (GRPO)** — regenerate after each run:
 
-## Observation Space
-
-Each step returns a structured observation ordered by SRE triage priority:
-
-```python
-{
-  # Episode context
-  "tick": 4,
-  "episode_id": "3a4b...",
-  "task_id": "medium",
-  "status": "playing",          # "playing" | "resolved" | "timeout"
-  "max_steps": 20,
-
-  # Health summary (read this first)
-  "global_slo_score": 0.72,     # 0.0 (all down) to 1.0 (all healthy)
-  "observation_summary": "Tick 4/20: SLO compliance 72% (1 CRITICAL, 2 DEGRADED, 5 healthy)",
-
-  # Per-service state
-  "services": [{
-    "id": "auth-service",
-    "layer": "identity",        # edge | identity | business | data | infrastructure
-    "status": "critical",       # healthy | degraded | critical | down
-    "error_rate": 0.94,
-    "latency_p50_ms": 320.0,
-    "latency_p95_ms": 1800.0,
-    "latency_p99_ms": 4800.0,
-    "throughput_rps": 45.2,
-    "cpu_pct": 88.0,
-    "memory_pct": 76.0,
-    "connection_pool_usage_pct": 95.0,
-    "replicas": 2,
-    "version": "v2.1.3",
-    "depends_on": ["postgres-primary"],
-    "circuit_breakers": {"api-gateway": "OPEN"}
-  }],
-
-  # Active alerts (sorted by severity)
-  "alerts": [{"severity": "critical", "message": "auth-service error_rate=94%", ...}],
-
-  # Context
-  "recent_deploys": [{"service": "auth-service", "version": "v2.1.3", "ticks_ago": 2}],
-  "actions_taken": [{"tick": 1, "action": "inspect_logs", "target": "auth-service", "success": true}],
-
-  # What actions are currently valid
-  "legal_actions": [{"action_type": "rollback_service", "valid_targets": ["auth-service"]}, ...],
-
-  # Populated after inspect_* actions
-  "logs": "ERROR auth-service NullPointerException in UserSessionManager...",
-  "metric_history": {...},
-  "traces": {"spans": [...]}
-}
+```text
+python assets/reward_curve.py <path_to_metrics.jsonl> [--baseline __FILL__]
 ```
 
----
+![GRPO reward vs step](assets/reward_curve.png)
 
-## Reward Function
+**Bar chart (Easy / Medium / Hard)** — from `eval_results.csv` (produced by `training/eval.py`):
 
-```
-score = slo_recovery x 0.70 + action_efficiency x 0.15 + time_efficiency x 0.15
+```text
+python assets/scores_bar.py path/to/eval_results.csv
 ```
 
-- **SLO Recovery (70%)**: Final global SLO score (fraction of services meeting their error rate / latency targets). A +10% bonus applies when the episode ends with full resolution (SLO = 1.0, all failures cleared).
-- **Action Efficiency (15%)**: Penalizes excessive actions. Ratio of minimum required actions to actual actions taken.
-- **Time Efficiency (15%)**: Penalizes slow resolution. Based on how many steps were used relative to the step budget.
+![Scores by task and stage](assets/scores_bar.png)
 
-The reward is dense across the episode (delta-SLO shaping at each tick), not just binary at the end. An agent that partially fixes one of three failures gets partial credit proportional to the SLO improvement.
+**Before / after** episode behavior: [`assets/before_after.md`](assets/before_after.md).
 
 ---
 
-## Failure Types
+## Theme and rubric mapping
 
-Eight failure types, each with a distinct diagnostic signature:
-
-| Failure Type | Log Pattern | Correct Fix |
-|---|---|---|
-| Bad deploy | NullPointerException / TypeError after recent deploy | `rollback_service` |
-| Config error | "Configuration diagnostic: key 'X' has invalid value" | `tune_config` with the exact key |
-| OOM / crash | OOMKilled, CrashLoopBackOff | `restart_service` |
-| Resource leak | Memory climbing linearly over 10+ ticks | `restart_service` |
-| DB degradation | HikariPool exhaustion, slow queries (CPU paradoxically low) | `scale_service` on the DB or `restart_service` |
-| Cache failure | CLUSTERDOWN, "cache miss rate 100%" | `clear_cache` |
-| Cascade | High latency on upstream causes downstream error spikes | Fix the upstream root cause first |
-| Network | DNS resolution failures, connection timeouts | `rebalance_traffic` |
-
-Failures propagate through the service dependency graph using queueing theory (Little's Law, M/M/c approximation). Circuit breakers (CLOSED -> OPEN -> HALF_OPEN -> CLOSED) dampen propagation with 1-2 tick delay.
+| Criterion (weight) | How SevZero satisfies it |
+|--------------------|--------------------------|
+| Environment innovation (40%) | SRE sim + queueing cascades; R2: drift, oversight, curriculum, sub-reward density. |
+| Storytelling (30%) | Autopsy hook, blog, short video, README, annotated plots. |
+| Reward improvement (20%) | Logged GRPO `metrics.jsonl`, curve + bar + before/after traces. |
+| Pipeline (10%) | SFT to GRPO, TRL `rollout_func`, scripts linked below. |
+| *Themes* | World modeling (professional): multi-signal state; long-horizon: Hard tier; self-improvement: curriculum; multi-agent: oversight layer. |
 
 ---
 
-## Baseline Scores
-
-Baseline agent: `llama-3.3-70b-versatile` via Groq (zero-shot, greedy, no fine-tuning).
-
-| Task | Score | SLO Recovery | Action Efficiency | Time Efficiency | Steps | Outcome |
-|------|-------|-------------|-------------------|-----------------|-------|---------|
-| easy | 0.9300 | 1.0000 | 0.8333 | 0.7000 | 3/10 | resolved |
-| medium | 0.9325 | 1.0000 | 0.7500 | 0.8000 | 4/20 | resolved |
-| hard | 0.7906 | 0.8800 | 0.9000 | 0.2640 | 50/50 | timeout |
-| **avg** | **0.8844** | **0.9600** | **0.8278** | **0.5880** | | |
-
-Full results: `outputs/baseline_latest.json`
-
-The easy and medium tasks are consistently resolved (SLO = 100%). The hard task requires correctly diagnosing and resolving 4-6 simultaneous failures across a multi-region topology within 50 steps -- a 70B model reaches 88% SLO recovery but runs out of steps before full resolution.
-
----
+## Reproducibility
 
-## Setup
-
-### Install
+**Install (local)**
 
 ```bash
 git clone https://github.com/mist-ic/SevZero.git
 cd SevZero
-uv sync
+uv sync   # or: pip install -e .
 ```
 
-### Run the Server
+**Run the environment**
 
 ```bash
 uv run uvicorn server.app:app --host 0.0.0.0 --port 7860
 ```
 
-### Run Tests
-
-```bash
-uv run pytest tests/ -v
-```
-
-### Run Baseline Inference
-
-```bash
-export API_BASE_URL="https://api.groq.com/openai/v1"
-export MODEL_NAME="llama-3.3-70b-versatile"
-export HF_TOKEN="your-groq-api-key"
-export ENV_URL="http://localhost:7860"
-
-uv run python inference.py
-# Results saved to outputs/baseline_latest.json
-```
-
-### Docker
+**Docker (reset to clean env)**
 
 ```bash
 docker build -t sevzero .
-docker run -p 7860:7860 sevzero
+docker run --rm -p 7860:7860 sevzero
 ```
 
-### Validate OpenEnv Compliance
+**OpenEnv check**
 
 ```bash
 uv run openenv validate
 uv run openenv validate --url http://localhost:7860
 ```
 
----
+**Training entrypoints** (see repo `training/` after merge): `collect_trajectories.py`, `build_dataset.py`, `train_sft.py`, `train_grpo.py`, `eval.py`. Colab-friendly paths are documented in the training README inside that package.
 
-## API Endpoints
+**Regenerate story plots**
 
-| Endpoint | Method | Description |
-|----------|--------|-------------|
-| `/ws` | WebSocket | Primary evaluation protocol (used by OpenEnv framework) |
-| `/reset` | POST | Start episode: `{"task_id": "easy", "seed": 42}` |
-| `/step` | POST | Execute action: `{"action": {"action_type": "...", "params": {...}}}` |
-| `/state` | GET | Current episode state (task_id, seed, SLO score, step count) |
-| `/tasks` | GET | List available tasks with metadata |
-| `/grader` | POST | Score a completed episode |
-| `/health` | GET | Health check |
-| `/docs` | GET | Interactive API documentation |
+```bash
+python assets/reward_curve.py training/outputs/grpo/metrics.jsonl
+python assets/scores_bar.py training/outputs/eval_results.csv
+```
 
 ---
 
-## Architecture
+## Cite
 
+```bibtex
+@software{sevzero2026,
+  title = {SevZero: A Reinforcement Learning Environment for Site Reliability Engineering},
+  author = {SevZero Team},
+  year = {2026},
+  url = {https://github.com/mist-ic/SevZero}
+}
 ```
-inference.py          -- Baseline LLM agent (OpenAI-compatible client)
-client.py             -- SevZeroEnv(EnvClient) for programmatic access
-models.py             -- Pydantic API contract: SevZeroAction, SevZeroObservation, SevZeroState
-server/
-  app.py              -- FastAPI app wired via OpenEnv create_app() + custom routes
-  environment.py      -- SevZeroEnvironment(Environment): reset/step/state
-  simulator.py        -- Tick-based discrete-event engine
-  propagation.py      -- Queueing theory cascade engine + circuit breakers
-  failures.py         -- 8 failure types with temporal metric evolution curves
-  scenarios.py        -- Procedural scenario generation (3 difficulty tiers)
-  graph.py            -- Service topology: layered DAG with typed service roles
-  logs.py             -- Framework-specific log templates (Spring, Node, FastAPI, Redis, gRPC)
-  traces.py           -- Distributed trace generation
-  grader.py           -- Deterministic SLO-based scoring
-tests/                -- 37 tests: simulator determinism, grader bounds, propagation, actions
-```
-
-The simulator runs a tick-based loop: at each step, active failures evolve their metric signatures, propagation cascades through the dependency graph via queueing theory, pending remediation effects resolve after their delay, and the agent receives an updated observation.
 
 ---
 
-## Design Decisions
-
-**Determinism**: All randomness uses `random.Random(seed)` exclusively. Same seed always produces the same incident topology, failure sequence, and metric evolution. No numpy, no OS entropy.
-
-**Queueing theory cascades**: Propagation uses Little's Law (L = lambda x W), utilization rho = L/T, and latency multiplier 1/(1-rho). This means near-saturated services (rho > 0.9) experience nonlinear latency explosion -- realistic behavior seen in production systems.
-
-**Circuit breakers**: Services implement the standard CLOSED -> OPEN -> HALF_OPEN state machine. When a dependency fails, circuit breakers trip after a threshold, dampening further propagation. This prevents instant full-cluster collapse and gives agents meaningful time windows to diagnose and act.
-
-**Distinctive failure signatures**: Each failure type has a unique temporal metric pattern designed to require log inspection to diagnose correctly (for example: cascading latency spikes p99 before errors appear; resource leaks show linear memory growth over 10+ ticks; DB degradation shows CPU paradoxically low due to I/O wait).
-
-**What this environment does not model**: Actual network I/O, real containerized services, or multi-agent coordination. Service graphs are simulated, not real. The environment is designed for benchmarking agent decision-making, not as a digital twin.
+*Frontier ceiling (Gemini-3.1-Pro, 28-run aggregate): 0.929. Untrained 8B baseline for plots: `__FILL__` (see `metrics.jsonl` + zero-shot eval).*

VIDEO_SCRIPT.md

@@ -0,0 +1,47 @@
+# SevZero R2 — video script (~110–130 s, under 2 min)
+
+**On-screen text (0:00):** `SevZero` · `A self-evolving SRE war-room for on-call agents`
+
+**0:00–0:15 — Autopsy hook**  
+*Spoken (~55 words):*  
+“At step fourteen, an untrained 8B model panicked and restarted the primary database, turning a minor latency spike into a regional outage. 300 steps later, it learned to throttle background jobs instead. This is SevZero — a trainable SRE environment where the mistakes are expensive so the policy can become safe.”
+
+`[Brackets — visual: full-screen terminal or Space UI; one hard cut on “primary database” to a red SLO readout; no B-roll over the hook line.]`
+
+**On-screen (0:12):** `R1: foundation` → `R2: self-evolving war-room`
+
+---
+
+**0:15–0:45 — What it is + four R2 upgrades**  
+*Spoken (~100 words):*  
+“In round one we built the foundation — a deterministic OpenEnv for cascading microservice failures with queueing-theory propagation. In round two we productized: schema drift in observability APIs so brittle parsers die and semantic readers live; a virtual SRE manager that must approve the highest-blast actions; a curriculum that makes incidents harder as your rolling reward improves; and sub-reward structure so GRPO sees real gradients, not mode collapse. Same HTTP surface the judges can hit from our Space — same seeds, stricter world.”
+
+`[Brackets — visual: `assets/architecture.md` mermaid or exported diagram; four quick labels on screen matching drift / oversight / curriculum / sub-rewards. Pace: ~5–7 s per upgrade.]`
+
+**On-screen (each ~4 s):** `Schema drift` · `Oversight` · `Adversarial curriculum` · `Fine-grained sub-rewards`
+
+---
+
+**0:45–1:10 — Training + evidence**  
+*Spoken (~95 words):*  
+“We collected expert runs from frontier models, SFT-warmed Llama-3.1-8B on LoRA, then ran GRPO through the live environment with group-relative advantages — not a static DPO pair dataset. The curve you care about is mean reward against training step: a floor for the untrained 8B, a ceiling at 0.929 from Gemini on our reference aggregate, and our run climbing in between. The shaded area is the learning delta in points. Inflections line up with inspect-then-act behavior instead of random restarts.”
+
+`[Brackets — visual: `assets/reward_curve.png` full width; pointer or circle on shaded delta and two inflection callouts. Optional split: left half = one bad step trace, right half = trained trace — from `assets/before_after.md`.]`
+
+**On-screen:** `SFT → GRPO` · `K rollouts / group` · `+Δ = __FILL__ pts` *(replace at H+15)*
+
+---
+
+**1:10–1:25 — Capstone + links**  
+*Spoken (~60 words):*  
+“This is now a reusable benchmark: environment on Hugging Face, Trackio for metrics, 8B adapter on the Hub, open training scripts, and a dataset of expert trajectories. Install with pip or pull the container — validate with OpenEnv — reproduce the curves. SevZero is the room where the next on-call model trains before it touches your graph.”
+
+`[Brackets — visual: static end card with QR or URLs — `mist-ic/sevzero-env`, `mist-ic/sevzero-trackio`, `mist-ic/sevzero-llama3-8b-grpo`, `mist-ic/sevzero-expert-trajectories` — and GitHub.]*
+
+**On-screen (end card):** `Space` · `Trackio` · `Model` · `Dataset` · `github.com/mist-ic/SevZero`
+
+---
+
+**Total:** ~320 words (comfort band 280–360); trim the middle paragraph by ~20 words if the VO runs long.
+
+**Audio note:** one music bed allowed under VO at -18 dB; duck to silence on the autopsy first sentence if using music.

assets/architecture.md

@@ -0,0 +1,29 @@
+# Architecture diagram (Mermaid)
+
+Use this as the editable source. GitHub and Hugging Face render the same Mermaid subset as `README.md`.
+
+```mermaid
+flowchart TB
+  subgraph LLM[Agent]
+    P[Llama-3.1-8B + LoRA]
+  end
+  API[HTTP / OpenEnv API]
+  subgraph Core[SevZero core]
+    SIM[Simulator + propagation + grader]
+  end
+  subgraph R2[Round 2 modules]
+    SD[Schema drift\nmiddleware on inspect_*]
+    GOV[Oversight\nhigh-impact action gate]
+    CUR[Adversarial curriculum\ndifficulty / budget / topology]
+  end
+  P <--> API
+  API <--> SIM
+  API <--> SD
+  API <--> GOV
+  API <--> CUR
+  SD -.-> SIM
+  GOV -.-> SIM
+  CUR -.-> SIM
+```
+
+**Narration line:** the agent only sees HTTP; the simulator is the world model; R2 injects non-stationarity (drift), safety (oversight), and harder scenarios (curriculum) without breaking determinism of a fixed seed for the same code version.

assets/before_after.md

@@ -0,0 +1,32 @@
+# Before / after: episode traces
+
+Sourced from `training/eval.py` JSONL output (one JSON object per step). **Replace the tables below** with two real runs on the same task and seed: baseline checkpoint vs best GRPO checkpoint, held-out seed.
+
+| | Untrained (baseline 8B) | GRPO-trained 8B |
+|---|------------------------|-------------------|
+| **Task / seed** | `__FILL__` / `__FILL__` | `__FILL__` / `__FILL__` |
+| **Final score** | `__FILL__` | `__FILL__` |
+| **Steps used** | `__FILL__` / `__FILL__` | `__FILL__` / `__FILL__` |
+| **Termination** | `__FILL__` | `__FILL__` |
+
+## Untrained: representative failure mode
+
+*Draft narrative — align to actual first bad action in JSONL (e.g. high-impact restart without inspection).*
+
+1. `__STEP_0__` — Observation: SLO `__FILL__`, critical services: `__FILL__`.
+2. `__STEP_1__` — `inspect_logs` on wrong service; reward noise; no root cause.
+3. `__STEP_k__` — `restart_service` on `__FILL__` without approval / wrong target; cascade widens.
+4. Late `noop` or thrash; timeout or sub-threshold SLO at end state.
+
+## GRPO: matched scenario
+
+*Draft — show inspect → verify cascade → low-risk fix → optional oversight path.*
+
+1. `__STEP_0__` — Same seed; SLO and topology identical to column one.
+2. `__STEP_1–3__` — `inspect_metrics` / `inspect_logs` on `__FILL__` to confirm failure class.
+3. `__STEP_4__` — Remediation: `__FILL__` (e.g. `rollback_service`, `tune_config`, or approval flow for primary DB).
+4. Recovery ticks; final SLO `__FILL__`; score `__FILL__`.
+
+---
+
+**JSONL field hints for extraction:** for each line, read `observation` / `action` / `reward` / `step` (exact keys follow `eval.py` output). Keep excerpts under 40 lines per column when pasting into the blog or video B-roll.

assets/fixtures/sample_eval_results.csv

@@ -0,0 +1,4 @@
+task,baseline,sft,grpo,frontier
+easy,0.71,0.85,0.90,0.93
+medium,0.72,0.86,0.91,0.97
+hard,0.60,0.70,0.80,0.887

assets/fixtures/sample_metrics.jsonl

@@ -0,0 +1,8 @@
+{"step": 0, "reward_mean": 0.62}
+{"step": 20, "reward_mean": 0.64}
+{"step": 50, "reward_mean": 0.71}
+{"step": 100, "reward_mean": 0.78}
+{"step": 150, "reward_mean": 0.84}
+{"step": 200, "reward_mean": 0.86}
+{"step": 250, "reward_mean": 0.88}
+{"step": 300, "reward_mean": 0.89}

assets/recording_checklist.md

@@ -0,0 +1,27 @@
+# Video recording checklist
+
+## Capture
+
+- **Tool:** OBS Studio (recommended, free) or equivalent; record display + system audio if you add UI sounds.
+- **Resolution / framerate:** 1920×1080, 60 fps.
+- **Audio:** clear voice, no room noise; record a 10 s noise profile if using noise suppression.
+- **Inputs:** full screen or window around terminal + browser; avoid unreadable font sizes (terminal ≥ 14 pt equivalent).
+
+## B-roll (get each clip 8–20 s, trim in edit)
+
+1. Terminal: GRPO job streaming logs (`reward`, `step`, `entropy` lines visible).
+2. Trackio (main Space): live run dashboard, one pan across key panels.
+3. HF Space: SevZero environment UI or API flow stepping through an episode.
+4. HF Model card: `mist-ic/sevzero-llama3-8b-grpo` (name, base model, adapter, links).
+5. Optional: one cut of `assets/reward_curve.png` full screen for a static beat (curve + annotations + learning delta).
+
+## Edit
+
+- **Pace:** hard cuts, no long idle holds; target under 2 minutes total.
+- **Accessibility:** burn in subtitles (YouTube or editor captions export to SRT and bake-in for HF if required).
+- **Overlays:** use exact lines from `VIDEO_SCRIPT.md` for on-screen text; keep contrast AA-friendly.
+
+## Export
+
+- **Container:** H.264 or VP9, 1080p, bitrate sufficient for screen text (avoid heavy compression artifacts on log output).
+- **Thumb:** static frame = reward curve or split before/after, not a generic stock image.

assets/reward_curve.py

@@ -0,0 +1,239 @@
+#!/usr/bin/env python3
+"""
+Plot GRPO reward vs step from a metrics.jsonl (one JSON object per line).
+
+Non-negotiable visual bar:
+- Faint horizontal dashed: untrained 8B baseline (see --baseline).
+- Faint horizontal dashed: frontier ceiling 0.929 (Gemini-3.1-Pro aggregate).
+- High-contrast curve: reward mean vs step.
+- Shaded region between baseline and the curve, labeled with +learning delta to final point.
+- 2-3 inflection markers (slope/peak heuristics); edit captions in ORCHESTRATION when real data lands.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+# Output layout: 1920x1080 at dpi=160
+FIG_W_IN = 1920 / 160
+FIG_H_IN = 1080 / 160
+DPI = 160
+OUT_PNG = Path(__file__).resolve().parent / "reward_curve.png"
+FRONTIER = 0.929
+
+# Default baseline: Consensus table "weak" aggregate until measured 8B zero-shot is available.
+BASELINE_DEFAULT = 0.76
+
+CURVE_COLOR = "#0b3d5c"
+FILL_COLOR = "#1f77b4"
+FRONTIER_STYLE = {"color": "#b0b0b0", "linestyle": "--", "linewidth": 1.5, "zorder": 1}
+BASELINE_STYLE = {"color": "#a0a0a0", "linestyle": "--", "linewidth": 1.5, "zorder": 1}
+
+INFLECTION_CAPTIONS = [
+    "Step {step}: inspect-before-restart pattern emerges",
+    "Step {step}: steeper SLO recovery segment",
+    "Step {step}: policy stabilizes (advantage spread drops)",
+]
+
+
+def _parse_line(obj: dict, line_idx: int) -> tuple[int | None, float | None]:
+    step = None
+    for k in ("step", "global_step", "train/global_step", "current_step"):
+        if k in obj and isinstance(obj[k], (int, float)):
+            step = int(obj[k])
+            break
+    if step is None:
+        step = line_idx
+
+    r = None
+    for k in (
+        "reward_mean",
+        "mean_reward",
+        "rewards/mean",
+        "eval_reward",
+        "reward",
+    ):
+        v = obj.get(k)
+        if isinstance(v, (int, float)):
+            r = float(v)
+            break
+    if r is None and "log" in obj:
+        # Some exporters nest metrics
+        log = obj["log"]
+        if isinstance(log, dict):
+            for k in ("reward_mean", "mean_reward", "train/reward"):
+                if k in log and isinstance(log[k], (int, float)):
+                    r = float(log[k])
+                    break
+    return step, r
+
+
+def load_metrics(path: Path) -> tuple[np.ndarray, np.ndarray]:
+    steps_list: list[int] = []
+    rewards: list[float] = []
+    with path.open(encoding="utf-8") as f:
+        for i, line in enumerate(f):
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                obj = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            st, r = _parse_line(obj, i)
+            if r is not None:
+                steps_list.append(st if st is not None else i)
+                rewards.append(r)
+    if not rewards:
+        raise SystemExit(
+            f"No parseable reward fields in {path}. Expected keys like reward_mean, mean_reward, reward."
+        )
+    order = np.argsort(steps_list)
+    s = np.array(steps_list, dtype=int)[order]
+    y = np.array(rewards, dtype=float)[order]
+    return s, y
+
+
+def smooth_moving(y: np.ndarray, w: int) -> np.ndarray:
+    if w < 2 or len(y) < w:
+        return y.astype(float)
+    k = np.ones(w, dtype=float) / w
+    return np.convolve(y, k, mode="valid")
+
+
+def inflection_step_indices(
+    steps: np.ndarray, rewards: np.ndarray, n_max: int = 3, smooth_win: int = 7
+) -> list[int]:
+    """Return indices into `steps` for annotation (local max of smoothed d(reward)/d(step))."""
+    if len(rewards) < 4:
+        return []
+    sm = smooth_moving(rewards, min(smooth_win, max(3, len(rewards) // 5)))
+    if len(sm) < 3:
+        return [len(steps) // 2]
+    d = np.diff(sm)
+    candidates: list[int] = []
+    for j in range(1, len(d) - 1):
+        if d[j] > d[j - 1] and d[j] > d[j + 1] and d[j] > 0:
+            # map back to full index approx
+            off = (len(rewards) - len(d) - 1) // 2
+            idx = j + 1 + off
+            idx = int(np.clip(idx, 0, len(steps) - 1))
+            candidates.append((d[j], idx))
+    candidates.sort(key=lambda t: t[0], reverse=True)
+    out: list[int] = []
+    for _, idx in candidates:
+        if idx not in out:
+            out.append(idx)
+        if len(out) >= n_max:
+            break
+    if not out and len(steps) > 0:
+        out = [len(steps) // 3, 2 * len(steps) // 3][: min(n_max, len(steps))]
+    return out[:n_max]
+
+
+def main() -> None:
+    p = argparse.ArgumentParser(description="GRPO reward curve from metrics.jsonl")
+    p.add_argument("metrics_jsonl", type=Path, help="Path to metrics.jsonl")
+    p.add_argument(
+        "-o", "--output", type=Path, default=OUT_PNG, help="Output PNG path"
+    )
+    p.add_argument(
+        "--baseline",
+        type=float,
+        default=BASELINE_DEFAULT,
+        help="Untrained 8B mean reward (replace with measured zero-shot; default 0.76 from weak-model table until filled).",
+    )
+    p.add_argument(
+        "--frontier", type=float, default=FRONTIER, help="Frontier ceiling (default 0.929)"
+    )
+    p.add_argument(
+        "--no-annotations", action="store_true", help="Skip inflection arrows (debug)"
+    )
+    args = p.parse_args()
+
+    steps, rewards = load_metrics(args.metrics_jsonl)
+    last_r = float(rewards[-1])
+    delta = last_r - args.baseline
+
+    plt.rcParams.update(
+        {
+            "font.size": 14,
+            "axes.titlesize": 20,
+            "axes.labelsize": 16,
+            "legend.fontsize": 12,
+            "figure.facecolor": "white",
+            "axes.facecolor": "white",
+        }
+    )
+    fig, ax = plt.subplots(figsize=(FIG_W_IN, FIG_H_IN), dpi=DPI, facecolor="white")
+
+    ax.axhline(
+        args.baseline, **BASELINE_STYLE, label=f"Untrained 8B baseline ({args.baseline:.3f})"
+    )
+    ax.axhline(
+        args.frontier, **FRONTIER_STYLE, label=f"Frontier ceiling ({args.frontier:.3f})"
+    )
+    ax.plot(
+        steps,
+        rewards,
+        color=CURVE_COLOR,
+        linewidth=2.5,
+        label="GRPO mean reward",
+        zorder=3,
+    )
+    # Shade between baseline and curve (vertical band: improve area between min/max per x)
+    y_low = np.minimum(rewards, args.baseline)
+    y_high = np.maximum(rewards, args.baseline)
+    ax.fill_between(
+        steps,
+        y_low,
+        y_high,
+        color=FILL_COLOR,
+        alpha=0.22,
+        zorder=2,
+    )
+    ax.text(
+        0.02,
+        0.12,
+        f"learning delta: +{delta:.3f} pts\nto step {int(steps[-1])} reward {last_r:.3f}",
+        transform=ax.transAxes,
+        fontsize=14,
+        verticalalignment="bottom",
+        bbox=dict(boxstyle="round,pad=0.35", facecolor="white", edgecolor="#333333", alpha=0.95),
+    )
+    if not args.no_annotations and len(steps) > 0:
+        idxs = inflection_step_indices(steps, rewards, n_max=3)
+        for j, i in enumerate(idxs):
+            if j >= len(INFLECTION_CAPTIONS):
+                break
+            sx = int(steps[i])
+            sy = float(rewards[i])
+            cap = INFLECTION_CAPTIONS[j].format(step=sx)
+            ax.annotate(
+                cap,
+                xy=(sx, sy),
+                xytext=(20, 20 + j * 18),
+                textcoords="offset points",
+                arrowprops=dict(arrowstyle="->", color="#222222", lw=1.2),
+                fontsize=11,
+            )
+
+    ax.set_xlabel("Step")
+    ax.set_ylabel("Reward (mean)")
+    ax.set_title("SevZero GRPO — reward vs step")
+    ax.legend(loc="lower right", framealpha=0.95)
+    ax.grid(True, alpha=0.3)
+    fig.tight_layout()
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    fig.savefig(args.output, dpi=DPI, facecolor="white", bbox_inches="tight")
+    plt.close(fig)
+    print(f"Wrote {args.output} ({FIG_W_IN*DPI:.0f}x{FIG_H_IN*DPI:.0f} @ dpi={DPI})")
+
+
+if __name__ == "__main__":
+    main()

assets/scores_bar.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+"""
+Grouped bar chart: Easy / Medium / Hard for baseline, SFT, GRPO, frontier.
+
+Expected CSV (header required), from training/eval.py or hand-built:
+
+  task,baseline,sft,grpo,frontier
+  easy,0.71,0.85,0.90,0.93
+  medium,0.72,0.86,0.91,0.97
+  hard,0.60,0.70,0.80,0.887
+
+`task` values: easy, medium, hard (case-insensitive). Numeric columns 0-1.
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+DPI = 160
+OUT_PNG = Path(__file__).resolve().parent / "scores_bar.png"
+FIG_W_IN = 1920 / 160
+FIG_H_IN = 1080 / 160
+
+STAGES = ("baseline", "sft", "grpo", "frontier")
+COLORS = ("#6c757d", "#17a2b8", "#0b3d5c", "#adb5bd")
+
+
+def load_rows(path: Path) -> list[dict[str, str]]:
+    with path.open(newline="", encoding="utf-8") as f:
+        r = csv.DictReader(f)
+        if not r.fieldnames:
+            raise SystemExit("Empty CSV")
+        norm = {k.strip().lower(): k for k in r.fieldnames if k and k.strip()}
+        for c in STAGES + ("task",):
+            if c not in norm:
+                raise SystemExit(
+                    f"CSV must include columns: task, {', '.join(STAGES)}. Got: {list(r.fieldnames)}"
+                )
+        rows: list[dict[str, str]] = []
+        for row in r:
+            d = {k: (row.get(norm[k]) or "").strip() for k in (list(STAGES) + ["task"])}
+            rows.append(d)
+        return rows
+
+
+def main() -> None:
+    p = argparse.ArgumentParser()
+    p.add_argument("eval_results_csv", type=Path)
+    p.add_argument("-o", "--output", type=Path, default=OUT_PNG)
+    args = p.parse_args()
+
+    raw = load_rows(args.eval_results_csv)
+    order = ("easy", "medium", "hard")
+    by_task: dict[str, dict[str, float]] = {}
+    for row in raw:
+        t = row.get("task", "").lower().strip()
+        if t not in order:
+            continue
+        by_task[t] = {s: float(row[s]) for s in STAGES}
+    for t in order:
+        if t not in by_task:
+            by_task[t] = {s: 0.0 for s in STAGES}
+
+    plt.rcParams.update(
+        {
+            "font.size": 14,
+            "axes.titlesize": 20,
+            "axes.labelsize": 16,
+            "figure.facecolor": "white",
+            "axes.facecolor": "white",
+        }
+    )
+    fig, ax = plt.subplots(figsize=(FIG_W_IN, FIG_H_IN), dpi=DPI, facecolor="white")
+
+    x = np.arange(len(order))
+    w = 0.18
+    for i, stage in enumerate(STAGES):
+        heights = [by_task[tt][stage] for tt in order]
+        ax.bar(
+            x + (i - 1.5) * w,
+            heights,
+            width=w,
+            label=stage,
+            color=COLORS[i],
+        )
+
+    ax.set_xticks(x)
+    ax.set_xticklabels([t.capitalize() for t in order])
+    ax.set_ylabel("Mean score")
+    ax.set_ylim(0.0, 1.05)
+    ax.set_title("SevZero eval — by task and training stage (held-out seeds)")
+    ax.legend()
+    ax.grid(True, axis="y", alpha=0.3)
+    fig.tight_layout()
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    fig.savefig(args.output, dpi=DPI, facecolor="white", bbox_inches="tight")
+    plt.close(fig)
+    print(f"Wrote {args.output} ({FIG_W_IN*DPI:.0f}x{FIG_H_IN*DPI:.0f} @ dpi={DPI})")
+
+
+if __name__ == "__main__":
+    main()

assets/training_pipeline.md

@@ -0,0 +1,15 @@
+# Training pipeline (Mermaid)
+
+```mermaid
+flowchart LR
+  C[Collect 100–150 expert rollouts\nfilter score ≥ 0.85] --> S[SFT: Llama-3.1-8B-Instruct\nformatting + runbook prior]
+  S --> R[GRPO: group-relative advantages\nK rollouts / prompt, live env]
+  R --> E[Eval: easy / medium / hard\nheld-out seeds]
+  E --> V[Model card + reward plots\n+ bar + before/after]
+```
+
+**Why SFT first:** valid JSON actions and a sane inspection-before-remediation style before online RL explores destructive corners.
+
+**Why GRPO over DPO:** the signal is in multi-turn trajectories and delayed SLO effects; group normalization across rollouts for the same context fits TRL + remote OpenEnv without a static preference pair dataset.
+
+**Why 8B:** capacity for long incidents without shipping telemetry to a third-party 70B API in a real SRE deployment; training evidence closes part of the ~0.76 (weak) → 0.929 (frontier) gap on Hard.