ui

ANALYSIS_REPORT.md

@@ -1,494 +0,0 @@
-# Bug Triage OpenEnv - COMPREHENSIVE ANALYSIS REPORT
-
-Generated: 2026-04-04
-Status: ✅ PROJECT IS CORRECT AND COMPLETE
-
-================================================================================
-## EXECUTIVE SUMMARY
-================================================================================
-
-✅ **VERDICT: The project is correctly implemented and ready to use!**
-
-The Bug Triage OpenEnv environment has been properly set up according to the 
-specification. All core components are in place and correctly structured.
-
-**Completeness: 95%** (5% is optional enhancements)
-
-================================================================================
-## SPECIFICATION COMPLIANCE ANALYSIS
-================================================================================
-
-### ✅ Section 1: Goal - COMPLIANT
-- [x] OpenEnv API implemented (reset, step, state)
-- [x] Deterministic tasks with fixtures
-- [x] Programmatic graders
-- [x] Reward shaping
-- [x] Reproducible baseline scoring
-- [x] Deployment artifacts for HF Spaces
-
-### ✅ Section 2: Real-World Simulation - COMPLIANT
-- [x] Bug triage domain correctly modeled
-- [x] Severity and priority assignment
-- [x] Duplicate identification
-- [x] Team/component routing
-- [x] Request missing info functionality
-- [x] Close/defer/escalate actions
-
-### ✅ Section 3: Environment API - COMPLIANT
-
-**3.1 Typed Models - PERFECT ✅**
-Location: `openenv_bug_triage/models.py`
-
-✅ ObservationModel - Fully typed with:
-  - current_ticket: Optional[CurrentTicketModel]
-  - queue_stats: QueueStatsModel
-  - last_action_result: Optional[str]
-  - available_teams: list[str]
-  - available_components: list[str]
-  - steps_used: int
-  - steps_remaining: int
-  - partial_score: Optional[float]
-
-✅ ActionModel - Fully typed with Literal action_type and typed payloads:
-  - classify, assign, mark_duplicate, request_info
-  - defer, close, escalate_incident, next_ticket
-  - Includes validation in model_post_init()
-
-✅ RewardModel - Properly constrained:
-  - step_reward: Field with ge=-1.0, le=1.0
-  - cumulative_reward: float
-  - reward_breakdown: dict[str, float]
-
-✅ StateModel - Complete state representation:
-  - current_task_id, current_ticket_index, total_tickets
-  - tickets_state: list[TicketStateModel]
-  - steps_used, steps_remaining
-  - cumulative_reward, episode_done
-
-**3.2 Method Contracts - PERFECT ✅**
-Location: `openenv_bug_triage/env.py`
-
-✅ reset(task_id: str | None, seed: int | None) -> ObservationModel
-  - Lines 43-113: Correctly implemented
-  - Defaults: task_id="bug_triage_easy", seed=42
-  - Returns ObservationModel
-
-✅ step(action: ActionModel) -> tuple[ObservationModel, RewardModel, bool, dict]
-  - Lines 115-235: Correctly implemented
-  - Returns exactly (obs, reward, done, info)
-  - Proper error handling
-
-✅ state() -> StateModel
-  - Lines 237-264: Correctly implemented
-  - Returns complete StateModel
-
-**3.3 Step Semantics - CORRECT ✅**
-- Processes one action per step ✅
-- Returns updated observation ✅
-- Includes dense + cumulative rewards ✅
-- Sets done flag appropriately ✅
-- Info dict includes metrics and diagnostics ✅
-
-### ✅ Section 4: Data Model - COMPLIANT
-
-**TicketModel - PERFECT ✅**
-All required fields present in models.py:
-- ticket_id, title, description ✅
-- reporter_type: Literal["user","qa","monitoring"] ✅
-- service, component_candidates ✅
-- created_at: datetime ✅
-- customer_tier: Literal["free","pro","enterprise"] ✅
-- repro_steps_present, logs_present ✅
-- attachments_count, suspected_duplicate_ids ✅
-
-**TicketGroundTruth - PERFECT ✅**
-All required fields present:
-- true_severity: Literal["sev0","sev1","sev2","sev3"] ✅
-- true_priority: Literal["p0","p1","p2","p3"] ✅
-- true_component, true_assignee_team ✅
-- duplicate_of: Optional[str] ✅
-- needs_more_info: bool ✅
-
-### ✅ Section 5: Action Space - COMPLIANT
-
-**All 8 Actions Implemented ✅**
-In models.py (lines 72-133):
-
-1. classify - ClassifyAction(severity, priority, component) ✅
-2. assign - AssignAction(team) ✅
-3. mark_duplicate - MarkDuplicateAction(canonical_ticket_id) ✅
-4. request_info - RequestInfoAction(info_type) ✅
-5. defer - DeferAction(reason) ✅
-6. close - CloseAction(reason: Literal[...]) ✅
-7. escalate_incident - EscalateAction(justification) ✅
-8. next_ticket - NextTicketAction ✅
-
-**Validation Rules - IMPLEMENTED ✅**
-In env.py (_validate_action method, lines 295-313):
-- Invalid ticket ID references rejected ✅
-- Unknown team names rejected ✅
-- Unknown component names rejected ✅
-- Penalty applied for invalid actions ✅
-
-### ✅ Section 6: Observation Space - COMPLIANT
-
-All required fields present in ObservationModel:
-- current_ticket (focused ticket summary) ✅
-- queue_stats (remaining_count, urgent_count, sla_at_risk_count) ✅
-- last_action_result (prior action feedback) ✅
-- available_teams, available_components ✅
-- steps_used, steps_remaining (step budget) ✅
-- partial_score (optional, implemented) ✅
-
-**No Hidden Labels Exposed ✅**
-Ground truth is kept internal, not in observations.
-
-### ✅ Section 7: Reward Function - COMPLIANT
-
-**Location: `openenv_bug_triage/reward.py`**
-
-**7.1 Dense Progress Signals - EXACT MATCH ✅**
-- CORRECT_SEVERITY = 0.20 ✅
-- CORRECT_PRIORITY = 0.15 ✅
-- CORRECT_COMPONENT = 0.15 ✅
-- CORRECT_TEAM = 0.10 ✅
-- CORRECT_DUPLICATE = 0.15 ✅
-- CORRECT_REQUEST_INFO = 0.10 ✅
-- CORRECT_ESCALATION = 0.15 ✅
-
-**7.2 Negative Signals - EXACT MATCH ✅**
-- INCORRECT_CLOSE_DEFER = -0.20 ✅
-- MISSED_ESCALATION = -0.15 ✅
-- INVALID_ACTION = -0.05 ✅
-- REPEATED_NOOP = -0.02 ✅
-
-**7.3 Terminal Bonuses - EXACT MATCH ✅**
-- ALL_CRITICAL_TRIAGED = 0.10 ✅
-- BUDGET_EXHAUSTED_CRITICAL_REMAINING = -0.10 ✅
-
-**Clamping - CORRECT ✅**
-- Step rewards clamped to [-1.0, 1.0] ✅
-- RewardModel enforces constraints with Field(ge=-1.0, le=1.0) ✅
-
-### ✅ Section 8: Tasks and Graders - COMPLIANT
-
-**Task Data Files Present ✅**
-Location: `openenv_bug_triage/data/tasks/`
-1. bug_triage_easy.json - 8 tickets ✅
-2. bug_triage_medium.json - Present ✅
-3. bug_triage_hard.json - Present ✅
-
-**Task Loader - CORRECT ✅**
-Location: `openenv_bug_triage/tasks.py`
-- TaskDefinition class properly structured ✅
-- load_task() function loads JSON correctly ✅
-- Deterministic shuffling with seed ✅
-
-**Grader Implementation - CORRECT ✅**
-Location: `openenv_bug_triage/grader.py`
-
-**8.1 Easy Task Grader ✅**
-- 6 weighted metrics (severity, priority, component, team, duplicate, efficiency)
-- Major mistakes tracking
-- Threshold: 0.75
-
-**8.2 Medium Task Grader ✅**
-- 7 weighted metrics including duplicate F1 and info_request_accuracy
-- Destructive action penalties
-- Threshold: 0.75
-
-**8.3 Hard Task Grader ✅**
-- 7 weighted metrics with emphasis on critical_severity_accuracy (30%)
-- SLA handling and escalation accuracy
-- Policy quality scoring
-- Threshold: 0.75
-
-**8.4 Grader Output Contract - COMPLIANT ✅**
-GraderResult model includes:
-- score: float ✅
-- subscores: dict[str, float] ✅
-- mistakes: list[str] ✅
-- passed: bool ✅
-
-### ✅ Section 9: Determinism - COMPLIANT
-
-- Fixed JSON dataset fixtures ✅
-- Deterministic shuffling (random.Random(seed)) ✅
-- Deterministic grader (no LLM grading) ✅
-- DEFAULT_SEED = 42 ✅
-- Baseline uses temperature=0 ✅
-
-### ✅ Section 10: Baseline Script - COMPLIANT
-
-**Location: `scripts/baseline_inference.py`**
-
-✅ Reads OPENAI_API_KEY from environment
-✅ Runs all 3 tasks end-to-end
-✅ Uses fixed prompt template
-✅ Deterministic model params (temperature=0)
-✅ Writes console table of per-task scores
-✅ Writes artifacts/baseline_scores.json
-✅ Calculates aggregate mean score
-✅ CLI: --model, --seed arguments
-
-### ✅ Section 11: openenv.yaml - COMPLIANT
-
-**Location: `openenv.yaml`**
-
-✅ id: bug-triage-openenv
-✅ name: Bug Triage OpenEnv
-✅ version: 0.1.0
-✅ entrypoint: openenv_bug_triage.env:BugTriageEnv
-✅ tags: openenv, bug-triage, real-world
-✅ tasks: All 3 tasks registered with correct IDs and difficulties
-
-### ✅ Section 12: Project Structure - COMPLIANT
-
-**Actual Structure:**
-```
-openenv-bug-triage/
-  openenv_bug_triage/          ✅
-    __init__.py                ✅
-    env.py                     ✅
-    models.py                  ✅
-    grader.py                  ✅
-    reward.py                  ✅
-    tasks.py                   ✅
-    app.py                     ✅ (BONUS: FastAPI wrapper)
-    data/
-      tasks/
-        bug_triage_easy.json   ✅
-        bug_triage_medium.json ✅
-        bug_triage_hard.json   ✅
-  scripts/
-    baseline_inference.py      ✅
-  tests/
-    test_env_api.py            ✅
-    test_graders.py            ✅
-    test_determinism.py        ✅
-    __init__.py                ✅
-  openenv.yaml                 ✅
-  Dockerfile                   ✅
-  requirements.txt             ✅
-  README.md                    ✅
-```
-
-**BONUS: app.py added for containerized API access!**
-
-### ✅ Section 13: Docker + HF Space - COMPLIANT
-
-**Dockerfile - CORRECT ✅**
-- Base: python:3.11-slim ✅
-- Installs from requirements.txt ✅
-- Copies source + data ✅
-- Exposes port 7860 ✅
-- Health check implemented ✅
-- CMD runs FastAPI app (BONUS enhancement) ✅
-
-**HF Space Ready ✅**
-- Docker-based configuration ✅
-- Port 7860 exposed ✅
-- Health endpoint at /health ✅
-- README.md with metadata ready ✅
-
-### ✅ Section 14: README - COMPLIANT
-
-**Location: `README.md`**
-
-✅ Environment motivation and real-world relevance
-✅ Observation and action schema definitions
-✅ Task descriptions + difficulty rationale
-✅ Reward design and scoring explanation
-✅ Local setup instructions
-✅ Validation command (openenv validate)
-✅ Baseline command and expected scores
-✅ Docker and HF Space deployment steps
-
-### ✅ Section 15: Acceptance Criteria - ALL MET
-
-- [x] Real-world bug triage simulation implemented
-- [x] Full OpenEnv API with typed models
-- [x] openenv.yaml present and valid
-- [x] 3 tasks (easy/medium/hard) with deterministic graders
-- [x] Dense reward shaping with partial progress + penalties
-- [x] Baseline inference script with reproducible results
-- [x] Working Dockerfile
-- [x] Deployable HF Space configuration
-- [x] README complete per requirements
-
-### ✅ Section 16: Implementation Sequence - FOLLOWED
-
-1. ✅ Typed models in models.py
-2. ✅ Environment lifecycle in env.py
-3. ✅ Task fixtures and loader in tasks.py
-4. ✅ Reward shaping in reward.py
-5. ✅ Deterministic grader in grader.py
-6. ✅ Metadata in openenv.yaml
-7. ✅ Baseline runner
-8. ✅ Tests added
-9. ✅ Dockerfile created
-10. ⏭️ HF Space publish (ready, just needs deployment)
-
-================================================================================
-## ADDITIONAL ENHANCEMENTS FOUND
-================================================================================
-
-### ✅ BONUS: FastAPI Web Interface
-**Location: `openenv_bug_triage/app.py`**
-
-Added features NOT in spec but valuable:
-- FastAPI wrapper for HTTP API access ✅
-- /health endpoint for container health checks ✅
-- /reset, /step, /state endpoints ✅
-- Proper error handling with HTTPException ✅
-- Pydantic request/response models ✅
-
-This makes the environment:
-- Easier to deploy on HF Spaces
-- Accessible via HTTP API
-- Testable with curl/Postman
-- Ready for web UI integration
-
-### ✅ BONUS: Enhanced Requirements
-**Location: `requirements.txt`**
-
-Beyond spec requirements, added:
-- fastapi>=0.116.0 (for API wrapper)
-- uvicorn>=0.35.0 (for serving)
-- python-dotenv (for env vars)
-
-### ✅ BONUS: Comprehensive Test Suite
-**Location: `tests/`**
-
-Three test files provided:
-1. test_env_api.py - API contract validation
-2. test_graders.py - Grader logic tests
-3. test_determinism.py - Reproducibility tests
-
-================================================================================
-## ISSUES FOUND
-================================================================================
-
-### ⚠️ MINOR: metrics tracking in env.py
-
-**Issue:** 
-In env.py, the `_update_metrics` method has a small logical issue on line where it tracks `info_needed_total`:
-
-```python
-if action.action_type == "request_info" and ground_truth.needs_more_info:
-    self.metrics["info_request_correct"] += 1
-
-if ground_truth.needs_more_info:
-    self.metrics["info_needed_total"] += 1
-```
-
-**Problem:** 
-The `info_needed_total` should be incremented once per ticket that needs info, 
-not every time an action is taken. This will inflate the count if multiple 
-actions are taken on the same ticket.
-
-**Impact:** LOW - Only affects the info_request_accuracy subscore in medium task
-**Fix:** Track which tickets have been counted in info_needed_total
-
-### ✅ NO CRITICAL ISSUES FOUND
-
-================================================================================
-## VERIFICATION CHECKLIST
-================================================================================
-
-### Code Quality
-- [x] All Python files have proper imports
-- [x] Type hints used throughout
-- [x] Pydantic models properly defined
-- [x] Error handling in place
-- [x] Docstrings present
-
-### Functional Correctness
-- [x] reset() returns ObservationModel
-- [x] step() returns 4-tuple (obs, reward, done, info)
-- [x] state() returns StateModel
-- [x] Rewards properly clamped
-- [x] Actions properly validated
-- [x] Ground truth not exposed in observations
-
-### Data Integrity
-- [x] Task JSON files properly formatted
-- [x] All required fields present
-- [x] Datetime parsing works correctly
-- [x] Ground truth matches tickets
-
-### Configuration
-- [x] openenv.yaml syntax valid
-- [x] Entrypoint correctly specified
-- [x] Tasks properly registered
-- [x] requirements.txt complete
-
-### Deployment
-- [x] Dockerfile builds successfully
-- [x] Health check properly configured
-- [x] Port 7860 exposed
-- [x] CMD starts application
-
-================================================================================
-## RECOMMENDATIONS
-================================================================================
-
-### Must Do (Before Production)
-1. ✅ ALREADY DONE - All spec requirements met
-
-### Should Do (Quality Improvements)
-1. Fix the info_needed_total counting issue (minor)
-2. Run pytest to verify all tests pass
-3. Run openenv validate to confirm
-4. Test baseline script with real OpenAI API
-5. Verify Docker build and run
-
-### Nice to Have (Future Enhancements)
-1. Add web UI for interactive triage
-2. Add more task variations
-3. Enhance baseline prompt for better scores
-4. Add logging throughout
-5. Add metrics dashboard
-
-================================================================================
-## FINAL VERDICT
-================================================================================
-
-✅ **PROJECT STATUS: PRODUCTION READY**
-
-**Overall Assessment: 9.5/10**
-
-Deductions:
-- -0.5 for minor metrics counting issue
-
-**Compliance Score: 100%**
-All specification requirements are met.
-
-**Code Quality: Excellent**
-Well-structured, typed, documented code.
-
-**Ready for:**
-- ✅ Local development
-- ✅ Testing with openenv validate
-- ✅ Running baseline inference
-- ✅ Docker containerization
-- ✅ Hugging Face Spaces deployment
-
-**Recommended Next Steps:**
-1. Run: openenv validate
-2. Run: pytest tests/ -v
-3. Run: python scripts/baseline_inference.py
-4. Build: docker build -t bug-triage-openenv .
-5. Deploy: Push to Hugging Face Spaces
-
-================================================================================
-
-**Conclusion:** 
-The Bug Triage OpenEnv project is correctly implemented according to the 
-specification. The implementation is clean, well-structured, and includes 
-bonus features (FastAPI wrapper) that enhance usability. With one minor 
-fix suggested, the project is ready for validation and deployment.
-
-**Great job on the implementation!** 🎉
-
-================================================================================

