Deploy India case study and premium visuals

.gitattributes

@@ -33,3 +33,13 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+assets/case_study/capabl_india_microgrid_hero.webp filter=lfs diff=lfs merge=lfs -text
+assets/case_study/capabl_neighbourhood_dispatch.webp filter=lfs diff=lfs merge=lfs -text
+assets/case_study/capabl_rooftop_infrastructure.webp filter=lfs diff=lfs merge=lfs -text
+assets/case_study/gridops_control_room.webp filter=lfs diff=lfs merge=lfs -text
+assets/case_study/gridops_environment_loop.webp filter=lfs diff=lfs merge=lfs -text
+assets/case_study/gridops_hero_microgrid.webp filter=lfs diff=lfs merge=lfs -text
+assets/case_study/gridops_impact_split.webp filter=lfs diff=lfs merge=lfs -text
+assets/case_study/india_microgrid_operator_layer.webp filter=lfs diff=lfs merge=lfs -text
+assets/case_study/india_microgrid_value_flows.webp filter=lfs diff=lfs merge=lfs -text
+assets/case_study/india_solar_society_hero.webp filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -9,6 +9,8 @@ RUN pip install --no-cache-dir numpy pydantic fastapi "uvicorn[standard]" websoc
 # Copy app code
 COPY gridops/ gridops/
 COPY server/ server/
+COPY assets/ assets/
+COPY evals/ evals/
 COPY inference.py openenv.yaml README.md ./
 COPY scripts/ scripts/
 

README.md

@@ -37,6 +37,60 @@ tags:
 
 ---
 
