Upload trained LoRA adapter from Kaggle

.dockerignore

@@ -0,0 +1,7 @@
+venv/
+**/__pycache__/
+*.pyc
+.env
+*.log
+.git/
+results/

.gitattributes

@@ -33,13 +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
-checkpoint-100/tokenizer.json filter=lfs diff=lfs merge=lfs -text
-checkpoint-150/tokenizer.json filter=lfs diff=lfs merge=lfs -text
-checkpoint-200/tokenizer.json filter=lfs diff=lfs merge=lfs -text
-checkpoint-250/tokenizer.json filter=lfs diff=lfs merge=lfs -text
-checkpoint-300/tokenizer.json filter=lfs diff=lfs merge=lfs -text
-checkpoint-350/tokenizer.json filter=lfs diff=lfs merge=lfs -text
-checkpoint-400/tokenizer.json filter=lfs diff=lfs merge=lfs -text
-checkpoint-449/tokenizer.json filter=lfs diff=lfs merge=lfs -text
-checkpoint-50/tokenizer.json filter=lfs diff=lfs merge=lfs -text
-tokenizer.json filter=lfs diff=lfs merge=lfs -text
+*.sh text eol=lf
+*.lock text eol=lf
+huggingface_tokenizers_cache/models--unsloth--qwen2.5-1.5b-instruct-unsloth-bnb-4bit/blobs/9c5ae00e602b8860cbd784ba82a8aa14e8feecec692e7076590d014d7b7fdafa filter=lfs diff=lfs merge=lfs -text
+huggingface_tokenizers_cache/models--unsloth--qwen2.5-1.5b-instruct-unsloth-bnb-4bit/snapshots/3d254dbee5e3beae81bb8a717ad3a03427a09d26/tokenizer.json filter=lfs diff=lfs merge=lfs -text
+results/phase1/checkpoint-100/tokenizer.json filter=lfs diff=lfs merge=lfs -text
+results/phase1/checkpoint-150/tokenizer.json filter=lfs diff=lfs merge=lfs -text
+results/phase1/checkpoint-200/tokenizer.json filter=lfs diff=lfs merge=lfs -text
+results/phase1/checkpoint-222/tokenizer.json filter=lfs diff=lfs merge=lfs -text
+results/phase1/checkpoint-50/tokenizer.json filter=lfs diff=lfs merge=lfs -text
+results/phase1/tokenizer.json filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,6 @@
+venv/
+__pycache__/
+*.pyc
+.env
+*.log
+.DS_Store

Dockerfile

@@ -0,0 +1,14 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+EXPOSE 8000
+
+# Startup script runs both services
+CMD ["sh", "start.sh"]

GUIDE.md

@@ -0,0 +1,245 @@
+# 📖 Complete Guide — AI Sprint Manager OpenEnv
+
+**What we built, how to test it, how to demo it, and how to explain it.**
+
+---
+
+## 🤔 What Are We Building — Plain English
+
+Imagine you're the Tech Lead of a software company. Every 2 weeks (called a "sprint"), your team gets a list of tasks — new features, bug fixes, tech debt. Your job is to decide:
+
+- Which developer gets which task?
+- What's most urgent when a new bug appears?
+- What do you do when someone calls in sick?
+- How do you avoid burning out your best developer?
+
+**We built a simulation of this scenario** so an AI agent can practice making these decisions thousands of times and learn to get better — just like how AlphaGo learned to play Go by playing millions of games against itself.
+
+The AI plays the role of the Tech Lead. It looks at the sprint state and decides what to do. The environment tells it how well it did (reward). Over time, it learns better strategies.
+
+---
+
+## 🏗️ How It's Built — Layer by Layer
+
+```
+YOU / AI AGENT
+  ↓  makes decisions (assign, skip, reprioritize...)
+FASTAPI SERVER  (ui.py / server/app.py)
+  ↓  receives actions, returns results
+SPRINT ENVIRONMENT  (sprint_env/environment.py)
+  ↓  core logic: tracks tasks, devs, days, rewards
+DATA  (data/sprint_data.json)
+  ↓  tasks and developers — fully customizable
+GRADIO UI  (ui.py)
+     visual sprint board, charts, controls
+```
+
+---
+
+## 📁 What Each File Does
+
+| File | Purpose | Change it to... |
+|------|---------|----------------|
+| `data/sprint_data.json` | All scenario data | Add your own tasks/devs |
+| `sprint_env/models.py` | Data contracts (Action/Observation/State) | Add new fields |
+| `sprint_env/tasks.py` | Task & Developer classes | Add new task types |
+| `sprint_env/environment.py` | Core RL logic | Change simulation rules |
+| `sprint_env/graders.py` | Scoring (easy/medium/hard) | Change scoring weights |
+| `sprint_env/data_loader.py` | Loads JSON data with caching | Point to custom data |
+| `server/app.py` | OpenEnv HTTP API entry point | Add new endpoints |
+| `client.py` | Typed Python client for RL training | Use in training scripts |
+| `ui.py` | Gradio UI + combined server | Change UI layout |
+| `inference.py` | Baseline LLM agent | Change model/strategy |
+| `openenv.yaml` | OpenEnv spec metadata | Update task list |
+
+---
+
+## 🔄 What Happens Each Step
+
+```
+Day 1 → Day 2 → Day 3 → ... → Day 10 → DONE
+  ↑        ↑        ↑
+agent    agent    agent
+acts     acts     acts
+```
+
+**One step = one day in the sprint:**
+
+1. Agent receives observation (all tasks, all devs, current day)
+2. Agent picks an action (e.g. "assign T1 to dev1")
+3. Environment validates the action
+4. Developers work on assigned tasks — progress increases
+5. Random events fire (dev goes sick, new bug appears)
+6. Reward is calculated and returned
+7. Repeat until Day 10 or all tasks resolved
+
+---
+
+## 💰 Reward Design — Why It Works for RL
+
+The reward function is **shaped** (signal at every step) not **sparse** (only at the end):
+
+```
+Good actions  →  positive reward immediately
+Bad actions   →  negative reward immediately
+Task done on time  →  bonus
+Task missed deadline  →  penalty
+Sprint ends  →  final_score × 10 bonus
+```
+
+This means a learning agent gets feedback on every single decision — critical for efficient RL training with GRPO, PPO, or any policy gradient algorithm.
+
+---
+
+## ✅ How To Know Everything Is Working
+
+### Quick 60-second check
+
+```bash
+# 1. Start server
+python ui.py
+
+# 2. In another terminal — health check
+curl http://localhost:7860/health
+# Expected: {"status":"ok","env":"ai-sprint-manager"}
+
+# 3. Reset
+curl -X POST http://localhost:7860/reset \
+  -H "Content-Type: application/json" \
+  -d '{"task_name":"easy_sprint","seed":42}'
+# Expected: JSON with current_day=1, 5 tasks in backlog
+
+# 4. Step
+curl -X POST http://localhost:7860/step \
+  -H "Content-Type: application/json" \
+  -d '{"action":{"action_type":"assign","task_id":"T1","dev_id":"dev1"}}'
+# Expected: reward around +1.2, T1 now in_progress
+
+# 5. Validate
+openenv validate
+# Expected: [OK] ai-sprint-manager: Ready for multi-mode deployment
+
+# 6. Run inference
+python inference.py
+# Expected: [START]/[STEP]/[END] lines, scores for all 3 tasks
+```
+
+### Full test checklist
+
+| # | Test | How | Pass Condition |
+|---|------|-----|---------------|
+| 1 | Server health | `GET /health` | `{"status":"ok"}` |
+| 2 | Reset works | `POST /reset` | day=1, tasks in backlog |
+| 3 | Assign works | `POST /step` assign T1→dev1 | reward +1.2, T1 in_progress |
+| 4 | Skill mismatch rejected | Assign backend task to frontend dev | reward -0.15, error message |
+| 5 | Sprint ends | 10 skip steps | `done: true` |
+| 6 | Grader runs | Check final_score in info | value between 0.0 and 1.0 |
+| 7 | OpenEnv valid | `openenv validate` | `[OK]` message |
+| 8 | Inference output | `python inference.py` | `[START]` `[STEP]` `[END]` lines |
+| 9 | Docker build | `docker build .` | Exit code 0 |
+| 10 | Docker run | `docker run -p 7860:7860 ...` then health | `{"status":"ok"}` |
+| 11 | Live Space | `curl https://sejal-k-ai-sprint-manager.hf.space/health` | `{"status":"ok"}` |
+| 12 | UI loads | Open http://localhost:7860 | Gradio UI visible |
+| 13 | UI reset | Click Reset Sprint | Sprint board populates |
+| 14 | Auto-assign | Click Auto-Assign All | Tasks move to in_progress |
+| 15 | Reward chart | Take 3+ actions | Sparkline appears |
+
+---
+
+## 🎤 Project Demo Script (10 minutes)
+
+### Before Demo
+```bash
+python ui.py
+# Open http://localhost:7860 in browser — full screen
+# Have terminal with inference.py output ready
+```
+
+### [0:00 — 1:30] The Problem
+> "Software teams waste hours every sprint on planning. Which developer gets which task? What happens when someone goes sick? What if a critical bug appears on day 5? These decisions directly affect delivery speed and developer burnout."
+
+> "We built an RL environment that simulates exactly this — so an AI agent can learn to make these decisions better."
+
+### [1:30 — 3:00] Show the UI
+- Select `easy_sprint` → **🔄 Reset Sprint**
+- Point to sprint board: *"5 tasks in backlog, 3 developers, 10 day sprint"*
+- Point to Skill Guide: *"This tells you which dev is right for which task. Backend tasks need Alice, frontend tasks need Bob."*
+
+### [3:00 — 4:30] Manual Play — Good vs Bad Decision
+- Assign T3 (frontend) → dev1 (backend): *"Wrong skill — negative reward, task rejected"*
+- Assign T3 (frontend) → dev2 (frontend): *"Correct match — positive reward, task starts"*
+- Point to reward chart: *"See the reward signal? This is exactly what the AI learns from."*
+
+### [4:30 — 6:00] Auto-Assign
+- Click **🤖 Auto-Assign All**
+- *"Rule-based auto-assign picks the best skill match for every task."*
+- Click **▶️ Take Action** (skip) a few times
+- *"Each day the sprint advances, tasks progress, deadlines approach."*
+
+### [6:00 — 7:30] Hard Sprint
+- Reset with `hard_sprint`
+- *"12 tasks, 5 developers, random events — developers go sick, urgent bugs appear mid-sprint."*
+- Auto-assign, then skip a few times
+- When a 🚨 event fires: *"There — urgent bug on day 4. A trained agent needs to react and reassign resources."*
+
+### [7:30 — 9:00] Inference Output
+- Show terminal with inference.py output
+- *"This is our Llama 3.1 baseline running against all 3 scenarios automatically."*
+- Point to structured output: *"`[START]` `[STEP]` `[END]` — machine-parseable format the judges require."*
+- Point to scores: *"Easy sprint perfect score of 1.0 — validates the environment works. Hard sprint 0.0 — shows it genuinely challenges frontier models."*
+
+### [9:00 — 10:00] Technical Highlights
+> "What makes this submission stand out:"
+
+- **Real-world domain** — not CartPole, not a game — actual software engineering
+- **External data file** — `data/sprint_data.json` — anyone can plug in their own team
+- **Typed Python client** — `client.py` makes it plug-and-play with TRL, Stable-Baselines3
+- **OpenEnv compliant** — passes all 3 validation checks
+- **Shaped rewards** — signal at every step, enables efficient RL training
+
+---
+
+## 🐛 Common Issues & Fixes
+
+| Problem | Cause | Fix |
+|---------|-------|-----|
+| `ModuleNotFoundError` | Missing package | `pip install -r requirements.txt` |
+| Port 7860 in use | Other process | Kill it or change port in ui.py |
+| `401 Unauthorized` in inference | Bad HF token | Regenerate at hf.co/settings/tokens |
+| Validate step 3 fails | openenv not in PATH | Activate venv before running script |
+| Tasks not progressing | No devs assigned | Auto-Assign or assign manually |
+| Score always 0.0 | All tasks missed | Assign earlier, prioritize urgent tasks |
+| Docker timeout | venv in context | Check `.dockerignore` has `venv/` |
+
+---
+
+## 🔬 Is This a Real RL Environment?
+
+| Criterion | Our Environment |
+|-----------|----------------|
+| Sequential decisions | ✅ Each day depends on previous assignments |
+| Large state space | ✅ Tasks × Developers × Day — combinatorial |
+| Non-trivial action space | ✅ 5 types × 12 tasks × 5 devs |
+| Shaped reward | ✅ Signal every step, not just episode end |
+| Stochastic transitions | ✅ Random dev absences, mid-sprint bugs |
+| Clean episode boundaries | ✅ reset() gives fresh state every time |
+| Partial observability | ✅ Agent can't predict future events |
+| Trainable with RL | ✅ GRPO / PPO / any policy gradient |
+
+**A trained RL agent (not zero-shot LLM) should score 0.7+ on medium and 0.4+ on hard** after sufficient training — currently it scores 0.42 and 0.0 with baseline Llama 3.1. That's the gap RL training is meant to close.
+
+---
+
+## 📊 Baseline Score Interpretation
+
+```
+easy_sprint:   1.00  ← LLM figured out skill matching perfectly
+medium_sprint: 0.42  ← Partial success, random events hurt performance
+hard_sprint:   0.00  ← Cascade failures overwhelm baseline LLM
+average:       0.47
+```
+
+These scores are intentional and show the difficulty curve works correctly:
+- Easy solvable by any agent → environment is correct
+- Medium shows partial success → reward shaping works
+- Hard challenges frontier models → difficulty is genuine

README.md

@@ -1,73 +1,304 @@
 ---
-base_model: unsloth/qwen2.5-1.5b-instruct-unsloth-bnb-4bit
-library_name: peft
-model_name: trained_model
-tags:
-- base_model:adapter:unsloth/qwen2.5-1.5b-instruct-unsloth-bnb-4bit
-- grpo
-- lora
-- transformers
-- trl
-- unsloth
-licence: license
-pipeline_tag: text-generation
+title: AI Sprint Manager
+emoji: 🤖
+colorFrom: blue
+colorTo: purple
+sdk: docker
+pinned: false
+tags: [openenv, reinforcement-learning, agile, sprint-management, fastapi, gradio]
 ---
 
-# Model Card for trained_model
+# 🤖 AI Sprint Manager — OpenEnv
 