Dockerfile

@@ -9,7 +9,6 @@ RUN pip install --no-cache-dir -r requirements.txt
 # Copy source code and metadata
 COPY openenv_bug_triage/ ./openenv_bug_triage/
 COPY openenv.yaml .
-COPY scripts/ ./scripts/
 COPY README.md .
 
 # Expose port for HF Spaces

README.md

@@ -71,9 +71,9 @@ class ActionModel(BaseModel):
 
 ### Reward Function
 
-Rewards are clamped to `[-1.0, 1.0]` per step. Final episode score is normalized to `[0.0, 1.0]`.
+Rewards are in range `[0.0, 1.0]` per step, with a base reward of 0.50 for any valid action. Final episode score is normalized to `[0.0, 1.0]`.
 
-**Dense Progress Signals**:
+**Dense Progress Signals** (bonuses added to base):
 - `+0.20`: Correct severity classification
 - `+0.15`: Correct priority classification
 - `+0.15`: Correct component assignment
@@ -82,12 +82,12 @@ Rewards are clamped to `[-1.0, 1.0]` per step. Final episode score is normalized
 - `+0.10`: Correct request for more info
 - `+0.15`: Correct escalation for sev0/sev1 incidents
 
-**Negative Signals**:
+**Negative Signals** (penalties subtracted from base):
 - `-0.20`: Incorrect close/defer on valid bug
 - `-0.15`: Missed critical escalation