+## SFT Training Pipeline Upgrade
+
+This branch adds a CarbonAlpha-style training harness around the original GridOps environment without changing the public OpenEnv API.
+
+| Artifact | Link |
+|---|---|
+| Shared prompt/action contract | [`gridops/prompting.py`](gridops/prompting.py) |
+| Reusable oracle + adversarial policies | [`gridops/policies.py`](gridops/policies.py) |
+| 1,200-row curriculum dataset | [`sft_traces/gridops_curriculum_1200.jsonl`](sft_traces/gridops_curriculum_1200.jsonl) |
+| Trace generator | [`scripts/generate_sft_traces.py`](scripts/generate_sft_traces.py) |
+| OpenRouter/DeepSeek trace generator | [`scripts/generate_openrouter_deepseek_traces.py`](scripts/generate_openrouter_deepseek_traces.py) |
+| Trace validator | [`scripts/validate_traces.py`](scripts/validate_traces.py) |
+| Holdout/adversarial evaluator | [`scripts/evaluate_gridops_model.py`](scripts/evaluate_gridops_model.py) |
+| Local adapter evaluator | [`scripts/evaluate_gridops_adapter.py`](scripts/evaluate_gridops_adapter.py) |
+| Guarded SFT script | [`scripts/hf_sft_gridops.py`](scripts/hf_sft_gridops.py) |
+| Eval plotter | [`scripts/plot_gridops_evals.py`](scripts/plot_gridops_evals.py) |
+| Colab-ready notebook | [`notebooks/gridops_sft_pipeline.ipynb`](notebooks/gridops_sft_pipeline.ipynb) |
+| Model card | [`GRIDOPS_MODEL_CARD.md`](GRIDOPS_MODEL_CARD.md) |
+
+The first milestone is **SFT only**: teach a compact model to emit valid JSON actions for each hourly observation. The first adapter passed the SFT gate on held-out seeds `7001,7002,7003`.
+
+| Model | Avg score | Valid JSON | Task 1 | Task 2 | Task 3 |
+|---|---:|---:|---:|---:|---:|
+| Do-nothing | 0.5133 | 100.00% | 0.5820 | 0.5057 | 0.4522 |
+| GridOps SFT v1 | 0.6854 | 99.85% | 0.6615 | 0.7300 | 0.6648 |
+| Oracle | 0.7688 | 100.00% | 0.7932 | 0.8087 | 0.7046 |
+
+| Gate | Target |
+|---|---:|
+| Valid JSON action rate | >= 98% |
+| Average holdout score | >= 0.65 |
+| No task below do-nothing baseline | required |
+| Task 3 crisis score | >= 0.55 |
+| Fixed-seed determinism | stable |
+
+Final SFT v1 artifact:
+
+```text
+Qwen/Qwen2.5-3B-Instruct -> QLoRA SFT adapter:
+77ethers/gridops-models/sft_qwen25_3b_gridops_mixed1418_v1
+```
+
+Evidence:
+
+- [SFT training curve](evals/plots/gridops_sft_training_curve.png)
+- [Holdout scores](evals/plots/gridops_holdout_scores.png)
+- [Battery throughput](evals/plots/gridops_battery_throughput.png)
+- [Blackout reduction](evals/plots/gridops_blackout_kwh.png)
+- [Holdout summary JSON](evals/plots/gridops_holdout_summary.json)
+
+The existing leaderboard remains historical. The table above is reported separately as **GridOps SFT v1**.
+
+---
+
 ## Why This Environment Exists
 
 Community microgrid operation is a **real job** in India under the [RDSS](https://rdss.gov.in/) (Revamped Distribution Sector Scheme). IEX prosumer bidding is live. Over 50 million Indian homes will have rooftop solar by 2030, and someone — or some agent — needs to manage the battery-grid-diesel tradeoff in real time.
@@ -228,6 +282,24 @@ open http://localhost:8000/dashboard/
 # Validate oracle + determinism
 python scripts/oracle_test.py
 
+# Generate and validate the SFT curriculum
+python scripts/generate_sft_traces.py
+python scripts/validate_traces.py sft_traces/gridops_curriculum_1200.jsonl
+
+# Optional: generate 10-at-a-time teacher traces with DeepSeek on OpenRouter
+export API_BASE_URL="https://openrouter.ai/api/v1"
+export OPENROUTER_API_KEY="your-token"
+python scripts/generate_openrouter_deepseek_traces.py --model deepseek/deepseek-v4-pro
+
+# Evaluate reusable policies on holdout seeds
+python scripts/evaluate_gridops_model.py --policy oracle
+python scripts/evaluate_gridops_model.py --policy do_nothing
+
+# Evaluate an API-hosted or HF-router model with the SFT prompt contract
+export HF_API_TOKEN="your-token"
+export MODEL_NAME="your-gridops-sft-endpoint-or-model"
+python scripts/evaluate_gridops_model.py --model-name "$MODEL_NAME"
+
 # Run LLM baseline
 export API_BASE_URL="https://router.huggingface.co/v1"
 export HF_TOKEN="your-token"

assets/case_study/README.md

@@ -0,0 +1,39 @@
+# GridOps Case Study Visual Assets
+
+Generated with the Gemini API for the Capabl Machines GridOps case study.
+The `capabl_*` assets were generated directly with Codex image generation for
+the India-focused case-study page; the earlier `gridops_*` and `india_*` assets
+remain as source/alternate visuals.
+
+Source script:
+
+```bash
+set -a; . ./.env; set +a
+.venv/bin/python scripts/generate_case_study_images_gemini.py
+```
+
+Official Gemini image-generation docs used:
+
+- https://ai.google.dev/gemini-api/docs/image-generation
+- https://ai.google.dev/gemini-api/docs/imagen
+
+## Assets
+
+Use the `.webp` versions in web pages. Keep the `.png` files as source-quality originals.
+
+| Web asset | Source | Purpose |
+|---|---|
+| `gridops_hero_microgrid.webp` | `gridops_hero_microgrid.png` | Case-study hero: Indian community microgrid, solar, battery, grid context. |
+| `gridops_control_room.webp` | `gridops_control_room.png` | Operational expertise visual: engineers monitoring microgrid dispatch. |
+| `gridops_environment_loop.webp` | `gridops_environment_loop.png` | Environment/model/action loop visual for architecture sections. |
+| `gridops_impact_split.webp` | `gridops_impact_split.png` | Impact visual contrasting do-nothing vs trained-model operation. |
+| `india_solar_society_hero.webp` | `india_solar_society_hero.png` | India-context hero: apartment society, rooftop solar, battery, EV charging, and local dispatch. |
+| `india_microgrid_operator_layer.webp` | `india_microgrid_operator_layer.png` | RWA/society operator supported by an AI intelligence layer. |
+| `india_microgrid_value_flows.webp` | `india_microgrid_value_flows.png` | Visual metaphor for savings, reliability, and earning potential from local flexibility. |
+| `capabl_india_microgrid_hero.webp` | `capabl_india_microgrid_hero.png` | Premium hero: blue-hour Indian society microgrid with rooftop solar, storage, EV charging, and text-safe negative space. |
+| `capabl_rooftop_infrastructure.webp` | `capabl_rooftop_infrastructure.png` | Rooftop/courtyard infrastructure view showing solar, battery, transformer, and EV charging. |
+| `capabl_society_operator.webp` | `capabl_society_operator.png` | Society manager and solar installer using a practical intelligence layer. |
+| `capabl_neighbourhood_dispatch.webp` | `capabl_neighbourhood_dispatch.png` | Neighbourhood microgrid dispatch under evening grid stress. |
+| `capabl_energy_journey_infographic.svg` | n/a | Deterministic horizontal infographic showing the journey from India's solar scale to local microgrid intelligence and community outcomes. |
+
+These are editorial visuals for storytelling. For exact metrics and evidence, use the committed eval plots in `evals/plots/`.

evals/plots/gridops_holdout_summary.json

@@ -0,0 +1,89 @@
+{
+  "do_nothing": {
+    "average_score": 0.5133,
+    "valid_action_rate": 1.0,
+    "by_task": {
+      "task_1_normal": {
+        "score": 0.582,
+        "battery_throughput_kwh": 0.0,
+        "blackout_kwh": 298.85,
+        "diesel_kwh": 0.0,
+        "cost": 72200.57
+      },
+      "task_2_heatwave": {
+        "score": 0.5057,
+        "battery_throughput_kwh": 0.0,
+        "blackout_kwh": 895.0,
+        "diesel_kwh": 0.0,
+        "cost": 185916.24
+      },
+      "task_3_crisis": {
+        "score": 0.4522,
+        "battery_throughput_kwh": 0.0,
+        "blackout_kwh": 2425.76,
+        "diesel_kwh": 0.0,
+        "cost": 478392.31
+      }
+    }
+  },
+  "sft": {
+    "average_score": 0.6854,
+    "valid_action_rate": 0.9985,
+    "by_task": {
+      "task_1_normal": {
+        "score": 0.6615,
+        "battery_throughput_kwh": 577.97,
+        "blackout_kwh": 177.57,
+        "diesel_kwh": 0.0,
+        "cost": 58685.13
+      },
+      "task_2_heatwave": {
+        "score": 0.73,
+        "battery_throughput_kwh": 1721.05,
+        "blackout_kwh": 258.3,
+        "diesel_kwh": 48.89,
+        "cost": 103310.54
+      },
+      "task_3_crisis": {
+        "score": 0.6648,
+        "battery_throughput_kwh": 2898.1,
+        "blackout_kwh": 978.99,
+        "diesel_kwh": 275.29,
+        "cost": 297079.42
+      }
+    }
+  },
+  "oracle": {
+    "average_score": 0.7688,
+    "valid_action_rate": 1.0,
+    "by_task": {
+      "task_1_normal": {
+        "score": 0.7932,
+        "battery_throughput_kwh": 970.62,
+        "blackout_kwh": 15.24,
+        "diesel_kwh": 0.0,
+        "cost": 36369.09
+      },
+      "task_2_heatwave": {
+        "score": 0.8087,
+        "battery_throughput_kwh": 2075.75,
+        "blackout_kwh": 41.25,
+        "diesel_kwh": 86.2,
+        "cost": 74089.62
+      },
+      "task_3_crisis": {
+        "score": 0.7046,
+        "battery_throughput_kwh": 3170.6,
+        "blackout_kwh": 699.56,
+        "diesel_kwh": 416.56,
+        "cost": 261602.58
+      }
+    }
+  },
+  "training": {
+    "logged_points": 30,
+    "first_loss": 1.53,
+    "final_loss": 0.1478,
+    "final_mean_token_accuracy": 0.9486
+  }
+}

evals/plots/gridops_sft_training_metrics.json

@@ -0,0 +1,272 @@
+[
+  {
+    "loss": "1.53",
+    "grad_norm": "1.562",
+    "learning_rate": "0.000194",
+    "entropy": "1.517",
+    "num_tokens": "1.058e+05",
+    "mean_token_accuracy": "0.6596",
+    "epoch": "0.1128"
+  },
+  {
+    "loss": "0.2563",
+    "grad_norm": "0.2266",
+    "learning_rate": "0.0001873",
+    "entropy": "0.3015",
+    "num_tokens": "2.118e+05",
+    "mean_token_accuracy": "0.9213",
+    "epoch": "0.2257"
+  },
+  {
+    "loss": "0.1809",
+    "grad_norm": "0.126",
+    "learning_rate": "0.0001807",
+    "entropy": "0.1859",
+    "num_tokens": "3.175e+05",
+    "mean_token_accuracy": "0.9362",
+    "epoch": "0.3385"
+  },
+  {
+    "loss": "0.1726",
+    "grad_norm": "0.1465",
+    "learning_rate": "0.000174",
+    "entropy": "0.1778",
+    "num_tokens": "4.234e+05",
+    "mean_token_accuracy": "0.9372",
+    "epoch": "0.4513"
+  },
+  {
+    "loss": "0.1631",
+    "grad_norm": "0.1143",
+    "learning_rate": "0.0001673",
+    "entropy": "0.1673",
+    "num_tokens": "5.29e+05",
+    "mean_token_accuracy": "0.9398",
+    "epoch": "0.5642"
+  },
+  {
+    "loss": "0.1589",
+    "grad_norm": "0.1162",
+    "learning_rate": "0.0001607",
+    "entropy": "0.1621",
+    "num_tokens": "6.347e+05",
+    "mean_token_accuracy": "0.9414",
+    "epoch": "0.677"
+  },
+  {
+    "loss": "0.1552",
+    "grad_norm": "0.1309",
+    "learning_rate": "0.000154",
+    "entropy": "0.16",
+    "num_tokens": "7.403e+05",
+    "mean_token_accuracy": "0.9428",
+    "epoch": "0.7898"
+  },
+  {
+    "loss": "0.1531",
+    "grad_norm": "0.1484",
+    "learning_rate": "0.0001473",
+    "entropy": "0.1565",
+    "num_tokens": "8.462e+05",
+    "mean_token_accuracy": "0.943",
+    "epoch": "0.9027"
+  },
+  {
+    "loss": "0.1524",
+    "grad_norm": "0.1934",
+    "learning_rate": "0.0001407",
+    "entropy": "0.1575",
+    "num_tokens": "9.48e+05",
+    "mean_token_accuracy": "0.943",
+    "epoch": "1.011"
+  },
+  {
+    "loss": "0.1513",
+    "grad_norm": "0.1279",
+    "learning_rate": "0.000134",
+    "entropy": "0.1565",
+    "num_tokens": "1.054e+06",
+    "mean_token_accuracy": "0.9437",
+    "epoch": "1.124"
+  },
+  {
+    "loss": "0.1472",
+    "grad_norm": "0.124",
+    "learning_rate": "0.0001273",
+    "entropy": "0.1562",
+    "num_tokens": "1.159e+06",
+    "mean_token_accuracy": "0.9451",
+    "epoch": "1.237"
+  },
+  {
+    "loss": "0.1503",
+    "grad_norm": "0.1235",
+    "learning_rate": "0.0001207",
+    "entropy": "0.1636",
+    "num_tokens": "1.265e+06",
+    "mean_token_accuracy": "0.9442",
+    "epoch": "1.35"
+  },
+  {
+    "loss": "0.1483",
+    "grad_norm": "0.1533",
+    "learning_rate": "0.000114",
+    "entropy": "0.1645",
+    "num_tokens": "1.371e+06",
+    "mean_token_accuracy": "0.9447",
+    "epoch": "1.463"
+  },
+  {
+    "loss": "0.1509",
+    "grad_norm": "0.1455",
+    "learning_rate": "0.0001073",
+    "entropy": "0.175",
+    "num_tokens": "1.477e+06",
+    "mean_token_accuracy": "0.9439",
+    "epoch": "1.575"
+  },
+  {
+    "loss": "0.149",
+    "grad_norm": "0.1641",
+    "learning_rate": "0.0001007",
+    "entropy": "0.1695",
+    "num_tokens": "1.583e+06",
+    "mean_token_accuracy": "0.9441",
+    "epoch": "1.688"
+  },
+  {
+    "loss": "0.146",
+    "grad_norm": "0.1582",
+    "learning_rate": "9.4e-05",
+    "entropy": "0.1701",
+    "num_tokens": "1.688e+06",
+    "mean_token_accuracy": "0.9456",
+    "epoch": "1.801"
+  },
+  {
+    "loss": "0.1422",
+    "grad_norm": "0.1445",
+    "learning_rate": "8.733e-05",
+    "entropy": "0.1639",
+    "num_tokens": "1.794e+06",
+    "mean_token_accuracy": "0.9465",
+    "epoch": "1.914"
+  },
+  {
+    "loss": "0.1459",
+    "grad_norm": "0.1602",
+    "learning_rate": "8.067e-05",
+    "entropy": "0.167",
+    "num_tokens": "1.896e+06",
+    "mean_token_accuracy": "0.9455",
+    "epoch": "2.023"
+  },
+  {
+    "loss": "0.1413",
+    "grad_norm": "0.1318",
+    "learning_rate": "7.4e-05",
+    "entropy": "0.161",
+    "num_tokens": "2.002e+06",
+    "mean_token_accuracy": "0.947",
+    "epoch": "2.135"
+  },
+  {
+    "loss": "0.1405",
+    "grad_norm": "0.1465",
+    "learning_rate": "6.733e-05",
+    "entropy": "0.1624",
+    "num_tokens": "2.107e+06",
+    "mean_token_accuracy": "0.9485",
+    "epoch": "2.248"
+  },
+  {
+    "loss": "0.1407",
+    "grad_norm": "0.1924",
+    "learning_rate": "6.067e-05",
+    "entropy": "0.1652",
+    "num_tokens": "2.213e+06",
+    "mean_token_accuracy": "0.9477",
+    "epoch": "2.361"
+  },
+  {
+    "loss": "0.1433",
+    "grad_norm": "0.1943",
+    "learning_rate": "5.4e-05",
+    "entropy": "0.1712",
+    "num_tokens": "2.319e+06",
+    "mean_token_accuracy": "0.9472",
+    "epoch": "2.474"
+  },
+  {
+    "loss": "0.1418",
+    "grad_norm": "0.1963",
+    "learning_rate": "4.733e-05",
+    "entropy": "0.1759",
+    "num_tokens": "2.425e+06",
+    "mean_token_accuracy": "0.9475",
+    "epoch": "2.587"
+  },
+  {
+    "loss": "0.1405",
+    "grad_norm": "0.1865",
+    "learning_rate": "4.067e-05",
+    "entropy": "0.1795",
+    "num_tokens": "2.531e+06",
+    "mean_token_accuracy": "0.9483",
+    "epoch": "2.7"
+  },
+  {
+    "loss": "0.1423",
+    "grad_norm": "0.2676",
+    "learning_rate": "3.4e-05",
+    "entropy": "0.1906",
+    "num_tokens": "2.636e+06",
+    "mean_token_accuracy": "0.9482",
+    "epoch": "2.812"
+  },
+  {
+    "loss": "0.146",
+    "grad_norm": "0.3164",
+    "learning_rate": "2.733e-05",
+    "entropy": "0.2049",
+    "num_tokens": "2.742e+06",
+    "mean_token_accuracy": "0.9475",
+    "epoch": "2.925"
+  },
+  {
+    "loss": "0.1456",
+    "grad_norm": "0.2461",
+    "learning_rate": "2.067e-05",
+    "entropy": "0.2129",
+    "num_tokens": "2.844e+06",
+    "mean_token_accuracy": "0.948",
+    "epoch": "3.034"
+  },
+  {
+    "loss": "0.1444",
+    "grad_norm": "0.2578",
+    "learning_rate": "1.4e-05",
+    "entropy": "0.2143",
+    "num_tokens": "2.95e+06",
+    "mean_token_accuracy": "0.9493",
+    "epoch": "3.147"
+  },
+  {
+    "loss": "0.1454",
+    "grad_norm": "0.2539",
+    "learning_rate": "7.333e-06",
+    "entropy": "0.2226",
+    "num_tokens": "3.055e+06",
+    "mean_token_accuracy": "0.9483",
+    "epoch": "3.26"
+  },
+  {
+    "loss": "0.1478",
+    "grad_norm": "0.3105",
+    "learning_rate": "6.667e-07",
+    "entropy": "0.2262",
+    "num_tokens": "3.161e+06",
+    "mean_token_accuracy": "0.9486",
+    "epoch": "3.372"
+  }
+]

gridops/policies.py

@@ -0,0 +1,136 @@
+"""Reusable GridOps policies for traces, baselines, and adversarial tests."""
+
+from __future__ import annotations
+
+import numpy as np
+
+from gridops.models import GridOpsAction
+
+
+GRID_MAX_KW = 200.0
+
+
+def oracle_policy(obs: dict, task_id: str | None = None) -> GridOpsAction:
+    """Price/SOC/outage-aware operator policy used as SFT expert labels."""
+    hour_of_day = (int(obs["hour"]) + 6) % 24
+    hour = int(obs["hour"])
+    soc = float(obs["battery_soc"])
+    price = float(obs["grid_price"])
+    demand = float(obs["demand_kw"])
+    solar = float(obs["solar_kw"])
+    fuel = float(obs["diesel_fuel_remaining"])
+    demand_fc = [float(v) for v in obs.get("demand_forecast_4h", [])]
+    solar_fc = [float(v) for v in obs.get("solar_forecast_4h", [])]
+    price_fc = [float(v) for v in obs.get("price_forecast_4h", [])]
+
+    battery = 0.0
+    diesel = 0.0
+    shedding = 0.0
+    net = demand - solar
+    future_net_peak = max([net] + [d - s for d, s in zip(demand_fc, solar_fc)])
+    future_price_peak = max([price] + price_fc)
+    outage_soon = task_id == "task_3_crisis" and 26 <= hour <= 35
+    in_outage = task_id == "task_3_crisis" and 30 <= hour <= 35
+
+    if in_outage:
+        gap = max(0.0, demand - solar)
+        if soc > 0.18:
+            battery = min(1.0, gap / 100.0)
+            gap -= battery * 100.0
+        if gap > 0 and fuel > 0.04:
+            diesel = min(1.0, gap / 100.0)
+            gap -= diesel * 100.0
+        if gap > 0:
+            shedding = min(1.0, gap / max(demand * 0.20, 1.0))
+    elif outage_soon:
+        if soc < 0.9:
+            battery = -0.9
+        else:
+            battery = 0.0
+    elif hour_of_day < 6:
+        if soc < 0.9:
+            battery = -0.8
+    elif 6 <= hour_of_day < 15:
+        if solar > demand and soc < 0.95:
+            battery = -min(1.0, (solar - demand) / 100.0)
+        elif soc < 0.72 and (price < 6.0 or future_net_peak > GRID_MAX_KW):
+            battery = -0.5
+    elif 15 <= hour_of_day < 18:
+        if soc < 0.82 or future_price_peak > 14.0 or future_net_peak > GRID_MAX_KW:
+            battery = -0.8
+    elif 18 <= hour_of_day < 23:
+        if net > GRID_MAX_KW and soc > 0.1:
+            gap = net - GRID_MAX_KW
+            battery = min(1.0, gap / 100.0)
+            gap -= battery * 100.0
+            if gap > 0 and fuel > 0.05:
+                diesel = min(1.0, gap / 100.0)
+                gap -= diesel * 100.0
+            if gap > 0:
+                shedding = min(1.0, gap / max(demand * 0.20, 1.0))
+        elif price > 10.0 and soc > 0.5:
+            battery = min(0.6, (price - 8.0) / 10.0)
+    else:
+        if soc < 0.4:
+            battery = -0.5
+
+    return GridOpsAction(
+        battery_dispatch=float(np.clip(battery, -1, 1)),
+        diesel_dispatch=float(np.clip(diesel, 0, 1)),
+        demand_shedding=float(np.clip(shedding, 0, 1)),
+    )
+
+
+def do_nothing_policy(obs: dict, task_id: str | None = None) -> GridOpsAction:
+    return GridOpsAction()
+
+
+def always_charge_policy(obs: dict, task_id: str | None = None) -> GridOpsAction:
+    return GridOpsAction(battery_dispatch=-1.0)
+
+
+def always_discharge_policy(obs: dict, task_id: str | None = None) -> GridOpsAction:
+    return GridOpsAction(battery_dispatch=1.0)
+
+
+def always_diesel_policy(obs: dict, task_id: str | None = None) -> GridOpsAction:
+    return GridOpsAction(diesel_dispatch=1.0)
+
+
+def shed_farmer_policy(obs: dict, task_id: str | None = None) -> GridOpsAction:
+    return GridOpsAction(demand_shedding=1.0)
+
+
+def diesel_chatter_policy(obs: dict, task_id: str | None = None) -> GridOpsAction:
+    return GridOpsAction(diesel_dispatch=1.0 if int(obs["hour"]) % 2 == 0 else 0.0)
+
+
+def blackout_acceptor_policy(obs: dict, task_id: str | None = None) -> GridOpsAction:
+    return GridOpsAction(battery_dispatch=0.0, diesel_dispatch=0.0, demand_shedding=0.0)
+
+
+def price_greedy_policy(obs: dict, task_id: str | None = None) -> GridOpsAction:
+    price = float(obs["grid_price"])
+    if price > 8.0:
+        return GridOpsAction(battery_dispatch=1.0)
+    if price < 5.0:
+        return GridOpsAction(battery_dispatch=-1.0)
+    return GridOpsAction()
+
+
+def grid_only_policy(obs: dict, task_id: str | None = None) -> GridOpsAction:
+    return GridOpsAction(battery_dispatch=0.0, diesel_dispatch=0.0, demand_shedding=0.0)
+
+
+POLICIES = {
+    "oracle": oracle_policy,
+    "do_nothing": do_nothing_policy,
+    "always_charge": always_charge_policy,
+    "always_discharge": always_discharge_policy,
+    "always_diesel": always_diesel_policy,
+    "shed_farmer": shed_farmer_policy,
+    "diesel_chatter": diesel_chatter_policy,
+    "blackout_acceptor": blackout_acceptor_policy,
+    "price_greedy": price_greedy_policy,
+    "grid_only": grid_only_policy,
+}

gridops/prompting.py

@@ -0,0 +1,127 @@
+"""Prompting and action parsing for GridOps model training/inference.
+
+This module is the single source of truth for the JSON-only action contract
+used by API inference, SFT traces, and rollout evaluation.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from pydantic import ValidationError
+
+from gridops.models import GridOpsAction
+
+
+SYSTEM_PROMPT = """\
+You are an expert microgrid operator managing a 100-home community in India during summer.
+
+You control three actions each hour:
+- battery_dispatch: -1 (charge 100 kW from grid) to +1 (discharge 100 kW to community)
+- diesel_dispatch: 0 (off) to 1 (100 kW). Costs Rs 25/kWh + Rs 100 startup if was off.
+- demand_shedding: 0 (none) to 1 (shed 20% of demand). WARNING: 100% rebounds next hour! Rs 40/kWh penalty.
+
+The GRID automatically absorbs the residual (capped at +/-200 kW).
+If demand exceeds grid + solar + battery + diesel, that becomes BLACKOUT (Rs 150/kWh penalty).
+
+Key economics:
+- Grid prices vary Rs 3-20/kWh. Cheap at night, expensive evening.
+- Battery: 500 kWh, 100 kW max, 90% round-trip efficiency, Rs 2.5/kWh degradation.
+- Solar: 250 kW peak, free, bell curve 6AM-6PM, zero at night.
+- Demand: about 100 kW average, 250 kW evening peak. Grid cap = 200 kW, so the battery matters.
+- Diesel and shedding are emergency tools, not default tools.
+
+Strategy:
+1. Night: charge battery when grid is cheap and demand is low.
+2. Solar hours: use solar first; charge from surplus when available.
+3. Pre-peak: keep enough battery for evening or outage hours.
+4. Evening peak: discharge battery to cover demand above the grid cap.
+5. Crisis/outage: ration battery and diesel, shed only when unavoidable.
+
+Respond ONLY with valid JSON:
+{"battery_dispatch": float, "diesel_dispatch": float, "demand_shedding": float}"""
+
+
+def format_observation(obs: dict[str, Any]) -> str:
+    """Format a GridOps observation into the model's user prompt."""
+    return (
+        f"Hour {obs['hour']:.0f}/72 (Day {obs.get('day_of_episode', '?')})\n"
+        f"Demand: {obs['demand_kw']:.0f} kW | Solar: {obs['solar_kw']:.0f} kW\n"
+        f"Battery SOC: {obs['battery_soc'] * 100:.0f}% | Grid Price: Rs {obs['grid_price']:.1f}/kWh\n"
+        f"Diesel Fuel: {obs['diesel_fuel_remaining'] * 100:.0f}% | Diesel On: {obs.get('diesel_is_on', False)}\n"
+        f"Grid import last step: {obs.get('grid_kw_this_step', 0):.0f} kW\n"
+        f"Forecasts (next 4h):\n"
+        f"  Demand: {[f'{v:.0f}' for v in obs.get('demand_forecast_4h', [])]}\n"
+        f"  Solar:  {[f'{v:.0f}' for v in obs.get('solar_forecast_4h', [])]}\n"
+        f"  Price:  {[f'{v:.1f}' for v in obs.get('price_forecast_4h', [])]}\n"
+        f"Cumulative: blackout={obs['cumulative_blackout_kwh']:.1f} kWh, cost=Rs {obs['cumulative_cost']:.0f}\n"
+        f"{obs.get('narration', '')}\n"
+        "\nWhat action? Reply with JSON only."
+    )
+
+
+def messages_for_observation(obs: dict[str, Any]) -> list[dict[str, str]]:
+    """Return chat messages for one GridOps decision."""
+    return [
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {"role": "user", "content": format_observation(obs)},
+    ]
+
+
+def action_to_json(action: GridOpsAction) -> str:
+    """Serialize an action as compact JSON for SFT completions."""
+    return json.dumps(
+        {
+            "battery_dispatch": round(float(action.battery_dispatch), 4),
+            "diesel_dispatch": round(float(action.diesel_dispatch), 4),
+            "demand_shedding": round(float(action.demand_shedding), 4),
+        },
+        separators=(",", ":"),
+    )
+
+
+def extract_action_json(text: str) -> dict[str, Any] | None:
+    """Extract the first JSON object from model text."""
+    text = (text or "").strip()
+    if not text:
+        return None
+    start = text.find("{")
+    end = text.rfind("}")
+    if start < 0 or end <= start:
+        return None
+    try:
+        parsed = json.loads(text[start:end + 1])
+    except json.JSONDecodeError:
+        return None
+    return parsed if isinstance(parsed, dict) else None
+
+
+def parse_action(text: str, default: GridOpsAction | None = None) -> GridOpsAction:
+    """Parse and validate a model response into a bounded GridOpsAction."""
+    payload = extract_action_json(text)
+    if payload is None:
+        return default or GridOpsAction()
+    try:
+        return GridOpsAction(**payload)
+    except (TypeError, ValueError, ValidationError):
+        return default or GridOpsAction()
+
+
+def validate_completion(text: str) -> tuple[bool, str]:
+    """Validate a JSON-only completion for trace/eval gates."""
+    payload = extract_action_json(text)
+    if payload is None:
+        return False, "missing_json"
+    stripped = text.strip()
+    if stripped != json.dumps(payload, separators=(",", ":")) and stripped != json.dumps(payload):
+        # JSON with whitespace is acceptable; prose outside JSON is not.
+        before = stripped[:stripped.find("{")].strip()
+        after = stripped[stripped.rfind("}") + 1:].strip()
+        if before or after:
+            return False, "prose_outside_json"
+    try:
+        GridOpsAction(**payload)
+    except (TypeError, ValueError, ValidationError) as exc:
+        return False, f"invalid_action:{type(exc).__name__}"
+    return True, "ok"

gridops/server/app.py

@@ -12,7 +12,7 @@ from pathlib import Path
 from typing import Any
 
 from fastapi import FastAPI
-from fastapi.responses import RedirectResponse
+from fastapi.responses import HTMLResponse, RedirectResponse
 from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel
 
@@ -101,29 +101,42 @@ def list_tasks():
     }
 
 