-This model is a fine-tuned version of [unsloth/qwen2.5-1.5b-instruct-unsloth-bnb-4bit](https://huggingface.co/unsloth/qwen2.5-1.5b-instruct-unsloth-bnb-4bit).
-It has been trained using [TRL](https://github.com/huggingface/trl).
+> **A reinforcement learning environment where an AI agent acts as a Tech Lead managing agile software sprints.**
 
-## Quick start
+---
 
-```python
-from transformers import pipeline
+## 🎯 What Is This?
+
+Modern software teams spend enormous time on sprint planning decisions:
+- Which developer gets which task?
+- What do you do when someone goes sick mid-sprint?
+- How do you handle an urgent production bug that appears on day 5?
+
+This environment simulates these real-world decisions so an AI agent can **learn optimal sprint management strategies** through reinforcement learning.
+
+The agent plays the role of a Tech Lead. Each step it observes the full sprint state (tasks, developers, workloads, deadlines) and takes an action. The environment responds with a reward signal that guides learning.
+
+---
+
+## 🏗️ Architecture
 
-question = "If you had a time machine, but could only go to the past or the future once and never return, which would you choose and why?"
-generator = pipeline("text-generation", model="None", device="cuda")
-output = generator([{"role": "user", "content": question}], max_new_tokens=128, return_full_text=False)[0]
-print(output["generated_text"])
 ```
+┌─────────────────────────────────────────┐
+│     RL Agent / LLM / Training Loop      │
+│         (uses client.py)                │
+└──────────────────┬──────────────────────┘
+                   │ HTTP  reset / step / state
+                   ▼
+┌─────────────────────────────────────────┐
+│         FastAPI Server (port 7860)      │
+│    /reset  /step  /state  /health       │
+└──────────────────┬──────────────────────┘
+                   │
+                   ▼
+┌─────────────────────────────────────────┐
+│      Sprint Environment (core logic)    │
+│  • Task/developer simulation            │
+│  • Reward calculation                   │
+│  • Random events (bugs, absences)       │
+│  • 3 graders: easy / medium / hard      │
+└──────────────────┬──────────────────────┘
+                   │ data loaded from
+                   ▼
+┌─────────────────────────────────────────┐
+│      data/sprint_data.json              │
+│  (customizable — bring your own data!)  │
+└─────────────────────────────────────────┘
+```
+
+---
 
-## Training procedure
+## 🎮 Live Demo
 
- 
 
+1. Select a sprint scenario (easy / medium / hard)
+2. Click **🔄 Reset Sprint**
+3. Use the **Skill → Dev Guide** to assign tasks correctly
+4. Or click **🤖 Auto-Assign All** to let the system decide
+5. Watch the reward history and task status update in real time
 
-This model was trained with GRPO, a method introduced in [DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models](https://huggingface.co/papers/2402.03300).
+---
 
-### Framework versions
+## 📐 Action Space
 
-- PEFT 0.18.1
-- TRL: 0.24.0
-- Transformers: 5.5.0
-- Pytorch: 2.10.0+cu128
-- Datasets: 4.3.0
-- Tokenizers: 0.22.2
+| Field | Type | Values |
+|---|---|---|
+| `action_type` | string | `assign`, `reassign`, `reprioritize`, `unblock`, `skip` |
+| `task_id` | string | Task ID e.g. `"T1"`, `"T6"` |
+| `dev_id` | string | Developer ID e.g. `"dev1"`, `"dev3"` |
+| `new_priority` | int | 1–5 (1=highest, for reprioritize only) |
 
-## Citations
+## 📊 Observation Space
 
-Cite GRPO as:
+| Field | Type | Description |
+|---|---|---|
+| `current_day` | int | Day in sprint (1–10) |
+| `sprint_length` | int | Total sprint length |
+| `developers` | list | Each dev's skill, capacity, load, tasks, availability |
+| `tasks` | list | Each task's type, priority, effort, deadline, status, progress |
+| `reward` | float | Step reward |
+| `cumulative_reward` | float | Total reward this episode |
+| `tasks_completed/missed/in_progress/backlog` | int | Status counts |
+| `workload_balance_score` | float | 0=unbalanced, 1=perfect |
+| `events` | list | Events that just happened (completions, misses, absences) |
+| `done` | bool | Whether episode is complete |
 
-```bibtex
-@article{shao2024deepseekmath,
-    title        = {{DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models}},
-    author       = {Zhihong Shao and Peiyi Wang and Qihao Zhu and Runxin Xu and Junxiao Song and Mingchuan Zhang and Y. K. Li and Y. Wu and Daya Guo},
-    year         = 2024,
-    eprint       = {arXiv:2402.03300},
-}
+---
+
+## 🎯 Tasks (Scenarios)
+
+| ID | Difficulty | Devs | Tasks | Random Events |
+|---|---|---|---|---|
+| `easy_sprint` | 🟢 Easy | 3 | 5 | None |
+| `medium_sprint` | 🟡 Medium | 4 | 8 | Dev absences, bugs expire |
+| `hard_sprint` | 🔴 Hard | 5 | 12 | Urgent bugs mid-sprint, cascading failures |
+
+### Baseline Scores (meta-llama/Llama-3.1-8B-Instruct)
+
+| Task | Score |
+|---|---|
+| `easy_sprint` | 0.01 |
+| `medium_sprint` | 0.46 ████████ |
+| `hard_sprint` | 0.01 |
+| **Average** | **0.16** |
+
+---
 
+## 💰 Reward Function
+
+| Event | Reward |
+|---|---|
+| Assign task (skill match) | +0.8 to +1.3 |
+| Assign task (skill mismatch penalty) | +0.1 to +0.6 |
+| Wrong skill / over capacity | -0.15 |
+| Task completed on time | +0.5 to +2.5 |
+| Task completed late | +0.1 |
+| Task missed deadline | -0.3 to -1.5 |
+| Urgent bug missed | -0.25 extra |
+| Skip (no action) | -0.05 |
+| Final score bonus | score × 10.0 |
+
+---
+
+## 🔌 API Reference
+
+```bash
+# Health check
+GET /health → {"status": "ok", "env": "ai-sprint-manager"}
+
+# Start new episode
+POST /reset
+Body: {"task_name": "easy_sprint", "seed": 42}
+
+# Take one action
+POST /step
+Body: {"action": {"action_type": "assign", "task_id": "T1", "dev_id": "dev1"}}
+
+# Get full state
+GET /state
+
+# List scenarios
+GET /tasks
 ```
 
-Cite TRL as:
-    
-```bibtex
-@misc{vonwerra2022trl,
-	title        = {{TRL: Transformer Reinforcement Learning}},
-	author       = {Leandro von Werra and Younes Belkada and Lewis Tunstall and Edward Beeching and Tristan Thrush and Nathan Lambert and Shengyi Huang and Kashif Rasul and Quentin Gallou{\'e}dec},
-	year         = 2020,
-	journal      = {GitHub repository},
-	publisher    = {GitHub},
-	howpublished = {\url{https://github.com/huggingface/trl}}
+---
+
+## 🐍 Python Client Usage
+
+```python
+from client import SprintEnvClient
+from sprint_env.models import SprintAction
+
+# Connect to live Space
+with SprintEnvClient(base_url="https://sejal-k-ai-sprint-manager.hf.space") as env:
+    # Reset
+    obs = env.reset(task_name="medium_sprint", seed=42)
+
+    # Agent loop
+    while not obs["done"]:
+        action = SprintAction(
+            action_type="assign",
+            task_id="T1",
+            dev_id="dev1",
+        )
+        result = env.step(action)
+        print(result)  # StepResult(reward=+1.20, done=False, day=2, completed=0)
+        obs = result.observation
+```
+
+---
+
+## 🗂️ Project Structure
+
+```
+ai-sprint-manager-openenv/
+├── openenv.yaml              # OpenEnv spec metadata
+├── pyproject.toml            # Project dependencies
+├── Dockerfile                # Container definition
+├── requirements.txt          # Python dependencies
+├── inference.py              # Baseline LLM agent script
+├── client.py                 # Typed Python client (for RL training)
+├── ui.py                     # Gradio UI + FastAPI combined server
+├── start.sh                  # Container startup script
+│
+├── data/
+│   └── sprint_data.json      # All scenario data (customizable!)
+│
+├── sprint_env/
+│   ├── __init__.py
+│   ├── models.py             # Pydantic Action/Observation/State
+│   ├── tasks.py              # Task & Developer dataclasses
+│   ├── environment.py        # Core RL environment logic
+│   ├── graders.py            # Scoring functions (easy/medium/hard)
+│   └── data_loader.py        # JSON data loader with caching
+│
+└── server/
+    ├── __init__.py
+    └── app.py                # OpenEnv-compliant FastAPI server entry
+```
+
+---
+
+## 🔧 Bring Your Own Data
+
+Don't want to use our sample scenarios? Edit `data/sprint_data.json`:
+
+```json
+{
+  "scenarios": {
+    "my_custom_sprint": {
+      "description": "My team's actual sprint",
+      "difficulty": "medium",
+      "developers": [
+        {"id": "dev1", "name": "Your Name", "skill": "backend", "capacity": 5, "productivity": 1.0}
+      ],
+      "tasks": [
+        {"id": "T1", "name": "Your Task", "task_type": "feature", "priority": 1,
+         "effort": 3, "deadline": 5, "required_skill": "backend"}
+      ]
+    }
+  }
 }
-```
+```
+
+Or point to your own file:
+```bash
+export SPRINT_DATA_PATH=/path/to/your/data.json
+python ui.py
+```
+
+---
+
+## 🚀 Setup & Run
+
+```bash
+# Clone
+git clone https://github.com/sejalsksagar/ai-sprint-manager-openenv.git
+cd ai-sprint-manager-openenv
+
+# Install
+python -m venv venv
+source venv/bin/activate  # Windows: venv\Scripts\activate
+pip install -r requirements.txt
+
+# Configure
+cp .env.example .env
+# Edit .env with your HF_TOKEN
+
+# Run locally
+python ui.py
+# Open http://localhost:7860
+
+# Docker
+docker build -t ai-sprint-manager .
+docker run -p 7860:7860 ai-sprint-manager
+
+# Run inference
+python inference.py
+```
+
+---
+
+## 🤖 Can an RL Agent Learn From This?
+
+Yes. The environment is designed for policy gradient training (GRPO, PPO):
+
+```python
+# Example training loop skeleton (TRL/GRPO compatible)
+from client import SprintEnvClient
+from sprint_env.models import SprintAction
+
+env = SprintEnvClient(base_url="http://localhost:7860")
+
+for episode in range(1000):
+    obs = env.reset(task_name="medium_sprint")
+    trajectory = []
+
+    while not obs["done"]:
+        action = policy.sample(obs)           # your policy here
+        result = env.step(action)
+        trajectory.append((obs, action, result.reward))
+        obs = result.observation
+
+    policy.update(trajectory)                 # GRPO/PPO update
+```
+
+The shaped reward function provides learning signal at every step — not just at episode end — which is critical for efficient RL training.
+
+
+---
+
+## 👥 Team
+
+Built for the **Meta PyTorch OpenEnv Hackathon x SST | India AI Hackathon '26**

SETUP.md

@@ -0,0 +1,266 @@
+# 🛠️ Team Setup Guide — AI Sprint Manager OpenEnv
+
+Complete setup instructions for Windows and Mac teammates.
+
+---
+
+## 📋 Prerequisites
+
+### Windows
+
+1. **Install Python 3.11**
+   - Download from https://www.python.org/downloads/
+   - ✅ Check **"Add Python to PATH"** during install
+   - Verify: open PowerShell and run `python --version`
+
+2. **Install Git**
+   - Download from https://git-scm.com/download/win
+   - Use default options during install
+   - Verify: `git --version`
+
+3. **Install Docker Desktop**
+   - Download from https://www.docker.com/products/docker-desktop/
+   - Requires Windows 10/11 with WSL2 enabled
+   - After install, open Docker Desktop and wait for it to start
+   - Verify: `docker --version`
+
+4. **Install VS Code** (recommended)
+   - Download from https://code.visualstudio.com/
+
+### Mac
+
+1. **Install Homebrew** (package manager)
+   ```bash
+   /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+   ```
+
+2. **Install Python 3.11**
+   ```bash
+   brew install python@3.11
+   ```
+   Verify: `python3.11 --version`
+
+3. **Install Git**
+   ```bash
+   brew install git
+   ```
+   Verify: `git --version`
+
+4. **Install Docker Desktop**
+   - Download from https://www.docker.com/products/docker-desktop/
+   - Choose Apple Silicon or Intel depending on your Mac
+   - Open Docker Desktop and wait for it to start
+   - Verify: `docker --version`
+
+---
+
+## 📥 Clone the GitHub Repo
+
+```bash
+# Both Windows (PowerShell) and Mac (Terminal)
+git clone https://github.com/YOUR_GITHUB_USERNAME/ai-sprint-manager-openenv.git
+cd ai-sprint-manager-openenv
+```
+
+---
+
+## 🌿 Create Your Own Branch
+
+```bash
+# Replace "yourname" with your actual name
+git checkout -b feature/yourname-improvements
+```
+
+Verify you're on your branch:
+```bash
+git branch
+# Should show * feature/yourname-improvements
+```
+
+---
+
+## 🐍 Set Up Virtual Environment
+
+### Windows
+```powershell
+python -m venv venv
+venv\Scripts\activate
+pip install --upgrade pip
+pip install -r requirements.txt
+pip install python-dotenv
+```
+
+### Mac
+```bash
+python3 -m venv venv
+source venv/bin/activate
+pip install --upgrade pip
+pip install -r requirements.txt
+pip install python-dotenv
+```
+
+---
+
+## ⚙️ Create Your `.env` File
+
+Create a file called `.env` in the project root (never commit this!):
+
+```
+HF_TOKEN=hf_your_token_here
+API_BASE_URL=https://router.huggingface.co/v1
+MODEL_NAME=meta-llama/Llama-3.1-8B-Instruct
+ENV_BASE_URL=http://localhost:7860
+```
+
+We'll get the HF_TOKEN in the next section.
+
+---
+
+## 🤗 Create Hugging Face Account & Token
+
+1. Go to https://huggingface.co and sign up
+2. Go to https://huggingface.co/settings/tokens
+3. Click **New token**
+4. Name: `sprint-manager-token`
+5. Type: **Read**
+6. Click **Create token** and copy it
+7. Paste it into your `.env` file as `HF_TOKEN=hf_...`
+
+---
+
+## 🚀 Run Locally & Test
+
+### Terminal 1 — Start the API + UI server
+#### Windows
+```powershell
+python ui.py
+```
+#### Mac
+```bash
+python ui.py
+```
+
+### Terminal 2 — Test the API
+#### Windows
+```powershell
+Invoke-WebRequest -Uri http://localhost:7860/health -Method GET
+```
+#### Mac
+```bash
+curl http://localhost:7860/health
+# Expected: {"status":"ok","env":"ai-sprint-manager"}
+```
+
+### Test via Browser
+Open http://localhost:7860 — you should see the Gradio sprint board UI.
+
+Try:
+1. Select `easy_sprint`, click **🔄 Reset Sprint**
+2. Set Action=`assign`, Task ID=`T1`, Dev ID=`dev1`
+3. Click **▶️ Take Action**
+4. You should see a positive reward and T1 assigned to Alice
+
+### Run Inference Locally
+```bash
+# Make sure .env file has your HF_TOKEN
+python inference.py
+```
+
+---
+
+## 🐳 Test with Docker
+
+```bash
+docker build -t ai-sprint-manager .
+```
+
+### Windows
+```powershell
+docker run -p 7860:7860 ai-sprint-manager
+```
+### Mac
+```bash
+docker run -p 7860:7860 ai-sprint-manager
+```
+
+Open http://localhost:7860 to verify.
+
+---
+
+## ☁️ Create Your Own HF Space & Deploy
+
+1. Go to https://huggingface.co/new-space
+2. Fill in:
+   - **Space name:** `ai-sprint-manager-yourname`
+   - **SDK:** Docker
+   - **Visibility:** Public
+3. Click **Create Space**
+
+4. Add your HF token as a Secret:
+   - Go to Space → **Settings** → **Variables and secrets**
+   - Add secret: Name=`HF_TOKEN`, Value=your token
+
+5. Add HF as a git remote and push your branch:
+```bash
+git remote add myspace https://huggingface.co/spaces/YOUR_HF_USERNAME/ai-sprint-manager-yourname
+git push myspace feature/yourname-improvements:main
+```
+
+6. Wait 2-3 minutes for build. Test your live Space:
+
+### Windows
+```powershell
+Invoke-WebRequest -Uri "https://YOUR_HF_USERNAME-ai-sprint-manager-yourname.hf.space/health" -Method GET
+```
+### Mac
+```bash
+curl https://YOUR_HF_USERNAME-ai-sprint-manager-yourname.hf.space/health
+```
+
+---
+
+## 🔧 Run OpenEnv Validation
+
+```bash
+pip install openenv-core uv
+uv lock
+openenv validate
+# Expected: [OK] ai-sprint-manager: Ready for multi-mode deployment
+```
+
+---
+
+## 💡 Suggested Improvements for Teammates
+
+### 🟢 Easy (Good for getting started)
+
+1. **Better skill matching UI** — Show a skill-to-dev mapping table in the Gradio UI so users know which dev to pick
+2. **Sprint history chart** — Add a reward-over-time line chart using `gr.Plot`
+3. **Add more tasks** — Expand `tasks.py` with more realistic task names and types
+4. **Auto-assign button** — Add a Gradio button that automatically assigns all backlog tasks using a simple rule (best skill match)
+
+### 🟡 Medium
+
+5. **Session isolation** — Currently all users share one env instance. Add session IDs so multiple users can use the UI simultaneously
+6. **Sprint replay** — Save the full episode history and add a "replay" feature to the UI
+7. **Better reward visualization** — Add a bar chart showing per-task completion status
+8. **Configurable sprint length** — Let users set sprint length (5/10/15 days) in the UI
+
+### 🔴 Hard (Advanced)
+
+9. **Real RL training loop** — Add a `train.py` script using Stable-Baselines3 or TRL+GRPO to actually train a policy
+10. **Multi-agent support** — Let multiple AI agents collaborate on sprint management
+11. **WebSocket support** — Upgrade from HTTP to WebSocket for real-time updates per OpenEnv spec
+12. **Custom sprint builder** — Let users define their own tasks and team in the UI
+
+---
+
+## 📤 Submit Your Changes
+
+```bash
+git add .
+git commit -m "feat: your improvement description"
+git push origin feature/yourname-improvements
+```
+
+Then open a Pull Request on GitHub to merge into `main`.

client.py

@@ -0,0 +1,134 @@
+"""
+Sprint Manager — OpenEnv Client
+
+This is what RL researchers import in their training code.
+It provides a clean typed interface to the environment server.
+
+Usage:
+    import requests
+    from client import SprintEnvClient, SprintAction
+
+    client = SprintEnvClient(base_url="https://sejal-k-ai-sprint-manager.hf.space")
+    obs = client.reset(task_name="easy_sprint")
+    result = client.step(SprintAction(action_type="assign", task_id="T1", dev_id="dev1"))
+    state = client.state()
+    client.close()
+
+    # Or as context manager:
+    with SprintEnvClient(base_url="http://localhost:7860") as client:
+        obs = client.reset(task_name="medium_sprint", seed=42)
+        while not obs["done"]:
+            result = client.step(SprintAction(action_type="skip"))
+            obs = result["observation"]
+"""
+from __future__ import annotations
+import requests
+from typing import Optional, Any
+from sprint_env.models import SprintAction
+
+
+class StepResult:
+    """Typed result from a step() call."""
+    def __init__(self, payload: dict):
+        self.observation: dict = payload["observation"]
+        self.reward: float = payload["reward"]
+        self.done: bool = payload["done"]
+        self.info: dict = payload.get("info", {})
+
+    def __repr__(self):
+        return (
+            f"StepResult(reward={self.reward:+.2f}, done={self.done}, "
+            f"day={self.observation.get('current_day')}, "
+            f"completed={self.observation.get('tasks_completed')})"
+        )
+
+
+class SprintEnvClient:
+    """
+    HTTP client for the Sprint Manager OpenEnv environment.
+
+    Wraps the REST API into a clean Python interface.
+    Use this in RL training loops, notebooks, or evaluation scripts.
+    """
+
+    def __init__(self, base_url: str = "http://localhost:7860", timeout: int = 30):
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self._session = requests.Session()
+
+    def reset(
+        self,
+        task_name: str = "easy_sprint",
+        seed: Optional[int] = None,
+        episode_id: Optional[str] = None,
+    ) -> dict:
+        """
+        Reset the environment and return initial observation.
+
+        Args:
+            task_name: One of "easy_sprint", "medium_sprint", "hard_sprint"
+            seed: Random seed for reproducibility
+            episode_id: Optional episode identifier
+
+        Returns:
+            Observation dict
+        """
+        payload = {"task_name": task_name}
+        if seed is not None:
+            payload["seed"] = seed
+        if episode_id is not None:
+            payload["episode_id"] = episode_id
+
+        resp = self._session.post(
+            f"{self.base_url}/reset", json=payload, timeout=self.timeout
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+    def step(self, action: SprintAction) -> StepResult:
+        """
+        Take one action and advance the sprint by one day.
+
+        Args:
+            action: SprintAction with action_type, task_id, dev_id, new_priority
+
+        Returns:
+            StepResult with observation, reward, done, info
+        """
+        payload = {"action": action.model_dump()}
+        resp = self._session.post(
+            f"{self.base_url}/step", json=payload, timeout=self.timeout
+        )
+        resp.raise_for_status()
+        return StepResult(resp.json())
+
+    def state(self) -> dict:
+        """Return the full current environment state."""
+        resp = self._session.get(f"{self.base_url}/state", timeout=self.timeout)
+        resp.raise_for_status()
+        return resp.json()
+
+    def health(self) -> dict:
+        """Check server health."""
+        resp = self._session.get(f"{self.base_url}/health", timeout=self.timeout)
+        resp.raise_for_status()
+        return resp.json()
+
+    def list_tasks(self) -> list[dict]:
+        """List all available sprint scenarios."""
+        resp = self._session.get(f"{self.base_url}/tasks", timeout=self.timeout)
+        resp.raise_for_status()
+        return resp.json()["tasks"]
+
+    def close(self):
+        """Close the HTTP session."""
+        self._session.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+    def __repr__(self):
+        return f"SprintEnvClient(base_url='{self.base_url}')"

data/project_data.json

@@ -0,0 +1,231 @@
+{
+  "scenarios": {
+    "project_easy": {
+      "description": "Small stable team, clear backlog, no cascade failures. Good for baseline LLM testing on multi-sprint horizon.",
+      "difficulty": "easy",
+      "num_sprints": 6,
+      "days_per_sprint": 10,
+      "developers": [
+        {"id": "dev1", "name": "Alice",  "skill": "backend",   "capacity": 5, "productivity": 1.2},
+        {"id": "dev2", "name": "Bob",    "skill": "frontend",  "capacity": 4, "productivity": 1.0},
+        {"id": "dev3", "name": "Carol",  "skill": "fullstack", "capacity": 6, "productivity": 1.1},
+        {"id": "dev4", "name": "Dave",   "skill": "devops",    "capacity": 4, "productivity": 1.0}
+      ],
+      "tasks": [
+        {"id": "T01", "name": "User Auth API",            "task_type": "feature",    "priority": 1, "effort": 3, "sprint": 1, "deadline_day": 8,  "required_skill": "backend",   "depends_on": []},
+        {"id": "T02", "name": "Login UI",                 "task_type": "feature",    "priority": 1, "effort": 3, "sprint": 1, "deadline_day": 9,  "required_skill": "frontend",  "depends_on": []},
+        {"id": "T03", "name": "CI/CD Setup",              "task_type": "feature",    "priority": 2, "effort": 3, "sprint": 1, "deadline_day": 10, "required_skill": "devops",    "depends_on": []},
+        {"id": "T04", "name": "Database Schema v1",       "task_type": "feature",    "priority": 1, "effort": 4, "sprint": 1, "deadline_day": 9,  "required_skill": "backend",   "depends_on": []},
+
+        {"id": "T05", "name": "User Profile API",         "task_type": "feature",    "priority": 1, "effort": 4, "sprint": 2, "deadline_day": 18, "required_skill": "backend",   "depends_on": ["T01"]},
+        {"id": "T06", "name": "Profile Page UI",          "task_type": "feature",    "priority": 2, "effort": 3, "sprint": 2, "deadline_day": 19, "required_skill": "frontend",  "depends_on": ["T02"]},
+        {"id": "T07", "name": "Fix Login CSS Bug",        "task_type": "bug",        "priority": 1, "effort": 1, "sprint": 2, "deadline_day": 13, "required_skill": "frontend",  "depends_on": []},
+        {"id": "T08", "name": "Docker Deployment",        "task_type": "feature",    "priority": 2, "effort": 3, "sprint": 2, "deadline_day": 20, "required_skill": "devops",    "depends_on": ["T03"]},
+
+        {"id": "T09", "name": "Search API",               "task_type": "feature",    "priority": 2, "effort": 4, "sprint": 3, "deadline_day": 28, "required_skill": "backend",   "depends_on": ["T04"]},
+        {"id": "T10", "name": "Search UI",                "task_type": "feature",    "priority": 2, "effort": 3, "sprint": 3, "deadline_day": 29, "required_skill": "frontend",  "depends_on": []},
+        {"id": "T11", "name": "Email Notifications",      "task_type": "feature",    "priority": 3, "effort": 3, "sprint": 3, "deadline_day": 30, "required_skill": "backend",   "depends_on": ["T05"]},
+        {"id": "T12", "name": "Staging Environment",      "task_type": "feature",    "priority": 2, "effort": 2, "sprint": 3, "deadline_day": 27, "required_skill": "devops",    "depends_on": ["T08"]},
+
+        {"id": "T13", "name": "Payment Integration",      "task_type": "feature",    "priority": 1, "effort": 5, "sprint": 4, "deadline_day": 38, "required_skill": "backend",   "depends_on": ["T05"]},
+        {"id": "T14", "name": "Checkout UI",              "task_type": "feature",    "priority": 1, "effort": 4, "sprint": 4, "deadline_day": 39, "required_skill": "frontend",  "depends_on": ["T10"]},
+        {"id": "T15", "name": "API Rate Limiting",        "task_type": "tech_debt",  "priority": 3, "effort": 3, "sprint": 4, "deadline_day": 40, "required_skill": "backend",   "depends_on": []},
+        {"id": "T16", "name": "Load Balancer Config",     "task_type": "feature",    "priority": 2, "effort": 3, "sprint": 4, "deadline_day": 38, "required_skill": "devops",    "depends_on": ["T12"]},
+
+        {"id": "T17", "name": "Analytics Dashboard",      "task_type": "feature",    "priority": 2, "effort": 4, "sprint": 5, "deadline_day": 49, "required_skill": "fullstack",  "depends_on": ["T13"]},
+        {"id": "T18", "name": "Accessibility Audit",      "task_type": "tech_debt",  "priority": 3, "effort": 3, "sprint": 5, "deadline_day": 50, "required_skill": "frontend",   "depends_on": []},
+        {"id": "T19", "name": "Performance Optimisation", "task_type": "tech_debt",  "priority": 3, "effort": 3, "sprint": 5, "deadline_day": 48, "required_skill": "backend",    "depends_on": []},
+        {"id": "T20", "name": "Monitoring & Alerting",    "task_type": "feature",    "priority": 2, "effort": 3, "sprint": 5, "deadline_day": 50, "required_skill": "devops",     "depends_on": ["T16"]},
+
+        {"id": "T21", "name": "Final Security Hardening", "task_type": "bug",        "priority": 1, "effort": 4, "sprint": 6, "deadline_day": 58, "required_skill": "backend",    "depends_on": ["T15"]},
+        {"id": "T22", "name": "Production Release UI",    "task_type": "feature",    "priority": 1, "effort": 3, "sprint": 6, "deadline_day": 59, "required_skill": "frontend",   "depends_on": ["T14", "T18"]},
+        {"id": "T23", "name": "Runbook Documentation",    "task_type": "tech_debt",  "priority": 3, "effort": 2, "sprint": 6, "deadline_day": 60, "required_skill": "fullstack",  "depends_on": []},
+        {"id": "T24", "name": "Production Deploy",        "task_type": "feature",    "priority": 1, "effort": 3, "sprint": 6, "deadline_day": 60, "required_skill": "devops",     "depends_on": ["T20", "T21"]}
+      ],
+      "instructions": [
+        {"id": "I01", "release_day": 1,  "text": "Prioritise auth tasks above all others in sprint 1.", "target_sprint": 1, "affects_tasks": ["T01", "T02"]},
+        {"id": "I02", "release_day": 5,  "text": "Ensure CI/CD is completed before sprint 1 ends.", "target_sprint": 1, "affects_tasks": ["T03"]},
+        {"id": "I03", "release_day": 11, "text": "The login CSS bug is blocking QA — resolve first in sprint 2.", "target_sprint": 2, "affects_tasks": ["T07"]},
+        {"id": "I04", "release_day": 14, "text": "Docker deployment must be validated by day 20.", "target_sprint": 2, "affects_tasks": ["T08"]},
+        {"id": "I05", "release_day": 21, "text": "Search must be demo-ready by end of sprint 3.", "target_sprint": 3, "affects_tasks": ["T09", "T10"]},
+        {"id": "I06", "release_day": 25, "text": "Email notifications are now a stakeholder requirement for sprint 3.", "target_sprint": 3, "affects_tasks": ["T11"]},
+        {"id": "I07", "release_day": 31, "text": "Payment integration is the top priority for sprint 4 — assign best backend dev.", "target_sprint": 4, "affects_tasks": ["T13"]},
+        {"id": "I08", "release_day": 35, "text": "API rate limiting must ship in sprint 4 before production scaling.", "target_sprint": 4, "affects_tasks": ["T15"]},
+        {"id": "I09", "release_day": 41, "text": "Analytics dashboard needs to be interactive — fullstack only.", "target_sprint": 5, "affects_tasks": ["T17"]},
+        {"id": "I10", "release_day": 45, "text": "Accessibility audit result must be attached to sprint 5 report.", "target_sprint": 5, "affects_tasks": ["T18"]},
+        {"id": "I11", "release_day": 51, "text": "Security hardening is a release gate — cannot ship without it.", "target_sprint": 6, "affects_tasks": ["T21"]},
+        {"id": "I12", "release_day": 55, "text": "Production deploy is on day 60 — no delays accepted.", "target_sprint": 6, "affects_tasks": ["T24"]}
+      ]
+    },
+
+    "project_medium": {
+      "description": "Mid-size team with developer absences, mid-sprint urgent bugs, and instructions that conflict with prior plans.",
+      "difficulty": "medium",
+      "num_sprints": 6,
+      "days_per_sprint": 10,
+      "developers": [
+        {"id": "dev1", "name": "Alice", "skill": "backend",   "capacity": 5, "productivity": 1.1},
+        {"id": "dev2", "name": "Bob",   "skill": "frontend",  "capacity": 4, "productivity": 0.9},
+        {"id": "dev3", "name": "Carol", "skill": "devops",    "capacity": 5, "productivity": 1.0},
+        {"id": "dev4", "name": "Dave",  "skill": "fullstack", "capacity": 6, "productivity": 1.2},
+        {"id": "dev5", "name": "Eve",   "skill": "backend",   "capacity": 5, "productivity": 1.0}
+      ],
+      "absences": [
+        {"dev_id": "dev2", "day_start": 14, "day_end": 16, "reason": "sick leave"},
+        {"dev_id": "dev4", "day_start": 33, "day_end": 35, "reason": "conference"},
+        {"dev_id": "dev1", "day_start": 52, "day_end": 54, "reason": "vacation"}
+      ],
+      "tasks": [
+        {"id": "T01", "name": "Auth Microservice",          "task_type": "feature",    "priority": 1, "effort": 5, "sprint": 1, "deadline_day": 8,  "required_skill": "backend",   "depends_on": []},
+        {"id": "T02", "name": "Login & Register UI",        "task_type": "feature",    "priority": 1, "effort": 4, "sprint": 1, "deadline_day": 9,  "required_skill": "frontend",  "depends_on": []},
+        {"id": "T03", "name": "Kubernetes Base Setup",      "task_type": "feature",    "priority": 2, "effort": 5, "sprint": 1, "deadline_day": 10, "required_skill": "devops",    "depends_on": []},
+        {"id": "T04", "name": "DB Schema & Migrations",     "task_type": "feature",    "priority": 1, "effort": 4, "sprint": 1, "deadline_day": 9,  "required_skill": "backend",   "depends_on": []},
+        {"id": "T05", "name": "API Gateway Setup",          "task_type": "feature",    "priority": 2, "effort": 4, "sprint": 1, "deadline_day": 10, "required_skill": "fullstack", "depends_on": []},
+
+        {"id": "T06", "name": "User Profile Service",       "task_type": "feature",    "priority": 1, "effort": 5, "sprint": 2, "deadline_day": 18, "required_skill": "backend",   "depends_on": ["T01"]},
+        {"id": "T07", "name": "Profile & Settings UI",      "task_type": "feature",    "priority": 2, "effort": 4, "sprint": 2, "deadline_day": 19, "required_skill": "frontend",  "depends_on": ["T02"]},
+        {"id": "T08", "name": "Prod DB Crash Fix",          "task_type": "urgent_bug", "priority": 1, "effort": 2, "sprint": 2, "deadline_day": 12, "required_skill": "backend",   "depends_on": []},
+        {"id": "T09", "name": "Helm Chart Deployment",      "task_type": "feature",    "priority": 2, "effort": 4, "sprint": 2, "deadline_day": 20, "required_skill": "devops",    "depends_on": ["T03"]},
+        {"id": "T10", "name": "Inter-Service Auth",         "task_type": "feature",    "priority": 1, "effort": 4, "sprint": 2, "deadline_day": 19, "required_skill": "fullstack", "depends_on": ["T05"]},
+
+        {"id": "T11", "name": "Notification Service",       "task_type": "feature",    "priority": 2, "effort": 5, "sprint": 3, "deadline_day": 28, "required_skill": "backend",   "depends_on": ["T06"]},
+        {"id": "T12", "name": "Notification Preference UI", "task_type": "feature",    "priority": 2, "effort": 3, "sprint": 3, "deadline_day": 29, "required_skill": "frontend",  "depends_on": ["T07"]},
+        {"id": "T13", "name": "Payment Gateway API",        "task_type": "feature",    "priority": 1, "effort": 6, "sprint": 3, "deadline_day": 30, "required_skill": "backend",   "depends_on": ["T04"]},
+        {"id": "T14", "name": "Service Mesh (Istio)",       "task_type": "feature",    "priority": 2, "effort": 5, "sprint": 3, "deadline_day": 28, "required_skill": "devops",    "depends_on": ["T09"]},
+        {"id": "T15", "name": "Search & Filter API",        "task_type": "feature",    "priority": 2, "effort": 4, "sprint": 3, "deadline_day": 29, "required_skill": "fullstack", "depends_on": ["T10"]},
+
+        {"id": "T16", "name": "Checkout & Orders API",      "task_type": "feature",    "priority": 1, "effort": 5, "sprint": 4, "deadline_day": 38, "required_skill": "backend",   "depends_on": ["T13"]},
+        {"id": "T17", "name": "Checkout Flow UI",           "task_type": "feature",    "priority": 1, "effort": 5, "sprint": 4, "deadline_day": 39, "required_skill": "frontend",  "depends_on": ["T12"]},
+        {"id": "T18", "name": "Payment Security Audit",     "task_type": "bug",        "priority": 1, "effort": 3, "sprint": 4, "deadline_day": 36, "required_skill": "backend",   "depends_on": ["T13"]},
+        {"id": "T19", "name": "Canary Deployment Setup",    "task_type": "feature",    "priority": 2, "effort": 4, "sprint": 4, "deadline_day": 39, "required_skill": "devops",    "depends_on": ["T14"]},
+        {"id": "T20", "name": "Full-Text Search (ES)",      "task_type": "feature",    "priority": 3, "effort": 5, "sprint": 4, "deadline_day": 40, "required_skill": "fullstack", "depends_on": ["T15"]},
+
+        {"id": "T21", "name": "Reporting & Analytics API",  "task_type": "feature",    "priority": 2, "effort": 5, "sprint": 5, "deadline_day": 49, "required_skill": "backend",   "depends_on": ["T16"]},
+        {"id": "T22", "name": "Analytics Dashboard UI",     "task_type": "feature",    "priority": 2, "effort": 4, "sprint": 5, "deadline_day": 49, "required_skill": "frontend",  "depends_on": ["T17"]},
+        {"id": "T23", "name": "SLA & SLO Monitoring",       "task_type": "tech_debt",  "priority": 3, "effort": 3, "sprint": 5, "deadline_day": 50, "required_skill": "devops",    "depends_on": ["T19"]},
+        {"id": "T24", "name": "Mobile API Optimisation",    "task_type": "tech_debt",  "priority": 3, "effort": 4, "sprint": 5, "deadline_day": 50, "required_skill": "fullstack", "depends_on": ["T20"]},
+        {"id": "T25", "name": "Data Privacy Compliance",    "task_type": "tech_debt",  "priority": 2, "effort": 3, "sprint": 5, "deadline_day": 48, "required_skill": "backend",   "depends_on": []},
+
+        {"id": "T26", "name": "Pen Test & Remediation",     "task_type": "bug",        "priority": 1, "effort": 5, "sprint": 6, "deadline_day": 57, "required_skill": "backend",   "depends_on": ["T18", "T25"]},
+        {"id": "T27", "name": "Final UI Polish & QA",       "task_type": "feature",    "priority": 1, "effort": 4, "sprint": 6, "deadline_day": 59, "required_skill": "frontend",  "depends_on": ["T22"]},
+        {"id": "T28", "name": "Blue-Green Production Swap", "task_type": "feature",    "priority": 1, "effort": 4, "sprint": 6, "deadline_day": 60, "required_skill": "devops",    "depends_on": ["T23"]},
+        {"id": "T29", "name": "Runbooks & Postmortem Docs", "task_type": "tech_debt",  "priority": 3, "effort": 3, "sprint": 6, "deadline_day": 60, "required_skill": "fullstack", "depends_on": []},
+        {"id": "T30", "name": "Stakeholder Demo Prep",      "task_type": "feature",    "priority": 2, "effort": 2, "sprint": 6, "deadline_day": 60, "required_skill": "fullstack", "depends_on": ["T21", "T22"]}
+      ],
+      "instructions": [
+        {"id": "I01", "release_day": 1,  "text": "Auth microservice is a hard dependency for all downstream services — finish before day 8.", "target_sprint": 1, "affects_tasks": ["T01"]},
+        {"id": "I02", "release_day": 3,  "text": "API gateway must be validated with at least one downstream service by end of sprint 1.", "target_sprint": 1, "affects_tasks": ["T05"]},
+        {"id": "I03", "release_day": 7,  "text": "Kubernetes base setup is blocking the DevOps track — escalate if behind.", "target_sprint": 1, "affects_tasks": ["T03"]},
+        {"id": "I04", "release_day": 11, "text": "Production DB crash is P0 — drop everything and assign a backend dev immediately.", "target_sprint": 2, "affects_tasks": ["T08"]},
+        {"id": "I05", "release_day": 15, "text": "Bob is on sick leave — redistribute frontend tasks for sprint 2.", "target_sprint": 2, "affects_tasks": ["T07"]},
+        {"id": "I06", "release_day": 18, "text": "Inter-service auth must be ready before notification service starts in sprint 3.", "target_sprint": 2, "affects_tasks": ["T10"]},
+        {"id": "I07", "release_day": 21, "text": "Payment gateway is now a sprint 3 commitment to the business — no slip.", "target_sprint": 3, "affects_tasks": ["T13"]},
+        {"id": "I08", "release_day": 24, "text": "Service mesh complexity is underestimated — pair Carol with Dave on Istio.", "target_sprint": 3, "affects_tasks": ["T14"]},
+        {"id": "I09", "release_day": 27, "text": "Add payment security audit as a sprint 3 exit gate before sprint 4 checkout work begins.", "target_sprint": 3, "affects_tasks": ["T18"]},
+        {"id": "I10", "release_day": 31, "text": "Checkout flow is top priority — nothing ships in sprint 4 before T16 and T17 are green.", "target_sprint": 4, "affects_tasks": ["T16", "T17"]},
+        {"id": "I11", "release_day": 33, "text": "Dave is at conference days 33-35 — replan sprint 4 fullstack tasks.", "target_sprint": 4, "affects_tasks": ["T20"]},
+        {"id": "I12", "release_day": 36, "text": "Canary deployment must be validated before blue-green swap in sprint 6.", "target_sprint": 4, "affects_tasks": ["T19"]},
+        {"id": "I13", "release_day": 41, "text": "Data privacy compliance is now a legal requirement — must complete sprint 5.", "target_sprint": 5, "affects_tasks": ["T25"]},
+        {"id": "I14", "release_day": 44, "text": "Analytics dashboard needs real-time updates — scope increase noted.", "target_sprint": 5, "affects_tasks": ["T22"]},
+        {"id": "I15", "release_day": 48, "text": "SLA monitoring must include payment service endpoints.", "target_sprint": 5, "affects_tasks": ["T23"]},
+        {"id": "I16", "release_day": 51, "text": "Alice is on vacation days 52-54 — replan sprint 6 backend tasks.", "target_sprint": 6, "affects_tasks": ["T26"]},
+        {"id": "I17", "release_day": 53, "text": "Pen test results are back — two critical findings must be fixed before blue-green swap.", "target_sprint": 6, "affects_tasks": ["T26", "T28"]},
+        {"id": "I18", "release_day": 56, "text": "Stakeholder demo is on day 60 — runbooks and demo prep are release gates.", "target_sprint": 6, "affects_tasks": ["T29", "T30"]}
+      ]
+    },
+
+    "project_hard": {
+      "description": "Large team, cascading failures, urgent mid-project pivots, conflicting instructions, and hard delivery deadline with zero tolerance for missed dependencies.",
+      "difficulty": "hard",
+      "num_sprints": 6,
+      "days_per_sprint": 10,
+      "developers": [
+        {"id": "dev1", "name": "Alice",   "skill": "backend",   "capacity": 5, "productivity": 1.3},
+        {"id": "dev2", "name": "Bob",     "skill": "frontend",  "capacity": 4, "productivity": 0.8},
+        {"id": "dev3", "name": "Carol",   "skill": "devops",    "capacity": 5, "productivity": 1.0},
+        {"id": "dev4", "name": "Dave",    "skill": "fullstack", "capacity": 7, "productivity": 1.1},
+        {"id": "dev5", "name": "Eve",     "skill": "backend",   "capacity": 5, "productivity": 0.9},
+        {"id": "dev6", "name": "Frank",   "skill": "frontend",  "capacity": 4, "productivity": 1.0},
+        {"id": "dev7", "name": "Grace",   "skill": "devops",    "capacity": 5, "productivity": 1.1}
+      ],
+      "absences": [
+        {"dev_id": "dev2", "day_start": 12, "day_end": 15, "reason": "sick leave"},
+        {"dev_id": "dev5", "day_start": 23, "day_end": 26, "reason": "family emergency"},
+        {"dev_id": "dev4", "day_start": 33, "day_end": 37, "reason": "conference"},
+        {"dev_id": "dev1", "day_start": 51, "day_end": 55, "reason": "vacation"},
+        {"dev_id": "dev3", "day_start": 43, "day_end": 45, "reason": "sick leave"}
+      ],
+      "tasks": [
+        {"id": "T01", "name": "Auth & IAM Service",            "task_type": "feature",    "priority": 1, "effort": 6, "sprint": 1, "deadline_day": 7,  "required_skill": "backend",   "depends_on": []},
+        {"id": "T02", "name": "API Gateway + Rate Limiting",   "task_type": "feature",    "priority": 1, "effort": 5, "sprint": 1, "deadline_day": 8,  "required_skill": "fullstack", "depends_on": []},
+        {"id": "T03", "name": "Design System Setup",           "task_type": "feature",    "priority": 2, "effort": 4, "sprint": 1, "deadline_day": 9,  "required_skill": "frontend",  "depends_on": []},
+        {"id": "T04", "name": "Kubernetes + Helm Base",        "task_type": "feature",    "priority": 1, "effort": 6, "sprint": 1, "deadline_day": 9,  "required_skill": "devops",    "depends_on": []},
+        {"id": "T05", "name": "Core DB Schema & Seed Data",    "task_type": "feature",    "priority": 1, "effort": 4, "sprint": 1, "deadline_day": 8,  "required_skill": "backend",   "depends_on": []},
+        {"id": "T06", "name": "Service-to-Service Auth",       "task_type": "feature",    "priority": 1, "effort": 4, "sprint": 1, "deadline_day": 10, "required_skill": "fullstack", "depends_on": ["T01"]},
+        {"id": "T07", "name": "CI/CD Pipelines",               "task_type": "feature",    "priority": 2, "effort": 4, "sprint": 1, "deadline_day": 10, "required_skill": "devops",    "depends_on": []},
+
+        {"id": "T08", "name": "User Management API",           "task_type": "feature",    "priority": 1, "effort": 5, "sprint": 2, "deadline_day": 17, "required_skill": "backend",   "depends_on": ["T01", "T05"]},
+        {"id": "T09", "name": "User Management UI",            "task_type": "feature",    "priority": 1, "effort": 4, "sprint": 2, "deadline_day": 18, "required_skill": "frontend",  "depends_on": ["T03"]},
+        {"id": "T10", "name": "Istio Service Mesh",            "task_type": "feature",    "priority": 2, "effort": 6, "sprint": 2, "deadline_day": 20, "required_skill": "devops",    "depends_on": ["T04"]},
+        {"id": "T11", "name": "Event Bus (Kafka)",             "task_type": "feature",    "priority": 1, "effort": 6, "sprint": 2, "deadline_day": 19, "required_skill": "fullstack", "depends_on": ["T06"]},
+        {"id": "T12", "name": "Prod DB Failure — Hotfix",      "task_type": "urgent_bug", "priority": 1, "effort": 3, "sprint": 2, "deadline_day": 12, "required_skill": "backend",   "depends_on": []},
+        {"id": "T13", "name": "Payment Compliance Spike",      "task_type": "tech_debt",  "priority": 2, "effort": 3, "sprint": 2, "deadline_day": 20, "required_skill": "backend",   "depends_on": []},
+
+        {"id": "T14", "name": "Payment Gateway Service",       "task_type": "feature",    "priority": 1, "effort": 7, "sprint": 3, "deadline_day": 28, "required_skill": "backend",   "depends_on": ["T08", "T13"]},
+        {"id": "T15", "name": "Checkout UI — Multi-step",      "task_type": "feature",    "priority": 1, "effort": 6, "sprint": 3, "deadline_day": 29, "required_skill": "frontend",  "depends_on": ["T09"]},
+        {"id": "T16", "name": "Canary + Rollback Automation",  "task_type": "feature",    "priority": 2, "effort": 5, "sprint": 3, "deadline_day": 30, "required_skill": "devops",    "depends_on": ["T10"]},
+        {"id": "T17", "name": "Notification & Event Service",  "task_type": "feature",    "priority": 2, "effort": 5, "sprint": 3, "deadline_day": 29, "required_skill": "fullstack", "depends_on": ["T11"]},
+        {"id": "T18", "name": "Inventory & Orders API",        "task_type": "feature",    "priority": 1, "effort": 6, "sprint": 3, "deadline_day": 28, "required_skill": "backend",   "depends_on": ["T05"]},
+        {"id": "T19", "name": "Payment Security Audit",        "task_type": "bug",        "priority": 1, "effort": 3, "sprint": 3, "deadline_day": 27, "required_skill": "backend",   "depends_on": ["T14"]},
+
+        {"id": "T20", "name": "Order Management UI",           "task_type": "feature",    "priority": 1, "effort": 5, "sprint": 4, "deadline_day": 37, "required_skill": "frontend",  "depends_on": ["T15", "T18"]},
+        {"id": "T21", "name": "Fraud Detection Service",       "task_type": "feature",    "priority": 1, "effort": 6, "sprint": 4, "deadline_day": 38, "required_skill": "fullstack", "depends_on": ["T14", "T17"]},
+        {"id": "T22", "name": "Full-Text Search (ES)",         "task_type": "feature",    "priority": 2, "effort": 5, "sprint": 4, "deadline_day": 39, "required_skill": "backend",   "depends_on": ["T18"]},
+        {"id": "T23", "name": "Multi-Region Failover",         "task_type": "feature",    "priority": 2, "effort": 6, "sprint": 4, "deadline_day": 40, "required_skill": "devops",    "depends_on": ["T16"]},
+        {"id": "T24", "name": "Mid-Sprint Scope Pivot — Recs", "task_type": "feature",    "priority": 2, "effort": 5, "sprint": 4, "deadline_day": 39, "required_skill": "fullstack", "depends_on": []},
+        {"id": "T25", "name": "Payment Gateway Bug Surge",     "task_type": "urgent_bug", "priority": 1, "effort": 4, "sprint": 4, "deadline_day": 34, "required_skill": "backend",   "depends_on": []},
+
+        {"id": "T26", "name": "Reporting & BI API",            "task_type": "feature",    "priority": 2, "effort": 5, "sprint": 5, "deadline_day": 48, "required_skill": "backend",   "depends_on": ["T22"]},
+        {"id": "T27", "name": "Executive Dashboard UI",        "task_type": "feature",    "priority": 2, "effort": 5, "sprint": 5, "deadline_day": 49, "required_skill": "frontend",  "depends_on": ["T20"]},
+        {"id": "T28", "name": "SLO / SLA Monitoring",          "task_type": "tech_debt",  "priority": 2, "effort": 4, "sprint": 5, "deadline_day": 49, "required_skill": "devops",    "depends_on": ["T23"]},
+        {"id": "T29", "name": "Recommendation Engine v1",      "task_type": "feature",    "priority": 2, "effort": 6, "sprint": 5, "deadline_day": 50, "required_skill": "fullstack", "depends_on": ["T24"]},
+        {"id": "T30", "name": "GDPR / Data Privacy Pass",      "task_type": "tech_debt",  "priority": 1, "effort": 4, "sprint": 5, "deadline_day": 48, "required_skill": "backend",   "depends_on": []},
+        {"id": "T31", "name": "Mobile API Adaptation Layer",   "task_type": "feature",    "priority": 3, "effort": 4, "sprint": 5, "deadline_day": 50, "required_skill": "fullstack", "depends_on": ["T21"]},
+
+        {"id": "T32", "name": "Penetration Test & Fixes",      "task_type": "bug",        "priority": 1, "effort": 6, "sprint": 6, "deadline_day": 56, "required_skill": "backend",   "depends_on": ["T19", "T30"]},
+        {"id": "T33", "name": "Final UI QA & Accessibility",   "task_type": "bug",        "priority": 1, "effort": 4, "sprint": 6, "deadline_day": 58, "required_skill": "frontend",  "depends_on": ["T27"]},
+        {"id": "T34", "name": "Blue-Green Production Deploy",  "task_type": "feature",    "priority": 1, "effort": 5, "sprint": 6, "deadline_day": 60, "required_skill": "devops",    "depends_on": ["T28", "T32"]},
+        {"id": "T35", "name": "Fraud Rule Tuning",             "task_type": "tech_debt",  "priority": 2, "effort": 3, "sprint": 6, "deadline_day": 58, "required_skill": "fullstack", "depends_on": ["T21"]},
+        {"id": "T36", "name": "Runbooks & DR Documentation",   "task_type": "tech_debt",  "priority": 2, "effort": 3, "sprint": 6, "deadline_day": 59, "required_skill": "fullstack", "depends_on": []},
+        {"id": "T37", "name": "Stakeholder Demo & Handoff",    "task_type": "feature",    "priority": 1, "effort": 2, "sprint": 6, "deadline_day": 60, "required_skill": "fullstack", "depends_on": ["T33", "T35", "T36"]}
+      ],
+      "instructions": [
+        {"id": "I01", "release_day": 1,  "text": "Auth & IAM must be done before day 7 — it gates all other services.", "target_sprint": 1, "affects_tasks": ["T01"]},
+        {"id": "I02", "release_day": 2,  "text": "API gateway rate limiting is a launch requirement — not optional.", "target_sprint": 1, "affects_tasks": ["T02"]},
+        {"id": "I03", "release_day": 5,  "text": "Service-to-service auth must be validated in sprint 1 before Kafka work begins.", "target_sprint": 1, "affects_tasks": ["T06"]},
+        {"id": "I04", "release_day": 8,  "text": "Kubernetes must be ready for sprint 2 deployments — escalate any blockers.", "target_sprint": 1, "affects_tasks": ["T04"]},
+        {"id": "I05", "release_day": 11, "text": "Prod DB failure is P0 — assign Alice immediately, push T08 if needed.", "target_sprint": 2, "affects_tasks": ["T12"]},
+        {"id": "I06", "release_day": 12, "text": "Bob is on sick leave days 12-15 — redistribute T09 to Frank.", "target_sprint": 2, "affects_tasks": ["T09"]},
+        {"id": "I07", "release_day": 16, "text": "Kafka event bus is a hard dependency for notification service in sprint 3.", "target_sprint": 2, "affects_tasks": ["T11"]},
+        {"id": "I08", "release_day": 19, "text": "Payment compliance spike must close before sprint 3 payment work starts.", "target_sprint": 2, "affects_tasks": ["T13"]},
+        {"id": "I09", "release_day": 21, "text": "Payment gateway is the sprint 3 critical path — assign Eve and Alice.", "target_sprint": 3, "affects_tasks": ["T14"]},
+        {"id": "I10", "release_day": 23, "text": "Eve is out days 23-26 — replan sprint 3 backend with Alice carrying payment.", "target_sprint": 3, "affects_tasks": ["T14", "T18"]},
+        {"id": "I11", "release_day": 25, "text": "Payment security audit is a release gate — must pass before checkout UI is signed off.", "target_sprint": 3, "affects_tasks": ["T19"]},
+        {"id": "I12", "release_day": 28, "text": "Canary rollback automation must be validated before multi-region failover in sprint 4.", "target_sprint": 3, "affects_tasks": ["T16"]},
+        {"id": "I13", "release_day": 31, "text": "Fraud detection is now a sprint 4 commitment — do not descope.", "target_sprint": 4, "affects_tasks": ["T21"]},
+        {"id": "I14", "release_day": 33, "text": "Dave is at conference days 33-37 — all fullstack sprint 4 tasks need replan.", "target_sprint": 4, "affects_tasks": ["T21", "T24"]},
+        {"id": "I15", "release_day": 33, "text": "Payment bug surge T25 is P0 — assign best available backend dev.", "target_sprint": 4, "affects_tasks": ["T25"]},
+        {"id": "I16", "release_day": 36, "text": "Recommendation engine scope has been greenlit — T24 must ship in sprint 4.", "target_sprint": 4, "affects_tasks": ["T24"]},
+        {"id": "I17", "release_day": 39, "text": "Multi-region failover must be tested before sprint 6 production deploy.", "target_sprint": 4, "affects_tasks": ["T23"]},
+        {"id": "I18", "release_day": 41, "text": "GDPR pass is now a legal requirement — must complete in sprint 5 no exceptions.", "target_sprint": 5, "affects_tasks": ["T30"]},
+        {"id": "I19", "release_day": 43, "text": "Carol is sick days 43-45 — DevOps SLO monitoring may slip, flag risk.", "target_sprint": 5, "affects_tasks": ["T28"]},
+        {"id": "I20", "release_day": 45, "text": "Executive dashboard needs live data feed — scope increase, coordinate with backend.", "target_sprint": 5, "affects_tasks": ["T27", "T26"]},
+        {"id": "I21", "release_day": 47, "text": "Mobile API layer has been reprioritised by CPO — must not miss sprint 5.", "target_sprint": 5, "affects_tasks": ["T31"]},
+        {"id": "I22", "release_day": 51, "text": "Alice is on vacation days 51-55 — pen test fixes must be pre-assigned.", "target_sprint": 6, "affects_tasks": ["T32"]},
+        {"id": "I23", "release_day": 53, "text": "Pen test returned 3 critical CVEs — T32 scope has increased, adjust sprint 6 plan.", "target_sprint": 6, "affects_tasks": ["T32"]},
+        {"id": "I24", "release_day": 55, "text": "Blue-green deploy is hard-locked to day 60 — no rescheduling.", "target_sprint": 6, "affects_tasks": ["T34"]},
+        {"id": "I25", "release_day": 57, "text": "Stakeholder demo requires fraud rule tuning and runbooks to be complete first.", "target_sprint": 6, "affects_tasks": ["T35", "T36", "T37"]}
+      ]
+    }
+  }
+}

data/sprint_data.json

@@ -0,0 +1,65 @@
+{
+  "scenarios": {
+    "easy_sprint": {
+      "description": "Small team, clear tasks, no surprises. Good for baseline testing.",
+      "difficulty": "easy",
+      "developers": [
+        {"id": "dev1", "name": "Alice",  "skill": "backend",  "capacity": 5, "productivity": 1.2},
+        {"id": "dev2", "name": "Bob",    "skill": "frontend", "capacity": 4, "productivity": 1.0},
+        {"id": "dev3", "name": "Carol",  "skill": "fullstack","capacity": 6, "productivity": 1.1}
+      ],
+      "tasks": [
+        {"id": "T1", "name": "User Login API",        "task_type": "feature",    "priority": 2, "effort": 3, "deadline": 5,  "required_skill": "backend"},
+        {"id": "T2", "name": "Dashboard UI",          "task_type": "feature",    "priority": 2, "effort": 3, "deadline": 6,  "required_skill": "frontend"},
+        {"id": "T3", "name": "Fix CSS Layout Bug",    "task_type": "bug",        "priority": 1, "effort": 1, "deadline": 3,  "required_skill": "frontend"},
+        {"id": "T4", "name": "Database Migration",    "task_type": "feature",    "priority": 3, "effort": 4, "deadline": 7,  "required_skill": "backend"},
+        {"id": "T5", "name": "Setup CI/CD Pipeline",  "task_type": "feature",    "priority": 3, "effort": 3, "deadline": 8,  "required_skill": "devops"}
+      ]
+    },
+    "medium_sprint": {
+      "description": "Mid-size team with bugs and random dev absences.",
+      "difficulty": "medium",
+      "developers": [
+        {"id": "dev1", "name": "Alice", "skill": "backend",  "capacity": 5, "productivity": 1.1},
+        {"id": "dev2", "name": "Bob",   "skill": "frontend", "capacity": 4, "productivity": 0.9},
+        {"id": "dev3", "name": "Carol", "skill": "devops",   "capacity": 5, "productivity": 1.0},
+        {"id": "dev4", "name": "Dave",  "skill": "fullstack","capacity": 6, "productivity": 1.2}
+      ],
+      "tasks": [
+        {"id": "T1", "name": "Auth Service",           "task_type": "feature",    "priority": 1, "effort": 5, "deadline": 5, "required_skill": "backend"},
+        {"id": "T2", "name": "Profile Page UI",        "task_type": "feature",    "priority": 2, "effort": 4, "deadline": 6, "required_skill": "frontend"},
+        {"id": "T3", "name": "Payment Integration",    "task_type": "feature",    "priority": 1, "effort": 6, "deadline": 7, "required_skill": "backend"},
+        {"id": "T4", "name": "Docker Deployment",      "task_type": "feature",    "priority": 2, "effort": 3, "deadline": 5, "required_skill": "devops"},
+        {"id": "T5", "name": "Login Page",             "task_type": "feature",    "priority": 2, "effort": 3, "deadline": 5, "required_skill": "frontend"},
+        {"id": "T6", "name": "Prod DB Crash Fix",      "task_type": "bug",        "priority": 1, "effort": 2, "deadline": 3, "required_skill": "backend"},
+        {"id": "T7", "name": "API Rate Limiting",      "task_type": "tech_debt",  "priority": 4, "effort": 3, "deadline": 9, "required_skill": "backend"},
+        {"id": "T8", "name": "Mobile Layout Fix",      "task_type": "bug",        "priority": 2, "effort": 2, "deadline": 4, "required_skill": "frontend"}
+      ]
+    },
+    "hard_sprint": {
+      "description": "Large team, many tasks, urgent bugs appear mid-sprint, dev absences cascade.",
+      "difficulty": "hard",
+      "developers": [
+        {"id": "dev1", "name": "Alice", "skill": "backend",  "capacity": 5, "productivity": 1.3},
+        {"id": "dev2", "name": "Bob",   "skill": "frontend", "capacity": 4, "productivity": 0.8},
+        {"id": "dev3", "name": "Carol", "skill": "devops",   "capacity": 5, "productivity": 1.0},
+        {"id": "dev4", "name": "Dave",  "skill": "fullstack","capacity": 7, "productivity": 1.1},
+        {"id": "dev5", "name": "Eve",   "skill": "backend",  "capacity": 5, "productivity": 0.9}
+      ],
+      "tasks": [
+        {"id": "T1",  "name": "Microservices Refactor",    "task_type": "feature",     "priority": 1, "effort": 8, "deadline": 5, "required_skill": "backend"},
+        {"id": "T2",  "name": "Real-time Notifications",   "task_type": "feature",     "priority": 1, "effort": 6, "deadline": 5, "required_skill": "fullstack"},
+        {"id": "T3",  "name": "Security Audit Fixes",      "task_type": "bug",         "priority": 1, "effort": 5, "deadline": 4, "required_skill": "backend"},
+        {"id": "T4",  "name": "Kubernetes Migration",      "task_type": "feature",     "priority": 2, "effort": 7, "deadline": 6, "required_skill": "devops"},
+        {"id": "T5",  "name": "Homepage Redesign",         "task_type": "feature",     "priority": 2, "effort": 5, "deadline": 6, "required_skill": "frontend"},
+        {"id": "T6",  "name": "Payment Gateway Bug",       "task_type": "urgent_bug",  "priority": 1, "effort": 3, "deadline": 3, "required_skill": "backend"},
+        {"id": "T7",  "name": "Search Performance",        "task_type": "tech_debt",   "priority": 3, "effort": 4, "deadline": 7, "required_skill": "backend"},
+        {"id": "T8",  "name": "A/B Testing Framework",     "task_type": "feature",     "priority": 3, "effort": 5, "deadline": 8, "required_skill": "fullstack"},
+        {"id": "T9",  "name": "CDN Integration",           "task_type": "feature",     "priority": 3, "effort": 3, "deadline": 7, "required_skill": "devops"},
+        {"id": "T10", "name": "OAuth2 Provider",           "task_type": "feature",     "priority": 2, "effort": 6, "deadline": 6, "required_skill": "backend"},
+        {"id": "T11", "name": "Analytics Dashboard",       "task_type": "feature",     "priority": 3, "effort": 5, "deadline": 8, "required_skill": "fullstack"},
+        {"id": "T12", "name": "Accessibility Audit",       "task_type": "tech_debt",   "priority": 4, "effort": 3, "deadline": 9, "required_skill": "frontend"}
+      ]
+    }
+  }
+}

evaluate.py

@@ -0,0 +1,203 @@
+"""
+evaluate.py — Compare baseline vs trained RL policy
+=====================================================
+Run after train.py completes.
+"""
+from __future__ import annotations
+import os
+import json
+import requests
+from openai import OpenAI
+from dotenv import load_dotenv
+
+load_dotenv()
+
+ENV_URL        = os.getenv("ENV_BASE_URL", "https://sejal-k-ai-sprint-manager.hf.space")
+BASELINE_MODEL = os.getenv("MODEL_NAME", "meta-llama/Llama-3.1-8B-Instruct")
+API_BASE_URL   = os.getenv("API_BASE_URL", "https://router.huggingface.co/v1")
+API_KEY        = os.getenv("HF_TOKEN", "dummy")
+POLICY_PATH    = "./results/best_policy.json"
+TASKS          = ["easy_sprint", "medium_sprint", "hard_sprint"]
+N_SEEDS        = 5
+
+SYSTEM = """You are a Tech Lead. Output ONLY JSON.
+{"action_type": "assign", "task_id": "T1", "dev_id": "dev1", "new_priority": null}
+Only assign backlog tasks to available skill-matched developers."""
+
+
+# ── Shared helpers ────────────────────────────────────────────────────────────
+
+def env_reset(task_name, seed=42):
+    r = requests.post(f"{ENV_URL}/reset",
+                      json={"task_name": task_name, "seed": seed}, timeout=30)
+    r.raise_for_status()
+    return r.json()
+
+def env_step(action):
+    r = requests.post(f"{ENV_URL}/step", json={"action": {
+        "action_type":  action.get("action_type", "skip"),
+        "task_id":      action.get("task_id"),
+        "dev_id":       action.get("dev_id"),
+        "new_priority": action.get("new_priority"),
+    }}, timeout=30)
+    r.raise_for_status()
+    return r.json()
+
+def run_episode(act_fn, task_name, seed=42):
+    obs    = env_reset(task_name, seed)
+    result = {"info": {}}
+    for _ in range(12):
+        if obs.get("done"):
+            break
+        action = act_fn(obs)
+        result = env_step(action)
+        obs    = result["observation"]
+    return max(0.01, min(0.99, result.get("info", {}).get("final_score", 0.01)))
+
+def evaluate(act_fn, name):
+    print(f"\n  {name}")
+    print(f"  {'─'*45}")
+    scores = {}
+    for task in TASKS:
+        vals = []
+        for seed in range(N_SEEDS):
+            try:
+                vals.append(run_episode(act_fn, task, seed=seed*13+42))
+            except Exception:
+                vals.append(0.01)
+        avg = sum(vals) / len(vals)
+        scores[task] = round(avg, 4)
+        bar = "█" * int(avg * 20)
+        print(f"  {task:<20} {avg:.4f}  {bar}")
+    overall = sum(scores.values()) / len(scores)
+    scores["average"] = round(overall, 4)
+    print(f"  {'AVERAGE':<20} {overall:.4f}")
+    return scores
+
+
+# ── Trained policy agent ──────────────────────────────────────────────────────
+
+class TrainedPolicy:
+    def __init__(self, path):
+        with open(path) as f:
+            w = json.load(f)
+        self.priority_weight = w["priority_weight"]
+        self.deadline_weight = w["deadline_weight"]
+        self.skill_weight    = w["skill_weight"]
+        self.load_weight     = w["load_weight"]
+
+    def act(self, obs):
+        day     = obs.get("current_day", 1)
+        backlog = [t for t in obs["tasks"] if t["status"] == "backlog"]
+        avail   = [d for d in obs["developers"]
+                   if d["is_available"] and d["current_load"] < d["capacity"]]
+        if not backlog or not avail:
+            return {"action_type": "skip", "task_id": None,
+                    "dev_id": None, "new_priority": None}
+
+        best, bt, bd = float("-inf"), None, None
+        for t in backlog:
+            for d in avail:
+                s  = self.priority_weight * (6 - t["priority"])
+                s += self.deadline_weight * (10 / max(1, t["deadline"] - day))
+                if d["skill"] == t["required_skill"]:
+                    s += self.skill_weight * 3
+                elif d["skill"] == "fullstack":
+                    s += self.skill_weight * 2
+                else:
+                    s -= self.skill_weight * 2
+                s -= self.load_weight * (d["current_load"] / max(d["capacity"], 1)) * 2
+                if s > best:
+                    best, bt, bd = s, t, d
+        if bt and bd:
+            return {"action_type": "assign", "task_id": bt["id"],
+                    "dev_id": bd["id"], "new_priority": None}
+        return {"action_type": "skip", "task_id": None,
+                "dev_id": None, "new_priority": None}
+
+
+# ── Baseline LLM agent ────────────────────────────────────────────────────────
+
+def make_baseline_act():
+    client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
+
+    def act(obs):
+        backlog = sorted([t for t in obs["tasks"] if t["status"] == "backlog"],
+                         key=lambda t: (t["priority"], t["deadline"]))
+        avail   = [d for d in obs["developers"]
+                   if d["is_available"] and d["current_load"] < d["capacity"]]
+        prompt  = (
+            f"Day {obs['current_day']}/{obs['sprint_length']}\n"
+            f"Backlog: {[t['id']+':'+t['required_skill'] for t in backlog[:4]]}\n"
+            f"Devs: {[d['id']+':'+d['skill'] for d in avail]}\n"
+            f"JSON action:"
+        )
+        try:
+            resp = client.chat.completions.create(
+                model=BASELINE_MODEL,
+                messages=[
+                    {"role": "system", "content": SYSTEM},
+                    {"role": "user",   "content": prompt},
+                ],
+                temperature=0.1, max_tokens=80,
+            )
+            text = resp.choices[0].message.content or ""
+            a = json.loads(text.strip())
+            if a.get("action_type") in ("assign","reassign","skip","unblock"):
+                return a
+        except Exception:
+            pass
+        return {"action_type": "skip", "task_id": None,
+                "dev_id": None, "new_priority": None}
+    return act
+
+
+# ── Main ──────────────────────────────────────────────────────────────────────
+
+def main():
+    try:
+        r = requests.get(f"{ENV_URL}/health", timeout=10)
+        print(f"Server: {r.json()}")
+    except Exception:
+        print("ERROR: Start server first: python ui.py")
+        return
+
+    print("\n" + "="*55)
+    print("  EVALUATION: Baseline vs Trained RL Policy")
+    print("="*55)
+
+    results = {}
+
+    # Baseline
+    results["baseline"] = evaluate(make_baseline_act(), f"Baseline LLM ({BASELINE_MODEL})")
+
+    # Trained policy
+    if os.path.exists(POLICY_PATH):
+        policy = TrainedPolicy(POLICY_PATH)
+        results["trained"] = evaluate(policy.act, f"Trained RL Policy ({POLICY_PATH})")
+
+        # Comparison table
+        print(f"\n{'='*55}")
+        print("  IMPROVEMENT SUMMARY")
+        print(f"{'='*55}")
+        print(f"  {'Task':<20} {'Baseline':>10} {'Trained':>10} {'Delta':>10}")
+        print(f"  {'─'*48}")
+        for task in TASKS + ["average"]:
+            b     = results["baseline"].get(task, 0)
+            t     = results["trained"].get(task, 0)
+            delta = t - b
+            sign  = "+" if delta >= 0 else ""
+            print(f"  {task:<20} {b:>10.4f} {t:>10.4f} {sign}{delta:>9.4f}")
+    else:
+        print(f"\n  No trained policy at {POLICY_PATH}")
+        print("  Run python train.py first.")
+
+    # Save
+    os.makedirs("results", exist_ok=True)
+    with open("results/evaluation.json", "w") as f:
+        json.dump(results, f, indent=2)
+    print(f"\n  Saved → results/evaluation.json")
+
+
+if __name__ == "__main__":
+    main()

evaluate_r2.py

@@ -0,0 +1,457 @@
+"""
+evaluate_r2.py — Round 2 Evaluation Script
+============================================
+Compares baseline (rule-based) vs trained LLM on both R1 and R2 tasks.
+Produces the before/after improvement table judges want to see.
+Saves results to results/r2_evaluation.json.
+
+Usage:
+    # Baseline only (rule-based, no model needed):
+    python evaluate_r2.py --baseline-only
+
+    # Full comparison (trained model vs baseline):
+    python evaluate_r2.py --model results/trained_model
+
+    # Quick 1-episode-per-task run:
+    python evaluate_r2.py --model results/trained_model --episodes 1
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import time
+from pathlib import Path
+
+import requests
+
+ENV_BASE_URL = os.getenv("ENV_BASE_URL", "https://sejal-k-ai-sprint-manager.hf.space")
+HF_TOKEN     = os.getenv("HF_TOKEN", "")
+API_BASE_URL = os.getenv("API_BASE_URL", "https://router.huggingface.co/v1")
+# NOTE: MODEL_NAME here is for INFERENCE comparison only.
+# For TRAINING, use Qwen/Qwen2.5-1.5B-Instruct (loaded locally in train_llm.py).
+MODEL_NAME   = os.getenv("MODEL_NAME", "Qwen/Qwen2.5-1.5B-Instruct")
+
+RESULTS_DIR = Path("results")
+RESULTS_DIR.mkdir(exist_ok=True)
+
+R1_TASKS = ["easy_sprint", "medium_sprint", "hard_sprint"]
+R2_TASKS = ["project_easy", "project_medium", "project_hard"]
+
+# ── Measured baselines (FINAL — do not change) ────────────────────────────────
+# R1: Llama-3.1-8B zero-shot inference (inference.py), measured 2025-01
+LLAMA_BASELINE_R1 = {
+    "easy_sprint":   0.0100,
+    "medium_sprint": 0.4583,
+    "hard_sprint":   0.0100,
+    "average":       0.1594,
+}
+
+# R2: Llama-3.1-8B zero-shot inference (inference_r2.py), measured 2025-01
+LLAMA_BASELINE_R2 = {
+    "project_easy":   0.3198,
+    "project_medium": 0.2443,
+    "project_hard":   0.2520,
+    "average":        0.2720,
+}
+
+# Training model: Qwen/Qwen2.5-1.5B-Instruct (GRPO, local 4-bit QLoRA)
+TRAINING_MODEL = "Qwen/Qwen2.5-1.5B-Instruct"
+
+
+# ── Rule-based policies ───────────────────────────────────────────────────────
+
+def rule_based_r1(obs: dict) -> dict:
+    tasks  = obs.get("tasks", [])
+    devs   = obs.get("developers", [])
+    avail  = [d for d in devs if d["is_available"] and d["current_load"] < d["capacity"]]
+    backlog = sorted([t for t in tasks if t["status"] == "backlog"],
+                     key=lambda t: (t["priority"], t["deadline"]))
+    for task in backlog:
+        match = [d for d in avail if d["skill"] == task.get("required_skill") or d["skill"] == "fullstack"]
+        dev = match[0] if match else (avail[0] if avail else None)
+        if dev:
+            return {"action_type": "assign", "task_id": task["id"],
+                    "dev_id": dev["id"], "new_priority": None}
+    return {"action_type": "skip", "task_id": None, "dev_id": None, "new_priority": None}
+
+
+def rule_based_r2(obs: dict) -> dict:
+    tasks    = obs.get("tasks", [])
+    devs     = obs.get("developers", [])
+    done_ids = {t["id"] for t in tasks if t["status"] == "done"}
+    avail    = [d for d in devs if d["is_available"] and d["current_load"] < d["capacity"] * 2]
+
+    def best_dev(task):
+        m = [d for d in avail if d["skill"] == task.get("required_skill") or d["skill"] == "fullstack"]
+        return m[0] if m else (avail[0] if avail else None)
+
+    for inst in [i for i in obs.get("instruction_queue", []) if not i.get("followed", False)]:
+        for tid in inst.get("affects_tasks", []):
+            t = next((t for t in tasks if t["id"] == tid and t["status"] == "backlog"), None)
+            if t and all(d in done_ids for d in t.get("metadata", {}).get("depends_on", [])):
+                dev = best_dev(t)
+                if dev:
+                    return {"action_type": "assign", "task_id": t["id"],
+                            "dev_id": dev["id"], "new_priority": None}
+
+    backlog = sorted([t for t in tasks if t["status"] == "backlog"],
+                     key=lambda t: (t["priority"], t["deadline"]))
+    for t in backlog:
+        if all(d in done_ids for d in t.get("metadata", {}).get("depends_on", [])):
+            dev = best_dev(t)
+            if dev:
+                return {"action_type": "assign", "task_id": t["id"],
+                        "dev_id": dev["id"], "new_priority": None}
+
+    return {"action_type": "skip", "task_id": None, "dev_id": None, "new_priority": None}
+
+
+# ── Score calculators ─────────────────────────────────────────────────────────
+
+def score_r1_obs(obs: dict) -> float:
+    """Extract R1 final score from terminal observation."""
+    done   = sum(1 for t in obs.get("tasks", []) if t["status"] == "done")
+    total  = len(obs.get("tasks", [])) or 1
+    missed = sum(1 for t in obs.get("tasks", []) if t["status"] == "missed")
+    raw    = done / total - missed / total * 0.3
+    return round(max(0.01, min(0.99, raw)), 4)
+
+
+def score_r2_obs(obs: dict) -> float:
+    """Compute R2 project score from terminal observation.
+    Formula: delivery×0.55 + instruction_following×0.30 + team_health×0.15
+    """
+    tasks_total   = len(obs.get("tasks", [])) or 1
+    tasks_done    = obs.get("tasks_completed", 0)
+    inst_score    = obs.get("instruction_following_score", 0.01)
+    delivery_rate = tasks_done / tasks_total
+    debt_count    = len(obs.get("tech_debt", []))
+    team_health   = max(0.01, 1.0 - debt_count * 0.02)
+    raw = delivery_rate * 0.55 + inst_score * 0.30 + team_health * 0.15
+    return round(max(0.01, min(0.99, raw)), 4)
+
+
+# ── Episode runners ───────────────────────────────────────────────────────────
+
+def run_r1_episode(r1_client, task_name: str, policy_fn) -> dict:
+    """Run one R1 episode. Calls /step directly as dict to avoid model_dump() issue."""
+    import requests as _req
+    obs = r1_client.reset(task_name=task_name, seed=42)
+    rewards, actions = [], []
+    base_url = r1_client.base_url
+    for _ in range(12):
+        if obs.get("done", False):
+            break
+        action = policy_fn(obs)
+        resp = _req.post(f"{base_url}/step", json={"action": action}, timeout=30)
+        resp.raise_for_status()
+        result = resp.json()
+        obs = result["observation"]
+        rewards.append(result["reward"])
+        actions.append(action["action_type"])
+        if result["done"]:
+            break
+    return {
+        "task":              task_name,
+        "score":             score_r1_obs(obs),
+        "cumulative_reward": round(sum(rewards), 4),
+        "steps":             len(rewards),
+        "tasks_completed":   obs.get("tasks_completed", 0),
+        "tasks_missed":      obs.get("tasks_missed", 0),
+        "action_breakdown":  {a: actions.count(a) for a in set(actions)},
+    }
+
+
+def run_r2_episode(r2_client, task_name: str, policy_fn) -> dict:
+    obs = r2_client.reset(task_name=task_name, seed=42)
+    rewards, actions, sprint_rewards = [], [], []
+    for _ in range(60):
+        if obs.get("done", False):
+            break
+        action = policy_fn(obs)
+        result = r2_client.step(action)
+        obs    = result.observation if hasattr(result, "observation") else result["observation"]
+        rew    = result.reward      if hasattr(result, "reward")      else result["reward"]
+        done   = result.done        if hasattr(result, "done")         else result["done"]
+        rewards.append(rew)
+        actions.append(action["action_type"])
+        sprint_rewards = obs.get("sprint_rewards", [])
+        if done:
+            break
+    return {
+        "task":                       task_name,
+        "score":                      score_r2_obs(obs),
+        "cumulative_reward":          round(sum(rewards), 4),
+        "steps":                      len(rewards),
+        "tasks_completed":            obs.get("tasks_completed", 0),
+        "tasks_missed":               obs.get("tasks_missed", 0),
+        "instruction_following_score": obs.get("instruction_following_score", 0.0),
+        "tech_debt_count":            len(obs.get("tech_debt", [])),
+        "sprint_rewards":             sprint_rewards,
+        "action_breakdown":           {a: actions.count(a) for a in set(actions)},
+    }
+
+
+# ── LLM policy builders ───────────────────────────────────────────────────────
+
+def _build_api_policy(model_id: str, system_prompt: str):
+    """Build an LLM policy that calls the HF router API."""
+    from openai import OpenAI
+    client = OpenAI(api_key=HF_TOKEN, base_url=API_BASE_URL)
+
+    def policy(obs: dict) -> dict:
+        import json as _json
+        user_msg = f"Current state:\n{_json.dumps(obs, indent=2)}\nOutput JSON action only."
+        try:
+            resp = client.chat.completions.create(
+                model=model_id,
+                messages=[{"role": "system", "content": system_prompt},
+                          {"role": "user",   "content": user_msg}],
+                max_tokens=60,
+                temperature=0.1,
+            )
+            raw = resp.choices[0].message.content.strip()
+            start = raw.find("{")
+            end   = raw.rfind("}") + 1
+            if start >= 0 and end > start:
+                return _json.loads(raw[start:end])
+        except Exception:
+            pass
+        return {"action_type": "skip", "task_id": None, "dev_id": None, "new_priority": None}
+
+    return policy
+
+
+def build_llm_policy(model_path: str, system_prompt: str):
+    """Build R2 LLM policy — tries local model first, falls back to API."""
+    # Try local model (after training)
+    local_path = Path(model_path)
+    if local_path.exists():
+        try:
+            from transformers import AutoModelForCausalLM, AutoTokenizer
+            import torch, json as _json
+            tokenizer = AutoTokenizer.from_pretrained(str(local_path))
+            model = AutoModelForCausalLM.from_pretrained(
+                str(local_path), torch_dtype=torch.float16, device_map="auto"
+            )
+            print(f"[INFO] Loaded local model from {local_path}", flush=True)
+
+            def local_policy(obs: dict) -> dict:
+                prompt = f"{system_prompt}\n\nState:\n{_json.dumps(obs)}\nAction:"
+                inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+                with torch.no_grad():
+                    outputs = model.generate(**inputs, max_new_tokens=60, temperature=0.1, do_sample=True)
+                raw = tokenizer.decode(outputs[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True)
+                try:
+                    start = raw.find("{"); end = raw.rfind("}") + 1
+                    if start >= 0 and end > start:
+                        return _json.loads(raw[start:end])
+                except Exception:
+                    pass
+                return {"action_type": "skip", "task_id": None, "dev_id": None, "new_priority": None}
+
+            return local_policy
+        except Exception as e:
+            print(f"[WARN] Could not load local model: {e}", flush=True)
+
+    # Fall back to HF API (model_path is an HF model ID like "sejal-k/ai-sprint-manager-trained")
+    print(f"[INFO] Using HF API for model {model_path}", flush=True)
+    return _build_api_policy(model_path, system_prompt)
+
+
+# ── Main evaluation ───────────────────────────────────────────────────────────
+
+def evaluate(model_path: str | None = None, n_episodes: int = 3, baseline_only: bool = False):
+    from client import SprintEnvClient
+    from project_client import ProjectEnvClient
+
+    print(f"\n{'='*60}", flush=True)
+    print(f" AI Sprint Manager — Evaluation", flush=True)
+    print(f" Env:   {ENV_BASE_URL}", flush=True)
+    print(f" Model: {model_path or 'rule-based only'}", flush=True)
+    print(f" Training model: {TRAINING_MODEL}", flush=True)
+    print(f"{'='*60}", flush=True)
+
+    # Health check
+    try:
+        r = requests.get(f"{ENV_BASE_URL}/health", timeout=10)
+        r.raise_for_status()
+        r2 = requests.get(f"{ENV_BASE_URL}/project/health", timeout=10)
+        r2.raise_for_status()
+        print(f"[OK] Environment is live", flush=True)
+    except Exception as e:
+        print(f"[ERROR] Server unreachable: {e}", flush=True)
+        sys.exit(1)
+
+    results = {
+        "metadata": {
+            "timestamp":       time.strftime("%Y-%m-%d %H:%M:%S"),
+            "model":           model_path or "rule-based",
+            "training_model":  TRAINING_MODEL,
+            "env_url":         ENV_BASE_URL,
+            "n_episodes":      n_episodes,
+            "baseline_only":   baseline_only,
+        },
+        # Measured Llama-3.1-8B zero-shot baselines (FINAL)
+        "r1_llama_baseline": LLAMA_BASELINE_R1,
+        "r2_llama_baseline": LLAMA_BASELINE_R2,
+        # Live run results
+        "r1_rule_based": {},
+        "r1_llm":        {},
+        "r2_rule_based": {},
+        "r2_llm":        {},
+        "improvement":   {},
+    }
+
+    r1_client = SprintEnvClient(base_url=ENV_BASE_URL)
+    r2_client = ProjectEnvClient(base_url=ENV_BASE_URL)
+
+    # ── R1 rule-based baseline ────────────────────────────────────────────────
+    print(f"\n{'─'*55}", flush=True)
+    print(f" R1 — Rule-based baseline", flush=True)
+    print(f"{'─'*55}", flush=True)
+    for task in R1_TASKS:
+        ep_results = []
+        for ep in range(n_episodes):
+            r = run_r1_episode(r1_client, task, rule_based_r1)
+            ep_results.append(r)
+            print(f"  {task} ep{ep+1}: score={r['score']:.4f} "
+                  f"done={r['tasks_completed']} reward={r['cumulative_reward']:.2f}", flush=True)
+        avg_score = sum(r["score"] for r in ep_results) / n_episodes
+        results["r1_rule_based"][task] = {
+            "avg_score": round(avg_score, 4),
+            "episodes":  ep_results,
+        }
+
+    if not baseline_only and model_path:
+        from inference_r2 import R2_SYSTEM_PROMPT
+
+        R1_SYSTEM_PROMPT = (
+            "You are an expert Tech Lead managing an agile sprint. "
+            "Output a JSON action: {\"action_type\":\"<assign|reassign|reprioritize|unblock|skip>\","
+            "\"task_id\":\"<id or null>\",\"dev_id\":\"<id or null>\",\"new_priority\":<1-5 or null>}. "
+            "Only output JSON. Assign backlog tasks to available developers, skill match preferred."
+        )
+
+        llm_r1_policy = _build_api_policy(model_path, R1_SYSTEM_PROMPT)
+        llm_r2_policy = build_llm_policy(model_path, R2_SYSTEM_PROMPT)
+
+        # ── R1 LLM ───────────────────────────────────────────────────────────
+        print(f"\n{'─'*55}", flush=True)
+        print(f" R1 — LLM ({model_path})", flush=True)
+        print(f"{'─'*55}", flush=True)
+        for task in R1_TASKS:
+            ep_results = []
+            for ep in range(n_episodes):
+                r = run_r1_episode(r1_client, task, llm_r1_policy)
+                ep_results.append(r)
+                print(f"  {task} ep{ep+1}: score={r['score']:.4f}", flush=True)
+            avg_score = sum(r["score"] for r in ep_results) / n_episodes
+            results["r1_llm"][task] = {
+                "avg_score": round(avg_score, 4),
+                "episodes":  ep_results,
+            }
+
+        # ── R2 LLM ───────────────────────────────────────────────────────────
+        print(f"\n{'─'*55}", flush=True)
+        print(f" R2 — LLM ({model_path})", flush=True)
+        print(f"{'─'*55}", flush=True)
+        for task in R2_TASKS:
+            ep_results = []
+            for ep in range(n_episodes):
+                r = run_r2_episode(r2_client, task, llm_r2_policy)
+                ep_results.append(r)
+                print(f"  {task} ep{ep+1}: score={r['score']:.4f} "
+                      f"inst={r['instruction_following_score']:.2f}", flush=True)
+            avg_score = sum(r["score"] for r in ep_results) / n_episodes
+            results["r2_llm"][task] = {
+                "avg_score": round(avg_score, 4),
+                "episodes":  ep_results,
+            }
+
+        # ── Improvement table ─────────────────────────────────────────────────
+        for task in R2_TASKS:
+            base_llama = LLAMA_BASELINE_R2.get(task, 0)
+            llm        = results["r2_llm"].get(task, {}).get("avg_score", base_llama)
+            delta_vs_llama = round(llm - base_llama, 4)
+            results["improvement"][task] = {
+                "llama_baseline":    base_llama,
+                "trained_llm":       llm,
+                "delta_vs_llama":    delta_vs_llama,
+                "pct_gain_vs_llama": round(delta_vs_llama / max(base_llama, 0.01) * 100, 1),
+            }
+
+    r1_client.close()
+    r2_client.close()
+
+    _print_summary(results, baseline_only)
+
+    out_path = RESULTS_DIR / "r2_evaluation.json"
+    with open(out_path, "w") as f:
+        json.dump(results, f, indent=2)
+    print(f"\n[INFO] Results saved to {out_path}", flush=True)
+    return results
+
+
+def _print_summary(results: dict, baseline_only: bool):
+    print(f"\n{'='*65}", flush=True)
+    print(f" EVALUATION SUMMARY", flush=True)
+    print(f"{'='*65}", flush=True)
+
+    print(f"\n{'R1 SCORES (Llama-3.1-8B zero-shot — measured baseline)':─<65}", flush=True)
+    print(f"  {'Task':<22} {'Llama Baseline':>15} {'LLM Trained':>12}", flush=True)
+    for task in ["easy_sprint", "medium_sprint", "hard_sprint"]:
+        llama = results["r1_llama_baseline"].get(task, 0)
+        llm   = results["r1_llm"].get(task, {}).get("avg_score", 0)
+        llm_s = f"{llm:.4f}" if llm else "—"
+        print(f"  {task:<22} {llama:>15.4f} {llm_s:>12}", flush=True)
+    avg = results["r1_llama_baseline"].get("average", 0)
+    print(f"  {'AVERAGE':<22} {avg:>15.4f}", flush=True)
+
+    print(f"\n{'R2 SCORES':─<65}", flush=True)
+    print(f"  {'Task':<22} {'Llama Baseline':>15} {'LLM Trained':>12} {'Δ vs Llama':>10}", flush=True)
+    for task in ["project_easy", "project_medium", "project_hard"]:
+        llama = results["r2_llama_baseline"].get(task, 0)
+        llm   = results["r2_llm"].get(task, {}).get("avg_score", 0)
+        imp   = results["improvement"].get(task, {})
+        delta = imp.get("delta_vs_llama", 0)
+        llm_s   = f"{llm:.4f}" if llm else "—"
+        delta_s = f"+{delta:.4f}" if delta > 0 else (f"{delta:.4f}" if delta else "—")
+        print(f"  {task:<22} {llama:>15.4f} {llm_s:>12} {delta_s:>10}", flush=True)
+    avg_r2 = results["r2_llama_baseline"].get("average", 0)
+    print(f"  {'AVERAGE':<22} {avg_r2:>15.4f}", flush=True)
+
+    print(f"\n{'='*65}", flush=True)
+    print(f"  Training model: Qwen/Qwen2.5-1.5B-Instruct (GRPO, 4-bit QLoRA)", flush=True)
+    print(f"  Baselines: Llama-3.1-8B zero-shot (via HF Router)", flush=True)
+    print(f"{'='*65}", flush=True)
+
+
+# ── CLI ───────────────────────────────────────────────────────────────────────
+
+def main():
+    parser = argparse.ArgumentParser(description="Evaluate R1+R2 before/after training")
+    parser.add_argument("--model",         type=str, default=None,
+                        help="Path to trained model dir or HF model ID")
+    parser.add_argument("--baseline-only", action="store_true",
+                        help="Run rule-based baseline only (no model needed)")
+    parser.add_argument("--episodes",      type=int, default=3,
+                        help="Episodes per task (default: 3)")
+    args = parser.parse_args()
+
+    if not args.baseline_only and not args.model:
+        print("[INFO] No --model specified. Running baseline-only evaluation.", flush=True)
+        args.baseline_only = True
+
+    evaluate(
+        model_path=args.model,
+        n_episodes=args.episodes,
+        baseline_only=args.baseline_only,
+    )
+
+
+if __name__ == "__main__":
+    main()

huggingface_tokenizers_cache/CACHEDIR.TAG

@@ -0,0 +1,4 @@
+Signature: 8a477f597d28d172789f06886806bc55
+# This file is a cache directory tag created by huggingface_hub.
+# For information about cache directory tags, see:
+#	https://bford.info/cachedir/

huggingface_tokenizers_cache/models--unsloth--qwen2.5-1.5b-instruct-unsloth-bnb-4bit/blobs/482ced4679301bf287ebb310bdd1790eb4514232

@@ -0,0 +1,24 @@
+{
+  "</tool_call>": 151658,
+  "<tool_call>": 151657,
+  "<|box_end|>": 151649,
+  "<|box_start|>": 151648,
+  "<|endoftext|>": 151643,
+  "<|file_sep|>": 151664,
+  "<|fim_middle|>": 151660,
+  "<|fim_pad|>": 151662,
+  "<|fim_prefix|>": 151659,
+  "<|fim_suffix|>": 151661,
+  "<|im_end|>": 151645,
+  "<|im_start|>": 151644,
+  "<|image_pad|>": 151655,
+  "<|object_ref_end|>": 151647,
+  "<|object_ref_start|>": 151646,
+  "<|quad_end|>": 151651,
+  "<|quad_start|>": 151650,
+  "<|repo_name|>": 151663,
+  "<|video_pad|>": 151656,
+  "<|vision_end|>": 151653,
+  "<|vision_pad|>": 151654,
+  "<|vision_start|>": 151652
+}

huggingface_tokenizers_cache/models--unsloth--qwen2.5-1.5b-instruct-unsloth-bnb-4bit/blobs/76ac30de06e0158be805f42a4e63934bedb5a169

@@ -0,0 +1,58 @@
+{
+  "_name_or_path": "Qwen/Qwen2.5-1.5B-Instruct",
+  "architectures": [
+    "Qwen2ForCausalLM"
+  ],
+  "attention_dropout": 0.0,
+  "eos_token_id": 151645,
+  "hidden_act": "silu",
+  "hidden_size": 1536,
+  "initializer_range": 0.02,
+  "intermediate_size": 8960,
+  "max_position_embeddings": 32768,
+  "max_window_layers": 21,
+  "model_type": "qwen2",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 28,
+  "num_key_value_heads": 2,
+  "pad_token_id": 151654,
+  "quantization_config": {
+    "_load_in_4bit": true,
+    "_load_in_8bit": false,
+    "bnb_4bit_compute_dtype": "bfloat16",
+    "bnb_4bit_quant_storage": "uint8",
+    "bnb_4bit_quant_type": "nf4",
+    "bnb_4bit_use_double_quant": true,
+    "llm_int8_enable_fp32_cpu_offload": false,
+    "llm_int8_has_fp16_weight": false,
+    "llm_int8_skip_modules": [
+      "lm_head",
+      "multi_modal_projector",
+      "merger",
+      "modality_projection",
+      "model.layers.0.self_attn",
+      "model.layers.1.mlp",
+      "model.layers.2.mlp",
+      "model.layers.3.mlp",
+      "model.layers.7.mlp",
+      "model.layers.24.mlp",
+      "model.layers.26.mlp",
+      "model.layers.15.self_attn"
+    ],
+    "llm_int8_threshold": 6.0,
+    "load_in_4bit": true,
+    "load_in_8bit": false,
+    "quant_method": "bitsandbytes"
+  },
+  "rms_norm_eps": 1e-06,
+  "rope_scaling": null,
+  "rope_theta": 1000000.0,
+  "sliding_window": null,
+  "tie_word_embeddings": true,
+  "torch_dtype": "bfloat16",
+  "transformers_version": "4.49.0.dev0",
+  "unsloth_fixed": true,
+  "use_cache": true,
+  "use_sliding_window": false,
+  "vocab_size": 151936
+}

huggingface_tokenizers_cache/models--unsloth--qwen2.5-1.5b-instruct-unsloth-bnb-4bit/blobs/9b8043f10c758210957b050c77f14d6282f33a52

@@ -0,0 +1,31 @@
+{
+  "additional_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "eos_token": {
+    "content": "<|im_end|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "<|vision_pad|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

huggingface_tokenizers_cache/models--unsloth--qwen2.5-1.5b-instruct-unsloth-bnb-4bit/blobs/9c5ae00e602b8860cbd784ba82a8aa14e8feecec692e7076590d014d7b7fdafa

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9c5ae00e602b8860cbd784ba82a8aa14e8feecec692e7076590d014d7b7fdafa
+size 11421896

huggingface_tokenizers_cache/models--unsloth--qwen2.5-1.5b-instruct-unsloth-bnb-4bit/blobs/a5de2eb6cac65b89846ac1bcfb837a3d83459f40

@@ -0,0 +1,209 @@
+{
+  "add_bos_token": false,
+  "add_prefix_space": false,
+  "added_tokens_decoder": {
+    "151643": {
+      "content": "<|endoftext|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151644": {
+      "content": "<|im_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151645": {
+      "content": "<|im_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151646": {
+      "content": "<|object_ref_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151647": {
+      "content": "<|object_ref_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151648": {
+      "content": "<|box_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151649": {
+      "content": "<|box_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151650": {
+      "content": "<|quad_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151651": {
+      "content": "<|quad_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151652": {
+      "content": "<|vision_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151653": {
+      "content": "<|vision_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151654": {
+      "content": "<|vision_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151655": {
+      "content": "<|image_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151656": {
+      "content": "<|video_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151657": {
+      "content": "<tool_call>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151658": {
+      "content": "</tool_call>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151659": {
+      "content": "<|fim_prefix|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151660": {
+      "content": "<|fim_middle|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151661": {
+      "content": "<|fim_suffix|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151662": {
+      "content": "<|fim_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151663": {
+      "content": "<|repo_name|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151664": {
+      "content": "<|file_sep|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    }
+  },
+  "additional_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "bos_token": null,
+  "chat_template": "{%- if tools %}\n    {{- '<|im_start|>system\\n' }}\n    {%- if messages[0]['role'] == 'system' %}\n        {{- messages[0]['content'] }}\n    {%- else %}\n        {{- 'You are Qwen, created by Alibaba Cloud. You are a helpful assistant.' }}\n    {%- endif %}\n    {{- \"\\n\\n# Tools\\n\\nYou may call one or more functions to assist with the user query.\\n\\nYou are provided with function signatures within <tools></tools> XML tags:\\n<tools>\" }}\n    {%- for tool in tools %}\n        {{- \"\\n\" }}\n        {{- tool | tojson }}\n    {%- endfor %}\n    {{- \"\\n</tools>\\n\\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\\n<tool_call>\\n{\\\"name\\\": <function-name>, \\\"arguments\\\": <args-json-object>}\\n</tool_call><|im_end|>\\n\" }}\n{%- else %}\n    {%- if messages[0]['role'] == 'system' %}\n        {{- '<|im_start|>system\\n' + messages[0]['content'] + '<|im_end|>\\n' }}\n    {%- else %}\n        {{- '<|im_start|>system\\nYou are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>\\n' }}\n    {%- endif %}\n{%- endif %}\n{%- for message in messages %}\n    {%- if (message.role == \"user\") or (message.role == \"system\" and not loop.first) or (message.role == \"assistant\" and not message.tool_calls) %}\n        {{- '<|im_start|>' + message.role + '\\n' + message.content + '<|im_end|>' + '\\n' }}\n    {%- elif message.role == \"assistant\" %}\n        {{- '<|im_start|>' + message.role }}\n        {%- if message.content %}\n            {{- '\\n' + message.content }}\n        {%- endif %}\n        {%- for tool_call in message.tool_calls %}\n            {%- if tool_call.function is defined %}\n                {%- set tool_call = tool_call.function %}\n            {%- endif %}\n            {{- '\\n<tool_call>\\n{\"name\": \"' }}\n            {{- tool_call.name }}\n            {{- '\", \"arguments\": ' }}\n            {{- tool_call.arguments | tojson }}\n            {{- '}\\n</tool_call>' }}\n        {%- endfor %}\n        {{- '<|im_end|>\\n' }}\n    {%- elif message.role == \"tool\" %}\n        {%- if (loop.index0 == 0) or (messages[loop.index0 - 1].role != \"tool\") %}\n            {{- '<|im_start|>user' }}\n        {%- endif %}\n        {{- '\\n<tool_response>\\n' }}\n        {{- message.content }}\n        {{- '\\n</tool_response>' }}\n        {%- if loop.last or (messages[loop.index0 + 1].role != \"tool\") %}\n            {{- '<|im_end|>\\n' }}\n        {%- endif %}\n    {%- endif %}\n{%- endfor %}\n{%- if add_generation_prompt %}\n    {{- '<|im_start|>assistant\\n' }}\n{%- endif %}\n",
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "errors": "replace",
+  "extra_special_tokens": {},
+  "model_max_length": 32768,
+  "pad_token": "<|vision_pad|>",
+  "padding_side": "left",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "unk_token": null
+}

huggingface_tokenizers_cache/models--unsloth--qwen2.5-1.5b-instruct-unsloth-bnb-4bit/refs/main

@@ -0,0 +1 @@
+3d254dbee5e3beae81bb8a717ad3a03427a09d26

huggingface_tokenizers_cache/models--unsloth--qwen2.5-1.5b-instruct-unsloth-bnb-4bit/snapshots/3d254dbee5e3beae81bb8a717ad3a03427a09d26/added_tokens.json

@@ -0,0 +1,24 @@
+{
+  "</tool_call>": 151658,
+  "<tool_call>": 151657,
+  "<|box_end|>": 151649,
+  "<|box_start|>": 151648,
+  "<|endoftext|>": 151643,
+  "<|file_sep|>": 151664,
+  "<|fim_middle|>": 151660,
+  "<|fim_pad|>": 151662,
+  "<|fim_prefix|>": 151659,
+  "<|fim_suffix|>": 151661,
+  "<|im_end|>": 151645,
+  "<|im_start|>": 151644,
+  "<|image_pad|>": 151655,
+  "<|object_ref_end|>": 151647,
+  "<|object_ref_start|>": 151646,
+  "<|quad_end|>": 151651,
+  "<|quad_start|>": 151650,
+  "<|repo_name|>": 151663,
+  "<|video_pad|>": 151656,
+  "<|vision_end|>": 151653,
+  "<|vision_pad|>": 151654,
+  "<|vision_start|>": 151652
+}

huggingface_tokenizers_cache/models--unsloth--qwen2.5-1.5b-instruct-unsloth-bnb-4bit/snapshots/3d254dbee5e3beae81bb8a717ad3a03427a09d26/config.json

@@ -0,0 +1,58 @@
+{
+  "_name_or_path": "Qwen/Qwen2.5-1.5B-Instruct",
+  "architectures": [
+    "Qwen2ForCausalLM"
+  ],
+  "attention_dropout": 0.0,
+  "eos_token_id": 151645,
+  "hidden_act": "silu",
+  "hidden_size": 1536,
+  "initializer_range": 0.02,
+  "intermediate_size": 8960,
+  "max_position_embeddings": 32768,
+  "max_window_layers": 21,
+  "model_type": "qwen2",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 28,
+  "num_key_value_heads": 2,
+  "pad_token_id": 151654,
+  "quantization_config": {
+    "_load_in_4bit": true,
+    "_load_in_8bit": false,
+    "bnb_4bit_compute_dtype": "bfloat16",
+    "bnb_4bit_quant_storage": "uint8",
+    "bnb_4bit_quant_type": "nf4",
+    "bnb_4bit_use_double_quant": true,
+    "llm_int8_enable_fp32_cpu_offload": false,
+    "llm_int8_has_fp16_weight": false,
+    "llm_int8_skip_modules": [
+      "lm_head",
+      "multi_modal_projector",
+      "merger",
+      "modality_projection",
+      "model.layers.0.self_attn",
+      "model.layers.1.mlp",
+      "model.layers.2.mlp",
+      "model.layers.3.mlp",
+      "model.layers.7.mlp",
+      "model.layers.24.mlp",
+      "model.layers.26.mlp",
+      "model.layers.15.self_attn"
+    ],
+    "llm_int8_threshold": 6.0,
+    "load_in_4bit": true,
+    "load_in_8bit": false,
+    "quant_method": "bitsandbytes"
+  },
+  "rms_norm_eps": 1e-06,
+  "rope_scaling": null,
+  "rope_theta": 1000000.0,
+  "sliding_window": null,
+  "tie_word_embeddings": true,
+  "torch_dtype": "bfloat16",
+  "transformers_version": "4.49.0.dev0",
+  "unsloth_fixed": true,
+  "use_cache": true,
+  "use_sliding_window": false,
+  "vocab_size": 151936
+}

huggingface_tokenizers_cache/models--unsloth--qwen2.5-1.5b-instruct-unsloth-bnb-4bit/snapshots/3d254dbee5e3beae81bb8a717ad3a03427a09d26/special_tokens_map.json

@@ -0,0 +1,31 @@
+{
+  "additional_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "eos_token": {
+    "content": "<|im_end|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "<|vision_pad|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

huggingface_tokenizers_cache/models--unsloth--qwen2.5-1.5b-instruct-unsloth-bnb-4bit/snapshots/3d254dbee5e3beae81bb8a717ad3a03427a09d26/tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9c5ae00e602b8860cbd784ba82a8aa14e8feecec692e7076590d014d7b7fdafa
+size 11421896

huggingface_tokenizers_cache/models--unsloth--qwen2.5-1.5b-instruct-unsloth-bnb-4bit/snapshots/3d254dbee5e3beae81bb8a717ad3a03427a09d26/tokenizer_config.json

@@ -0,0 +1,209 @@
+{
+  "add_bos_token": false,
+  "add_prefix_space": false,
+  "added_tokens_decoder": {
+    "151643": {
+      "content": "<|endoftext|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151644": {
+      "content": "<|im_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151645": {
+      "content": "<|im_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151646": {
+      "content": "<|object_ref_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151647": {
+      "content": "<|object_ref_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151648": {
+      "content": "<|box_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151649": {
+      "content": "<|box_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151650": {
+      "content": "<|quad_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151651": {
+      "content": "<|quad_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151652": {
+      "content": "<|vision_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151653": {
+      "content": "<|vision_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151654": {
+      "content": "<|vision_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151655": {
+      "content": "<|image_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151656": {
+      "content": "<|video_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151657": {
+      "content": "<tool_call>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151658": {
+      "content": "</tool_call>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151659": {
+      "content": "<|fim_prefix|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151660": {
+      "content": "<|fim_middle|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151661": {
+      "content": "<|fim_suffix|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151662": {
+      "content": "<|fim_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151663": {
+      "content": "<|repo_name|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151664": {
+      "content": "<|file_sep|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    }
+  },
+  "additional_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "bos_token": null,
+  "chat_template": "{%- if tools %}\n    {{- '<|im_start|>system\\n' }}\n    {%- if messages[0]['role'] == 'system' %}\n        {{- messages[0]['content'] }}\n    {%- else %}\n        {{- 'You are Qwen, created by Alibaba Cloud. You are a helpful assistant.' }}\n    {%- endif %}\n    {{- \"\\n\\n# Tools\\n\\nYou may call one or more functions to assist with the user query.\\n\\nYou are provided with function signatures within <tools></tools> XML tags:\\n<tools>\" }}\n    {%- for tool in tools %}\n        {{- \"\\n\" }}\n        {{- tool | tojson }}\n    {%- endfor %}\n    {{- \"\\n</tools>\\n\\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\\n<tool_call>\\n{\\\"name\\\": <function-name>, \\\"arguments\\\": <args-json-object>}\\n</tool_call><|im_end|>\\n\" }}\n{%- else %}\n    {%- if messages[0]['role'] == 'system' %}\n        {{- '<|im_start|>system\\n' + messages[0]['content'] + '<|im_end|>\\n' }}\n    {%- else %}\n        {{- '<|im_start|>system\\nYou are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>\\n' }}\n    {%- endif %}\n{%- endif %}\n{%- for message in messages %}\n    {%- if (message.role == \"user\") or (message.role == \"system\" and not loop.first) or (message.role == \"assistant\" and not message.tool_calls) %}\n        {{- '<|im_start|>' + message.role + '\\n' + message.content + '<|im_end|>' + '\\n' }}\n    {%- elif message.role == \"assistant\" %}\n        {{- '<|im_start|>' + message.role }}\n        {%- if message.content %}\n            {{- '\\n' + message.content }}\n        {%- endif %}\n        {%- for tool_call in message.tool_calls %}\n            {%- if tool_call.function is defined %}\n                {%- set tool_call = tool_call.function %}\n            {%- endif %}\n            {{- '\\n<tool_call>\\n{\"name\": \"' }}\n            {{- tool_call.name }}\n            {{- '\", \"arguments\": ' }}\n            {{- tool_call.arguments | tojson }}\n            {{- '}\\n</tool_call>' }}\n        {%- endfor %}\n        {{- '<|im_end|>\\n' }}\n    {%- elif message.role == \"tool\" %}\n        {%- if (loop.index0 == 0) or (messages[loop.index0 - 1].role != \"tool\") %}\n            {{- '<|im_start|>user' }}\n        {%- endif %}\n        {{- '\\n<tool_response>\\n' }}\n        {{- message.content }}\n        {{- '\\n</tool_response>' }}\n        {%- if loop.last or (messages[loop.index0 + 1].role != \"tool\") %}\n            {{- '<|im_end|>\\n' }}\n        {%- endif %}\n    {%- endif %}\n{%- endfor %}\n{%- if add_generation_prompt %}\n    {{- '<|im_start|>assistant\\n' }}\n{%- endif %}\n",
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "errors": "replace",
+  "extra_special_tokens": {},
+  "model_max_length": 32768,
+  "pad_token": "<|vision_pad|>",
+  "padding_side": "left",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "unk_token": null
+}

inference.py

@@ -0,0 +1,220 @@
+"""
+Inference Script — AI Sprint Manager OpenEnv
+============================================================
+MANDATORY:
+  API_BASE_URL  : LLM endpoint
+  MODEL_NAME    : Model identifier
+  HF_TOKEN      : Hugging Face / API key
+"""
+from __future__ import annotations
+import os
+import json
+import time
+import sys
+import requests
+from dotenv import load_dotenv
+from openai import OpenAI
+
+load_dotenv()
+
+# ── Config ────────────────────────────────────────────────────────────────────
+API_BASE_URL = os.getenv("API_BASE_URL", "https://router.huggingface.co/v1")
+API_KEY      = os.getenv("HF_TOKEN") or os.getenv("API_KEY", "dummy")
+MODEL_NAME   = os.getenv("MODEL_NAME", "meta-llama/Llama-3.1-8B-Instruct")
+ENV_BASE_URL = os.getenv("ENV_BASE_URL", "https://sejal-k-ai-sprint-manager.hf.space")
+
+MAX_STEPS   = 12
+TEMPERATURE = 0.2
+MAX_TOKENS  = 300
+TASKS       = ["easy_sprint", "medium_sprint", "hard_sprint"]
+
+client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
+
+SYSTEM_PROMPT = """You are an expert Tech Lead managing an agile sprint.
+Your goal: maximize task completion, balance developer workload, and meet deadlines.
+
+Each step output a JSON action with this exact schema:
+{
+  "action_type": "<assign|reassign|reprioritize|unblock|skip>",
+  "task_id": "<task id or null>",
+  "dev_id": "<developer id or null>",
+  "new_priority": <1-5 or null>
+}
+
+Rules:
+- assign: put a backlog task onto an available developer
+- reassign: move an in-progress task to a different developer
+- reprioritize: change a task priority (1=highest)
+- unblock: unblock a blocked task
+- skip: do nothing
+
+Output ONLY the JSON object. No explanation."""
+
+
+def build_user_prompt(obs: dict) -> str:
+    tasks_summary = "\n".join(
+        f"  [{t['id']}] {t['name']} | {t['task_type']} | P{t['priority']} | "
+        f"effort={t['effort']} | due=Day{t['deadline']} | status={t['status']} | "
+        f"dev={t['assigned_to']} | progress={t['progress']:.0%}"
+        for t in obs["tasks"]
+    )
+    devs_summary = "\n".join(
+        f"  [{d['id']}] {d['name']} | skill={d['skill']} | "
+        f"load={d['current_load']}/{d['capacity']} | available={d['is_available']}"
+        for d in obs["developers"]
+    )
+    events_str = "\n  ".join(obs.get("events", [])) or "None"
+    return f"""Day: {obs['current_day']}/{obs['sprint_length']}
+Done:{obs['tasks_completed']} Missed:{obs['tasks_missed']} InProgress:{obs['tasks_in_progress']} Backlog:{obs['tasks_backlog']}
+Cumulative Reward: {obs['cumulative_reward']:.2f}
+
+Events: {events_str}
+
+TASKS:
+{tasks_summary}
+
+DEVELOPERS:
+{devs_summary}
+
+Output your JSON action:"""
+
+
+def call_env(endpoint: str, payload: dict = None, method: str = "POST") -> dict:
+    url = f"{ENV_BASE_URL}/{endpoint}"
+    if method == "GET":
+        resp = requests.get(url, timeout=30)
+    else:
+        resp = requests.post(url, json=payload or {}, timeout=30)
+    resp.raise_for_status()
+    return resp.json()
+
+
+def get_rule_based_action(obs: dict) -> str:
+    """Fallback rule-based action when LLM unavailable."""
+    tasks = obs.get("tasks", [])
+    devs = obs.get("developers", [])
+    backlog = sorted(
+        [t for t in tasks if t["status"] == "backlog"],
+        key=lambda t: (t["priority"], t["deadline"])
+    )
+    if not backlog:
+        return '{"action_type": "skip"}'
+    task = backlog[0]
+    available = [d for d in devs if d["is_available"] and d["current_load"] < d["capacity"]]
+    skill_match = [d for d in available if d["skill"] == task["required_skill"] or d["skill"] == "fullstack"]
+    dev = skill_match[0] if skill_match else (available[0] if available else None)
+    if not dev:
+        return '{"action_type": "skip"}'
+    return json.dumps({"action_type": "assign", "task_id": task["id"], "dev_id": dev["id"], "new_priority": None})
+
+
+def parse_action(text: str) -> dict:
+    text = text.strip()
+    if "```" in text:
+        lines = [l for l in text.split("\n") if not l.strip().startswith("```")]
+        text = "\n".join(lines)
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        start, end = text.find("{"), text.rfind("}") + 1
+        if start >= 0 and end > start:
+            try:
+                return json.loads(text[start:end])
+            except Exception:
+                pass
+    return {"action_type": "skip", "task_id": None, "dev_id": None, "new_priority": None}
+
+
+def run_episode(task_name: str) -> float:
+    """Run one complete episode and return final score."""
+
+    # ── [START] block ─────────────────────────────────────────────────────────
+    print(f"[START] task={task_name}", flush=True)
+
+    obs = call_env("reset", {"task_name": task_name, "seed": 42})
+    final_score = 0.0
+    step_num = 0
+
+    for step_num in range(1, MAX_STEPS + 1):
+        if obs.get("done", False):
+            break
+
+        try:
+            completion = client.chat.completions.create(
+                model=MODEL_NAME,
+                messages=[
+                    {"role": "system", "content": SYSTEM_PROMPT},
+                    {"role": "user",   "content": build_user_prompt(obs)},
+                ],
+                temperature=TEMPERATURE,
+                max_tokens=MAX_TOKENS,
+            )
+            response_text = completion.choices[0].message.content or ""
+        except Exception as e:
+            response_text = get_rule_based_action(obs)
+
+        action = parse_action(response_text)
+        result = call_env("step", {"action": action})
+        obs = result["observation"]
+        reward = result["reward"]
+        done = result["done"]
+        info = result.get("info", {})
+
+        # ── [STEP] block ──────────────────────────────────────────────────────
+        print(
+            f"[STEP] task={task_name} step={step_num} "
+            f"action={action.get('action_type')} reward={reward:.4f} "
+            f"cumulative={obs.get('cumulative_reward', 0):.4f} done={done}",
+            flush=True
+        )
+
+        if done:
+            final_score = max(0.01, min(0.99, info.get("final_score", 0.01)))
+            break
+
+    # ── [END] block ───────────────────────────────────────────────────────────
+    print(
+        f"[END] task={task_name} score={final_score:.4f} steps={step_num}",
+        flush=True
+    )
+    return final_score
+
+
+def main():
+    print(f"[INFO] model={MODEL_NAME} server={ENV_BASE_URL}", flush=True)
+
+    try:
+        health = call_env("health", method="GET")
+        print(f"[INFO] health={health}", flush=True)
+    except Exception as e:
+        print(f"[ERROR] Cannot reach env server: {e}", flush=True)
+        sys.exit(1)
+
+    scores = {}
+    start_time = time.time()
+
+    for task in TASKS:
+        try:
+            score = run_episode(task)
+            scores[task] = score
+        except Exception as e:
+            print(f"[ERROR] task={task} error={e}", flush=True)
+            scores[task] = 0.0
+
+    elapsed = time.time() - start_time
+
+    # Human-readable summary
+    print("\n" + "="*60, flush=True)
+    print("  BASELINE SCORES", flush=True)
+    print("="*60, flush=True)
+    for task, score in scores.items():
+        bar = "█" * int(score * 20)
+        print(f"  {task:<20} {score:.4f}  {bar}", flush=True)
+    avg = sum(scores.values()) / len(scores) if scores else 0.0
+    print(f"  {'AVERAGE':<20} {avg:.4f}", flush=True)
+    print(f"\n  Runtime: {elapsed:.1f}s", flush=True)
+    print("="*60, flush=True)
+
+
+if __name__ == "__main__":
+    main()

inference_r2.py

@@ -0,0 +1,855 @@
+"""
+inference_r2.py — Round 2 LLM agent for AI Sprint Manager
+==========================================================
+
+ROOT-CAUSE FIXES in this version:
+  [FIX-I1] PROMPT ALIGNMENT — system prompt and user prompt now exactly match
+            train_llm.py (R2_SYSTEM_PROMPT + _build_r2_prompt format).
+            The fine-tuned model conditions strongly on the EXACT wording it
+            saw during training. The previous version used a completely different
+            system prompt ("You are a tech lead managing a 6-sprint...") and a
+            different user prompt format (day=/sprint= vs D/60 S/6).
+            This single mismatch is the biggest cause of poor inference scores.
+
+  [FIX-I2] LOCAL MODEL LOADING — sejal-k/ai-sprint-manager-trained is a LoRA
+            adapter, not a full model. The HF Router cannot serve it. The previous
+            version was routing all calls to the base Qwen model via HF Router,
+            producing base-model scores instead of fine-tuned scores.
+            Fix: load the adapter locally via Unsloth (preferred) or PEFT.
+            Set LOCAL_MODEL_PATH env var to the adapter path/HF repo ID.
+
+  [FIX-I3] LLM_CALL_EVERY=1 — was 3, meaning 2 out of every 3 steps used the
+            rule-based fallback regardless of model quality. With a local model
+            there is no rate-limit, so every step uses the LLM.
+
+  [FIX-I4] TEMPERATURE=0.3 for inference — was 0.1 (too greedy) and 0.8 (too
+            random). 0.3 gives slight diversity while staying near peak-prob output.
+
+  [FIX-I5] METADATA BUG — sort_key in smart_fallback used getattr(t, "metadata")
+            on plain dicts. Fixed to t.get("metadata", {}).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import time
+import random
+from typing import Optional, Tuple
+
+import requests
+
+# ─── Config ───────────────────────────────────────────────────────────────────
+# Set LOCAL_MODEL_PATH to use the fine-tuned adapter. Examples:
+#   export LOCAL_MODEL_PATH=results/trained_model            (local checkpoint)
+#   export LOCAL_MODEL_PATH=sejal-k/ai-sprint-manager-trained  (HF Hub adapter)
+LOCAL_MODEL_PATH = os.getenv("LOCAL_MODEL_PATH", "priyaaaaaasharmaaaaa/trial1")
+MODEL_NAME       = os.getenv("MODEL_NAME", "meta-llama/Llama-3.1-8B-Instruct")
+ENV_BASE_URL     = os.getenv("ENV_BASE_URL", "https://sejal-k-ai-sprint-manager.hf.space")
+API_BASE_URL     = os.getenv("API_BASE_URL", "https://router.huggingface.co/v1")
+HF_TOKEN         = os.getenv("HF_TOKEN", "")
+
+# Inference control: USE_LLM=0 → smart_fallback only (sanity vs LLM).
+_use_llm_raw = os.getenv("USE_LLM", "1").strip().lower()
+USE_LLM      = _use_llm_raw not in ("0", "false", "no", "off", "")
+LLM_COOLDOWN_STEPS       = int(os.getenv("LLM_COOLDOWN_STEPS", "15"))
+MAX_LLM_SOFT_FAIL_STREAK = int(os.getenv("MAX_LLM_SOFT_FAIL_STREAK", "3"))
+MAX_LLM_SKIP_STREAK      = int(os.getenv("MAX_LLM_SKIP_STREAK", "4"))
+MAX_SAME_BAD_ASSIGN_STREAK = int(os.getenv("MAX_SAME_BAD_ASSIGN_STREAK", "2"))
+
+MAX_TOKENS     = 96     # matches train_llm.py max_completion_length
+MAX_RETRIES    = 2
+LLM_CALL_EVERY = 1      # [FIX-I3] every step — no rate limit with local model
+TEMPERATURE    = 0.3    # [FIX-I4]
+
+TASK_ID_RE      = re.compile(r"^T\d+$")
+RETRYABLE_CODES = {429, 500, 502, 503, 504}
+
+
+# ─── [FIX-I1] Prompts — EXACTLY matching train_llm.py ────────────────────────
+# These strings must stay in sync with R2_SYSTEM_PROMPT and _build_r2_prompt()
+# in train_llm.py. Any wording difference causes the fine-tuned model to produce
+# lower-quality output because it no longer recognises its training context.
+
+R2_SYSTEM_PROMPT = """You are an Engineering Manager running a 60-day software project.
+Each step you MUST output exactly ONE JSON object and nothing else.
+
+Schema (use null for unused fields):
+{"action_type":"<assign|reassign|reprioritize|unblock|skip>","task_id":"<id or null>","dev_id":"<id or null>","new_priority":<1-5 or null>}
+
+Rules (follow in order):
+1. If ACTIVE INSTRUCTIONS exist, assign THEIR tasks first.
+2. Only assign tasks with status=backlog (never in_progress or done).
+3. Only assign if all dependency markers show ✓.
+4. Only assign to an AVAILABLE developer with matching or fullstack skill.
+5. Use unblock ONLY for explicitly blocked tasks whose deps are ✓.
+6. skip is last resort.
+
+Output ONLY the JSON. No explanation."""
+
+
+def build_user_prompt(
+    obs: dict,
+    *,
+    assigned_this_episode: Optional[set] = None,
+    assign_attempted_episode: Optional[set] = None,
+) -> str:
+    """
+    Core layout matches _build_r2_prompt() in train_llm.py.
+    Optional MEMORY block is inference-only: steers the model away from repeat
+    assigns and lists live IN_PROGRESS ids (training export can omit kwargs).
+    """
+    current_sprint = obs.get("current_sprint", 1)
+    current_day    = obs.get("current_day", 1)
+    days_left      = max(0, current_sprint * 10 - current_day + 1)
+    tasks          = obs.get("tasks", [])
+    done_ids       = {t["id"] for t in tasks if t.get("status") == "done"}
+
+    active_insts = [i for i in obs.get("instruction_queue", []) if not i.get("followed", False)]
+    inst_section = (
+        "⚡FOLLOW: " + " | ".join(f"[{i['id']}] {i['text'][:50]}" for i in active_insts[:2])
+    ) if active_insts else "No instructions."
+
+    debt_raw   = obs.get("tech_debt", [])
+    debt_count = len(debt_raw) if isinstance(debt_raw, list) else int(debt_raw or 0)
+
+    backlog = sorted(
+        [t for t in tasks if t.get("status") == "backlog"],
+        key=lambda t: (t.get("priority", 9), t.get("deadline", 99))
+    )
+    in_prog = [t for t in tasks if t.get("status") == "in_progress"]
+
+    def fmt(t: dict) -> str:
+        meta   = t.get("metadata", {}) or {}          # [FIX-I5]
+        deps   = t.get("depends_on", []) or meta.get("depends_on", [])
+        dep_ok = "✓" if all(d in done_ids for d in deps) else "✗"
+        return (f"[{t['id']}]P{t.get('priority','?')} "
+                f"{str(t.get('required_skill','?'))[:4]} {dep_ok} "
+                f"D{t.get('deadline', t.get('deadline_day','?'))}")
+
+    backlog_str = " ".join(fmt(t) for t in backlog[:6])
+    if len(backlog) > 6:
+        backlog_str += f" +{len(backlog)-6}"
+
+    inprog_str = " ".join(f"[{t['id']}]→{t.get('assigned_to','?')}" for t in in_prog) or "none"
+    avail_devs = [d for d in obs.get("developers", []) if d.get("is_available", False)]
+    devs_str   = " ".join(
+        f"[{d['id']}]{str(d.get('name','?'))[:4]}({str(d.get('skill','?'))[:3]}) "
+        f"{d.get('current_load',0)}/{d.get('capacity',5)}"
+        for d in avail_devs
+    )
+
+    memory_lines: list[str] = []
+    in_prog_ids = [t["id"] for t in in_prog]
+    if in_prog_ids:
+        memory_lines.append(
+            "NO_REASSIGN_UNTIL_BACKLOG: " + " ".join(in_prog_ids)
+            + " — do NOT assign/reassign these while they stay in_progress."
+        )
+    if assigned_this_episode:
+        memory_lines.append(
+            "ASSIGNED_OK_THIS_EP: " + " ".join(sorted(assigned_this_episode))
+            + " — already started; do not assign again."
+        )
+    if assign_attempted_episode:
+        extra = assign_attempted_episode - set(assigned_this_episode or ())
+        if extra:
+            memory_lines.append(
+                "ASSIGN_ALREADY_TRIED: " + " ".join(sorted(extra))
+                + " — pick a different backlog task if still open."
+            )
+    memory_block = ("EPISODE_MEMORY:\n" + "\n".join(memory_lines) + "\n") if memory_lines else ""
+
+    return (
+        f"D{current_day}/60 S{current_sprint}/6 {days_left}d "
+        f"done={obs.get('tasks_completed',0)} miss={obs.get('tasks_missed',0)} "
+        f"inst={obs.get('instruction_following_score',0):.2f} debt={debt_count}\n"
+        f"{inst_section}\n"
+        f"BACKLOG(✓=deps_ok): {backlog_str}\n"
+        f"IN_PROG: {inprog_str}\n"
+        f"DEVS(avail): {devs_str}\n"
+        f"{memory_block}"
+        f"JSON:"
+    )
+
+
+def _completed_ids(obs: dict) -> set:
+    return {t["id"] for t in obs.get("tasks", []) if t.get("status") == "done"}
+
+
+def _deps_met_task(obs: dict, task: dict) -> bool:
+    done_ids = _completed_ids(obs)
+    meta = task.get("metadata", {}) or {}
+    deps = task.get("depends_on", []) or meta.get("depends_on", [])
+    return all(d in done_ids for d in deps)
+
+
+def _dev_by_id(obs: dict, dev_id: object) -> Optional[dict]:
+    sid = str(dev_id)
+    for d in obs.get("developers", []):
+        if str(d.get("id")) == sid:
+            return d
+    return None
+
+
+def validate_llm_action(
+    obs: dict,
+    action: Optional[dict],
+    assigned_this_episode: set,
+) -> Tuple[bool, str]:
+    """
+    Hard gate: reject LLM output that violates env rules (backlog, deps, dev).
+    """
+    if not action:
+        return False, "empty"
+    at = action.get("action_type")
+    if at not in {"assign", "reassign", "reprioritize", "unblock", "skip"}:
+        return False, "bad_type"
+
+    if at == "skip":
+        return True, "ok"
+
+    tid = action.get("task_id")
+    if not tid:
+        return False, "missing_task_id"
+
+    by_id = {t["id"]: t for t in obs.get("tasks", [])}
+    task = by_id.get(tid)
+    if task is None:
+        return False, "unknown_task"
+
+    if at == "unblock":
+        if task.get("status") != "blocked":
+            return False, "unblock_not_blocked"
+        if not _deps_met_task(obs, task):
+            return False, "unblock_deps"
+        return True, "ok"
+
+    if at == "reprioritize":
+        if task.get("status") != "backlog":
+            return False, "reprioritize_not_backlog"
+        if not _deps_met_task(obs, task):
+            return False, "reprioritize_deps"
+        np = action.get("new_priority")
+        if np is None:
+            return False, "reprioritize_no_priority"
+        try:
+            npi = int(np)
+        except (TypeError, ValueError):
+            return False, "reprioritize_bad_priority"
+        if not (1 <= npi <= 5):
+            return False, "reprioritize_range"
+        return True, "ok"
+
+    if at in ("assign", "reassign"):
+        st = task.get("status")
+        if st != "backlog":
+            return False, f"assign_bad_status:{st}"
+        if not _deps_met_task(obs, task):
+            return False, "assign_deps"
+        if tid in assigned_this_episode:
+            return False, "assign_already_started_episode"
+        did = action.get("dev_id")
+        if not did:
+            return False, "assign_no_dev"
+        dev = _dev_by_id(obs, did)
+        if dev is None:
+            return False, "assign_unknown_dev"
+        if not dev.get("is_available", False):
+            return False, "assign_dev_unavailable"
+        try:
+            rem = int(dev.get("remaining_capacity", dev.get("capacity", 1)))
+            if rem <= 0:
+                return False, "assign_dev_no_capacity"
+        except (TypeError, ValueError):
+            pass
+        skill = task.get("required_skill", "")
+        dskill = dev.get("skill", "")
+        if dskill not in (skill, "fullstack"):
+            return False, "assign_skill_mismatch"
+        return True, "ok"
+
+    return False, "unhandled"
+
+
+# ─── [FIX-I2] Local fine-tuned model loader ───────────────────────────────────
+
+_local_model     = None
+_local_tokenizer = None
+_local_backend   = None
+
+
+def _load_local_model(model_path: str) -> bool:
+    """
+    [FIX-I2] Load LoRA adapter locally. HF Router cannot serve LoRA adapters —
+    it requires fully merged weights. Unsloth first, PEFT+bitsandbytes fallback.
+    """
+    global _local_model, _local_tokenizer, _local_backend
+    if _local_model is not None:
+        return True
+
+    print(f"[INFO] Loading fine-tuned model: {model_path}", flush=True)
+
+    unsloth_err: Optional[BaseException] = None
+    # Attempt 1: Unsloth (fastest, native 4-bit, same library used for training)
+    try:
+        from unsloth import FastLanguageModel
+        model, tokenizer = FastLanguageModel.from_pretrained(
+            model_name=model_path, max_seq_length=2048, dtype=None,
+            load_in_4bit=True, token=HF_TOKEN or None,
+        )
+        FastLanguageModel.for_inference(model)
+        _local_model, _local_tokenizer, _local_backend = model, tokenizer, "unsloth"
+        print("[INFO] Loaded via Unsloth (fast 4-bit inference).", flush=True)
+        return True
+    except Exception as e:
+        unsloth_err = e
+        print(f"[WARN] Unsloth failed: {e}", flush=True)
+
+    # Attempt 2: PEFT + bitsandbytes
+    try:
+        import torch
+        from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
+        from peft import PeftModel
+        import huggingface_hub
+
+        try:
+            cfg_path = huggingface_hub.hf_hub_download(
+                model_path, "adapter_config.json", token=HF_TOKEN or None
+            )
+        except Exception:
+            cfg_path = os.path.join(model_path, "adapter_config.json")
+
+        with open(cfg_path) as f:
+            adapter_cfg = json.load(f)
+        base_id = adapter_cfg.get("base_model_name_or_path", "Qwen/Qwen2.5-1.5B-Instruct")
+        print(f"[INFO] Base model: {base_id}", flush=True)
+
+        bnb  = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_compute_dtype=torch.float16)
+        tok  = AutoTokenizer.from_pretrained(base_id, token=HF_TOKEN or None)
+        base = AutoModelForCausalLM.from_pretrained(
+            base_id, quantization_config=bnb, device_map="auto", token=HF_TOKEN or None
+        )
+        model = PeftModel.from_pretrained(base, model_path, token=HF_TOKEN or None)
+        model.eval()
+        _local_model, _local_tokenizer, _local_backend = model, tok, "peft"
+        print("[INFO] Loaded via PEFT + bitsandbytes 4-bit.", flush=True)
+        return True
+    except Exception as e2:
+        print(
+            f"[ERROR] Cannot load local model.\n  Unsloth: {unsloth_err}\n  PEFT: {e2}",
+            flush=True,
+        )
+        return False
+
+
+def _call_local_model(user_prompt: str) -> Optional[dict]:
+    """Run one inference step on the locally loaded fine-tuned model."""
+    if _local_model is None:
+        return None
+    import torch
+
+    messages = [
+        {"role": "system", "content": R2_SYSTEM_PROMPT},
+        {"role": "user",   "content": user_prompt},
+    ]
+    tok = _local_tokenizer
+    try:
+        if hasattr(tok, "apply_chat_template"):
+            prompt_text = tok.apply_chat_template(
+                messages, tokenize=False, add_generation_prompt=True
+            )
+        else:
+            prompt_text = "\n".join(
+                f"<|{m['role']}|>\n{m['content']}" for m in messages
+            ) + "\n<|assistant|>\n"
+
+        inputs  = tok(prompt_text, return_tensors="pt").to(_local_model.device)
+        inp_len = inputs["input_ids"].shape[1]
+
+        with torch.no_grad():
+            outputs = _local_model.generate(
+                **inputs, max_new_tokens=MAX_TOKENS,
+                temperature=TEMPERATURE, do_sample=True,
+                pad_token_id=tok.pad_token_id or tok.eos_token_id,
+            )
+
+        completion = tok.decode(outputs[0][inp_len:], skip_special_tokens=True).strip()
+        return parse_action(completion)
+
+    except Exception as e:
+        print(f"  [WARN] Local model inference error: {e}", flush=True)
+        return None
+
+
+# ─── HF Router client (fallback when no local model) ─────────────────────────
+
+def _call_api_model(user_prompt: str) -> Optional[dict]:
+    """Use HF Router — only for full (non-adapter) models."""
+    try:
+        from openai import OpenAI, APIStatusError
+    except ImportError:
+        return None
+    if not HF_TOKEN:
+        return None
+
+    client   = OpenAI(base_url=API_BASE_URL, api_key=HF_TOKEN)
+    messages = [
+        {"role": "system", "content": R2_SYSTEM_PROMPT},
+        {"role": "user",   "content": user_prompt},
+    ]
+    for attempt in range(1, MAX_RETRIES + 2):
+        try:
+            resp = client.chat.completions.create(
+                model=MODEL_NAME, messages=messages,
+                max_tokens=MAX_TOKENS, temperature=TEMPERATURE,
+            )
+            return parse_action(resp.choices[0].message.content or "")
+        except APIStatusError as e:
+            if e.status_code not in RETRYABLE_CODES:
+                return None
+            if attempt <= MAX_RETRIES:
+                time.sleep(2 ** attempt + random.uniform(0, 0.5))
+            else:
+                return None
+        except Exception:
+            if attempt <= MAX_RETRIES:
+                time.sleep(2 ** attempt)
+            else:
+                return None
+    return None
+
+
+def call_llm_user_prompt(user_prompt: str) -> Optional[dict]:
+    """Prefer local fine-tuned model; fall back to HF Router."""
+    if _local_model is not None:
+        return _call_local_model(user_prompt)
+    return _call_api_model(user_prompt)
+
+
+# ─── Action parser ────────────────────────────────────────────────────────────
+
+def parse_action(raw: str) -> Optional[dict]:
+    if not raw:
+        return None
+    raw = raw.strip()
+    raw = re.sub(r"^```[a-z]*\s*", "", raw)
+    raw = re.sub(r"\s*```$", "", raw)
+
+    # Find last balanced JSON object (handles CoT prefix the model might emit)
+    depth = 0; obj_start = -1; last_start = -1; last_end = -1
+    for i, ch in enumerate(raw):
+        if ch == "{":
+            if depth == 0: obj_start = i
+            depth += 1
+        elif ch == "}":
+            depth -= 1
+            if depth == 0 and obj_start >= 0:
+                last_start, last_end = obj_start, i + 1
+
+    obj = None
+    if last_start >= 0:
+        try:
+            obj = json.loads(raw[last_start:last_end])
+        except json.JSONDecodeError:
+            pass
+    if obj is None:
+        try:
+            obj = json.loads(raw)
+        except Exception:
+            return None
+
+    action_type = obj.get("action_type", "")
+    if action_type not in {"assign", "reassign", "reprioritize", "unblock", "skip"}:
+        return None
+
+    null_vals = {"null", "none", "None", "Null", "", "undefined", "N/A", "nil"}
+    for key in ("task_id", "dev_id", "new_priority"):
+        v = obj.get(key)
+        if v is not None and str(v).strip() in null_vals:
+            obj[key] = None
+
+    task_id = obj.get("task_id")
+    if task_id is not None and not TASK_ID_RE.match(str(task_id)):
+        print(f"  [INVALID] task_id={repr(task_id)} rejected", flush=True)
+        return None
+
+    if action_type in {"assign", "reassign"}:
+        if not task_id or not obj.get("dev_id"):
+            return None
+
+    return {
+        "action_type":  action_type,
+        "task_id":      task_id,
+        "dev_id":       obj.get("dev_id"),
+        "new_priority": obj.get("new_priority"),
+    }
+
+
+# Aliases for evaluate_r2 / train naming
+_build_r2_prompt = build_user_prompt
+_parse_action = parse_action
+
+
+# ─── Smart fallback ───────────────────────────────────────────────────────────
+
+def smart_fallback(obs: dict, assigned_this_episode: set, last_dev_idx: list) -> dict:
+    tasks          = obs.get("tasks", [])
+    devs           = obs.get("developers", [])
+    instructions   = obs.get("instruction_queue", [])
+    current_sprint = obs.get("current_sprint", 1)
+    completed_ids  = {t["id"] for t in tasks if t.get("status") == "done"}
+
+    def deps_met(task: dict) -> bool:
+        meta = task.get("metadata", {}) or {}   # [FIX-I5]
+        deps = task.get("depends_on", []) or meta.get("depends_on", [])
+        return all(dep in completed_ids for dep in deps)
+
+    skip = {"action_type": "skip", "task_id": None, "dev_id": None, "new_priority": None}
+
+    # Tier 1: unblock blocked tasks with met deps
+    for task in tasks:
+        if task.get("status") == "blocked" and deps_met(task):
+            return {"action_type": "unblock", "task_id": task["id"],
+                    "dev_id": None, "new_priority": None}
+
+    instruction_task_ids: set = set()
+    for inst in instructions:
+        if not inst.get("followed", False):
+            for tid in inst.get("affects_tasks", []):
+                instruction_task_ids.add(tid)
+
+    # Tier 2: reprioritize low-priority instruction tasks
+    for task in tasks:
+        if (task.get("status") == "backlog"
+                and task["id"] in instruction_task_ids
+                and task.get("priority", 9) > 2
+                and deps_met(task)):
+            return {"action_type": "reprioritize", "task_id": task["id"],
+                    "dev_id": None, "new_priority": 1}
+
+    # Tier 3: assign
+    assignable = [t for t in tasks if t.get("status") == "backlog" and deps_met(t)]
+    if not assignable:
+        return skip
+
+    def sort_key(t: dict) -> tuple:   # [FIX-I5]
+        meta          = t.get("metadata", {}) or {}
+        sprint_target = meta.get("sprint", current_sprint + 99)
+        in_inst       = 0 if t["id"] in instruction_task_ids else 1
+        return (in_inst, sprint_target, t.get("priority", 99))
+
+    assignable.sort(key=sort_key)
+    task = assignable[0]
+
+    available_devs = [
+        d for d in devs
+        if d.get("is_available", False)
+        and d.get("remaining_capacity", d.get("capacity", 1)) > 0
+    ]
+    if not available_devs:
+        available_devs = [d for d in devs if d.get("is_available", False)]
+    if not available_devs:
+        available_devs = devs
+
+    skill        = task.get("required_skill", "")
+    skilled_devs = [d for d in available_devs
+                    if d.get("skill") == skill or d.get("skill") == "fullstack"]
+    pool             = skilled_devs if skilled_devs else available_devs
+    idx              = last_dev_idx[0] % len(pool)
+    dev              = pool[idx]
+    last_dev_idx[0]  = (idx + 1) % len(pool)
+
+    return {"action_type": "assign", "task_id": task["id"],
+            "dev_id": dev["id"], "new_priority": None}
+
+
+# ─── Environment helpers ──────────────────────────────────────────────────────
+
+def _post(url: str, payload: dict, timeout: int = 15) -> dict:
+    resp = requests.post(url, json=payload, timeout=timeout)
+    resp.raise_for_status()
+    return resp.json()
+
+
+def step_env(action: dict) -> dict:
+    return _post(f"{ENV_BASE_URL}/project/step", {"action": action})
+
+
+def reset_env(scenario: str, seed: int = 42) -> dict:
+    return _post(f"{ENV_BASE_URL}/project/reset", {"task_name": scenario, "seed": seed})
+
+
+def health() -> dict:
+    resp = requests.get(f"{ENV_BASE_URL}/project/health", timeout=10)
+    resp.raise_for_status()
+    return resp.json()
+
+
+# ─── Episode runner ───────────────────────────────────────────────────────────
+
+def run_episode(scenario: str, seed: int = 42) -> dict:
+    obs_data = reset_env(scenario, seed)
+    obs      = obs_data.get("observation", obs_data)
+
+    assigned_this_episode: set = set()
+    assign_attempted_episode: set = set()
+    last_dev_idx = [0]
+    cumulative   = 0.0
+    step_num     = 0
+
+    llm_skip_streak = 0
+    llm_soft_fail_streak = 0
+    bad_assign_tid: Optional[str] = None
+    bad_assign_streak = 0
+    llm_cooldown_until = 0
+
+    MAX_STEPS = 200  # safety cap so your code doesn’t spiral forever
+    MAX_STEP_RETRIES = 3
+
+    print(f"\n[START] task={scenario}", flush=True)
+
+    while True:
+        step_num += 1
+
+        if step_num > MAX_STEPS:
+            print("[WARN] Max steps reached — forcing termination", flush=True)
+            break
+
+        day    = obs.get("current_day", step_num)
+        sprint = obs.get("current_sprint", 1)
+
+        router_ok = _local_model is not None or bool(HF_TOKEN)
+        allow_llm = (
+            USE_LLM
+            and (step_num % LLM_CALL_EVERY == 1)
+            and router_ok
+            and step_num > llm_cooldown_until
+        )
+
+        action = None
+
+        if allow_llm:
+            user_prompt = build_user_prompt(
+                obs,
+                assigned_this_episode=assigned_this_episode,
+                assign_attempted_episode=assign_attempted_episode,
+            )
+            proposed = call_llm_user_prompt(user_prompt)
+
+            if proposed is None:
+                llm_soft_fail_streak += 1
+                print("  [LLM] no parse / API fail → fallback", flush=True)
+            else:
+                ok, reason = validate_llm_action(obs, proposed, assigned_this_episode)
+                if ok:
+                    if proposed.get("action_type") == "skip":
+                        llm_skip_streak += 1
+                        if llm_skip_streak >= MAX_LLM_SKIP_STREAK:
+                            action = None
+                            llm_cooldown_until = max(
+                                llm_cooldown_until, step_num + LLM_COOLDOWN_STEPS
+                            )
+                            llm_skip_streak = 0
+                            llm_soft_fail_streak += 1
+                            print(
+                                "  [COOLDOWN] skip-spam — rule-based this step + "
+                                f"{LLM_COOLDOWN_STEPS}-step LLM pause",
+                                flush=True,
+                            )
+                        else:
+                            action = proposed
+                            llm_soft_fail_streak = 0
+                            bad_assign_tid = None
+                            bad_assign_streak = 0
+                    else:
+                        llm_skip_streak = 0
+                        action = proposed
+                        llm_soft_fail_streak = 0
+                        bad_assign_tid = None
+                        bad_assign_streak = 0
+                else:
+                    llm_soft_fail_streak += 1
+                    print(
+                        f"  [REJECT] LLM action invalid ({reason}) → fallback",
+                        flush=True,
+                    )
+                    if proposed.get("action_type") in ("assign", "reassign"):
+                        tidp = proposed.get("task_id")
+                        tid_key = str(tidp) if tidp is not None else None
+                        if tid_key == bad_assign_tid:
+                            bad_assign_streak += 1
+                        else:
+                            bad_assign_tid = tid_key
+                            bad_assign_streak = 1
+                    else:
+                        bad_assign_tid = None
+                        bad_assign_streak = 0
+
+            if bad_assign_streak >= MAX_SAME_BAD_ASSIGN_STREAK:
+                llm_cooldown_until = max(
+                    llm_cooldown_until, step_num + LLM_COOLDOWN_STEPS
+                )
+                bad_assign_streak = 0
+                bad_assign_tid = None
+                print(
+                    f"  [COOLDOWN] repeated bad assign → rule-based for {LLM_COOLDOWN_STEPS} steps",
+                    flush=True,
+                )
+
+            if llm_soft_fail_streak >= MAX_LLM_SOFT_FAIL_STREAK:
+                llm_cooldown_until = max(
+                    llm_cooldown_until, step_num + LLM_COOLDOWN_STEPS
+                )
+                llm_soft_fail_streak = 0
+                print(
+                    f"  [COOLDOWN] repeated LLM invalid → rule-based for {LLM_COOLDOWN_STEPS} steps",
+                    flush=True,
+                )
+
+        if action is None:
+            action = smart_fallback(obs, assigned_this_episode, last_dev_idx)
+
+        if action.get("action_type") in ("assign", "reassign") and action.get("task_id"):
+            assign_attempted_episode.add(action["task_id"])
+
+        # ─── STEP WITH RETRY + STATE VALIDATION ───────────────────────
+        success = False
+
+        for attempt in range(MAX_STEP_RETRIES):
+            result = step_env(action)
+            new_obs = result.get("observation", result)
+
+            # 🚨 HARD GUARD: detect time regression
+            if (
+                new_obs.get("current_day", 0) < obs.get("current_day", 0) or
+                new_obs.get("current_sprint", 0) < obs.get("current_sprint", 0)
+            ):
+                print(f"[ERROR] State regression detected (attempt {attempt+1}) — retrying", flush=True)
+                time.sleep(0.5)
+                continue
+
+            success = True
+            break
+
+        if not success:
+            print("[FATAL] Repeated environment corruption — aborting episode", flush=True)
+            break
+
+        reward     = result.get("reward", 0.0)
+        obs        = new_obs
+        done       = result.get("done", obs.get("done", False))
+        cumulative += reward
+
+        inst_score = obs.get("instruction_following_score", 0.0)
+        debt_raw   = obs.get("tech_debt", 0)
+
+        # Track tasks successfully moved to in_progress (assign / reassign)
+        if action.get("action_type") in ("assign", "reassign") and action.get("task_id"):
+            tid_sent = action["task_id"]
+            post_s   = {t["id"]: t.get("status") for t in obs.get("tasks", [])}
+            if post_s.get(tid_sent) == "in_progress":
+                assigned_this_episode.add(tid_sent)
+
+        debt_d = len(debt_raw) if isinstance(debt_raw, list) else int(debt_raw or 0)
+
+        print(
+            f"[STEP] task={scenario} step={step_num} day={day} sprint={sprint} "
+            f"action={action.get('action_type','?')} "
+            f"task_id={action.get('task_id','None')} "
+            f"dev={action.get('dev_id','None')} "
+            f"reward={reward:.4f} cumulative={cumulative:.4f} "
+            f"inst_score={inst_score:.3f} debt={debt_d} done={done}",
+            flush=True,
+        )
+
+        if done:
+            break
+
+    # ─── FINAL METRICS ───────────────────────────────────────────────
+    tasks         = obs.get("tasks", [])
+    completed     = sum(1 for t in tasks if t.get("status") == "done")
+    missed        = sum(1 for t in tasks if t.get("status") == "missed")
+    inst_score    = obs.get("instruction_following_score", 0.0)
+
+    debt_raw      = obs.get("tech_debt", 0)
+    debt_count    = len(debt_raw) if isinstance(debt_raw, list) else int(debt_raw or 0)
+
+    total         = len(tasks) or 1
+
+    final_score   = max(0.01, min(0.99,
+        (completed / total) * 0.55 +
+        inst_score * 0.30 +
+        max(0.01, 1.0 - debt_count * 0.02) * 0.15
+    ))
+
+    print(
+        f"[END] task={scenario} score={final_score:.4f} steps={step_num} "
+        f"completed={completed} missed={missed} "
+        f"inst_score={inst_score:.3f} debt={debt_count}",
+        flush=True,
+    )
+
+    return {
+        "scenario": scenario,
+        "score": final_score,
+        "completed": completed,
+        "missed": missed,
+        "inst_score": inst_score,
+        "debt": debt_count,
+        "steps": step_num
+    }
+
+# ─── Main ─────────────────────────────────────────────────────────────────────
+
+def main():
+    scenarios = ["project_easy", "project_medium", "project_hard"]
+
+    local_ok = False
+    if LOCAL_MODEL_PATH:
+        local_ok = _load_local_model(LOCAL_MODEL_PATH)
+        if not local_ok:
+            print("[WARN] Local model load failed — scores will reflect BASE model!", flush=True)
+
+    if not USE_LLM:
+        mode = "rule-based-only (USE_LLM=0)"
+    else:
+        mode = ("local-finetuned" if local_ok
+                else ("hf-router-base" if HF_TOKEN else "rule-based-only"))
+
+    print(f"[INFO] model={LOCAL_MODEL_PATH if local_ok else MODEL_NAME}", flush=True)
+    print(f"[INFO] inference mode={mode}", flush=True)
+    print(f"[INFO] USE_LLM={USE_LLM} cooldown_steps={LLM_COOLDOWN_STEPS}", flush=True)
+    print(f"[INFO] server={ENV_BASE_URL}", flush=True)
+
+    try:
+        print(f"[INFO] health={health()}", flush=True)
+    except Exception as e:
+        print(f"[WARN] health check failed: {e}", flush=True)
+
+    results = {}
+    t0 = time.time()
+    for scenario in scenarios:
+        try:
+            results[scenario] = run_episode(scenario)
+        except Exception as e:
+            print(f"[ERROR] {scenario}: {e}", flush=True)
+            results[scenario] = {"score": 0.01, "error": str(e)}
+
+    scores = [results[s].get("score", 0) for s in scenarios if s in results]
+    avg    = sum(scores) / len(scores) if scores else 0
+
+    print("\n" + "=" * 62, flush=True)
+    print(f" ROUND 2 — SCORES  [{mode}]", flush=True)
+    print("=" * 62, flush=True)
+    for s in scenarios:
+        sc  = results.get(s, {}).get("score", 0)
+        print(f"  {s:<22} {sc:.4f}  {'█' * int(sc * 20)}", flush=True)
+    print(f"\n  AVERAGE                {avg:.4f}", flush=True)
+    print(f"\n  Runtime: {time.time()-t0:.1f}s", flush=True)
+    print("=" * 62, flush=True)
+
+
+if __name__ == "__main__":
+    main()

openenv.yaml

@@ -0,0 +1,88 @@
+spec_version: 1
+name: ai-sprint-manager
+type: environment
+runtime: python
+app: server:app
+port: 8000
+description: >
+  An RL environment where an AI agent acts as a Tech Lead managing
+  agile sprints — assigning tasks to developers, balancing workload,
+  and handling unexpected events to maximize team productivity.
+tasks:
+  - id: easy_sprint
+    name: "Easy Sprint: Small Team, Clear Tasks"
+    difficulty: easy
+  - id: medium_sprint
+    name: "Medium Sprint: Bugs + Delays"
+    difficulty: medium
+  - id: hard_sprint
+    name: "Hard Sprint: Cascading Failures & Scope Changes"
+    difficulty: hard
+
+  - id: project_easy
+    description: >
+      AI Engineering Manager — 6-sprint project (60 days), small stable team,
+      clear backlog, no cascade failures. Tests long-horizon planning baseline.
+    difficulty: easy
+    reset_endpoint: /project/reset
+    step_endpoint: /project/step
+    state_endpoint: /project/state
+    health_endpoint: /project/health
+    reset_payload:
+      task_name: project_easy
+      seed: 42
+    max_steps: 60
+    score_field: instruction_following_score
+    metadata:
+      round: 2
+      num_sprints: 6
+      total_days: 60
+      num_tasks: 24
+      num_instructions: 12
+      theme: long_horizon_planning
+
+  - id: project_medium
+    description: >
+      AI Engineering Manager — 6-sprint project (60 days), mid-size team with
+      developer absences, urgent bugs, and conflicting instructions mid-sprint.
+    difficulty: medium
+    reset_endpoint: /project/reset
+    step_endpoint: /project/step
+    state_endpoint: /project/state
+    health_endpoint: /project/health
+    reset_payload:
+      task_name: project_medium
+      seed: 42
+    max_steps: 60
+    score_field: instruction_following_score
+    metadata:
+      round: 2
+      num_sprints: 6
+      total_days: 60
+      num_tasks: 30
+      num_instructions: 18
+      theme: long_horizon_planning
+
+  - id: project_hard
+    description: >
+      AI Engineering Manager — 6-sprint project (60 days), large team with
+      cascading failures, scope pivots, conflicting instructions, and hard
+      delivery deadline. Scale AI bonus prize target scenario.
+    difficulty: hard
+    reset_endpoint: /project/reset
+    step_endpoint: /project/step
+    state_endpoint: /project/state
+    health_endpoint: /project/health
+    reset_payload:
+      task_name: project_hard
+      seed: 42
+    max_steps: 60
+    score_field: instruction_following_score
+    metadata:
+      round: 2
+      num_sprints: 6
+      total_days: 60
+      num_tasks: 37
+      num_instructions: 25
+      theme: long_horizon_planning
+      scale_ai_bonus: true

plot_results.py

@@ -0,0 +1,421 @@
+"""
+plot_results.py — Results Charts for Hackathon Presentation
+============================================================
+Generates publication-ready charts from evaluation JSON data.
+Saves all charts to results/charts/ as both PNG and SVG.
+
+BASELINE CONSTANTS (FINAL — measured, do not change):
+  R1 Llama-3.1-8B zero-shot: easy=0.0100, medium=0.4583, hard=0.0100, avg=0.1594
+  R2 Llama-3.1-8B zero-shot: easy=0.3198, medium=0.2443, hard=0.2520, avg=0.2720
+  Training model:             Qwen/Qwen2.5-1.5B-Instruct (GRPO, 4-bit QLoRA)
+
+Charts produced:
+  1. r1_scores_comparison.png  — R1 Llama baseline vs trained bar chart
+  2. r2_scores_comparison.png  — R2 Llama zero-shot vs trained bar chart (no rule-based)
+  3. sprint_rewards.png        — Sprint-by-sprint reward for each R2 scenario
+  4. improvement_summary.png   — Combined before/after delta chart (main slide chart)
+  5. training_curve.png        — GRPO training loss/reward curve (if trainer_state.json present)
+
+Usage:
+    # After running evaluate_r2.py --baseline-only:
+    python plot_results.py --eval results/r2_evaluation.json
+
+    # With training curve (after train_llm.py):
+    python plot_results.py --eval results/r2_evaluation.json \\
+                           --trainer results/trained_model/trainer_state.json
+
+    # Hardcode known scores for presentation (no eval file needed):
+    python plot_results.py --demo
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from pathlib import Path
+
+CHARTS_DIR = Path("results/charts")
+CHARTS_DIR.mkdir(parents=True, exist_ok=True)
+
+# ── Measured baselines (FINAL) ────────────────────────────────────────────────
+LLAMA_BASELINE_R1 = {
+    "easy_sprint":   0.0100,
+    "medium_sprint": 0.4583,
+    "hard_sprint":   0.0100,
+    "average":       0.1594,
+}
+LLAMA_BASELINE_R2 = {
+    "project_easy":   0.3198,
+    "project_medium": 0.2443,
+    "project_hard":   0.2520,
+    "average":        0.2720,
+}
+TRAINING_MODEL = "Qwen/Qwen2.5-1.5B-Instruct"
+
+# ── Colour palette ────────────────────────────────────────────────────────────
+C_LLAMA     = "#6B7280"   # grey     — Llama zero-shot baseline
+C_RULE      = "#3B82F6"   # blue     — rule-based baseline
+C_TRAINED   = "#10B981"   # green    — trained Qwen (post-GRPO)
+C_EASY      = "#60A5FA"
+C_MEDIUM    = "#F59E0B"
+C_HARD      = "#EF4444"
+C_BG        = "#F9FAFB"
+C_TEXT      = "#111827"
+
+
+def _setup_matplotlib():
+    import matplotlib
+    matplotlib.use("Agg")   # headless
+    import matplotlib.pyplot as plt
+    import matplotlib.patches as mpatches
+    plt.rcParams.update({
+        "figure.facecolor":  C_BG,
+        "axes.facecolor":    C_BG,
+        "axes.edgecolor":    "#D1D5DB",
+        "axes.labelcolor":   C_TEXT,
+        "text.color":        C_TEXT,
+        "xtick.color":       C_TEXT,
+        "ytick.color":       C_TEXT,
+        "grid.color":        "#E5E7EB",
+        "grid.linestyle":    "--",
+        "grid.alpha":        0.7,
+        "font.family":       "sans-serif",
+        "font.size":         11,
+        "axes.titlesize":    13,
+        "axes.titleweight":  "bold",
+        "figure.dpi":        150,
+    })
+    return plt, mpatches
+
+
+def save(plt, name: str):
+    png = CHARTS_DIR / f"{name}.png"
+    svg = CHARTS_DIR / f"{name}.svg"
+    plt.tight_layout()
+    plt.savefig(png, bbox_inches="tight")
+    plt.savefig(svg, bbox_inches="tight")
+    plt.close()
+    print(f"  [SAVED] {png}", flush=True)
+
+
+# ── Chart 1: R1 scores comparison ────────────────────────────────────────────
+
+def chart_r1_comparison(eval_data: dict):
+    plt, mpatches = _setup_matplotlib()
+
+    tasks      = ["easy_sprint", "medium_sprint", "hard_sprint"]
+    labels     = ["Easy Sprint", "Medium Sprint", "Hard Sprint"]
+    llama_base = [eval_data.get("r1_llama_baseline", LLAMA_BASELINE_R1).get(t, 0) for t in tasks]
+    rule_based = [eval_data.get("r1_rule_based", {}).get(t, {}).get("avg_score", 0) for t in tasks]
+    llm_scores = [eval_data.get("r1_llm", {}).get(t, {}).get("avg_score", 0) for t in tasks]
+
+    has_llm = any(v > 0 for v in llm_scores)
+    x      = range(len(tasks))
+    width  = 0.28 if has_llm else 0.38
+    fig, ax = plt.subplots(figsize=(9, 5))
+
+    b1 = ax.bar([i - width for i in x], llama_base, width, label=f"Llama-3.1-8B (zero-shot baseline)", color=C_LLAMA,   zorder=3)
+    b2 = ax.bar([i         for i in x], rule_based, width, label="Rule-based",                           color=C_RULE,    zorder=3)
+    if has_llm:
+        b3 = ax.bar([i + width for i in x], llm_scores, width, label=f"{TRAINING_MODEL} (GRPO trained)", color=C_TRAINED, zorder=3)
+
+    def label_bars(bars):
+        for bar in bars:
+            h = bar.get_height()
+            if h > 0.01:
+                ax.text(bar.get_x() + bar.get_width()/2, h + 0.01,
+                        f"{h:.2f}", ha="center", va="bottom", fontsize=9)
+
+    label_bars(b1); label_bars(b2)
+    if has_llm: label_bars(b3)
+
+    ax.set_xticks(list(x))
+    ax.set_xticklabels(labels)
+    ax.set_ylim(0, 1.15)
+    ax.set_ylabel("Score (0.01 – 0.99)")
+    ax.set_title("Round 1 — Score Comparison")
+    ax.legend(loc="upper right")
+    ax.yaxis.grid(True, zorder=0)
+    ax.set_axisbelow(True)
+
+    save(plt, "r1_scores_comparison")
+
+
+# ── Chart 2: R2 scores comparison ────────────────────────────────────────────
+
+def chart_r2_comparison(eval_data: dict):
+    plt, mpatches = _setup_matplotlib()
+
+    tasks      = ["project_easy", "project_medium", "project_hard"]
+    labels     = ["Easy (6 sprints)", "Medium (6 sprints)", "Hard (6 sprints)"]
+    llama_base = [eval_data.get("r2_llama_baseline", LLAMA_BASELINE_R2).get(t, 0) for t in tasks]
+    llm_scores = [eval_data.get("r2_llm", {}).get(t, {}).get("avg_score", 0) for t in tasks]
+
+    has_llm = any(v > 0 for v in llm_scores)
+    x     = range(len(tasks))
+    width = 0.32 if has_llm else 0.5
+    fig, ax = plt.subplots(figsize=(9, 5))
+
+    b1 = ax.bar([i - width/2 for i in x], llama_base, width, label="Llama-3.1-8B (zero-shot)", color=C_LLAMA,   zorder=3)
+    if has_llm:
+        b2 = ax.bar([i + width/2 for i in x], llm_scores, width, label=f"{TRAINING_MODEL} (GRPO)", color=C_TRAINED, zorder=3)
+
+    for bars in ([b1] + ([b2] if has_llm else [])):
+        for bar in bars:
+            h = bar.get_height()
+            if h > 0.01:
+                ax.text(bar.get_x() + bar.get_width()/2, h + 0.01,
+                        f"{h:.2f}", ha="center", va="bottom", fontsize=9)
+
+    ax.set_xticks(list(x))
+    ax.set_xticklabels(labels)
+    ax.set_ylim(0, 1.15)
+    ax.set_ylabel("Project Score (delivery × instruction × health)")
+    ax.set_title("Round 2 — Multi-Sprint Project Score")
+    ax.legend(loc="upper right")
+    ax.yaxis.grid(True, zorder=0)
+    ax.set_axisbelow(True)
+
+    save(plt, "r2_scores_comparison")
+
+
+# ── Chart 3: Sprint reward curves ─────────────────────────────────────────────
+
+def chart_sprint_rewards(eval_data: dict):
+    """Per-sprint reward for each R2 scenario (Llama baseline vs trained)."""
+    plt, _ = _setup_matplotlib()
+    tasks  = ["project_easy", "project_medium", "project_hard"]
+    colors = [C_EASY, C_MEDIUM, C_HARD]
+    labels = ["Easy", "Medium", "Hard"]
+
+    fig, axes = plt.subplots(1, 3, figsize=(13, 4), sharey=True)
+
+    for ax, task, color, label in zip(axes, tasks, colors, labels):
+        llm_eps = eval_data.get("r2_llm", {}).get(task, {}).get("episodes", [])
+
+        if llm_eps:
+            sr = llm_eps[0].get("sprint_rewards", [])
+            if sr:
+                ax.plot(range(1, len(sr)+1), sr, "o-",
+                        color=color, label="Qwen GRPO", linewidth=2, markersize=6)
+
+        ax.set_xlabel("Sprint")
+        ax.set_title(f"{label} Project")
+        ax.set_xticks(range(1, 7))
+        ax.set_ylim(0, 2.2)
+        ax.yaxis.grid(True)
+        ax.set_axisbelow(True)
+        if ax == axes[0]:
+            ax.set_ylabel("Sprint Reward")
+        ax.legend(fontsize=8)
+
+    fig.suptitle("Sprint-by-Sprint Reward — Qwen GRPO Trained", y=1.02, fontsize=13, fontweight="bold")
+    save(plt, "sprint_rewards")
+
+
+# ── Chart 4: Improvement summary (main presentation slide) ───────────────────
+
+def chart_improvement_summary(eval_data: dict):
+    """Main before/after chart. Uses Llama zero-shot as the 'before' bar."""
+    plt, _ = _setup_matplotlib()
+
+    all_tasks = (
+        [f"R1: {t.replace('_sprint','').title()}" for t in ["easy_sprint","medium_sprint","hard_sprint"]] +
+        [f"R2: {t.replace('project_','').title()}" for t in ["project_easy","project_medium","project_hard"]]
+    )
+
+    llama_base, trained_scores = [], []
+    for t in ["easy_sprint","medium_sprint","hard_sprint"]:
+        llama_base.append(eval_data.get("r1_llama_baseline", LLAMA_BASELINE_R1).get(t, 0))
+        trained_scores.append(eval_data.get("r1_llm", {}).get(t, {}).get("avg_score", 0))
+    for t in ["project_easy","project_medium","project_hard"]:
+        llama_base.append(eval_data.get("r2_llama_baseline", LLAMA_BASELINE_R2).get(t, 0))
+        trained_scores.append(eval_data.get("r2_llm", {}).get(t, {}).get("avg_score", 0))
+
+    x     = range(len(all_tasks))
+    width = 0.36
+    fig, ax = plt.subplots(figsize=(11, 5))
+
+    b1 = ax.bar([i - width/2 for i in x], llama_base,     width,
+                label="Before: Llama-3.1-8B (zero-shot)", color=C_LLAMA,   zorder=3)
+    b2 = ax.bar([i + width/2 for i in x], trained_scores, width,
+                label=f"After: {TRAINING_MODEL} (GRPO)",  color=C_TRAINED, zorder=3)
+
+    # Delta arrows and labels
+    for i, (base, trained) in enumerate(zip(llama_base, trained_scores)):
+        if trained > base + 0.01:
+            ax.annotate("", xy=(i + width/2, trained + 0.02), xytext=(i - width/2, base + 0.02),
+                        arrowprops=dict(arrowstyle="->", color="#059669", lw=1.5))
+            ax.text(i, max(base, trained) + 0.06, f"+{trained-base:.2f}",
+                    ha="center", fontsize=8, color="#059669", fontweight="bold")
+
+    ax.set_xticks(list(x))
+    ax.set_xticklabels(all_tasks, rotation=15, ha="right")
+    ax.set_ylim(0, 1.25)
+    ax.set_ylabel("Score")
+    ax.set_title(f"Reward Improvement: Llama Zero-Shot → Qwen2.5-1.5B GRPO Trained")
+    ax.legend(loc="upper left")
+    ax.yaxis.grid(True, zorder=0)
+    ax.set_axisbelow(True)
+
+    # Divider between R1 and R2
+    ax.axvline(x=2.5, color="#9CA3AF", linestyle=":", linewidth=1.5)
+    ax.text(1.0, 1.20, "Round 1", ha="center", fontsize=10, color="#6B7280")
+    ax.text(4.0, 1.20, "Round 2", ha="center", fontsize=10, color="#6B7280")
+
+    save(plt, "improvement_summary")
+
+
+# ── Chart 5: Training loss/reward curve ───────────────────────────────────────
+
+def chart_training_curve(trainer_state_path: str):
+    plt, _ = _setup_matplotlib()
+
+    with open(trainer_state_path) as f:
+        state = json.load(f)
+
+    log_history = state.get("log_history", [])
+    if not log_history:
+        print("  [SKIP] No log_history in trainer_state.json", flush=True)
+        return
+
+    steps, losses, rewards = [], [], []
+    for entry in log_history:
+        if "loss" in entry:
+            steps.append(entry.get("step", 0))
+            losses.append(entry["loss"])
+        if "reward" in entry:
+            rewards.append((entry.get("step", 0), entry["reward"]))
+
+    fig, axes = plt.subplots(1, 2, figsize=(11, 4))
+
+    if steps and losses:
+        axes[0].plot(steps, losses, color=C_RULE, linewidth=2)
+        axes[0].set_xlabel("Training Step")
+        axes[0].set_ylabel("Loss")
+        axes[0].set_title("GRPO Training Loss (Qwen2.5-1.5B)")
+        axes[0].yaxis.grid(True)
+
+    if rewards:
+        rsteps, rvals = zip(*rewards)
+        axes[1].plot(rsteps, rvals, color=C_TRAINED, linewidth=2)
+        axes[1].set_xlabel("Training Step")
+        axes[1].set_ylabel("Mean Reward")
+        axes[1].set_title("GRPO Mean Reward per Step")
+        axes[1].yaxis.grid(True)
+
+    fig.suptitle(f"GRPO Training Curves — {TRAINING_MODEL}", fontsize=13, fontweight="bold")
+    save(plt, "training_curve")
+
+
+# ── Demo mode (hardcoded real baselines, placeholder trained scores) ──────────
+
+def demo_mode():
+    """
+    Generate charts using real measured baselines.
+    Trained scores are placeholders — replace with real evaluate_r2.py output after on-site training.
+    """
+    print("[INFO] Demo mode — real Llama baselines, placeholder trained scores", flush=True)
+    print(f"[INFO] Training model: {TRAINING_MODEL}", flush=True)
+
+    # Placeholder trained scores — update after on-site GRPO training
+    PLACEHOLDER_R1_TRAINED = {
+        "easy_sprint":   0.0,   # update after training
+        "medium_sprint": 0.0,   # update after training
+        "hard_sprint":   0.0,   # update after training
+    }
+    PLACEHOLDER_R2_TRAINED = {
+        "project_easy":   0.0,  # update after training
+        "project_medium": 0.0,  # update after training
+        "project_hard":   0.0,  # update after training
+    }
+
+    demo_data = {
+        "r1_llama_baseline": LLAMA_BASELINE_R1,
+        "r2_llama_baseline": LLAMA_BASELINE_R2,
+        "r1_rule_based": {
+            "easy_sprint":   {"avg_score": 0.92},
+            "medium_sprint": {"avg_score": 0.35},
+            "hard_sprint":   {"avg_score": 0.01},
+        },
+        "r1_llm": {
+            t: {"avg_score": v} for t, v in PLACEHOLDER_R1_TRAINED.items()
+        },
+        "r2_rule_based": {},
+        "r2_llm": {
+            t: {"avg_score": v, "episodes": []}
+            for t, v in PLACEHOLDER_R2_TRAINED.items()
+        },
+        "improvement": {
+            t: {
+                "llama_baseline": LLAMA_BASELINE_R2[t],
+                "trained_llm":    PLACEHOLDER_R2_TRAINED[t],
+                "delta_vs_llama": round(PLACEHOLDER_R2_TRAINED[t] - LLAMA_BASELINE_R2[t], 4),
+            }
+            for t in ["project_easy", "project_medium", "project_hard"]
+        },
+    }
+    return demo_data
+
+
+# ── CLI ───────────────────────────────────────────────────────────────────────
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate result charts for presentation")
+    parser.add_argument("--eval",    type=str, default=None,
+                        help="Path to r2_evaluation.json from evaluate_r2.py")
+    parser.add_argument("--trainer", type=str, default=None,
+                        help="Path to trainer_state.json from train_llm.py output")
+    parser.add_argument("--demo",    action="store_true",
+                        help="Generate charts with real baselines + placeholder trained scores")
+    args = parser.parse_args()
+
+    try:
+        import matplotlib
+    except ImportError:
+        print("[ERROR] matplotlib not installed. Run: pip install matplotlib", flush=True)
+        import sys; sys.exit(1)
+
+    if args.demo:
+        eval_data = demo_mode()
+    elif args.eval:
+        with open(args.eval) as f:
+            eval_data = json.load(f)
+        # Back-fill baseline keys if running against old JSON format
+        if "r1_llama_baseline" not in eval_data:
+            eval_data["r1_llama_baseline"] = LLAMA_BASELINE_R1
+        if "r2_llama_baseline" not in eval_data:
+            eval_data["r2_llama_baseline"] = LLAMA_BASELINE_R2
+    else:
+        print("[INFO] No --eval file specified. Using --demo mode.", flush=True)
+        eval_data = demo_mode()
+
+    print(f"\nGenerating charts → {CHARTS_DIR}/", flush=True)
+    print(f"  Baselines: R1 avg={LLAMA_BASELINE_R1['average']:.4f}  R2 avg={LLAMA_BASELINE_R2['average']:.4f}", flush=True)
+    print(f"  Training model: {TRAINING_MODEL}", flush=True)
+
+    print("  Chart 1: R1 scores comparison...", flush=True)
+    chart_r1_comparison(eval_data)
+
+    print("  Chart 2: R2 scores comparison...", flush=True)
+    chart_r2_comparison(eval_data)
+
+    print("  Chart 3: Sprint reward curves...", flush=True)
+    chart_sprint_rewards(eval_data)
+
+    print("  Chart 4: Improvement summary...", flush=True)
+    chart_improvement_summary(eval_data)
+
+    if args.trainer and Path(args.trainer).exists():
+        print("  Chart 5: Training curve...", flush=True)
+        chart_training_curve(args.trainer)
+    else:
+        print("  Chart 5: Training curve — skipped (no --trainer file provided)", flush=True)
+
+    print(f"\n✅ All charts saved to {CHARTS_DIR}/", flush=True)
+    print(f"   Use improvement_summary.png in your HF blog post and pitch slides.", flush=True)
+
+
+if __name__ == "__main__":
+    main()

project_client.py

@@ -0,0 +1,289 @@
+"""
+Project Manager — OpenEnv Client (Round 2)
+
+Typed HTTP client for the multi-sprint /project/* endpoints.
+Mirrors the R1 SprintEnvClient interface exactly, extended for R2.
+
+Usage:
+    from project_client import ProjectEnvClient
+
+    client = ProjectEnvClient(base_url="https://sejal-k-ai-sprint-manager.hf.space")
+    obs = client.reset(task_name="project_easy", seed=42)
+
+    while not obs["done"]:
+        result = client.step({"action_type": "assign", "task_id": "T01", "dev_id": "dev1"})
+        obs = result.observation
+
+    client.close()
+
+    # Or as context manager:
+    with ProjectEnvClient() as client:
+        obs = client.reset("project_hard")
+        while not obs["done"]:
+            result = client.step({"action_type": "skip"})
+            obs = result.observation
+"""
+
+from __future__ import annotations
+
+import requests
+from typing import Any, Optional
+
+
+# ── Typed step result ──────────────────────────────────────────────────────────
+
+class ProjectStepResult:
+    """
+    Typed result from a project step() call.
+
+    Extends R1 StepResult with R2-specific fields surfaced as properties.
+    """
+
+    def __init__(self, payload: dict) -> None:
+        self.observation: dict  = payload["observation"]
+        self.reward: float      = payload["reward"]
+        self.done: bool         = payload["done"]
+        self.info: dict         = payload.get("info", {})
+
+    # ── R2 convenience accessors ──────────────────────────────────────────────
+
+    @property
+    def current_sprint(self) -> int:
+        return self.observation.get("current_sprint", 1)
+
+    @property
+    def current_day(self) -> int:
+        return self.observation.get("current_day", 1)
+
+    @property
+    def instruction_queue(self) -> list[dict]:
+        """All instructions released up to current_day."""
+        return self.observation.get("instruction_queue", [])
+
+    @property
+    def active_instructions(self) -> list[dict]:
+        """Released instructions not yet followed."""
+        return [i for i in self.instruction_queue if not i.get("followed", False)]
+
+    @property
+    def tech_debt(self) -> list[str]:
+        """Task IDs that became tech debt at sprint boundaries."""
+        return self.observation.get("tech_debt", [])
+
+    @property
+    def sprint_rewards(self) -> list[float]:
+        """Per-sprint reward history."""
+        return self.observation.get("sprint_rewards", [])
+
+    @property
+    def instruction_following_score(self) -> float:
+        return self.observation.get("instruction_following_score", 1.0)
+
+    @property
+    def tasks_completed(self) -> int:
+        return self.observation.get("tasks_completed", 0)
+
+    @property
+    def tasks_missed(self) -> int:
+        return self.observation.get("tasks_missed", 0)
+
+    @property
+    def cumulative_reward(self) -> float:
+        return self.observation.get("cumulative_reward", 0.0)
+
+    def __repr__(self) -> str:
+        return (
+            f"ProjectStepResult("
+            f"reward={self.reward:+.3f}, done={self.done}, "
+            f"day={self.current_day}/60, sprint={self.current_sprint}/6, "
+            f"completed={self.tasks_completed}, "
+            f"inst_score={self.instruction_following_score:.2f}, "
+            f"debt={len(self.tech_debt)})"
+        )
+
+
+# ── Client ─────────────────────────────────────────────────────────────────────
+
+class ProjectEnvClient:
+    """
+    HTTP client for the R2 multi-sprint Project Manager environment.
+
+    Wraps the /project/* REST API into a clean typed Python interface.
+    Use this in RL training loops (train_llm.py), evaluation scripts
+    (evaluate_r2.py), and notebooks.
+
+    All endpoints mirror the R1 SprintEnvClient interface so training
+    code can swap between R1 and R2 with minimal changes.
+    """
+
+    def __init__(
+        self,
+        base_url: str = "http://localhost:7860",
+        timeout: int  = 60,          # 60s — R2 steps can be slower than R1
+    ) -> None:
+        self.base_url  = base_url.rstrip("/")
+        self.timeout   = timeout
+        self._session  = requests.Session()
+        self._prefix   = "/project"
+
+    # ── Core API ──────────────────────────────────────────────────────────────
+
+    def reset(
+        self,
+        task_name:  str           = "project_easy",
+        seed:       Optional[int] = None,
+        episode_id: Optional[str] = None,
+    ) -> dict:
+        """
+        Start a new 60-day multi-sprint episode.
+
+        Args:
+            task_name:  "project_easy" | "project_medium" | "project_hard"
+            seed:       Random seed for reproducibility
+            episode_id: Optional custom episode identifier
+
+        Returns:
+            Initial observation dict (includes current_sprint, instruction_queue,
+            tech_debt, sprint_rewards).
+        """
+        payload: dict[str, Any] = {"task_name": task_name}
+        if seed is not None:
+            payload["seed"] = seed
+        if episode_id is not None:
+            payload["episode_id"] = episode_id
+
+        resp = self._session.post(
+            f"{self.base_url}{self._prefix}/reset",
+            json=payload,
+            timeout=self.timeout,
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+    def step(self, action: dict[str, Any]) -> ProjectStepResult:
+        """
+        Take one action and advance the project by one day.
+
+        Args:
+            action: dict with keys: action_type, task_id, dev_id,
+                    new_priority, task_ids (for sprint_plan), notes.
+                    Minimum required: {"action_type": "skip"}
+
+        Returns:
+            ProjectStepResult with observation, reward, done, info,
+            plus R2 convenience properties.
+        """
+        payload = {"action": action}
+        resp = self._session.post(
+            f"{self.base_url}{self._prefix}/step",
+            json=payload,
+            timeout=self.timeout,
+        )
+        resp.raise_for_status()
+        return ProjectStepResult(resp.json())
+
+    def state(self) -> dict:
+        """Return the full current internal state snapshot."""
+        resp = self._session.get(
+            f"{self.base_url}{self._prefix}/state",
+            timeout=self.timeout,
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+    def health(self) -> dict:
+        """
+        Check R2 server health.
+        Returns round=2 and current episode summary.
+        """
+        resp = self._session.get(
+            f"{self.base_url}{self._prefix}/health",
+            timeout=self.timeout,
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+    def list_tasks(self) -> list[dict]:
+        """List all available R2 multi-sprint scenarios."""
+        resp = self._session.get(
+            f"{self.base_url}{self._prefix}/tasks",
+            timeout=self.timeout,
+        )
+        resp.raise_for_status()
+        return resp.json()["tasks"]
+
+    # ── Helpers ───────────────────────────────────────────────────────────────
+
+    def run_episode(
+        self,
+        task_name: str,
+        policy_fn,                     # Callable[[dict], dict]
+        seed: Optional[int] = None,
+        max_steps: int = 60,
+        verbose: bool = False,
+    ) -> dict:
+        """
+        Convenience: run a full episode with a policy function.
+
+        Args:
+            task_name:  Scenario name
+            policy_fn:  fn(observation: dict) -> action: dict
+            seed:       Optional random seed
+            max_steps:  Safety cap (default 60 = full project)
+            verbose:    Print step summaries to stdout
+
+        Returns:
+            dict with keys: steps, cumulative_reward, final_score,
+            tasks_completed, tasks_missed, instruction_following_score,
+            tech_debt, sprint_rewards, done
+        """
+        obs = self.reset(task_name=task_name, seed=seed)
+        total_reward = 0.0
+        steps = 0
+
+        for step_num in range(1, max_steps + 1):
+            if obs.get("done", False):
+                break
+            action = policy_fn(obs)
+            result = self.step(action)
+            obs = result.observation
+            total_reward += result.reward
+            steps += 1
+
+            if verbose:
+                print(
+                    f"  day={obs['current_day']-1:02d}/60 "
+                    f"sprint={obs['current_sprint']}/6 "
+                    f"done={obs['tasks_completed']} "
+                    f"missed={obs['tasks_missed']} "
+                    f"debt={len(obs['tech_debt'])} "
+                    f"inst={obs['instruction_following_score']:.2f} "
+                    f"reward={result.reward:+.3f}",
+                    flush=True,
+                )
+
+        return {
+            "steps":                      steps,
+            "cumulative_reward":          round(total_reward, 4),
+            "tasks_completed":            obs.get("tasks_completed", 0),
+            "tasks_missed":               obs.get("tasks_missed", 0),
+            "instruction_following_score": obs.get("instruction_following_score", 0.0),
+            "tech_debt":                  obs.get("tech_debt", []),
+            "sprint_rewards":             obs.get("sprint_rewards", []),
+            "done":                       obs.get("done", False),
+        }
+
+    # ── Session lifecycle ─────────────────────────────────────────────────────
+
+    def close(self) -> None:
+        """Close the underlying HTTP session."""
+        self._session.close()
+
+    def __enter__(self) -> "ProjectEnvClient":
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        self.close()
+
+    def __repr__(self) -> str:
+        return f"ProjectEnvClient(base_url='{self.base_url}', prefix='{self._prefix}')"

pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "ai-sprint-manager"
+version = "1.0.0"
+description = "RL environment for agile sprint management - OpenEnv"
+requires-python = ">=3.11,<3.13"
+dependencies = [
+    "fastapi==0.115.5",
+    "uvicorn==0.32.1",
+    "pydantic==2.10.3",
+    "openai",
+    "requests",
+    "openenv-core",
+]
+
+[project.scripts]
+server = "server.app:main"
+
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.backends.legacy:build"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["sprint_env*", "server*"]

results/phase1/README.md

@@ -0,0 +1,73 @@
+---
+base_model: unsloth/qwen2.5-1.5b-instruct-unsloth-bnb-4bit
+library_name: peft
+model_name: phase1
+tags:
+- base_model:adapter:unsloth/qwen2.5-1.5b-instruct-unsloth-bnb-4bit
+- grpo
+- lora
+- transformers
+- trl
+- unsloth
+licence: license
+pipeline_tag: text-generation
+---
+
+# Model Card for phase1
+
+This model is a fine-tuned version of [unsloth/qwen2.5-1.5b-instruct-unsloth-bnb-4bit](https://huggingface.co/unsloth/qwen2.5-1.5b-instruct-unsloth-bnb-4bit).
+It has been trained using [TRL](https://github.com/huggingface/trl).
+
+## Quick start
+
+```python
+from transformers import pipeline
+
+question = "If you had a time machine, but could only go to the past or the future once and never return, which would you choose and why?"
+generator = pipeline("text-generation", model="None", device="cuda")
+output = generator([{"role": "user", "content": question}], max_new_tokens=128, return_full_text=False)[0]
+print(output["generated_text"])
+```
+
+## Training procedure
+
+ 
+
+
+This model was trained with GRPO, a method introduced in [DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models](https://huggingface.co/papers/2402.03300).
+
+### Framework versions
+
+- PEFT 0.18.1
+- TRL: 0.24.0
+- Transformers: 5.5.0
+- Pytorch: 2.10.0+cu128
+- Datasets: 4.3.0
+- Tokenizers: 0.22.2
+
+## Citations
+
+Cite GRPO as:
+
+```bibtex
+@article{shao2024deepseekmath,
+    title        = {{DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models}},
+    author       = {Zhihong Shao and Peiyi Wang and Qihao Zhu and Runxin Xu and Junxiao Song and Mingchuan Zhang and Y. K. Li and Y. Wu and Daya Guo},
+    year         = 2024,
+    eprint       = {arXiv:2402.03300},
+}
+
+```
+
+Cite TRL as:
+    
+```bibtex
+@misc{vonwerra2022trl,
+	title        = {{TRL: Transformer Reinforcement Learning}},
+	author       = {Leandro von Werra and Younes Belkada and Lewis Tunstall and Edward Beeching and Tristan Thrush and Nathan Lambert and Shengyi Huang and Kashif Rasul and Quentin Gallou{\'e}dec},
+	year         = 2020,
+	journal      = {GitHub repository},
+	publisher    = {GitHub},
+	howpublished = {\url{https://github.com/huggingface/trl}}
+}
+```

results/phase1/adapter_config.json

@@ -0,0 +1,50 @@
+{
+  "alora_invocation_tokens": null,
+  "alpha_pattern": {},
+  "arrow_config": null,
+  "auto_mapping": {
+    "base_model_class": "Qwen2ForCausalLM",
+    "parent_library": "transformers.models.qwen2.modeling_qwen2",
+    "unsloth_fixed": true
+  },
+  "base_model_name_or_path": "unsloth/qwen2.5-1.5b-instruct-unsloth-bnb-4bit",
+  "bias": "none",
+  "corda_config": null,
+  "ensure_weight_tying": false,
+  "eva_config": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": true,
+  "init_lora_weights": true,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 32,
+  "lora_bias": false,
+  "lora_dropout": 0.05,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "peft_type": "LORA",
+  "peft_version": "0.18.1",
+  "qalora_group_size": 16,
+  "r": 16,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": [
+    "k_proj",
+    "up_proj",
+    "down_proj",
+    "o_proj",
+    "v_proj",
+    "gate_proj",
+    "q_proj"
+  ],
+  "target_parameters": null,
+  "task_type": "CAUSAL_LM",
+  "trainable_token_indices": null,
+  "use_dora": false,
+  "use_qalora": false,
+  "use_rslora": false
+}

results/phase1/adapter_model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6d9ce380266a065d31b8d4962851f4d105daeda1ef56d4e9cd0835e5d5d0644a
+size 73911112

results/phase1/chat_template.jinja

@@ -0,0 +1,54 @@
+{%- if tools %}
+    {{- '<|im_start|>system\n' }}
+    {%- if messages[0]['role'] == 'system' %}
+        {{- messages[0]['content'] }}
+    {%- else %}
+        {{- 'You are Qwen, created by Alibaba Cloud. You are a helpful assistant.' }}
+    {%- endif %}
+    {{- "\n\n# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within <tools></tools> XML tags:\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>\n\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\n<tool_call>\n{\"name\": <function-name>, \"arguments\": <args-json-object>}\n</tool_call><|im_end|>\n" }}
+{%- else %}
+    {%- if messages[0]['role'] == 'system' %}
+        {{- '<|im_start|>system\n' + messages[0]['content'] + '<|im_end|>\n' }}
+    {%- else %}
+        {{- '<|im_start|>system\nYou are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- for message in messages %}
+    {%- if (message.role == "user") or (message.role == "system" and not loop.first) or (message.role == "assistant" and not message.tool_calls) %}
+        {{- '<|im_start|>' + message.role + '\n' + message.content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {{- '<|im_start|>' + message.role }}
+        {%- if message.content %}
+            {{- '\n' + message.content }}
+        {%- endif %}
+        {%- for tool_call in message.tool_calls %}
+            {%- if tool_call.function is defined %}
+                {%- set tool_call = tool_call.function %}
+            {%- endif %}
+            {{- '\n<tool_call>\n{"name": "' }}
+            {{- tool_call.name }}
+            {{- '", "arguments": ' }}
+            {{- tool_call.arguments | tojson }}
+            {{- '}\n</tool_call>' }}
+        {%- endfor %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if (loop.index0 == 0) or (messages[loop.index0 - 1].role != "tool") %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {{- message.content }}
+        {{- '\n</tool_response>' }}
+        {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+{%- endif %}

results/phase1/checkpoint-100/README.md

@@ -0,0 +1,210 @@
+---
+base_model: unsloth/qwen2.5-1.5b-instruct-unsloth-bnb-4bit
+library_name: peft
+pipeline_tag: text-generation
+tags:
+- base_model:adapter:unsloth/qwen2.5-1.5b-instruct-unsloth-bnb-4bit
+- grpo
+- lora
+- transformers
+- trl
+- unsloth
+---
+
+# Model Card for Model ID
+
+<!-- Provide a quick summary of what the model is/does. -->
+
+
+
+## Model Details
+
+### Model Description
+
+<!-- Provide a longer summary of what this model is. -->
+
+
+
+- **Developed by:** [More Information Needed]
+- **Funded by [optional]:** [More Information Needed]
+- **Shared by [optional]:** [More Information Needed]
+- **Model type:** [More Information Needed]
+- **Language(s) (NLP):** [More Information Needed]
+- **License:** [More Information Needed]
+- **Finetuned from model [optional]:** [More Information Needed]
+
+### Model Sources [optional]
+
+<!-- Provide the basic links for the model. -->
+
+- **Repository:** [More Information Needed]
+- **Paper [optional]:** [More Information Needed]
+- **Demo [optional]:** [More Information Needed]
+
+## Uses
+
+<!-- Address questions around how the model is intended to be used, including the foreseeable users of the model and those affected by the model. -->
+
+### Direct Use
+
+<!-- This section is for the model use without fine-tuning or plugging into a larger ecosystem/app. -->
+
+[More Information Needed]
+
+### Downstream Use [optional]
+
+<!-- This section is for the model use when fine-tuned for a task, or when plugged into a larger ecosystem/app -->
+
+[More Information Needed]
+
+### Out-of-Scope Use
+
+<!-- This section addresses misuse, malicious use, and uses that the model will not work well for. -->
+
+[More Information Needed]
+
+## Bias, Risks, and Limitations
+
+<!-- This section is meant to convey both technical and sociotechnical limitations. -->
+
+[More Information Needed]
+
+### Recommendations
+
+<!-- This section is meant to convey recommendations with respect to the bias, risk, and technical limitations. -->
+
+Users (both direct and downstream) should be made aware of the risks, biases and limitations of the model. More information needed for further recommendations.
+
+## How to Get Started with the Model
+
+Use the code below to get started with the model.
+
+[More Information Needed]
+
+## Training Details
+
+### Training Data
+
+<!-- This should link to a Dataset Card, perhaps with a short stub of information on what the training data is all about as well as documentation related to data pre-processing or additional filtering. -->
+
+[More Information Needed]
+
+### Training Procedure
+
+<!-- This relates heavily to the Technical Specifications. Content here should link to that section when it is relevant to the training procedure. -->
+
+#### Preprocessing [optional]
+
+[More Information Needed]
+
+
+#### Training Hyperparameters
+
+- **Training regime:** [More Information Needed] <!--fp32, fp16 mixed precision, bf16 mixed precision, bf16 non-mixed precision, fp16 non-mixed precision, fp8 mixed precision -->
+
+#### Speeds, Sizes, Times [optional]
+
+<!-- This section provides information about throughput, start/end time, checkpoint size if relevant, etc. -->
+
+[More Information Needed]
+
+## Evaluation
+
+<!-- This section describes the evaluation protocols and provides the results. -->
+
+### Testing Data, Factors & Metrics
+
+#### Testing Data
+
+<!-- This should link to a Dataset Card if possible. -->
+
+[More Information Needed]
+
+#### Factors
+
+<!-- These are the things the evaluation is disaggregating by, e.g., subpopulations or domains. -->
+
+[More Information Needed]
+
+#### Metrics
+
+<!-- These are the evaluation metrics being used, ideally with a description of why. -->
+
+[More Information Needed]
+
+### Results
+
+[More Information Needed]
+
+#### Summary
+
+
+
+## Model Examination [optional]
+
+<!-- Relevant interpretability work for the model goes here -->
+
+[More Information Needed]
+
+## Environmental Impact
+
+<!-- Total emissions (in grams of CO2eq) and additional considerations, such as electricity usage, go here. Edit the suggested text below accordingly -->
+
+Carbon emissions can be estimated using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700).
+
+- **Hardware Type:** [More Information Needed]
+- **Hours used:** [More Information Needed]
+- **Cloud Provider:** [More Information Needed]
+- **Compute Region:** [More Information Needed]
+- **Carbon Emitted:** [More Information Needed]
+
+## Technical Specifications [optional]
+
+### Model Architecture and Objective
+
+[More Information Needed]
+
+### Compute Infrastructure
+
+[More Information Needed]
+
+#### Hardware
+
+[More Information Needed]
+
+#### Software
+
+[More Information Needed]
+
+## Citation [optional]
+
+<!-- If there is a paper or blog post introducing the model, the APA and Bibtex information for that should go in this section. -->
+
+**BibTeX:**
+
+[More Information Needed]
+
+**APA:**
+
+[More Information Needed]
+
+## Glossary [optional]
+
+<!-- If relevant, include terms and calculations in this section that can help readers understand the model or model card. -->
+
+[More Information Needed]
+
+## More Information [optional]
+
+[More Information Needed]
+
+## Model Card Authors [optional]
+
+[More Information Needed]
+
+## Model Card Contact
+
+[More Information Needed]
+### Framework versions
+
+- PEFT 0.18.1

results/phase1/checkpoint-100/adapter_config.json

@@ -0,0 +1,50 @@
+{
+  "alora_invocation_tokens": null,
+  "alpha_pattern": {},
+  "arrow_config": null,
+  "auto_mapping": {
+    "base_model_class": "Qwen2ForCausalLM",
+    "parent_library": "transformers.models.qwen2.modeling_qwen2",
+    "unsloth_fixed": true
+  },
+  "base_model_name_or_path": "unsloth/qwen2.5-1.5b-instruct-unsloth-bnb-4bit",
+  "bias": "none",
+  "corda_config": null,
+  "ensure_weight_tying": false,
+  "eva_config": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": true,
+  "init_lora_weights": true,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 32,
+  "lora_bias": false,
+  "lora_dropout": 0.05,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "peft_type": "LORA",
+  "peft_version": "0.18.1",
+  "qalora_group_size": 16,
+  "r": 16,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": [
+    "k_proj",
+    "up_proj",
+    "down_proj",
+    "o_proj",
+    "v_proj",
+    "gate_proj",
+    "q_proj"
+  ],
+  "target_parameters": null,
+  "task_type": "CAUSAL_LM",
+  "trainable_token_indices": null,
+  "use_dora": false,
+  "use_qalora": false,
+  "use_rslora": false
+}

results/phase1/checkpoint-100/adapter_model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d430aea910e6d8b7347568b5b75ef11de9ff5b23b6d2010fd456033e1f218b07
+size 73911112

results/phase1/checkpoint-100/chat_template.jinja

@@ -0,0 +1,54 @@
+{%- if tools %}
+    {{- '<|im_start|>system\n' }}
+    {%- if messages[0]['role'] == 'system' %}
+        {{- messages[0]['content'] }}
+    {%- else %}
+        {{- 'You are Qwen, created by Alibaba Cloud. You are a helpful assistant.' }}
+    {%- endif %}
+    {{- "\n\n# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within <tools></tools> XML tags:\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>\n\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\n<tool_call>\n{\"name\": <function-name>, \"arguments\": <args-json-object>}\n</tool_call><|im_end|>\n" }}
+{%- else %}
+    {%- if messages[0]['role'] == 'system' %}
+        {{- '<|im_start|>system\n' + messages[0]['content'] + '<|im_end|>\n' }}
+    {%- else %}
+        {{- '<|im_start|>system\nYou are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- for message in messages %}
+    {%- if (message.role == "user") or (message.role == "system" and not loop.first) or (message.role == "assistant" and not message.tool_calls) %}
+        {{- '<|im_start|>' + message.role + '\n' + message.content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {{- '<|im_start|>' + message.role }}
+        {%- if message.content %}
+            {{- '\n' + message.content }}
+        {%- endif %}
+        {%- for tool_call in message.tool_calls %}
+            {%- if tool_call.function is defined %}
+                {%- set tool_call = tool_call.function %}
+            {%- endif %}
+            {{- '\n<tool_call>\n{"name": "' }}
+            {{- tool_call.name }}
+            {{- '", "arguments": ' }}
+            {{- tool_call.arguments | tojson }}
+            {{- '}\n</tool_call>' }}
+        {%- endfor %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if (loop.index0 == 0) or (messages[loop.index0 - 1].role != "tool") %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {{- message.content }}
+        {{- '\n</tool_response>' }}
+        {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+{%- endif %}

results/phase1/checkpoint-100/optimizer.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:13de9f002823fbe63e71b9d1eb8ec6d2c4b8eca35a4ee367099322a459b3b1cb
+size 37969669

results/phase1/checkpoint-100/rng_state.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c1449e60d52f06cceec8589785267b0457345be74a8ca37687099a6addff91e0
+size 14645

results/phase1/checkpoint-100/scaler.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c4393a84a3109995aa1202073b039b12062e3189ed89aa0b94ef0510ba843009
+size 1383

results/phase1/checkpoint-100/scheduler.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7254cd54e69ff9b68992c6e5838d1590c8e033e5a4605990d0b4034185923db6
+size 1465

results/phase1/checkpoint-100/tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:af5891a15588546db1ac7f2baf8fa94835a51a85c032c39793a55bb048b47446
+size 11422523