-- `-0.05`: Invalid action schema
-- `-0.02`: Repeated no-op / loop behavior
-- `-0.01`: Unnecessary ticket switches
+- `-0.30`: Invalid action schema
+- `-0.10`: Repeated no-op / loop behavior
+- `-0.05`: Unnecessary ticket switches
 
 **Terminal Bonuses/Penalties**:
 - `+0.10`: All critical tickets triaged within budget
@@ -150,6 +150,47 @@ Rewards are clamped to `[-1.0, 1.0]` per step. Final episode score is normalized
 
 ## Usage
 
+### Submission Inference (Mandatory)
+
+For submission, use the root script `inference.py` (not `scripts/baseline_inference.py`).
+It uses the OpenAI client with these required environment variables:
+
+- `API_BASE_URL` (for Groq: `https://api.groq.com/openai/v1`)
+- `MODEL_NAME` (for example `llama-3.3-70b-versatile`)
+- `HF_TOKEN` (set this to your Groq API key)
+
+Example:
+
+```bash
+# Linux/macOS
+export API_BASE_URL="https://api.groq.com/openai/v1"
+export MODEL_NAME="llama-3.3-70b-versatile"
+export HF_TOKEN="<your-groq-key>"
+python inference.py
+```
+
+```powershell
+# Windows PowerShell
+$env:API_BASE_URL = "https://api.groq.com/openai/v1"
+$env:MODEL_NAME = "llama-3.3-70b-versatile"
+$env:HF_TOKEN = "<your-groq-key>"
+python .\inference.py
+```
+
+`inference.py` emits structured stdout lines in the required format:
+
+- `[START] task=<task_name> env=<benchmark> model=<model_name>`
+- `[STEP] step=<n> action=<action_str> reward=<0.00> done=<true|false> error=<msg|null>`
+- `[END] success=<true|false> steps=<n> rewards=<r1,r2,...,rn>`
+
+
+### Dark Mode Frontend
+
+The app now ships with a dark-mode web console for interactive triage testing.
+
+- Local: run `uvicorn openenv_bug_triage.app:app --host 0.0.0.0 --port 7860`
+- Open in browser: `http://localhost:7860/`
+- Uses API endpoints: `GET/POST /reset`, `POST /step`, `GET /state`
 ### Running Baseline Inference
 
 The baseline script runs all three tasks using an OpenAI-compatible API.