-# ── Root redirect to dashboard ───────────────────────────────────────────
+# ── Root and project pages ───────────────────────────────────────────────
+
+STATIC_DIR = Path(__file__).parent / "static"
+REPO_ROOT = Path(__file__).resolve().parents[2]
+ASSETS_DIR = REPO_ROOT / "assets"
+EVALS_DIR = REPO_ROOT / "evals"
 
 @app.get("/")
 def root_serve():
     """Serve dashboard directly at root so HF Space iframe shows the UI."""
-    from fastapi.responses import HTMLResponse
-    index = Path(__file__).parent / "static" / "index.html"
+    index = STATIC_DIR / "index.html"
     return HTMLResponse(content=index.read_text(), status_code=200)
 
 
 @app.get("/web")
 def web_serve():
     """Serve dashboard at /web (OpenEnv default web UI path)."""
-    from fastapi.responses import HTMLResponse
-    index = Path(__file__).parent / "static" / "index.html"
+    index = STATIC_DIR / "index.html"
+    return HTMLResponse(content=index.read_text(), status_code=200)
+
+
+@app.get("/case-study")
+def case_study_serve():
+    """Serve the Capabl Machines GridOps project case study."""
+    index = STATIC_DIR / "case-study.html"
     return HTMLResponse(content=index.read_text(), status_code=200)
 
 
 # ── Serve dashboard static files ────────────────────────────────────────
 