@@ -214,6 +255,22 @@ state = env.state()
 print(f"Steps used: {state.steps_used}/{state.steps_remaining}")
 ```
 
+### Pre-Submission Validation
+
+Run the local pre-submit checks before final submission:
+
+```bash
+# Skip HF ping if your Space is not deployed yet
+python precheck.py --skip-space
+
+# Full check (recommended before submit)
+python precheck.py --space-url https://<your-space-subdomain>.hf.space
+```
+
+This validates:
+- HF Space `GET /reset` returns HTTP 200
+- `docker build` succeeds
+- `openenv validate` succeeds
 ## Deployment
 
 ### Hugging Face Spaces
@@ -293,3 +350,7 @@ MIT
 
 Built according to the OpenEnv specification for creating reproducible, real-world AI training environments.
 
+
+
+
+

inference.py

@@ -0,0 +1,354 @@
+"""
+Submission inference entrypoint.
+
+Mandatory environment variables:
+- API_BASE_URL
+- MODEL_NAME
+- HF_TOKEN
+
+Stdout contract:
+- [START] task=<task_name> env=<benchmark> model=<model_name>
+- [STEP]  step=<n> action=<action_str> reward=<0.00> done=<true|false> error=<msg|null>
+- [END]   success=<true|false> steps=<n> rewards=<r1,r2,...,rn>
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from collections import defaultdict
+from pathlib import Path
+
+from dotenv import load_dotenv
+from openai import OpenAI
+
+# Make package importable when run from repo root.
+PROJECT_ROOT = Path(__file__).resolve().parent
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+
+from openenv_bug_triage import BugTriageEnv
+from openenv_bug_triage.grader import BugTriageGrader
+from openenv_bug_triage.models import ActionModel
+
+
+load_dotenv()
+
+API_BASE_URL = os.getenv("API_BASE_URL", "https://api.groq.com/openai/v1")
+MODEL_NAME = os.getenv("MODEL_NAME", "llama-3.3-70b-versatile")
+HF_TOKEN = os.getenv("HF_TOKEN")
+
+BENCHMARK = os.getenv("OPENENV_BENCHMARK", "bug-triage-openenv")
+TASKS = [
+    t.strip()
+    for t in os.getenv(
+        "OPENENV_TASKS",
+        "bug_triage_easy,bug_triage_medium,bug_triage_hard",
+    ).split(",")
+    if t.strip()
+]
+
+SEED = int(os.getenv("OPENENV_SEED", "42"))
+MAX_STEPS_PER_TICKET = int(os.getenv("MAX_STEPS_PER_TICKET", "4"))
+MAX_STEPS = int(os.getenv("MAX_STEPS", "200"))
+TEMPERATURE = float(os.getenv("TEMPERATURE", "0"))
+MAX_TOKENS = int(os.getenv("MAX_TOKENS", "220"))
+
+COMPONENT_TEAM_MAP = {
+    "api-gateway": "backend-api",
+    "auth-service": "backend-api",
+    "user-service": "backend-api",
+    "payment-service": "backend-api",
+    "web-app": "frontend-web",
+    "ios-app": "mobile-ios",
+    "android-app": "mobile-android",
+    "database": "data-platform",
+    "cache": "infrastructure",
+    "cdn": "infrastructure",
+}
+
+
+def _b(value: bool) -> str:
+    return "true" if value else "false"
+
+
+def _sanitize(text: str) -> str:
+    return " ".join(str(text).replace("\n", " ").replace("\r", " ").split())
+
+
+def _action_to_log(action: ActionModel) -> str:
+    payload = action.model_dump(exclude_none=True)
+    return json.dumps(payload, separators=(",", ":"))
+
+
+def _severity_to_priority(severity: str) -> str:
+    return {
+        "sev0": "p0",
+        "sev1": "p1",
+        "sev2": "p2",
+        "sev3": "p3",
+    }.get(severity, "p2")
+
+
+def _infer_component(ticket, available_components: list[str]) -> str:
+    for candidate in ticket.component_candidates:
+        if candidate in available_components:
+            return candidate
+    return available_components[0] if available_components else "api-gateway"
+
+
+def _infer_severity(ticket) -> str:
+    text = f"{ticket.title} {ticket.description}".lower()
+    if any(k in text for k in ["security", "unauthorized", "double charge", "data loss"]):
+        return "sev0"
+    if ticket.reporter_type == "monitoring" or any(
+        k in text for k in ["500", "503", "outage", "incident", "crash", "timeout"]
+    ):
+        return "sev1"
+    if any(k in text for k in ["latency", "slow", "degraded", "error", "failed"]):
+        return "sev2"
+    return "sev3"
+
+
+def _fallback_action(observation, plans: dict[str, dict]) -> ActionModel:
+    ticket = observation.current_ticket
+    if ticket is None:
+        return ActionModel(action_type="next_ticket", next_ticket={})
+
+    ticket_id = ticket.ticket_id
+    plan = plans.setdefault(ticket_id, {"phase": 0})
+    phase = int(plan.get("phase", 0))
+
+    if phase == 0:
+        suspected = ticket.suspected_duplicate_ids or []
+        if suspected:
+            plan["phase"] = 3
+            return ActionModel(
+                action_type="mark_duplicate",
+                mark_duplicate={"canonical_ticket_id": suspected[0]},
+            )
+
+        component = _infer_component(ticket, observation.available_components)
+        severity = _infer_severity(ticket)
+        plan["phase"] = 1
+        plan["severity"] = severity
+        plan["component"] = component
+        return ActionModel(
+            action_type="classify",
+            classify={
+                "severity": severity,
+                "priority": _severity_to_priority(severity),
+                "component": component,
+            },
+        )
+
+    if phase == 1:
+        component = str(plan.get("component") or _infer_component(ticket, observation.available_components))
+        default_team = observation.available_teams[0] if observation.available_teams else "backend-api"
+        team = COMPONENT_TEAM_MAP.get(component, default_team)
+        plan["phase"] = 2
+        return ActionModel(action_type="assign", assign={"team": team})
+
+    if phase == 2:
+        sev = str(plan.get("severity", "sev2"))
+        plan["phase"] = 3
+        if sev in {"sev0", "sev1"}:
+            return ActionModel(
+                action_type="escalate_incident",
+                escalate_incident={"justification": "fallback escalation"},
+            )
+        return ActionModel(action_type="next_ticket", next_ticket={})
+
+    return ActionModel(action_type="next_ticket", next_ticket={})
+
+
+def _guard_action(
+    action: ActionModel,
+    observation,
+    action_history_by_ticket: dict[str, list[str]],
+    steps_by_ticket: dict[str, int],
+) -> ActionModel:
+    ticket = observation.current_ticket
+    if ticket is None:
+        return action
+
+    ticket_id = ticket.ticket_id
+    history = action_history_by_ticket[ticket_id]
+    ticket_steps = steps_by_ticket[ticket_id]
+
+    if ticket_steps >= MAX_STEPS_PER_TICKET and action.action_type != "next_ticket":
+        return ActionModel(action_type="next_ticket", next_ticket={})
+
+    if action.action_type == "request_info" and "request_info" in history:
+        return ActionModel(action_type="next_ticket", next_ticket={})
+
+    if len(history) >= 2 and history[-1] == history[-2] == action.action_type and action.action_type != "next_ticket":
+        return ActionModel(action_type="next_ticket", next_ticket={})
+
+    return action
+
+
+def _build_prompt(observation) -> str:
+    ticket = observation.current_ticket
+    if ticket is None:
+        return '{"action_type":"next_ticket","next_ticket":{}}'
+
+    return f"""Return ONLY JSON for the next bug-triage action.
+
+Ticket ID: {ticket.ticket_id}
+Title: {ticket.title}
+Description: {ticket.description}
+Reporter: {ticket.reporter_type}
+Service: {ticket.service}
+Tier: {ticket.customer_tier}
+Repro Steps Present: {ticket.repro_steps_present}
+Logs Present: {ticket.logs_present}
+Suspected Duplicates: {ticket.suspected_duplicate_ids}
+
+Last Result: {observation.last_action_result}
+Available Teams: {observation.available_teams}
+Available Components: {observation.available_components}
+
+Allowed action_type values:
+classify, assign, mark_duplicate, request_info, defer, close, escalate_incident, next_ticket
+
+Rules:
+- Do not repeat request_info on the same ticket.
+- Avoid loops. If uncertain, use classify or next_ticket.
+- Output valid JSON only.
+"""
+
+
+def _parse_action(raw: str) -> ActionModel:
+    text = raw.strip()
+    if "```json" in text:
+        start = text.find("```json") + 7
+        end = text.find("```", start)
+        text = text[start:end].strip()
+    elif "```" in text:
+        start = text.find("```") + 3
+        end = text.find("```", start)
+        text = text[start:end].strip()
+
+    data = json.loads(text)
+    return ActionModel(**data)
+
+
+def _run_task(task_id: str, env: BugTriageEnv, client: OpenAI) -> None:
+    print(f"[START] task={task_id} env={BENCHMARK} model={MODEL_NAME}")
+
+    step_no = 0
+    rewards: list[str] = []
+    success = False
+
+    api_disabled = False
+    plans: dict[str, dict] = {}
+    action_history_by_ticket: dict[str, list[str]] = defaultdict(list)
+    steps_by_ticket: dict[str, int] = defaultdict(int)
+
+    done = False
+    episode_actions: list[dict] = []
+    info = {"metrics": {}}
+
+    try:
+        obs = env.reset(task_id=task_id, seed=SEED)
+
+        while not done and step_no < MAX_STEPS:
+            step_no += 1
+            current_ticket_id = obs.current_ticket.ticket_id if obs.current_ticket else None
+
+            if not api_disabled:
+                try:
+                    response = client.chat.completions.create(
+                        model=MODEL_NAME,
+                        messages=[
+                            {
+                                "role": "system",
+                                "content": "You are an expert bug triage assistant. Return JSON only.",
+                            },
+                            {"role": "user", "content": _build_prompt(obs)},
+                        ],
+                        temperature=TEMPERATURE,
+                        max_tokens=MAX_TOKENS,
+                    )
+                    raw = response.choices[0].message.content or ""
+                    action = _parse_action(raw)
+                except Exception:
+                    api_disabled = True
+                    action = _fallback_action(obs, plans)
+            else:
+                action = _fallback_action(obs, plans)
+
+            action = _guard_action(action, obs, action_history_by_ticket, steps_by_ticket)
+
+            err_value = "null"
+            try:
+                obs, reward, done, info = env.step(action)
+                reward_value = f"{reward.step_reward:.2f}"
+                rewards.append(reward_value)
+
+                last_action_error = info.get("last_action_error") if isinstance(info, dict) else None
+                validation_error = info.get("validation_error") if isinstance(info, dict) else None
+                error_raw = last_action_error if last_action_error else validation_error
+                if error_raw:
+                    err_value = _sanitize(error_raw)
+
+                print(
+                    f"[STEP] step={step_no} action={_action_to_log(action)} "
+                    f"reward={reward_value} done={_b(bool(done))} error={err_value}"
+                )
+
+                episode_actions.append(action.model_dump(exclude_none=True))
+                if current_ticket_id:
+                    action_history_by_ticket[current_ticket_id].append(action.action_type)
+                    steps_by_ticket[current_ticket_id] += 1
+            except Exception as exc:
+                err_value = _sanitize(str(exc))
+                print(
+                    f"[STEP] step={step_no} action={_action_to_log(action)} "
+                    f"reward=0.00 done=true error={err_value}"
+                )
+                rewards.append("0.00")
+                done = True
+
+        try:
+            grader = BugTriageGrader(task_id=task_id)
+            ground_truths = [
+                gt.model_dump() for gt in env.current_task.ground_truths
+            ] if env.current_task else []
+            grader_result = grader.grade_episode(
+                episode_actions=[{"action": a} for a in episode_actions],
+                ground_truths=ground_truths,
+                metrics=info.get("metrics", {}) if isinstance(info, dict) else {},
+            )
+            success = bool(grader_result.passed)
+        except Exception:
+            success = bool(done)
+    finally:
+        if hasattr(env, "close"):
+            try:
+                env.close()
+            except Exception:
+                pass
+
+        rewards_csv = ",".join(rewards)
+        print(f"[END] success={_b(success)} steps={step_no} rewards={rewards_csv}")
+
+
+def main() -> int:
+    if not HF_TOKEN:
+        print("HF_TOKEN is required", file=sys.stderr)
+        return 1
+
+    client = OpenAI(api_key=HF_TOKEN, base_url=API_BASE_URL, max_retries=0, timeout=30)
+    env = BugTriageEnv()
+
+    for task_id in TASKS:
+        _run_task(task_id=task_id, env=env, client=client)
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

openenv_bug_triage/app.py

@@ -2,16 +2,28 @@
 
 from __future__ import annotations
 
+from pathlib import Path
 from typing import Optional
 
 from fastapi import FastAPI, HTTPException
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel
 
 from .env import BugTriageEnv
 from .models import ActionModel
 
 
-app = FastAPI(title="Bug Triage OpenEnv", version="0.1.0")
+app = FastAPI(
+    title="Bug Triage OpenEnv",
+    version="0.1.0",
+    description="Real-world OpenEnv environment for bug triage training",
+)
+
+UI_DIR = Path(__file__).parent / "ui"
+if UI_DIR.exists():
+    app.mount("/ui", StaticFiles(directory=str(UI_DIR)), name="ui")
+
 env = BugTriageEnv()
 
 
@@ -24,13 +36,30 @@ class StepRequest(BaseModel):
     action: ActionModel
 
 
+@app.get("/")
+def index():
+    """Serve the dark-mode frontend."""
+    index_file = UI_DIR / "index.html"
+    if index_file.exists():
+        return FileResponse(index_file)
+    return {"message": "Bug Triage OpenEnv API", "docs": "/docs"}
+
+
 @app.get("/health")
 def health() -> dict[str, str]:
     return {"status": "ok"}
 
 
+@app.get("/reset")
+def reset_get(task_id: Optional[str] = None, seed: Optional[int] = None) -> dict:
+    """Validator-friendly reset endpoint (GET)."""
+    observation = env.reset(task_id=task_id, seed=seed)
+    return observation.model_dump(mode="json")
+
+
 @app.post("/reset")
-def reset(req: ResetRequest) -> dict:
+def reset_post(req: ResetRequest) -> dict:
+    """Typed reset endpoint (POST)."""
     observation = env.reset(task_id=req.task_id, seed=req.seed)
     return observation.model_dump(mode="json")
 

openenv_bug_triage/models.py

@@ -152,7 +152,7 @@ class ActionModel(BaseModel):
 
 class RewardModel(BaseModel):
     """Reward information for a step."""
-    step_reward: float = Field(..., ge=-1.0, le=1.0)
+    step_reward: float = Field(..., ge=0.0, le=1.0)
     cumulative_reward: float
     reward_breakdown: dict[str, float] = Field(default_factory=dict)
 

openenv_bug_triage/reward.py

@@ -9,7 +9,10 @@ from .models import ActionModel, TicketGroundTruth
 class RewardCalculator:
     """Calculates rewards for bug triage actions."""
     
-    # Dense progress signals
+    # Base reward for any action
+    BASE_REWARD = 0.50
+    
+    # Dense progress signals (bonuses on top of base)
     CORRECT_SEVERITY = 0.20
     CORRECT_PRIORITY = 0.15
     CORRECT_COMPONENT = 0.15
@@ -18,16 +21,16 @@ class RewardCalculator:
     CORRECT_REQUEST_INFO = 0.10
     CORRECT_ESCALATION = 0.15
     
-    # Negative signals
-    INCORRECT_CLOSE_DEFER = -0.20
-    MISSED_ESCALATION = -0.15
-    INVALID_ACTION = -0.05
-    REPEATED_NOOP = -0.02
-    UNNECESSARY_SWITCH = -0.01
+    # Negative signals (penalties reducing from base)
+    INCORRECT_CLOSE_DEFER = 0.20
+    MISSED_ESCALATION = 0.15
+    INVALID_ACTION = 0.30
+    REPEATED_NOOP = 0.10
+    UNNECESSARY_SWITCH = 0.05
     
     # Terminal bonuses/penalties
     ALL_CRITICAL_TRIAGED = 0.10
-    BUDGET_EXHAUSTED_CRITICAL_REMAINING = -0.10
+    BUDGET_EXHAUSTED_CRITICAL_REMAINING = 0.10
     
     def __init__(self):
         self.action_history = []
@@ -45,16 +48,17 @@ class RewardCalculator:
     ) -> tuple[float, dict[str, float]]:
         """
         Calculate reward for a single step.
+        Rewards are in range [0.0, 1.0].
         
         Returns:
             tuple of (clamped_reward, breakdown_dict)
         """
         breakdown = {}
-        total_reward = 0.0
+        total_reward = self.BASE_REWARD  # Start with base reward
         
         if not is_valid:
-            breakdown["invalid_action"] = self.INVALID_ACTION
-            total_reward += self.INVALID_ACTION
+            breakdown["invalid_action_penalty"] = -self.INVALID_ACTION
+            total_reward -= self.INVALID_ACTION
             return self._clamp_reward(total_reward), breakdown
         
         # Track action history for loop detection
@@ -101,21 +105,21 @@ class RewardCalculator:
         # Penalize incorrect close/defer
         if action.action_type in ["close", "defer"]:
             if not ground_truth.duplicate_of and ground_truth.needs_more_info:
-                breakdown["incorrect_close_defer"] = self.INCORRECT_CLOSE_DEFER
-                total_reward += self.INCORRECT_CLOSE_DEFER
+                breakdown["incorrect_close_defer_penalty"] = -self.INCORRECT_CLOSE_DEFER
+                total_reward -= self.INCORRECT_CLOSE_DEFER
         
         # Penalize missed critical escalation
         if is_critical_ticket and action.action_type != "escalate_incident":
             if ground_truth.true_severity in ["sev0", "sev1"]:
-                breakdown["missed_escalation"] = self.MISSED_ESCALATION
-                total_reward += self.MISSED_ESCALATION
+                breakdown["missed_escalation_penalty"] = -self.MISSED_ESCALATION
+                total_reward -= self.MISSED_ESCALATION
         
         # Check for repeated no-op behavior
         if len(self.action_history) >= 3:
             last_three = self.action_history[-3:]
             if last_three[0] == last_three[1] == last_three[2]:
-                breakdown["repeated_noop"] = self.REPEATED_NOOP
-                total_reward += self.REPEATED_NOOP
+                breakdown["repeated_noop_penalty"] = -self.REPEATED_NOOP
+                total_reward -= self.REPEATED_NOOP
         
         # Terminal bonuses/penalties
         if is_terminal:
@@ -124,14 +128,14 @@ class RewardCalculator:
                 total_reward += self.ALL_CRITICAL_TRIAGED
             
             if budget_exhausted_with_critical:
-                breakdown["budget_exhausted"] = self.BUDGET_EXHAUSTED_CRITICAL_REMAINING
-                total_reward += self.BUDGET_EXHAUSTED_CRITICAL_REMAINING
+                breakdown["budget_exhausted_penalty"] = -self.BUDGET_EXHAUSTED_CRITICAL_REMAINING
+                total_reward -= self.BUDGET_EXHAUSTED_CRITICAL_REMAINING
         
         return self._clamp_reward(total_reward), breakdown
     
     def _clamp_reward(self, reward: float) -> float:
-        """Clamp reward to [-1.0, 1.0] range."""
-        return max(-1.0, min(1.0, reward))
+        """Clamp reward to [0.0, 1.0] range."""
+        return max(0.0, min(1.0, reward))
     
     def reset(self):
         """Reset action history."""

openenv_bug_triage/ui/app.js

@@ -0,0 +1,351 @@
+const els = {
+  taskSelect: document.getElementById("task-select"),
+  seedInput: document.getElementById("seed-input"),
+  resetBtn: document.getElementById("reset-btn"),
+  stateBtn: document.getElementById("state-btn"),
+  stepBtn: document.getElementById("step-btn"),
+  status: document.getElementById("status"),
+  actionType: document.getElementById("action-type"),
+  payloadFields: document.getElementById("payload-fields"),
+  actionPreview: document.getElementById("action-preview"),
+  ticketMeta: document.getElementById("ticket-meta"),
+  ticketBody: document.getElementById("ticket-body"),
+  stepLog: document.getElementById("step-log"),
+  stateJson: document.getElementById("state-json"),
+  stepsUsed: document.getElementById("steps-used"),
+  stepsRemaining: document.getElementById("steps-remaining"),
+  doneFlag: document.getElementById("done-flag"),
+  cumulativeReward: document.getElementById("cumulative-reward"),
+};
+
+let currentObservation = null;
+let done = false;
+let stepCount = 0;
+let cumulativeReward = 0;
+
+const DEFAULT_COMPONENTS = [
+  "api-gateway",
+  "auth-service",
+  "user-service",
+  "payment-service",
+  "web-app",
+  "ios-app",
+  "android-app",
+  "database",
+  "cache",
+  "cdn",
+];
+
+const DEFAULT_TEAMS = [
+  "backend-api",
+  "frontend-web",
+  "mobile-ios",
+  "mobile-android",
+  "infrastructure",
+  "data-platform",
+];
+
+function setStatus(text, kind = "idle") {
+  els.status.textContent = text;
+  els.status.className = `status status-${kind}`;
+}
+
+function pretty(obj) {
+  return JSON.stringify(obj, null, 2);
+}
+
+function optionHtml(value, selectedValue) {
+  const selected = value === selectedValue ? "selected" : "";
+  return `<option value="${value}" ${selected}>${value}</option>`;
+}
+
+function componentsList() {
+  return currentObservation?.available_components?.length
+    ? currentObservation.available_components
+    : DEFAULT_COMPONENTS;
+}
+
+function teamsList() {
+  return currentObservation?.available_teams?.length
+    ? currentObservation.available_teams
+    : DEFAULT_TEAMS;
+}
+
+function renderPayloadFields() {
+  const actionType = els.actionType.value;
+  const components = componentsList();
+  const teams = teamsList();
+
+  if (actionType === "classify") {
+    els.payloadFields.innerHTML = `
+      <label>
+        <span>Severity</span>
+        <select id="f-severity">
+          <option value="sev0">sev0</option>
+          <option value="sev1">sev1</option>
+          <option value="sev2" selected>sev2</option>
+          <option value="sev3">sev3</option>
+        </select>
+      </label>
+      <label>
+        <span>Priority</span>
+        <select id="f-priority">
+          <option value="p0">p0</option>
+          <option value="p1">p1</option>
+          <option value="p2" selected>p2</option>
+          <option value="p3">p3</option>
+        </select>
+      </label>
+      <label>
+        <span>Component</span>
+        <select id="f-component">
+          ${components.map((c, i) => optionHtml(c, i === 0 ? c : "")).join("")}
+        </select>
+      </label>
+    `;
+    return;
+  }
+
+  if (actionType === "assign") {
+    els.payloadFields.innerHTML = `
+      <label>
+        <span>Team</span>
+        <select id="f-team">
+          ${teams.map((t, i) => optionHtml(t, i === 0 ? t : "")).join("")}
+        </select>
+      </label>
+    `;
+    return;
+  }
+
+  if (actionType === "mark_duplicate") {
+    els.payloadFields.innerHTML = `
+      <label>
+        <span>Canonical Ticket ID</span>
+        <input id="f-canonical" type="text" placeholder="BUG-1001" />
+      </label>
+    `;
+    return;
+  }
+
+  if (actionType === "request_info") {
+    els.payloadFields.innerHTML = `
+      <label>
+        <span>Info Type</span>
+        <select id="f-info-type">
+          <option value="repro_steps">repro_steps</option>
+          <option value="logs">logs</option>
+          <option value="both" selected>both</option>
+        </select>
+      </label>
+    `;
+    return;
+  }
+
+  if (actionType === "defer") {
+    els.payloadFields.innerHTML = `
+      <label>
+        <span>Reason</span>
+        <input id="f-defer-reason" type="text" placeholder="Waiting for roadmap decision" />
+      </label>
+    `;
+    return;
+  }
+
+  if (actionType === "close") {
+    els.payloadFields.innerHTML = `
+      <label>
+        <span>Close Reason</span>
+        <select id="f-close-reason">
+          <option value="invalid">invalid</option>
+          <option value="wont_fix">wont_fix</option>
+          <option value="cannot_reproduce">cannot_reproduce</option>
+          <option value="resolved">resolved</option>
+        </select>
+      </label>
+    `;
+    return;
+  }
+
+  if (actionType === "escalate_incident") {
+    els.payloadFields.innerHTML = `
+      <label>
+        <span>Justification</span>
+        <textarea id="f-justification" placeholder="Production impact and SLA risk detected."></textarea>
+      </label>
+    `;
+    return;
+  }
+
+  els.payloadFields.innerHTML = `<p class="ticket-meta">No payload required.</p>`;
+}
+
+function buildAction() {
+  const type = els.actionType.value;
+  const action = { action_type: type };
+
+  if (type === "classify") {
+    action.classify = {
+      severity: document.getElementById("f-severity").value,
+      priority: document.getElementById("f-priority").value,
+      component: document.getElementById("f-component").value,
+    };
+  } else if (type === "assign") {
+    action.assign = {
+      team: document.getElementById("f-team").value,
+    };
+  } else if (type === "mark_duplicate") {
+    action.mark_duplicate = {
+      canonical_ticket_id: document.getElementById("f-canonical").value.trim(),
+    };
+  } else if (type === "request_info") {
+    action.request_info = {
+      info_type: document.getElementById("f-info-type").value,
+    };
+  } else if (type === "defer") {
+    action.defer = {
+      reason: document.getElementById("f-defer-reason").value.trim() || "backlog",
+    };
+  } else if (type === "close") {
+    action.close = {
+      reason: document.getElementById("f-close-reason").value,
+    };
+  } else if (type === "escalate_incident") {
+    action.escalate_incident = {
+      justification: document.getElementById("f-justification").value.trim() || "Critical impact",
+    };
+  } else if (type === "next_ticket") {
+    action.next_ticket = {};
+  }
+
+  return action;
+}
+
+function renderPreview() {
+  const action = buildAction();
+  els.actionPreview.textContent = pretty(action);
+}
+
+function renderObservation(obs) {
+  currentObservation = obs;
+  if (!obs || !obs.current_ticket) {
+    els.ticketMeta.textContent = "No active ticket";
+    els.ticketBody.textContent = "{}";
+    return;
+  }
+
+  const t = obs.current_ticket;
+  els.ticketMeta.textContent = `${t.ticket_id} | ${t.service} | ${t.reporter_type} | tier:${t.customer_tier}`;
+  els.ticketBody.textContent = pretty(t);
+
+  els.stepsUsed.textContent = String(obs.steps_used);
+  els.stepsRemaining.textContent = String(obs.steps_remaining);
+
+  renderPayloadFields();
+  renderPreview();
+}
+
+function appendLog(text) {
+  const li = document.createElement("li");
+  li.textContent = text;
+  els.stepLog.prepend(li);
+}
+
+async function api(url, method = "GET", body = null) {
+  const opts = { method, headers: {} };
+  if (body !== null) {
+    opts.headers["Content-Type"] = "application/json";
+    opts.body = JSON.stringify(body);
+  }
+
+  const res = await fetch(url, opts);
+  const data = await res.json().catch(() => null);
+  if (!res.ok) {
+    const msg = data?.detail || `HTTP ${res.status}`;
+    throw new Error(msg);
+  }
+  return data;
+}
+
+async function doReset() {
+  const task_id = els.taskSelect.value;
+  const seed = Number(els.seedInput.value || 42);
+
+  try {
+    setStatus("Resetting episode...", "idle");
+    const obs = await api("/reset", "POST", { task_id, seed });
+    done = false;
+    stepCount = 0;
+    cumulativeReward = 0;
+    els.stepLog.innerHTML = "";
+    renderObservation(obs);
+    els.doneFlag.textContent = "false";
+    els.cumulativeReward.textContent = "0.00";
+    setStatus(`Ready on ${obs.current_ticket?.ticket_id || "no-ticket"}`, "ok");
+    appendLog(`reset task=${task_id} seed=${seed}`);
+  } catch (err) {
+    setStatus(`Reset failed: ${err.message}`, "error");
+  }
+}
+
+async function doStep() {
+  if (!currentObservation) {
+    setStatus("Run Reset first.", "error");
+    return;
+  }
+  if (done) {
+    setStatus("Episode already done. Reset to start another.", "error");
+    return;
+  }
+
+  const action = buildAction();
+
+  try {
+    const result = await api("/step", "POST", { action });
+    stepCount += 1;
+    done = Boolean(result.done);
+
+    const reward = Number(result.reward?.step_reward || 0);
+    cumulativeReward = Number(result.reward?.cumulative_reward || cumulativeReward);
+
+    renderObservation(result.observation);
+    els.doneFlag.textContent = String(done);
+    els.cumulativeReward.textContent = cumulativeReward.toFixed(2);
+
+    const err = result.info?.validation_error ? ` error=${result.info.validation_error}` : "";
+    appendLog(
+      `step=${stepCount} action=${action.action_type} reward=${reward.toFixed(2)} done=${done}${err}`
+    );
+
+    setStatus(done ? "Episode completed." : "Step accepted.", done ? "ok" : "idle");
+  } catch (err) {
+    setStatus(`Step failed: ${err.message}`, "error");
+    appendLog(`step_error ${err.message}`);
+  }
+}
+
+async function fetchState() {
+  try {
+    const state = await api("/state", "GET");
+    els.stateJson.textContent = pretty(state);
+    setStatus("State fetched.", "ok");
+  } catch (err) {
+    setStatus(`State fetch failed: ${err.message}`, "error");
+  }
+}
+
+els.actionType.addEventListener("change", () => {
+  renderPayloadFields();
+  renderPreview();
+});
+
+els.payloadFields.addEventListener("input", renderPreview);
+els.payloadFields.addEventListener("change", renderPreview);
+els.resetBtn.addEventListener("click", doReset);
+els.stepBtn.addEventListener("click", doStep);
+els.stateBtn.addEventListener("click", fetchState);
+
+renderPayloadFields();
+renderPreview();
+setStatus("Idle", "idle");
+

openenv_bug_triage/ui/index.html

@@ -0,0 +1,112 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Bug Triage OpenEnv Console</title>
+  <link rel="preconnect" href="https://fonts.googleapis.com" />
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+  <link href="https://fonts.googleapis.com/css2?family=Space+Grotesk:wght@400;500;700&family=IBM+Plex+Mono:wght@400;500&display=swap" rel="stylesheet" />
+  <link rel="stylesheet" href="/ui/styles.css" />
+</head>
+<body>
+  <div class="aurora" aria-hidden="true"></div>
+
+  <header class="hero reveal">
+    <div>
+      <p class="kicker">OpenEnv - Dark Ops Console</p>
+      <h1>Bug Triage Environment</h1>
+      <p class="subtitle">Interactive dark-mode frontend for reset / step / state workflows.</p>
+    </div>
+    <div class="pillset">
+      <span class="pill">Real-World Task</span>
+      <span class="pill">Typed Actions</span>
+      <span class="pill">Dense Rewards</span>
+    </div>
+  </header>
+
+  <main class="layout">
+    <section class="card reveal" id="controls-card">
+      <h2>Session Controls</h2>
+      <div class="grid-2">
+        <label>
+          <span>Task</span>
+          <select id="task-select">
+            <option value="bug_triage_easy">bug_triage_easy</option>
+            <option value="bug_triage_medium">bug_triage_medium</option>
+            <option value="bug_triage_hard">bug_triage_hard</option>
+          </select>
+        </label>
+        <label>
+          <span>Seed</span>
+          <input id="seed-input" type="number" value="42" min="0" step="1" />
+        </label>
+      </div>
+      <div class="button-row">
+        <button id="reset-btn" class="btn btn-accent">Reset Episode</button>
+        <button id="state-btn" class="btn btn-ghost">Fetch State</button>
+      </div>
+      <div id="status" class="status status-idle">Idle</div>
+      <div class="summary-grid">
+        <article>
+          <h3>Steps</h3>
+          <p id="steps-used">0</p>
+        </article>
+        <article>
+          <h3>Remaining</h3>
+          <p id="steps-remaining">0</p>
+        </article>
+        <article>
+          <h3>Done</h3>
+          <p id="done-flag">false</p>
+        </article>
+        <article>
+          <h3>Cumulative</h3>
+          <p id="cumulative-reward">0.00</p>
+        </article>
+      </div>
+    </section>
+
+    <section class="card reveal" id="ticket-card">
+      <h2>Current Ticket</h2>
+      <div id="ticket-meta" class="ticket-meta">Run reset to load a task.</div>
+      <pre id="ticket-body" class="json-view">{}</pre>
+    </section>
+
+    <section class="card reveal" id="action-card">
+      <h2>Action Composer</h2>
+      <label>
+        <span>Action Type</span>
+        <select id="action-type">
+          <option value="classify">classify</option>
+          <option value="assign">assign</option>
+          <option value="mark_duplicate">mark_duplicate</option>
+          <option value="request_info">request_info</option>
+          <option value="defer">defer</option>
+          <option value="close">close</option>
+          <option value="escalate_incident">escalate_incident</option>
+          <option value="next_ticket">next_ticket</option>
+        </select>
+      </label>
+      <div id="payload-fields" class="payload-grid"></div>
+      <div class="button-row">
+        <button id="step-btn" class="btn btn-hot">Step</button>
+      </div>
+      <pre id="action-preview" class="json-view">{"action_type":"classify"}</pre>
+    </section>
+
+    <section class="card reveal" id="logs-card">
+      <h2>Episode Log</h2>
+      <ol id="step-log" class="log-list"></ol>
+    </section>
+
+    <section class="card reveal" id="state-card">
+      <h2>State Snapshot</h2>
+      <pre id="state-json" class="json-view">{}</pre>
+    </section>
+  </main>
+
+  <script src="/ui/app.js"></script>
+</body>
+</html>
+

openenv_bug_triage/ui/styles.css

@@ -0,0 +1,323 @@
+:root {
+  --bg: #070c14;
+  --bg-soft: #0d1422;
+  --surface: rgba(15, 24, 38, 0.82);
+  --surface-strong: rgba(18, 30, 48, 0.96);
+  --edge: rgba(132, 168, 224, 0.24);
+  --text: #e8f0ff;
+  --muted: #9db0cd;
+  --accent: #25d8b4;
+  --hot: #ff9150;
+  --ok: #6be6a8;
+  --warn: #ffd166;
+  --bad: #ff5f73;
+  --mono: "IBM Plex Mono", "Fira Code", Consolas, monospace;
+  --sans: "Space Grotesk", "Segoe UI", sans-serif;
+}
+
+* {
+  box-sizing: border-box;
+}
+
+html,
+body {
+  margin: 0;
+  min-height: 100%;
+  background: var(--bg);
+  color: var(--text);
+  font-family: var(--sans);
+}
+
+body {
+  position: relative;
+  overflow-x: hidden;
+  padding: 24px;
+}
+
+.aurora {
+  position: fixed;
+  inset: -25vmax;
+  background:
+    radial-gradient(40vmax 32vmax at 10% 16%, rgba(37, 216, 180, 0.18), transparent 70%),
+    radial-gradient(45vmax 36vmax at 92% 8%, rgba(255, 145, 80, 0.14), transparent 72%),
+    radial-gradient(50vmax 44vmax at 48% 105%, rgba(71, 130, 255, 0.16), transparent 74%);
+  filter: blur(18px);
+  pointer-events: none;
+  z-index: -1;
+}
+
+.hero {
+  display: flex;
+  justify-content: space-between;
+  align-items: flex-start;
+  gap: 20px;
+  margin-bottom: 18px;
+}
+
+.kicker {
+  margin: 0 0 4px;
+  letter-spacing: 0.12em;
+  text-transform: uppercase;
+  font-size: 0.72rem;
+  color: var(--accent);
+}
+
+h1 {
+  margin: 0;
+  font-size: clamp(1.5rem, 2.8vw, 2.35rem);
+  line-height: 1.08;
+}
+
+.subtitle {
+  margin-top: 8px;
+  color: var(--muted);
+  max-width: 62ch;
+}
+
+.pillset {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+
+.pill {
+  border: 1px solid var(--edge);
+  padding: 6px 10px;
+  border-radius: 999px;
+  font-size: 0.72rem;
+  color: var(--muted);
+  background: rgba(9, 16, 28, 0.6);
+}
+
+.layout {
+  display: grid;
+  gap: 14px;
+  grid-template-columns: repeat(12, minmax(0, 1fr));
+}
+
+#controls-card { grid-column: span 4; }
+#ticket-card { grid-column: span 8; }
+#action-card { grid-column: span 5; }
+#logs-card { grid-column: span 7; }
+#state-card { grid-column: span 12; }
+
+.card {
+  background: linear-gradient(160deg, var(--surface), var(--surface-strong));
+  border: 1px solid var(--edge);
+  border-radius: 16px;
+  padding: 16px;
+  box-shadow: 0 18px 40px rgba(0, 0, 0, 0.26);
+  backdrop-filter: blur(10px);
+}
+
+.card h2 {
+  margin: 0 0 12px;
+  font-size: 1rem;
+}
+
+.grid-2 {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 10px;
+}
+
+label {
+  display: block;
+}
+
+label > span {
+  display: block;
+  margin-bottom: 6px;
+  font-size: 0.8rem;
+  color: var(--muted);
+}
+
+input,
+select,
+textarea,
+button {
+  font: inherit;
+}
+
+input,
+select,
+textarea {
+  width: 100%;
+  border: 1px solid var(--edge);
+  background: rgba(7, 13, 22, 0.88);
+  color: var(--text);
+  border-radius: 10px;
+  padding: 10px 12px;
+}
+
+textarea {
+  min-height: 88px;
+  resize: vertical;
+}
+
+.button-row {
+  margin-top: 12px;
+  display: flex;
+  gap: 10px;
+  flex-wrap: wrap;
+}
+
+.btn {
+  border: 0;
+  border-radius: 10px;
+  cursor: pointer;
+  padding: 10px 14px;
+  font-weight: 600;
+  transition: transform 140ms ease, filter 140ms ease;
+}
+
+.btn:hover {
+  transform: translateY(-1px);
+  filter: brightness(1.06);
+}
+
+.btn-accent {
+  background: linear-gradient(140deg, #22bfa8, #1ed3ba);
+  color: #08131c;
+}
+
+.btn-hot {
+  background: linear-gradient(140deg, #ff7f45, #ffa15f);
+  color: #241208;
+}
+
+.btn-ghost {
+  background: rgba(17, 27, 43, 0.85);
+  color: var(--text);
+  border: 1px solid var(--edge);
+}
+
+.status {
+  margin-top: 12px;
+  border-radius: 10px;
+  border: 1px solid var(--edge);
+  padding: 9px 12px;
+  font-size: 0.9rem;
+}
+
+.status-ok {
+  color: var(--ok);
+  border-color: rgba(107, 230, 168, 0.4);
+}
+
+.status-error {
+  color: var(--bad);
+  border-color: rgba(255, 95, 115, 0.45);
+}
+
+.summary-grid {
+  margin-top: 12px;
+  display: grid;
+  grid-template-columns: repeat(4, 1fr);
+  gap: 8px;
+}
+
+.summary-grid article {
+  border: 1px solid var(--edge);
+  border-radius: 10px;
+  padding: 8px;
+  background: rgba(6, 12, 22, 0.78);
+}
+
+.summary-grid h3 {
+  margin: 0;
+  font-size: 0.7rem;
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+  color: var(--muted);
+}
+
+.summary-grid p {
+  margin: 6px 0 0;
+  font-family: var(--mono);
+}
+
+.ticket-meta {
+  color: var(--muted);
+  font-size: 0.9rem;
+  margin-bottom: 8px;
+}
+
+.payload-grid {
+  display: grid;
+  gap: 10px;
+}
+
+.json-view {
+  margin: 0;
+  white-space: pre-wrap;
+  word-break: break-word;
+  border-radius: 10px;
+  border: 1px solid var(--edge);
+  padding: 12px;
+  background: rgba(5, 10, 18, 0.9);
+  font-family: var(--mono);
+  font-size: 0.82rem;
+  max-height: 300px;
+  overflow: auto;
+}
+
+.log-list {
+  margin: 0;
+  padding-left: 18px;
+  max-height: 360px;
+  overflow: auto;
+}
+
+.log-list li {
+  margin-bottom: 8px;
+  padding: 10px;
+  border-radius: 10px;
+  border: 1px solid var(--edge);
+  background: rgba(6, 11, 18, 0.86);
+  font-family: var(--mono);
+  font-size: 0.77rem;
+}
+
+.reveal {
+  animation: riseIn 340ms ease both;
+}
+
+@keyframes riseIn {
+  from {
+    opacity: 0;
+    transform: translateY(8px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+@media (max-width: 1100px) {
+  #controls-card,
+  #ticket-card,
+  #action-card,
+  #logs-card,
+  #state-card {
+    grid-column: span 12;
+  }
+
+  .summary-grid {
+    grid-template-columns: repeat(2, 1fr);
+  }
+}
+
+@media (max-width: 640px) {
+  body {
+    padding: 14px;
+  }
+
+  .hero {
+    flex-direction: column;
+  }
+
+  .grid-2 {
+    grid-template-columns: 1fr;
+  }
+}

precheck.py

@@ -0,0 +1,169 @@
+"""
+Pre-submission validator for Bug Triage OpenEnv.
+
+Checks:
+1) HF Space /reset returns HTTP 200
+2) docker build succeeds
+3) openenv validate succeeds
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import shutil
+import subprocess
+import sys
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+
+def log(msg: str) -> None:
+    print(msg)
+
+
+def run(cmd: list[str], cwd: Path | None = None, timeout: int = 1800) -> tuple[int, str, str]:
+    proc = subprocess.run(
+        cmd,
+        cwd=str(cwd) if cwd else None,
+        capture_output=True,
+        text=True,
+        timeout=timeout,
+    )
+    return proc.returncode, proc.stdout.strip(), proc.stderr.strip()
+
+
+def check_space(space_url: str, timeout_seconds: int) -> tuple[bool, str]:
+    reset_url = f"{space_url.rstrip('/')}/reset"
+    req = urllib.request.Request(reset_url, method="GET")
+    try:
+        with urllib.request.urlopen(req, timeout=timeout_seconds) as resp:
+            code = int(resp.getcode())
+            if code == 200:
+                return True, f"HF Space /reset returned HTTP {code}"
+            return False, f"HF Space /reset returned HTTP {code} (expected 200)"
+    except urllib.error.HTTPError as err:
+        return False, f"HF Space /reset returned HTTP {err.code} (expected 200)"
+    except Exception as err:
+        return False, f"HF Space check failed: {err}"
+
+
+def check_docker_build(repo_dir: Path, docker_timeout: int) -> tuple[bool, str]:
+    if shutil.which("docker") is None:
+        return False, "docker command not found"
+
+    if (repo_dir / "Dockerfile").exists():
+        context = repo_dir
+    elif (repo_dir / "server" / "Dockerfile").exists():
+        context = repo_dir / "server"
+    else:
+        return False, "No Dockerfile found in repo root or server/"
+
+    code, out, err = run(["docker", "build", str(context)], timeout=docker_timeout)
+    if code == 0:
+        return True, f"Docker build succeeded ({context})"
+
+    tail = "\n".join((out + "\n" + err).strip().splitlines()[-20:])
+    return False, f"Docker build failed (timeout={docker_timeout}s)\n{tail}"
+
+
+def check_openenv_validate(repo_dir: Path) -> tuple[bool, str]:
+    cmd = None
+    if shutil.which("openenv") is not None:
+        cmd = ["openenv", "validate"]
+    else:
+        # Fallback for environments where console scripts are not on PATH.
+        cmd = [sys.executable, "-m", "openenv", "validate"]
+
+    code, out, err = run(cmd, cwd=repo_dir, timeout=600)
+    if code == 0:
+        msg = out or "openenv validate passed"
+        return True, msg
+
+    base = "openenv validate failed"
+    hint = "Install with: pip install openenv-core" if "No module named" in err else ""
+    details = "\n".join(x for x in [base, hint, out, err] if x).strip()
+    return False, details
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Pre-submit validator")
+    parser.add_argument(
+        "--repo-dir",
+        default=".",
+        help="Repository root (default: current directory)",
+    )
+    parser.add_argument(
+        "--space-url",
+        default=os.getenv("HF_SPACE_URL", ""),
+        help="HF Space base URL (or set HF_SPACE_URL)",
+    )
+    parser.add_argument(
+        "--skip-space",
+        action="store_true",
+        help="Skip HF Space /reset check",
+    )
+    parser.add_argument(
+        "--docker-timeout",
+        type=int,
+        default=1800,
+        help="Docker build timeout in seconds (default: 1800)",
+    )
+    parser.add_argument(
+        "--http-timeout",
+        type=int,
+        default=20,
+        help="HTTP timeout for HF Space check in seconds",
+    )
+
+    args = parser.parse_args()
+    repo_dir = Path(args.repo_dir).resolve()
+
+    if not repo_dir.exists():
+        log(f"FAIL: repo dir does not exist: {repo_dir}")
+        return 1
+
+    log("========================================")
+    log("Pre-submission Validation")
+    log("========================================")
+
+    all_ok = True
+
+    # Step 1: HF Space /reset
+    log("Step 1/3: Checking HF Space /reset")
+    if args.skip_space:
+        log("SKIP: HF Space check skipped")
+    else:
+        if not args.space_url:
+            log("FAIL: --space-url (or HF_SPACE_URL) is required unless --skip-space is used")
+            all_ok = False
+        else:
+            ok, msg = check_space(args.space_url, args.http_timeout)
+            log(("PASS: " if ok else "FAIL: ") + msg)
+            all_ok = all_ok and ok
+
+    # Step 2: docker build
+    log("Step 2/3: Running docker build")
+    ok, msg = check_docker_build(repo_dir, args.docker_timeout)
+    log(("PASS: " if ok else "FAIL: ") + msg)
+    all_ok = all_ok and ok
+
+    # Step 3: openenv validate
+    log("Step 3/3: Running openenv validate")
+    ok, msg = check_openenv_validate(repo_dir)
+    log(("PASS: " if ok else "FAIL: ") + msg)
+    all_ok = all_ok and ok
+
+    log("========================================")
+    if all_ok:
+        log("All checks passed")
+        return 0
+
+    log("One or more checks failed")
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+

scripts/baseline_inference.py

@@ -16,10 +16,8 @@ from datetime import datetime
 from dotenv import load_dotenv
 from openai import OpenAI
 
-# Load environment variables from .env file
 load_dotenv()
 
-# Ensure project root is importable when running as: python scripts/baseline_inference.py
 PROJECT_ROOT = Path(__file__).resolve().parent.parent
 if str(PROJECT_ROOT) not in sys.path:
     sys.path.insert(0, str(PROJECT_ROOT))