-STATIC_DIR = Path(__file__).parent / "static"
 if STATIC_DIR.exists():
     app.mount("/dashboard", StaticFiles(directory=str(STATIC_DIR), html=True), name="dashboard")
+if ASSETS_DIR.exists():
+    app.mount("/assets", StaticFiles(directory=str(ASSETS_DIR)), name="assets")
+if EVALS_DIR.exists():
+    app.mount("/evals", StaticFiles(directory=str(EVALS_DIR)), name="evals")
 
 
 def main(host: str = "0.0.0.0", port: int = 8000):

gridops/server/static/case-study.html

@@ -0,0 +1,733 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>GridOps India Case Study | Capabl Machines</title>
+  <meta name="description" content="GridOps is a Capabl Machines case study on AI-managed community microgrids for India's fast-growing rooftop solar future.">
+  <link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 64 64'%3E%3Crect width='64' height='64' rx='14' fill='%23111827'/%3E%3Cpath d='M34 8 14 34h17l-3 22 22-30H33z' fill='%238ef2c3'/%3E%3C/svg%3E">
+  <style>
+    :root {
+      --ink: #15202b;
+      --muted: #5e6974;
+      --paper: #f7f7f1;
+      --white: #ffffff;
+      --line: #dce3e3;
+      --green: #138a62;
+      --mint: #86efac;
+      --teal: #0f7f8c;
+      --sun: #d9841f;
+      --indigo: #253b73;
+      --coal: #101923;
+      --shadow: 0 18px 60px rgba(21, 32, 43, 0.14);
+    }
+
+    * { box-sizing: border-box; }
+    html { scroll-behavior: smooth; }
+    body {
+      margin: 0;
+      color: var(--ink);
+      background: var(--paper);
+      font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+      line-height: 1.5;
+    }
+
+    a { color: inherit; text-decoration: none; }
+    img { display: block; max-width: 100%; }
+    code {
+      padding: 2px 5px;
+      border-radius: 4px;
+      color: #074b3a;
+      background: #e8f7ef;
+      font-size: 0.9em;
+    }
+
+    .nav {
+      position: fixed;
+      inset: 0 0 auto;
+      z-index: 20;
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      gap: 24px;
+      padding: 16px clamp(18px, 4vw, 56px);
+      color: #f8fafc;
+      background: linear-gradient(180deg, rgba(8, 14, 22, 0.78), rgba(8, 14, 22, 0));
+    }
+
+    .brand {
+      display: flex;
+      align-items: center;
+      gap: 10px;
+      font-weight: 900;
+      letter-spacing: 0.04em;
+      text-transform: uppercase;
+    }
+
+    .brand-mark {
+      width: 28px;
+      height: 28px;
+      border: 2px solid rgba(255, 255, 255, 0.92);
+      border-radius: 7px;
+      display: grid;
+      place-items: center;
+      color: var(--mint);
+      font-size: 18px;
+      line-height: 1;
+    }
+
+    .nav-links {
+      display: flex;
+      align-items: center;
+      gap: 10px;
+      flex-wrap: wrap;
+      justify-content: flex-end;
+      font-size: 13px;
+      font-weight: 800;
+    }
+
+    .nav-links a {
+      padding: 9px 12px;
+      border: 1px solid rgba(255, 255, 255, 0.28);
+      border-radius: 999px;
+      background: rgba(255, 255, 255, 0.1);
+      backdrop-filter: blur(8px);
+    }
+
+    .hero {
+      position: relative;
+      min-height: 92vh;
+      display: grid;
+      align-items: end;
+      padding: 112px clamp(18px, 5vw, 72px) 64px;
+      overflow: hidden;
+      color: #f8fafc;
+      background: var(--coal);
+    }
+
+    .hero::before {
+      content: "";
+      position: absolute;
+      inset: 0;
+      background:
+        linear-gradient(90deg, rgba(7, 13, 19, 0.93), rgba(7, 13, 19, 0.48) 52%, rgba(7, 13, 19, 0.12)),
+        linear-gradient(0deg, rgba(7, 13, 19, 0.86), rgba(7, 13, 19, 0.06) 44%),
+        url("/assets/case_study/capabl_india_microgrid_hero.webp") center / cover no-repeat;
+      transform: scale(1.01);
+    }
+
+    .hero-content {
+      position: relative;
+      max-width: 980px;
+    }
+
+    .eyebrow {
+      margin: 0 0 16px;
+      color: var(--mint);
+      font-size: 12px;
+      font-weight: 900;
+      letter-spacing: 0.16em;
+      text-transform: uppercase;
+    }
+
+    h1, h2, h3, p { margin-top: 0; }
+    h1 {
+      max-width: 900px;
+      margin-bottom: 18px;
+      font-size: clamp(43px, 7.4vw, 96px);
+      line-height: 0.96;
+      letter-spacing: 0;
+    }
+
+    .hero-subtitle {
+      max-width: 790px;
+      margin-bottom: 28px;
+      color: rgba(248, 250, 252, 0.88);
+      font-size: clamp(18px, 2vw, 24px);
+    }
+
+    .hero-actions {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 12px;
+    }
+
+    .button {
+      display: inline-flex;
+      align-items: center;
+      justify-content: center;
+      min-height: 46px;
+      padding: 12px 16px;
+      border-radius: 7px;
+      font-weight: 900;
+      border: 1px solid rgba(255, 255, 255, 0.28);
+    }
+
+    .button.primary {
+      color: #062218;
+      background: var(--mint);
+      border-color: var(--mint);
+    }
+
+    .button.secondary {
+      color: #f8fafc;
+      background: rgba(255, 255, 255, 0.1);
+      backdrop-filter: blur(8px);
+    }
+
+    .section {
+      padding: clamp(56px, 8vw, 98px) clamp(18px, 5vw, 72px);
+    }
+
+    .section.light { background: #fbfbf7; }
+    .section.soft { background: #edf5ed; }
+    .section.dark {
+      color: #f8fafc;
+      background: #101923;
+    }
+
+    .wrap {
+      max-width: 1180px;
+      margin: 0 auto;
+    }
+
+    .split {
+      display: grid;
+      grid-template-columns: minmax(0, 0.92fr) minmax(320px, 1.08fr);
+      gap: clamp(28px, 5vw, 72px);
+      align-items: center;
+    }
+
+    .split.reverse {
+      grid-template-columns: minmax(320px, 1.06fr) minmax(0, 0.94fr);
+    }
+
+    h2 {
+      margin-bottom: 18px;
+      font-size: clamp(31px, 4vw, 54px);
+      line-height: 1.04;
+      letter-spacing: 0;
+    }
+
+    h3 {
+      margin-bottom: 10px;
+      font-size: 21px;
+      line-height: 1.18;
+    }
+
+    .lede {
+      color: var(--muted);
+      font-size: clamp(17px, 1.7vw, 20px);
+    }
+
+    .dark .lede { color: rgba(248, 250, 252, 0.74); }
+
+    .stats {
+      display: grid;
+      grid-template-columns: repeat(4, minmax(0, 1fr));
+      gap: 14px;
+      margin-top: 34px;
+    }
+
+    .stat {
+      min-height: 132px;
+      padding: 18px;
+      border: 1px solid var(--line);
+      border-radius: 8px;
+      background: var(--white);
+    }
+
+    .stat strong {
+      display: block;
+      margin-bottom: 8px;
+      color: var(--teal);
+      font-size: clamp(28px, 4vw, 40px);
+      line-height: 1;
+    }
+
+    .stat span {
+      color: var(--muted);
+      font-size: 14px;
+      font-weight: 800;
+    }
+
+    .image-frame {
+      overflow: hidden;
+      border-radius: 12px;
+      background: #dfe8e6;
+      box-shadow: var(--shadow);
+    }
+
+    .image-frame img {
+      width: 100%;
+      aspect-ratio: 16 / 9;
+      object-fit: cover;
+    }
+
+    .wide-image {
+      margin-top: 34px;
+      overflow: hidden;
+      border-radius: 12px;
+      background: #dfe8e6;
+      box-shadow: var(--shadow);
+    }
+
+    .wide-image img {
+      width: 100%;
+      aspect-ratio: 16 / 7;
+      object-fit: cover;
+    }
+
+    .infographic {
+      margin-top: 34px;
+      overflow: hidden;
+      border: 1px solid var(--line);
+      border-radius: 14px;
+      background: #f7f7f1;
+      box-shadow: var(--shadow);
+    }
+
+    .infographic img {
+      width: 100%;
+      min-width: 980px;
+    }
+
+    .infographic-scroll {
+      overflow-x: auto;
+      -webkit-overflow-scrolling: touch;
+    }
+
+    .idea-grid {
+      display: grid;
+      grid-template-columns: repeat(3, minmax(0, 1fr));
+      gap: 15px;
+      margin-top: 30px;
+    }
+
+    .idea {
+      min-height: 186px;
+      padding: 24px;
+      border-top: 5px solid var(--green);
+      border-radius: 8px;
+      background: var(--white);
+      box-shadow: 0 10px 28px rgba(21, 32, 43, 0.06);
+    }
+
+    .idea:nth-child(2) { border-color: var(--sun); }
+    .idea:nth-child(3) { border-color: var(--indigo); }
+
+    .idea p {
+      margin: 0;
+      color: var(--muted);
+    }
+
+    .uses {
+      display: grid;
+      grid-template-columns: repeat(3, minmax(0, 1fr));
+      gap: 10px;
+      margin-top: 24px;
+    }
+
+    .use {
+      padding: 12px 14px;
+      border: 1px solid var(--line);
+      border-radius: 999px;
+      color: #284154;
+      background: #ffffff;
+      font-size: 14px;
+      font-weight: 800;
+      text-align: center;
+    }
+
+    .flow {
+      display: grid;
+      grid-template-columns: repeat(4, minmax(0, 1fr));
+      gap: 14px;
+      margin-top: 34px;
+    }
+
+    .flow-step {
+      padding: 22px;
+      border-top: 4px solid var(--mint);
+      background: rgba(255, 255, 255, 0.08);
+    }
+
+    .flow-step:nth-child(2) { border-color: #7dd3fc; }
+    .flow-step:nth-child(3) { border-color: #fbbf24; }
+    .flow-step:nth-child(4) { border-color: #c4b5fd; }
+
+    .flow-step span {
+      display: block;
+      margin-bottom: 16px;
+      color: rgba(248, 250, 252, 0.54);
+      font-size: 12px;
+      font-weight: 900;
+      letter-spacing: 0.12em;
+    }
+
+    .flow-step p {
+      margin: 0;
+      color: rgba(248, 250, 252, 0.72);
+      font-size: 14px;
+    }
+
+    .table-wrap {
+      margin-top: 28px;
+      overflow-x: auto;
+      border: 1px solid var(--line);
+      border-radius: 8px;
+      background: var(--white);
+    }
+
+    table {
+      width: 100%;
+      min-width: 720px;
+      border-collapse: collapse;
+    }
+
+    th, td {
+      padding: 14px 16px;
+      border-bottom: 1px solid var(--line);
+      text-align: left;
+      vertical-align: top;
+    }
+
+    th {
+      color: var(--muted);
+      font-size: 12px;
+      letter-spacing: 0.08em;
+      text-transform: uppercase;
+      background: #f0f4f4;
+    }
+
+    tr:last-child td { border-bottom: 0; }
+    td strong { color: var(--green); }
+
+    .plots {
+      display: grid;
+      grid-template-columns: repeat(2, minmax(0, 1fr));
+      gap: 18px;
+      margin-top: 28px;
+    }
+
+    .plot {
+      overflow: hidden;
+      border: 1px solid var(--line);
+      border-radius: 8px;
+      background: var(--white);
+    }
+
+    .plot img {
+      width: 100%;
+      aspect-ratio: 16 / 10;
+      object-fit: contain;
+      background: #ffffff;
+    }
+
+    .plot figcaption {
+      padding: 12px 14px 14px;
+      color: var(--muted);
+      font-size: 13px;
+      font-weight: 800;
+    }
+
+    .source-line {
+      margin-top: 18px;
+      color: var(--muted);
+      font-size: 13px;
+    }
+
+    .source-line a {
+      color: var(--teal);
+      font-weight: 800;
+      text-decoration: underline;
+      text-underline-offset: 3px;
+    }
+
+    .ledger {
+      display: grid;
+      grid-template-columns: repeat(3, minmax(0, 1fr));
+      gap: 14px;
+      margin-top: 30px;
+    }
+
+    .ledger a {
+      min-height: 118px;
+      padding: 18px;
+      border: 1px solid rgba(255, 255, 255, 0.18);
+      border-radius: 8px;
+      background: rgba(255, 255, 255, 0.08);
+    }
+
+    .ledger strong {
+      display: block;
+      margin-bottom: 8px;
+      color: var(--mint);
+    }
+
+    .ledger span {
+      color: rgba(248, 250, 252, 0.72);
+      font-size: 14px;
+    }
+
+    .footer {
+      padding: 28px clamp(18px, 5vw, 72px);
+      color: rgba(248, 250, 252, 0.64);
+      background: #070c12;
+      font-size: 14px;
+    }
+
+    .footer .wrap {
+      display: flex;
+      justify-content: space-between;
+      gap: 18px;
+      flex-wrap: wrap;
+    }
+
+    @media (max-width: 920px) {
+      .nav { position: absolute; align-items: flex-start; }
+      .nav-links { display: none; }
+      .hero { min-height: 92vh; padding-top: 90px; }
+      .split, .split.reverse, .stats, .idea-grid, .uses, .flow, .ledger { grid-template-columns: 1fr; }
+      .plots { grid-template-columns: 1fr; }
+    }
+
+    @media (max-width: 560px) {
+      .hero-actions .button { width: 100%; }
+      .stat { min-height: 112px; }
+      .use { border-radius: 8px; }
+    }
+  </style>
+</head>
+<body>
+  <nav class="nav" aria-label="Project navigation">
+    <a class="brand" href="/case-study" aria-label="GridOps India case study">
+      <span class="brand-mark">G</span>
+      <span>GridOps</span>
+    </a>
+    <div class="nav-links">
+      <a href="#india">India context</a>
+      <a href="#machine">Capabl Machine</a>
+      <a href="#results">Results</a>
+      <a href="/dashboard/">Live demo</a>
+    </div>
+  </nav>
+
+  <main>
+    <section class="hero">
+      <div class="hero-content">
+        <p class="eyebrow">For India's next solar decade</p>
+        <h1>Every society can run like a smart power plant.</h1>
+        <p class="hero-subtitle">Solar has scaled. Now the hard problem is local dispatch: when to store, buy, shed, use backup, or sell flexibility so communities save money and keep the lights on.</p>
+        <div class="hero-actions">
+          <a class="button primary" href="/dashboard/">Open the live environment</a>
+          <a class="button secondary" href="#results">See the model evidence</a>
+        </div>
+      </div>
+    </section>
+
+    <section class="section light" id="india">
+      <div class="wrap">
+        <p class="eyebrow">Why now</p>
+        <h2>India has already built the solar base. The next layer is intelligence.</h2>
+        <p class="lede">MNRE reports 150.26 GW of cumulative solar capacity as of March 31, 2026, including 25.73 GW of grid-connected rooftop solar. PIB's India Solar Momentum note shows how fast this moved: from 3 GW in 2014 to 129.92 GW by October 2025, with nearly 24 lakh PM Surya Ghar households already solarised by December 2025.</p>
+        <div class="stats">
+          <div class="stat"><strong>150.26 GW</strong><span>solar capacity reported by MNRE</span></div>
+          <div class="stat"><strong>25.73 GW</strong><span>grid-connected rooftop solar</span></div>
+          <div class="stat"><strong>24 lakh</strong><span>PM Surya Ghar households noted by PIB</span></div>
+          <div class="stat"><strong>1 crore</strong><span>national rooftop household ambition</span></div>
+        </div>
+        <div class="wide-image">
+          <img src="/assets/case_study/capabl_rooftop_infrastructure.webp" alt="Indian apartment society rooftop solar, battery storage, EV charging, and transformer infrastructure">
+        </div>
+        <p class="source-line">Context sources: <a href="https://mnre.gov.in/en/physical-progress/">MNRE Physical Achievements</a> and <a href="https://static.pib.gov.in/WriteReadData/specificdocs/documents/2025/dec/doc2025126720001.pdf">PIB India Solar Momentum</a>.</p>
+        <div class="infographic" id="journey" aria-label="GridOps India solar intelligence journey infographic">
+          <div class="infographic-scroll">
+            <img src="/assets/case_study/capabl_energy_journey_infographic.svg" alt="Journey from India's rooftop solar scale to local microgrid complexity, Capabl Machine dispatch, and community outcomes">
+          </div>
+        </div>
+      </div>
+    </section>
+
+    <section class="section soft">
+      <div class="wrap split">
+        <div>
+          <p class="eyebrow">The new operating problem</p>
+          <h2>A rooftop solar site is no longer just a bill reducer.</h2>
+          <p class="lede">An apartment society, campus, hospital, market, cold storage unit, EV hub, or rural microgrid is becoming a small energy business. It has solar, battery, grid tariffs, backup fuel, comfort expectations, outage risk, and sometimes export or demand-response opportunity.</p>
+          <p class="lede">Running that well usually needs a capable energy manager. GridOps asks a sharper question: can we turn that expertise into a Capabl Machine?</p>
+          <div class="uses" aria-label="Example users">
+            <span class="use">Apartment societies</span>
+            <span class="use">RWAs and townships</span>
+            <span class="use">Schools and campuses</span>
+            <span class="use">Hospitals and clinics</span>
+            <span class="use">EV charging hubs</span>
+            <span class="use">Rural microgrids</span>
+          </div>
+        </div>
+        <div class="image-frame">
+          <img src="/assets/case_study/capabl_society_operator.webp" alt="Indian society manager and solar installer reviewing microgrid intelligence">
+        </div>
+      </div>
+    </section>
+
+    <section class="section light" id="machine">
+      <div class="wrap split reverse">
+        <div class="image-frame">
+          <img src="/assets/case_study/capabl_neighbourhood_dispatch.webp" alt="Indian neighbourhood microgrid with solar, battery, EV charging, grid connection, and local dispatch">
+        </div>
+        <div>
+          <p class="eyebrow">What intelligence unlocks</p>
+          <h2>From solar asset to earning, resilient infrastructure.</h2>
+          <p class="lede">A model that understands local state can do more than answer questions. It can decide. Charge before a price spike. Save battery before an outage. Use diesel only when it protects critical load. Reduce peak demand. Export or shift load when the economics make sense.</p>
+          <div class="idea-grid">
+            <article class="idea">
+              <h3>Keep lights on</h3>
+              <p>Prioritise battery and backup for high-risk hours instead of wasting them early.</p>
+            </article>
+            <article class="idea">
+              <h3>Lower operating cost</h3>
+              <p>Buy less from the grid during expensive windows and avoid unnecessary diesel burn.</p>
+            </article>
+            <article class="idea">
+              <h3>Earn from flexibility</h3>
+              <p>Make solar, storage, EV chargers, and flexible loads act like a coordinated local power plant.</p>
+            </article>
+          </div>
+        </div>
+      </div>
+    </section>
+
+    <section class="section dark">
+      <div class="wrap">
+        <p class="eyebrow">How we built the Capabl Machine</p>
+        <h2>Environment first. Model second. Evidence always.</h2>
+        <p class="lede">GridOps is an OpenEnv microgrid environment with a stable API. The model sees hourly observations and must output one valid action: <code>{"battery_dispatch": ..., "diesel_dispatch": ..., "demand_shedding": ...}</code>. No vague prose. No fake expertise. The environment executes the action and scores the outcome.</p>
+        <div class="flow">
+          <article class="flow-step">
+            <span>01</span>
+            <h3>Simulate reality</h3>
+            <p>Demand, solar, price, battery, fuel, heatwave stress, and outage constraints.</p>
+          </article>
+          <article class="flow-step">
+            <span>02</span>
+            <h3>Teach the curriculum</h3>
+            <p>1,418 traces across normal, heatwave, crisis, and targeted edge cases.</p>
+          </article>
+          <article class="flow-step">
+            <span>03</span>
+            <h3>Train compactly</h3>
+            <p>Qwen2.5-3B-Instruct with QLoRA SFT to learn reliable JSON actions.</p>
+          </article>
+          <article class="flow-step">
+            <span>04</span>
+            <h3>Evaluate honestly</h3>
+            <p>Heldout seeds compare do-nothing, trained model, and oracle policy.</p>
+          </article>
+        </div>
+      </div>
+    </section>
+
+    <section class="section soft" id="results">
+      <div class="wrap">
+        <p class="eyebrow">What changed after training</p>
+        <h2>The model learned useful battery behaviour, not a shortcut.</h2>
+        <p class="lede">Across heldout seeds, the SFT model beat the do-nothing baseline on every task, reached 99.85% valid JSON actions, reduced blackout energy, and used the battery heavily in the hardest crisis setting.</p>
+        <div class="table-wrap" role="region" aria-label="GridOps holdout evaluation table" tabindex="0">
+          <table>
+            <thead>
+              <tr>
+                <th>Policy</th>
+                <th>Normal</th>
+                <th>Heatwave</th>
+                <th>Crisis</th>
+                <th>Average</th>
+                <th>What it means</th>
+              </tr>
+            </thead>
+            <tbody>
+              <tr>
+                <td>Do-nothing baseline</td>
+                <td>0.5820</td>
+                <td>0.5057</td>
+                <td>0.4522</td>
+                <td>0.5133</td>
+                <td>Solar exists, but no intelligent dispatch.</td>
+              </tr>
+              <tr>
+                <td><strong>SFT action model</strong></td>
+                <td><strong>0.6615</strong></td>
+                <td><strong>0.7300</strong></td>
+                <td><strong>0.6648</strong></td>
+                <td><strong>0.6854</strong></td>
+                <td>Reliable actions, lower outage impact, better energy use.</td>
+              </tr>
+              <tr>
+                <td>Oracle policy</td>
+                <td>0.7932</td>
+                <td>0.8087</td>
+                <td>0.7046</td>
+                <td>0.7688</td>
+                <td>Reference headroom for the next training phase.</td>
+              </tr>
+            </tbody>
+          </table>
+        </div>
+        <div class="stats">
+          <div class="stat"><strong>+33%</strong><span>average score lift vs do-nothing</span></div>
+          <div class="stat"><strong>99.85%</strong><span>valid JSON action rate</span></div>
+          <div class="stat"><strong>2,898 kWh</strong><span>crisis battery throughput</span></div>
+          <div class="stat"><strong>979 kWh</strong><span>crisis blackout kWh vs 2,426 baseline</span></div>
+        </div>
+        <div class="plots">
+          <figure class="plot">
+            <img src="/evals/plots/gridops_holdout_scores.png" alt="Holdout score comparison for do-nothing, SFT, and oracle policies">
+            <figcaption>Holdout score by task.</figcaption>
+          </figure>
+          <figure class="plot">
+            <img src="/evals/plots/gridops_battery_throughput.png" alt="Battery throughput by policy and task">
+            <figcaption>Battery throughput confirms active dispatch.</figcaption>
+          </figure>
+          <figure class="plot">
+            <img src="/evals/plots/gridops_blackout_kwh.png" alt="Blackout kilowatt hours by policy and task">
+            <figcaption>Blackout energy falls sharply versus baseline.</figcaption>
+          </figure>
+          <figure class="plot">
+            <img src="/evals/plots/gridops_sft_training_curve.png" alt="SFT training loss and token accuracy curve">
+            <figcaption>Real training loss and token accuracy from the run.</figcaption>
+          </figure>
+        </div>
+      </div>
+    </section>
+
+    <section class="section dark">
+      <div class="wrap">
+        <p class="eyebrow">The larger point</p>
+        <h2>Capable people will still matter. But every site should not need one full-time.</h2>
+        <p class="lede">The opportunity is to package operational judgement into a machine layer that local teams can trust: society managers, solar installers, facility operators, EV hub owners, campus admins, and microgrid developers. That is the Capabl Machines thesis in one working environment.</p>
+        <div class="ledger">
+          <a href="https://huggingface.co/spaces/77ethers/gridops">
+            <strong>Live OpenEnv Space</strong>
+            <span>Runnable dashboard and API surface.</span>
+          </a>
+          <a href="https://huggingface.co/77ethers/gridops-models">
+            <strong>Model repository</strong>
+            <span>Adapter, model card, plots, and evaluation summary.</span>
+          </a>
+          <a href="https://github.com/capabl-machines/gridops/tree/codex/gridops-sft-pipeline">
+            <strong>Source branch</strong>
+            <span>Training scripts, validation harness, notebook, and docs.</span>
+          </a>
+        </div>
+      </div>
+    </section>
+  </main>
+
+  <footer class="footer">
+    <div class="wrap">
+      <span>GridOps by Capabl Machines</span>
+      <span>Community energy intelligence for India's solar future</span>
+    </div>
+  </footer>
+</body>
+</html>

gridops/server/static/index.html

@@ -47,6 +47,12 @@
   .logo h1 { font-size: 18px; font-weight: 600; letter-spacing: 1px; }
   .logo h1 span { color: var(--cyan); }
   .header-info { display: flex; gap: 20px; font-size: 12px; color: var(--text-dim); }
+  .header-info a {
+    color: var(--cyan);
+    font-weight: 700;
+    text-decoration: none;
+  }
+  .header-info a:hover { color: var(--text); }
   .header-info .tag {
     padding: 3px 10px; border-radius: 4px;
     border: 1px solid var(--border);
@@ -518,6 +524,7 @@
     <span><strong id="hourDisp">6:00</strong></span>
     <span>Day <strong id="dayDisp">1</strong></span>
     <span>Step <strong id="stepDisp">0</strong>/72</span>
+    <a href="/case-study">Case Study</a>
   </div>
 </header>
 

inference.py

@@ -11,7 +11,6 @@ MANDATORY
 - Participants must use OpenAI Client for all LLM calls using above variables
 """
 
-import json
 import os
 import sys
 
@@ -26,73 +25,13 @@ MODEL_NAME = os.getenv("MODEL_NAME", "meta-llama/Llama-3.3-70B-Instruct")
 sys.path.insert(0, os.path.dirname(__file__))
 from gridops.server.environment import GridOpsEnvironment
 from gridops.models import GridOpsAction
+from gridops.prompting import SYSTEM_PROMPT, format_observation, parse_action
 
 TASKS = ["task_1_normal", "task_2_heatwave", "task_3_crisis"]
 MAX_STEPS = 72
 TEMPERATURE = 0.1
 MAX_TOKENS = 500  # higher to support reasoning models that emit thinking before JSON
 
-SYSTEM_PROMPT = """\
-You are an expert microgrid operator managing a 100-home community in India during summer.
-
-You control three actions each hour:
-- battery_dispatch: -1 (charge 100 kW from grid) to +1 (discharge 100 kW to community)
-- diesel_dispatch: 0 (off) to 1 (100 kW). Costs Rs 25/kWh + Rs 100 startup if was off.
-- demand_shedding: 0 (none) to 1 (shed 20% of demand). WARNING: 100% rebounds next hour! Rs 40/kWh penalty.
-
-The GRID automatically absorbs the residual (capped at ±200 kW).
-If demand exceeds grid + solar + battery + diesel → BLACKOUT (Rs 150/kWh penalty!).
-
-Key economics:
-- Grid prices vary Rs 3-20/kWh. Cheap at night, expensive evening.
-- Battery: 500 kWh, 100 kW max, 90% round-trip efficiency, Rs 2.5/kWh degradation.
-- Solar: 250 kW peak (free!), bell curve 6AM-6PM, zero at night.
-- Demand: ~100 kW avg, 250 kW evening peak. Grid cap = 200 kW → need battery for gap.
-
-Strategy:
-1. Night (0-6h): charge battery (cheap grid, low demand)
-2. Solar (6-15h): surplus charges battery or exports
-3. Pre-peak (15-17h): ensure battery > 70%
-4. Evening peak (18-22h): discharge battery to cover gap above grid 200 kW cap
-5. Diesel: only when battery empty AND peak demand. Avoid startup costs.
-
-Respond ONLY with valid JSON: {"battery_dispatch": float, "diesel_dispatch": float, "demand_shedding": float}"""
-
-
-def format_observation(obs: dict) -> str:
-    """Format observation into a readable prompt for the LLM."""
-    return (
-        f"Hour {obs['hour']:.0f}/72 (Day {obs.get('day_of_episode', '?')})\n"
-        f"Demand: {obs['demand_kw']:.0f} kW | Solar: {obs['solar_kw']:.0f} kW\n"
-        f"Battery SOC: {obs['battery_soc']*100:.0f}% | Grid Price: Rs {obs['grid_price']:.1f}/kWh\n"
-        f"Diesel Fuel: {obs['diesel_fuel_remaining']*100:.0f}% | Diesel On: {obs.get('diesel_is_on', False)}\n"
-        f"Grid import last step: {obs.get('grid_kw_this_step', 0):.0f} kW\n"
-        f"Forecasts (next 4h):\n"
-        f"  Demand: {[f'{v:.0f}' for v in obs.get('demand_forecast_4h', [])]}\n"
-        f"  Solar:  {[f'{v:.0f}' for v in obs.get('solar_forecast_4h', [])]}\n"
-        f"  Price:  {[f'{v:.1f}' for v in obs.get('price_forecast_4h', [])]}\n"
-        f"Cumulative: blackout={obs['cumulative_blackout_kwh']:.1f} kWh, cost=Rs {obs['cumulative_cost']:.0f}\n"
-        f"{obs.get('narration', '')}\n"
-        f"\nWhat action? Reply with JSON only."
-    )
-
-
-def parse_action(text: str) -> dict:
-    """Extract action JSON from LLM response."""
-    text = text.strip()
-    for start, end in [("{", "}"), ("```json", "```")]:
-        idx = text.find(start)
-        if idx >= 0:
-            if end == "}":
-                eidx = text.rfind("}") + 1
-            else:
-                eidx = text.find(end, idx + len(start))
-            try:
-                return json.loads(text[idx:eidx])
-            except json.JSONDecodeError:
-                continue
-    return {"battery_dispatch": 0.0, "diesel_dispatch": 0.0, "demand_shedding": 0.0}
-
 
 def run_task(client: OpenAI, env: GridOpsEnvironment, task_id: str, seed: int = 42) -> dict:
     """Run one full episode on a task, return grade."""
@@ -125,12 +64,7 @@ def run_task(client: OpenAI, env: GridOpsEnvironment, task_id: str, seed: int =
 
         messages.append({"role": "assistant", "content": reply})
 
-        action_dict = parse_action(reply)
-        action = GridOpsAction(
-            battery_dispatch=max(-1.0, min(1.0, float(action_dict.get("battery_dispatch", 0.0)))),
-            diesel_dispatch=max(0.0, min(1.0, float(action_dict.get("diesel_dispatch", 0.0)))),
-            demand_shedding=max(0.0, min(1.0, float(action_dict.get("demand_shedding", 0.0)))),
-        )
+        action = parse_action(reply, default=GridOpsAction())
         obs = env.step(action)
         obs_dict = obs.model_dump()
 

pyproject.toml

@@ -5,7 +5,7 @@ description = "Community Microgrid RL Environment — OpenEnv Hackathon"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
-    "openenv-core>=0.2.0",
+    "openenv-core>=0.2.3",
     "fastapi>=0.104.0",
     "uvicorn[standard]>=0.24.0",
     "pydantic>=2.0",
@@ -16,12 +16,16 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
-dev = ["pytest", "httpx"]
+dev = ["pytest", "httpx", "matplotlib"]
 inference = ["openai"]
 
 [project.scripts]
 server = "server.app:main"
 
+[tool.setuptools.packages.find]
+include = ["gridops*", "server*"]
+exclude = ["notebooks*", "sft_traces*", "tests*", "round_1*", "portfolio_env*"]
+
 [build-system]
 requires = ["setuptools>=68.0"]
 build-backend = "setuptools.build_meta"

scripts/oracle_test.py

@@ -8,119 +8,30 @@ Grid is the slack variable (absorbs residual up to ±200 kW).
 import sys
 sys.path.insert(0, ".")
 
-import numpy as np
 from gridops.server.environment import GridOpsEnvironment
 from gridops.models import GridOpsAction
+from gridops.policies import (
+    always_diesel_policy,
+    always_discharge_policy,
+    do_nothing_policy,
+    oracle_policy,
+)
 from gridops.tasks.definitions import TASKS
 
 
-def oracle_policy(obs: dict) -> GridOpsAction:
-    """
-    Smart oracle: manages battery for arbitrage + evening peak coverage.
-
-    Strategy:
-      - Night (cheap grid): charge battery
-      - Solar midday: let solar cover demand, charge battery from surplus
-      - Pre-peak (15-17h): top up battery
-      - Evening peak (18-22h): discharge battery to reduce expensive grid import
-      - Use diesel only when grid is at capacity AND battery is depleted
-      - Shed demand only as last resort during extreme peaks
-    """
-    hour_of_day = (int(obs["hour"]) + 6) % 24  # episode starts at 6 AM
-    soc = obs["battery_soc"]
-    price = obs["grid_price"]
-    demand = obs["demand_kw"]
-    solar = obs["solar_kw"]
-    fuel = obs["diesel_fuel_remaining"]
-
-    battery = 0.0   # -1=charge, +1=discharge
-    diesel = 0.0
-    shedding = 0.0
-
-    # Net demand after solar
-    net = demand - solar
-
-    if hour_of_day < 6:
-        # Night: cheap power, charge battery aggressively
-        if soc < 0.9:
-            battery = -0.8  # charge
-        else:
-            battery = 0.0
-
-    elif 6 <= hour_of_day < 15:
-        # Solar hours: if solar > demand, charge battery from surplus
-        if solar > demand:
-            # Surplus — charge battery (grid absorbs the rest as export)
-            if soc < 0.95:
-                battery = -min(1.0, (solar - demand) / 100.0)
-            else:
-                battery = 0.0  # battery full, surplus exports to grid
-        else:
-            # Deficit — grid covers it. Charge battery if cheap.
-            if soc < 0.7 and price < 6:
-                battery = -0.5
-            else:
-                battery = 0.0
-
-    elif 15 <= hour_of_day < 18:
-        # Pre-peak: ensure battery is charged for evening
-        if soc < 0.8:
-            battery = -0.8  # charge hard
-        else:
-            battery = 0.0
-
-    elif 18 <= hour_of_day < 23:
-        # Evening peak: discharge battery to cover demand beyond grid cap
-        if net > GRID_MAX_KW and soc > 0.1:
-            # Need battery to cover the gap
-            gap = net - GRID_MAX_KW
-            battery = min(1.0, gap / 100.0)
-
-            # If battery can't cover full gap, use diesel
-            remaining = gap - battery * 100
-            if remaining > 0 and fuel > 0.05:
-                diesel = min(1.0, remaining / 100.0)
-
-            # If still short, shed demand
-            remaining2 = remaining - diesel * 100
-            if remaining2 > 0:
-                shedding = min(1.0, remaining2 / (demand * 0.20 + 1))
-        elif price > 10 and soc > 0.5:
-            # Expensive grid: discharge battery to save money
-            battery = min(0.6, (price - 8) / 10.0)
-        else:
-            battery = 0.0
-
-    else:
-        # Hour 23: low demand, recharge if depleted
-        if soc < 0.4:
-            battery = -0.5
-        else:
-            battery = 0.0
-
-    return GridOpsAction(
-        battery_dispatch=float(np.clip(battery, -1, 1)),
-        diesel_dispatch=float(np.clip(diesel, 0, 1)),
-        demand_shedding=float(np.clip(shedding, 0, 1)),
-    )
-
-
-GRID_MAX_KW = 200.0  # for oracle calculations
-
-
 def heuristic_do_nothing(obs: dict) -> GridOpsAction:
     """Baseline: do nothing. Grid handles everything as slack."""
-    return GridOpsAction(battery_dispatch=0.0, diesel_dispatch=0.0, demand_shedding=0.0)
+    return do_nothing_policy(obs)
 
 
 def heuristic_always_discharge(obs: dict) -> GridOpsAction:
     """Bad: always discharge battery → empty for evening → blackout."""
-    return GridOpsAction(battery_dispatch=1.0, diesel_dispatch=0.0, demand_shedding=0.0)
+    return always_discharge_policy(obs)
 
 
 def heuristic_always_diesel(obs: dict) -> GridOpsAction:
     """Wasteful: always run diesel → hemorrhages money at Rs 25/kWh."""
-    return GridOpsAction(battery_dispatch=0.0, diesel_dispatch=1.0, demand_shedding=0.0)
+    return always_diesel_policy(obs)
 
 
 def run_episode(env, policy_fn, task_id="task_1_normal", seed=42):
@@ -129,7 +40,7 @@ def run_episode(env, policy_fn, task_id="task_1_normal", seed=42):
     obs_dict = obs.model_dump()
 
     for _ in range(72):
-        action = policy_fn(obs_dict)
+        action = policy_fn(obs_dict, task_id) if policy_fn is oracle_policy else policy_fn(obs_dict)
         obs = env.step(action)
         obs_dict = obs.model_dump()
         if obs.done: