Initial submission: IT Mental Health OpenEnv

.dockerignore

@@ -0,0 +1,17 @@
+.git
+.gitignore
+.env
+.env.*
+!.env.example
+venv/
+.venv/
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+build/
+dist/
+*.egg-info/
+Thumbs.db
+.DS_Store

.env.example

@@ -0,0 +1,5 @@
+API_BASE_URL=https://api-inference.huggingface.co/v1
+MODEL_NAME=meta-llama/Llama-3.1-8B-Instruct
+HF_TOKEN=
+LOCAL_IMAGE_NAME=
+ENV_BASE_URL=http://localhost:7860

.gitignore

@@ -0,0 +1,33 @@
+# Env files
+.env
+.env.*
+!.env.example
+
+# Python cache/build
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+
+# Virtual envs
+.venv/
+venv/
+env/
+
+# Coverage/build artifacts
+.coverage
+htmlcov/
+build/
+dist/
+*.egg-info/
+
+# IDE/editor
+.vscode/
+.idea/
+
+# OS files
+.DS_Store
+Thumbs.db

Dockerfile

@@ -0,0 +1,29 @@
+# IT Mental Health OpenEnv Dockerfile
+# Compatible with Hugging Face Spaces (port 7860)
+
+FROM python:3.11-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt /tmp/requirements.txt
+RUN pip install --no-cache-dir -r /tmp/requirements.txt
+
+COPY app.py /app/app.py
+COPY it_mental_health_environment.py /app/it_mental_health_environment.py
+COPY models.py /app/models.py
+COPY inference.py /app/inference.py
+COPY validate.py /app/validate.py
+COPY openenv.yaml /app/openenv.yaml
+COPY README.md /app/README.md
+COPY .env.example /app/.env.example
+
+EXPOSE 7860
+
+HEALTHCHECK --interval=30s --timeout=10s --start-period=15s --retries=3 \
+    CMD curl -f http://localhost:7860/health || exit 1
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1"]

README.md

@@ -0,0 +1,484 @@
+# IT Mental Health OpenEnv
+
+An OpenEnv-compatible reinforcement learning environment for mental health assessment and intervention planning in the IT and software engineering sector.
+
+Built for the [Scaler x Meta-PyTorch OpenEnv Hackathon 2026](https://www.scaler.com/school-of-technology/meta-pytorch-hackathon).
+
+## Elevator Pitch
+
+Modern IT teams operate under sprint pressure, on-call fatigue, remote isolation, and always-on expectations. Those stressors often appear long before a formal HR escalation, but most benchmark environments do not test whether an AI system can recognize burnout patterns, prioritize mental health risk, or propose realistic workplace interventions.
+
+This project solves that gap by turning workplace mental health into a structured evaluation environment. Instead of asking an agent to solve toy problems, it asks the agent to:
+
+1. detect burnout from an employee profile,
+2. triage multiple employees by urgency, and
+3. design a structured intervention plan for a team already showing systemic strain.
+
+The result is a benchmark that is easier to pitch to judges because it is:
+
+- socially meaningful,
+- clearly scoped,
+- grounded in recognizable workplace scenarios,
+- measurable through rubric-based rewards, and
+- extensible to future HR and wellbeing tasks.
+
+## What Problem It Solves
+
+Most LLM evaluation environments focus on navigation, coding, or generic QA. They do not measure whether an agent can reason through workplace mental health cases in a structured, actionable way.
+
+This environment is designed to evaluate:
+
+- recognition of burnout symptoms using the Maslach Burnout Inventory (MBI) framing,
+- prioritization of urgent cases using tiered stress triage,
+- generation of practical intervention plans rather than vague advice,
+- structured communication quality,
+- rewardable outputs for iterative benchmarking.
+
+For a hackathon pitch, the core story is:
+
+- burnout in IT is widespread,
+- companies need earlier detection and more structured support,
+- current AI benchmarks ignore this domain,
+- this environment turns that real-world problem into a reproducible benchmark.
+
+## Why This Is Useful in a Hackathon
+
+This project works well for a benchmark-oriented hackathon because it gives judges three things at once:
+
+- a novel domain,
+- a technically runnable benchmark,
+- a strong real-world narrative.
+
+It is also practical for submission because:
+
+- the API is simple and inspectable,
+- the inference flow is reproducible,
+- Docker packaging is supported,
+- validation is built in,
+- the benchmark returns normalized scores in `[0, 1]`.
+
+## Functional Overview
+
+The environment simulates three progressive tasks:
+
+| Task ID | Difficulty | Goal |
+|---|---|---|
+| `burnout_detection` | Easy | Detect MBI dimensions, severity, red flags, and HR escalation need |
+| `stress_triage` | Medium | Classify multiple employees by urgency and recommend immediate plus medium-term actions |
+| `intervention_plan` | Hard | Build a 4-week recovery/intervention plan for a team in distress |
+
+Each episode moves through those tasks in order. The agent receives a scenario, returns a text response, and gets:
+
+- a reward,
+- grader feedback,
+- a score breakdown,
+- and the next scenario until the episode ends.
+
+## Benchmark Design
+
+The benchmark is intentionally structured around realistic workplace mental health reasoning rather than open-ended chat.
+
+### Task 1: Burnout Detection
+
+The agent reviews a single employee profile and is expected to identify:
+
+- MBI dimensions present,
+- severity level,
+- top red flags,
+- whether immediate HR escalation is needed.
+
+### Task 2: Stress Triage
+
+The agent sees multiple employees and must:
+
+- assign each a stress tier,
+- identify likely primary stressor type,
+- recommend one immediate action,
+- recommend one medium-term support action,
+- rank intervention priority.
+
+### Task 3: Intervention Plan
+
+The agent receives a team-wide burnout scenario and must produce:
+
+- a 4-week phased plan,
+- clear responsibilities,
+- measurable outcomes,
+- KPIs,
+- a risk statement,
+- a budget band.
+
+## Architecture Diagram
+
+```mermaid
+flowchart TD
+    A[Client / Inference Runner] -->|POST /reset seed| B[FastAPI app.py]
+    B --> C[IT Mental Health Environment]
+    C --> D[Scenario Generator]
+    D -->|Task 1: Burnout Detection| E[Employee Profile]
+    D -->|Task 2: Stress Triage| F[Multi-Employee Cases]
+    D -->|Task 3: Intervention Plan| G[Team Scenario]
+    E --> H[Observation: scenario + task_id]
+    F --> H
+    G --> H
+    H --> A
+    A -->|POST /step response| B
+    B --> I{Grader}
+    I -->|Configured| J[LLM Judge]
+    I -->|Fallback| K[Heuristic Grader]
+    J --> L[Reward + Score Breakdown]
+    K --> L
+    L --> M[State Update<br/>cumulative_reward, tasks_completed]
+    M -->|done=false| D
+    M -->|done=true| N[Final Normalized Score 0-1]
+    N --> A
+```
+
+## How the Environment Works
+
+At a high level:
+
+1. `POST /reset` starts a new episode and returns the first scenario.
+2. `POST /step` accepts the agent's answer and advances the benchmark.
+3. The environment tracks reward, progress, and task order.
+4. `GET /state` exposes current episode metadata.
+5. `GET /tasks` and `GET /schema` help inspection and integration.
+
+The environment uses randomized scenario generation so episodes are not identical across resets unless a seed is supplied.
+
+## Reward and Scoring
+
+The environment uses rubric-based grading. Depending on runtime configuration, it can use:
+
+- an LLM judge, or
+- a heuristic fallback grader.
+
+The fallback heuristic is currently important because it allows the benchmark to run even without a configured external judge model.
+
+Reward properties:
+
+- each task returns a normalized reward in `[0.0, 1.0]`,
+- the score breakdown reports sub-dimension performance,
+- the inference script outputs step rewards and a final normalized score.
+
+### Rubric Themes
+
+The grader looks for factors such as:
+
+- clinical accuracy,
+- completeness,
+- relevance to the scenario,
+- prioritization quality,
+- structure and clarity,
+- intervention practicality.
+
+## Technical Architecture
+
+This repository uses a flat root layout:
+
+```text
+it_mental_health_env/
+|-- app.py
+|-- it_mental_health_environment.py
+|-- inference.py
+|-- validate.py
+|-- models.py
+|-- openenv.yaml
+|-- requirements.txt
+|-- requirements_inference.txt
+|-- .env.example
+|-- .gitignore
+|-- Dockerfile
+`-- README.md
+```
+
+### File Responsibilities
+
+- `app.py`
+  FastAPI application exposing the benchmark endpoints.
+- `it_mental_health_environment.py`
+  Core environment logic, scenario generation, rubrics, grader flow, and state transitions.
+- `models.py`
+  Typed action, observation, and state models.
+- `inference.py`
+  Benchmark runner using the OpenAI client with the required env-variable contract.
+- `validate.py`
+  Pre-submission sanity checker for API health and scoring behavior.
+- `openenv.yaml`
+  OpenEnv manifest for the environment.
+- `Dockerfile`
+  Container packaging for local and HF Spaces style deployment.
+
+## API Reference
+
+### `GET /health`
+
+Simple readiness check.
+
+Example response:
+
+```json
+{
+  "status": "ok",
+  "env": "it_mental_health_env",
+  "version": "1.0.0"
+}
+```
+
+### `POST /reset`
+
+Starts a new episode.
+
+Request body:
+
+```json
+{
+  "seed": 123
+}
+```
+
+Notes:
+
+- `seed` is optional.
+- when `seed` is provided, the same episode scenario sequence can be reproduced.
+
+### `POST /step`
+
+Submits the agent's answer for the current task.
+
+Request body:
+
+```json
+{
+  "response": "Your structured answer here",
+  "task_id": "burnout_detection",
+  "confidence": 0.9,
+  "metadata": {}
+}
+```
+
+Notes:
+
+- `metadata` is optional and can safely be `{}`.
+- `task_id` should usually match the `task_id` returned by the latest observation.
+- the environment itself advances task order internally.
+
+### `GET /state`
+
+Returns current episode progress.
+
+### `GET /tasks`
+
+Returns benchmark task metadata such as difficulty and description.
+
+### `GET /schema`
+
+Returns a human-readable action and observation schema.
+
+## Request and Response Shapes
+
+### Action
+
+```json
+{
+  "response": "string",
+  "task_id": "burnout_detection | stress_triage | intervention_plan",
+  "confidence": 0.9,
+  "metadata": {}
+}
+```
+
+### Observation
+
+```json
+{
+  "scenario": "string",
+  "feedback": "string",
+  "reward": 0.655,
+  "done": false,
+  "score_breakdown": {
+    "example_dimension": 0.8
+  },
+  "task_id": "stress_triage",
+  "metadata": {}
+}
+```
+
+### State
+
+```json
+{
+  "episode_id": "uuid",
+  "step_count": 1,
+  "current_task": "stress_triage",
+  "cumulative_reward": 0.655,
+  "tasks_completed": ["burnout_detection"]
+}
+```
+
+## Running Locally
+
+### 1. Install dependencies
+
+```bash
+pip install -r requirements.txt
+pip install -r requirements_inference.txt
+```
+
+### 2. Start the API server
+
+```bash
+python -m uvicorn app:app --host 127.0.0.1 --port 7860
+```
+
+### 3. Explore the interactive docs
+
+Open:
+
+- `http://127.0.0.1:7860/docs`
+- `http://127.0.0.1:7860/health`
+- `http://127.0.0.1:7860/tasks`
+
+### 4. Configure environment variables
+
+Start from `.env.example`:
+
+```env
+API_BASE_URL=https://api-inference.huggingface.co/v1
+MODEL_NAME=meta-llama/Llama-3.1-8B-Instruct
+HF_TOKEN=
+LOCAL_IMAGE_NAME=
+ENV_BASE_URL=http://localhost:7860
+```
+
+Important notes:
+
+- `HF_TOKEN` is required for the inference script.
+- `LOCAL_IMAGE_NAME` is optional and can stay empty in this repo's current HTTP-server workflow.
+- `ENV_BASE_URL` should point to your local FastAPI server.
+
+### 5. Run the inference script
+
+```bash
+python inference.py
+```
+
+## Inference Script Contract
+
+The hackathon requires the inference runner to follow a specific pattern. This repository's `inference.py` is aligned to that requirement:
+
+- it uses the OpenAI client for all LLM calls,
+- it reads `API_BASE_URL`, `MODEL_NAME`, and `HF_TOKEN`,
+- it includes optional `LOCAL_IMAGE_NAME`,
+- it emits plain-text structured logs to stdout.
+
+### Required stdout format
+
+```text
+[START] task=burnout_detection env=it_mental_health_env model=meta-llama/Llama-3.1-8B-Instruct
+[STEP] step=1 action=... reward=0.72 done=false error=null
+[STEP] step=2 action=... reward=0.68 done=false error=null
+[END] success=true steps=2 score=0.467 rewards=0.72,0.68
+```
+
+Rules followed:
+
+- exactly one `[START]` line,
+- one `[STEP]` line per environment step,
+- one `[END]` line even if execution fails,
+- rewards formatted to two decimals in step logs,
+- final score normalized to `[0, 1]`.
+
+## Manual API Testing
+
+If you want to test without the inference script:
+
+1. call `POST /reset`,
+2. copy the returned `scenario` and `task_id`,
+3. write a structured response,
+4. send it to `POST /step`,
+5. inspect `reward`, `feedback`, and `score_breakdown`.
+
+Example `POST /step` payload:
+
+```json
+{
+  "response": "1. MBI Dimensions\nExhaustion and Depersonalization are present.\n\n2. Severity\nHigh.\n\n3. Top 3 Red Flags\n- Long working hours\n- Extended period without vacation\n- Emotional detachment\n\n4. HR Escalation\nYes. The presentation suggests serious burnout risk and warrants prompt support.",
+  "task_id": "burnout_detection",
+  "confidence": 0.9,
+  "metadata": {}
+}
+```
+
+## Validation
+
+Run the pre-submission validator after the server is up:
+
+```bash
+python validate.py
+```
+
+What it checks:
+
+- manifest validity,
+- root `inference.py` presence,
+- `/health`,
+- `/reset`,
+- `/step`,
+- `/state`,
+- reward range compliance.
+
+## Docker Usage
+
+Build:
+
+```bash
+docker build -t it-mental-health-env .
+```
+
+Run:
+
+```bash
+docker run -p 7860:7860 it-mental-health-env
+```
+
+Then visit:
+
+- `http://127.0.0.1:7860/health`
+- `http://127.0.0.1:7860/docs`
+
+## Pitching Notes for Judges
+
+If you are demoing this live, emphasize:
+
+- **Domain relevance**
+  This benchmark addresses a real workplace problem with growing urgency.
+- **Novel evaluation target**
+  Most environments do not evaluate burnout detection, triage, or intervention planning.
+- **Structured benchmark**
+  The project is not just a chatbot; it is a measurable RL-style environment with rewards and step transitions.
+- **Technical completeness**
+  It includes API endpoints, validation, an inference runner, Docker packaging, and an OpenEnv manifest.
+- **Extensibility**
+  Future tasks could include return-to-work support, manager coaching, policy audits, absenteeism risk, or escalation workflows.
+
+## Current Limitations
+
+It is useful to be transparent about the current scope:
+
+- the benchmark is primarily for structured evaluation, not clinical diagnosis,
+- heuristic fallback grading can be blunt compared with a stronger external judge model,
+- the current flow is benchmark-first rather than custom-case analysis first,
+- duplicate names can occasionally appear in generated scenarios and affect grading clarity.
+
+## Suggested Future Improvements
+
+- add a custom scenario endpoint for real-world demos,
+- improve scenario diversity and de-duplicate names within multi-person cases,
+- strengthen grading with a more robust external LLM judge,
+- add analytics dashboards for reward trends and failure modes,
+- expand task coverage into HR escalation and manager support planning.
+
+## License
+
+MIT

app.py

@@ -0,0 +1,175 @@
+"""
+IT Mental Health OpenEnv - FastAPI Server
+Exposes /reset, /step, /state, /health, /tasks endpoints.
+"""
+
+from typing import Any, Dict, Optional
+
+import uvicorn
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+
+from it_mental_health_environment import ITMentalHealthEnvironment, TASK_ORDER
+from models import MentalHealthAction
+
+app = FastAPI(
+    title="IT Mental Health OpenEnv",
+    description="RL environment for mental health assessment in the IT sector.",
+    version="1.0.0",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Global environment instance (single session for Spaces)
+env = ITMentalHealthEnvironment()
+
+TASK_METADATA = {
+    "burnout_detection": {
+        "difficulty": "easy",
+        "description": "Identify Maslach burnout dimensions, severity, red flags, and whether HR escalation is needed.",
+    },
+    "stress_triage": {
+        "difficulty": "medium",
+        "description": "Triage three IT employees by stress tier and recommend immediate and medium-term support.",
+    },
+    "intervention_plan": {
+        "difficulty": "hard",
+        "description": "Design a four-week intervention plan for a software team facing systemic burnout.",
+    },
+}
+
+
+class ResetRequest(BaseModel):
+    seed: Optional[int] = None
+
+
+class StepRequest(BaseModel):
+    response: str
+    task_id: Optional[str] = "burnout_detection"
+    confidence: Optional[float] = 1.0
+    metadata: Optional[Dict[str, Any]] = {}
+
+
+class ObservationResponse(BaseModel):
+    scenario: str
+    feedback: str
+    reward: float
+    done: bool
+    score_breakdown: Dict[str, float] = {}
+    task_id: str
+    metadata: Dict[str, Any] = {}
+
+
+class StateResponse(BaseModel):
+    episode_id: Optional[str]
+    step_count: int
+    current_task: str
+    cumulative_reward: float
+    tasks_completed: list
+
+
+@app.get("/")
+def root():
+    return {
+        "name": "IT Mental Health OpenEnv",
+        "version": "1.0.0",
+        "docs": "/docs",
+        "health": "/health",
+        "tasks": "/tasks",
+    }
+
+
+@app.get("/health")
+def health():
+    return {"status": "ok", "env": "it_mental_health_env", "version": "1.0.0"}
+
+
+@app.post("/reset", response_model=ObservationResponse)
+def reset(req: ResetRequest = ResetRequest()):
+    obs = env.reset(seed=req.seed)
+    return ObservationResponse(
+        scenario=obs.scenario,
+        feedback=obs.feedback,
+        reward=obs.reward,
+        done=obs.done,
+        score_breakdown=obs.score_breakdown,
+        task_id=obs.task_id,
+        metadata=obs.metadata,
+    )
+
+
+@app.post("/step", response_model=ObservationResponse)
+def step(req: StepRequest):
+    action = MentalHealthAction(
+        response=req.response,
+        task_id=req.task_id or "burnout_detection",
+        confidence=req.confidence or 1.0,
+        metadata=req.metadata or {},
+    )
+    obs = env.step(action)
+    return ObservationResponse(
+        scenario=obs.scenario,
+        feedback=obs.feedback,
+        reward=obs.reward,
+        done=obs.done,
+        score_breakdown=obs.score_breakdown,
+        task_id=obs.task_id,
+        metadata=obs.metadata,
+    )
+
+
+@app.get("/state", response_model=StateResponse)
+def state():
+    s = env.state
+    return StateResponse(
+        episode_id=s.episode_id,
+        step_count=s.step_count,
+        current_task=s.current_task,
+        cumulative_reward=s.cumulative_reward,
+        tasks_completed=s.tasks_completed,
+    )
+
+
+@app.get("/tasks")
+def list_tasks():
+    """List all tasks with metadata used by grader validation."""
+    return {
+        "tasks": [
+            {
+                "task_id": tid,
+                "difficulty": TASK_METADATA[tid]["difficulty"],
+                "description": TASK_METADATA[tid]["description"],
+            }
+            for tid in TASK_ORDER
+        ]
+    }
+
+
+@app.get("/schema")
+def schema():
+    return {
+        "action": {
+            "response": "str - agent's textual answer",
+            "task_id": "str - one of: burnout_detection, stress_triage, intervention_plan",
+            "confidence": "float 0.0-1.0",
+            "metadata": "dict - optional",
+        },
+        "observation": {
+            "scenario": "str - current scenario text",
+            "feedback": "str - grader feedback",
+            "reward": "float 0.0-1.0",
+            "done": "bool",
+            "score_breakdown": "dict - partial scores per rubric dimension",
+            "task_id": "str",
+        },
+    }
+
+
+if __name__ == "__main__":
+    uvicorn.run("app:app", host="0.0.0.0", port=7860, reload=False)

inference.py

@@ -0,0 +1,164 @@
+"""
+Inference script for IT Mental Health OpenEnv.
+
+Required environment variables in the inference configuration:
+    API_BASE_URL   The API endpoint for the LLM.
+    MODEL_NAME     The model identifier to use for inference.
+    HF_TOKEN       Your Hugging Face / API key.
+
+Optional:
+    LOCAL_IMAGE_NAME  Present for compatibility with environments created from
+                      docker images.
+
+Defaults are set only for API_BASE_URL and MODEL_NAME.
+The script uses the OpenAI client for all LLM calls.
+"""
+
+import os
+import sys
+from typing import List, Optional
+
+import requests
+from openai import OpenAI
+
+API_BASE_URL = os.getenv("API_BASE_URL", "https://api-inference.huggingface.co/v1")
+MODEL_NAME = os.getenv("MODEL_NAME", "meta-llama/Llama-3.1-8B-Instruct")
+HF_TOKEN = os.getenv("HF_TOKEN")
+LOCAL_IMAGE_NAME = os.getenv("LOCAL_IMAGE_NAME")
+ENV_BASE_URL = os.getenv("ENV_BASE_URL", "http://localhost:7860")
+
+BENCHMARK = "it_mental_health_env"
+MAX_STEPS = 3
+TEMPERATURE = 0.3
+MAX_TOKENS = 800
+SUCCESS_SCORE_THRESHOLD = 0.6
+
+SYSTEM_PROMPT = """You are an expert occupational psychologist and workplace mental health consultant
+specialising in the IT/software engineering sector. You have deep knowledge of:
+- Maslach Burnout Inventory (MBI) dimensions
+- Stress triage frameworks (GREEN/AMBER/RED/CRITICAL)
+- Evidence-based workplace mental health interventions
+- Employee Assistance Programmes (EAP) and HR escalation protocols
+
+Respond in clear, structured format with headings and concrete recommendations.
+Be specific, actionable, and professional. Aim for 200-600 words per response."""
+
+
+def clean_field(value: Optional[str]) -> str:
+    if value is None:
+        return "null"
+    return " ".join(str(value).split())
+
+
+def log_start(task: str, env: str, model: str) -> None:
+    print(f"[START] task={clean_field(task)} env={clean_field(env)} model={clean_field(model)}", flush=True)
+
+
+def log_step(step: int, action: str, reward: float, done: bool, error: Optional[str]) -> None:
+    print(
+        f"[STEP] step={step} action={clean_field(action)} reward={reward:.2f} "
+        f"done={str(done).lower()} error={clean_field(error)}",
+        flush=True,
+    )
+
+
+def log_end(success: bool, steps: int, score: float, rewards: List[float]) -> None:
+    rewards_str = ",".join(f"{reward:.2f}" for reward in rewards)
+    print(
+        f"[END] success={str(success).lower()} steps={steps} score={score:.3f} rewards={rewards_str}",
+        flush=True,
+    )
+
+
+def call_env(endpoint: str, payload: Optional[dict] = None, method: str = "POST") -> dict:
+    url = f"{ENV_BASE_URL}/{endpoint}"
+    if method == "GET":
+        response = requests.get(url, timeout=30)
+    else:
+        response = requests.post(url, json=payload or {}, timeout=30)
+    response.raise_for_status()
+    return response.json()
+
+
+def get_model_response(client: OpenAI, scenario: str) -> str:
+    completion = client.chat.completions.create(
+        model=MODEL_NAME,
+        messages=[
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": scenario},
+        ],
+        temperature=TEMPERATURE,
+        max_tokens=MAX_TOKENS,
+        stream=False,
+    )
+    content = completion.choices[0].message.content or ""
+    return content.strip() or "Provide a structured assessment and immediate next steps."
+
+
+def main() -> None:
+    rewards: List[float] = []
+    steps_taken = 0
+    score = 0.0
+    success = False
+    current_task = "unknown"
+    start_logged = False
+
+    try:
+        if not HF_TOKEN:
+            raise RuntimeError("HF_TOKEN must be set for inference.")
+
+        client = OpenAI(base_url=API_BASE_URL, api_key=HF_TOKEN)
+        observation = call_env("reset", {})
+        current_task = observation.get("task_id", "unknown")
+        log_start(task=current_task, env=BENCHMARK, model=MODEL_NAME)
+        start_logged = True
+
+        for step in range(1, MAX_STEPS + 1):
+            if observation.get("done", False):
+                break
+
+            current_task = observation.get("task_id", "unknown")
+            action_text = get_model_response(client, observation["scenario"])
+
+            error = None
+            done = False
+            reward = 0.0
+
+            try:
+                observation = call_env(
+                    "step",
+                    {
+                        "response": action_text,
+                        "task_id": current_task,
+                        "confidence": 0.85,
+                        "metadata": {},
+                    },
+                )
+                reward = float(observation.get("reward", 0.0) or 0.0)
+                done = bool(observation.get("done", False))
+            except Exception as exc:
+                error = str(exc)
+                done = True
+
+            rewards.append(reward)
+            steps_taken = step
+            log_step(step=step, action=action_text, reward=reward, done=done, error=error)
+
+            if error or done:
+                break
+
+        score = sum(rewards) / MAX_STEPS if MAX_STEPS > 0 else 0.0
+        score = max(0.0, min(1.0, score))
+        success = score >= SUCCESS_SCORE_THRESHOLD
+    finally:
+        if not start_logged:
+            log_start(task=current_task, env=BENCHMARK, model=MODEL_NAME)
+        log_end(success=success, steps=steps_taken, score=score, rewards=rewards)
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as exc:
+        print(f"Inference failed: {exc}", file=sys.stderr)
+        sys.exit(1)

it_mental_health_environment.py

@@ -0,0 +1,430 @@
+"""
+IT Mental Health OpenEnv - Environment Logic  (v2 - improved)
+
+FIX 1: LLM-as-judge grader replaces keyword matching.
+FIX 2: Randomised episode generation — every reset() is unique.
+"""
+
+import os
+import uuid
+import random
+import json
+from typing import Optional
+from openai import OpenAI
+
+try:
+    from models import MentalHealthAction, MentalHealthObservation, MentalHealthState
+except ImportError:
+    try:
+        from server.models import MentalHealthAction, MentalHealthObservation, MentalHealthState
+    except ImportError:
+        import sys
+        sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+        from models import MentalHealthAction, MentalHealthObservation, MentalHealthState
+
+TASK_ORDER = ["burnout_detection", "stress_triage", "intervention_plan"]
+
+# ── LLM Judge client ──────────────────────────────────────────────────────────
+_llm_client: Optional[OpenAI] = None
+
+def _get_llm_client() -> Optional[OpenAI]:
+    global _llm_client
+    if _llm_client is None:
+        api_key = os.environ.get("HF_TOKEN", "")
+        base_url = os.environ.get("API_BASE_URL", "https://api-inference.huggingface.co/v1")
+        if api_key:
+            _llm_client = OpenAI(api_key=api_key, base_url=base_url)
+    return _llm_client
+
+
+# ── Randomised scenario data pools ───────────────────────────────────────────
+NAMES = ["Alex","Jordan","Sam","Riley","Morgan","Casey","Taylor","Drew","Jamie","Avery"]
+ROLES = ["Software Engineer","DevOps Engineer","QA Engineer","Data Scientist",
+         "Backend Developer","Frontend Developer","ML Engineer","Platform Engineer"]
+YEARS_EXP = [1,2,3,4,5,7,8,10]
+
+EXHAUSTION_SYMPTOMS = [
+    "sleeping only 4-5 hours/night",
+    "skipping meals regularly",
+    "frequent headaches and migraines",
+    "working 65-75 hours/week for 3+ months",
+    "no vacation in over 12 months",
+    "falling asleep at desk",
+    "constant tiredness even after weekends",
+]
+DEPERSONALIZATION_SYMPTOMS = [
+    "says 'I don't care about outcomes anymore'",
+    "becoming cynical about project goals",
+    "stopped attending team standups",
+    "avoids messages for hours",
+    "emotionally detached during sprint reviews",
+    "sarcastic about the company mission",
+]
+REDUCED_ACCOMPLISHMENT_SYMPTOMS = [
+    "submitting incomplete pull requests",
+    "missing sprint commitments regularly",
+    "says 'nothing I do matters anyway'",
+    "code review quality has declined sharply",
+    "stopped proposing solutions in meetings",
+    "productivity metrics down 40% vs last quarter",
+]
+
+SEVERITY_MAP = {
+    "Low":      {"hours_range":(42,50), "vacation_months":(1,4),  "dimensions":1},
+    "Moderate": {"hours_range":(50,60), "vacation_months":(4,8),  "dimensions":2},
+    "High":     {"hours_range":(60,68), "vacation_months":(8,14), "dimensions":2},
+    "Critical": {"hours_range":(68,80), "vacation_months":(14,24),"dimensions":3},
+}
+
+STRESS_TIER_TEMPLATES = {
+    "GREEN":    ["Feeling slightly overwhelmed with the sprint but I think I'll manage."],
+    "AMBER":    ["Haven't slept great — around 6 hours most nights. Starting to affect focus."],
+    "RED":      ["I snapped at a teammate yesterday. I'm scared of how I'm feeling lately."],
+    "CRITICAL": ["I've been having chest tightness every time I get a pager alert. Three weeks. Haven't told anyone."],
+}
+
+
+def generate_burnout_scenario(rng):
+    name = rng.choice(NAMES)
+    role = rng.choice(ROLES)
+    exp = rng.choice(YEARS_EXP)
+    severity_label, cfg = rng.choice(list(SEVERITY_MAP.items()))
+    hours = rng.randint(*cfg["hours_range"])
+    vacation = rng.randint(*cfg["vacation_months"])
+    n_dims = cfg["dimensions"]
+
+    all_dims = ["exhaustion","depersonalization","reduced_accomplishment"]
+    active_dims = rng.sample(all_dims, n_dims)
+    symptoms = []
+    ground_truth_dims = []
+    if "exhaustion" in active_dims:
+        symptoms += rng.sample(EXHAUSTION_SYMPTOMS, 2)
+        ground_truth_dims.append("Exhaustion")
+    if "depersonalization" in active_dims:
+        symptoms += rng.sample(DEPERSONALIZATION_SYMPTOMS, 2)
+        ground_truth_dims.append("Depersonalization")
+    if "reduced_accomplishment" in active_dims:
+        symptoms += rng.sample(REDUCED_ACCOMPLISHMENT_SYMPTOMS, 2)
+        ground_truth_dims.append("Reduced Personal Accomplishment")
+    rng.shuffle(symptoms)
+    sym_text = "\n".join(f"- {s}" for s in symptoms)
+
+    scenario = f"""[TASK: Burnout Detection — EASY]
+
+You are an occupational psychologist reviewing an IT employee profile.
+
+Employee Profile:
+- Name: {name} ({role}, {exp} years experience)
+- Working hours: ~{hours} hrs/week for the past 3 months
+- Last vacation: {vacation} months ago
+- Observed symptoms:
+{sym_text}
+
+Your task:
+1. Identify which MBI dimensions are present: Exhaustion / Depersonalization / Reduced Personal Accomplishment
+2. Rate severity: Low / Moderate / High / Critical
+3. List TOP 3 red-flag signals from the profile
+4. State whether immediate HR escalation is needed (Yes/No) and why
+
+Respond with clear headings."""
+
+    gt = {"active_dimensions":ground_truth_dims, "severity":severity_label,
+          "escalation_needed":severity_label in ("High","Critical"),
+          "name":name, "hours":hours, "vacation_months":vacation}
+    return scenario, gt
+
+
+def generate_stress_triage_scenario(rng):
+    tiers = ["CRITICAL","RED",rng.choice(["GREEN","AMBER"])]
+    rng.shuffle(tiers)
+    selected_names = rng.sample(NAMES, len(tiers))
+    employees = []
+    for idx, tier in enumerate(tiers):
+        employees.append({
+            "name": selected_names[idx],
+            "role": rng.choice(ROLES),
+            "tier": tier,
+            "quote": rng.choice(STRESS_TIER_TEMPLATES[tier]),
+        })
+    tier_order = {"CRITICAL":0,"RED":1,"AMBER":2,"GREEN":3}
+    priority_order = sorted(range(3), key=lambda i: tier_order[employees[i]["tier"]])
+
+    cases = "".join(
+        f'{i+1}. {e["name"]} ({e["role"]}): "{e["quote"]}"\n'
+        for i,e in enumerate(employees)
+    )
+    scenario = f"""[TASK: Stress Triage — MEDIUM]
+
+You are reviewing urgent mental health flags from an IT pulse survey.
+Triage these 3 employees and prioritise them.
+
+Cases:
+{cases}
+For each case:
+a) Assign: GREEN / AMBER / RED / CRITICAL
+b) Primary stressor: Workload / Physiological / Relationship / Cognitive
+c) ONE immediate action (within 24 hours)
+d) ONE medium-term support (within 2 weeks)
+
+Rank the 3 cases by intervention priority (1 = most urgent)."""
+
+    gt = {
+        "employees": employees,
+        "correct_tiers": {e["name"]:e["tier"] for e in employees},
+        "priority_order": [employees[i]["name"] for i in priority_order],
+        "names": [e["name"] for e in employees],
+    }
+    return scenario, gt
+
+
+def generate_intervention_plan_scenario(rng):
+    team_size = rng.choice([8,10,12,15,18,20])
+    affected = int(team_size * rng.choice([0.4,0.5,0.6,0.7]))
+    overtime = rng.choice([10,15,18,20,25])
+    oncall = rng.choice([2,3,4,5])
+    no_tb = rng.choice([6,9,12,15,18,24])
+    no_1on1 = rng.choice([3,4,5,6,8])
+    on_leave = rng.randint(1,3)
+    hr_c = rng.randint(1,4)
+
+    scenario = f"""[TASK: Intervention Plan — HARD]
+
+You are a workplace mental health consultant. Design a 4-week intervention for a
+software team with systemic burnout ({affected} of {team_size} members affected).
+
+Team Context:
+- Overtime: {overtime} hrs/week above contract
+- On-call: 1 person every {oncall} days (24/7)
+- No team-building in {no_tb} months
+- No manager 1:1s in {no_1on1} months
+- {hr_c} formal HR complaints about workload
+- {on_leave} members on anxiety-related medical leave
+
+Design a 4-week plan:
+Week 1: Immediate stabilisation
+Week 2: Assessment & listening
+Week 3: Process reforms (on-call, overtime, workload)
+Week 4: Sustainable systems
+
+For each week: 2+ concrete actions, responsible party (HR/Manager/EAP), measurable outcome.
+
+Also include:
+- 3 measurable KPIs for 90-day tracking
+- 1 key risk if plan is NOT executed
+- Budget: Low (<$500) / Medium ($500-$5000) / High (>$5000)"""
+
+    gt = {"team_size":team_size,"affected":affected,"overtime":overtime,
+          "oncall_days":oncall,"on_leave":on_leave,"hr_complaints":hr_c}
+    return scenario, gt
+
+
+# ── Clinical rubrics ──────────────────────────────────────────────────────────
+RUBRICS = {
+    "burnout_detection": {
+        "dimensions_identified": {"max":3.0,"desc":"1pt per correct MBI dimension identified (0-3)"},
+        "severity_accuracy":     {"max":2.0,"desc":"2=exact match, 1=adjacent, 0=wrong"},
+        "red_flags_quality":     {"max":2.0,"desc":"Flags are specific and drawn from the profile (0-2)"},
+        "escalation_reasoning":  {"max":2.0,"desc":"Correct Yes/No + sound clinical reasoning (0-2)"},
+        "structure_clarity":     {"max":1.0,"desc":"Clear headings, professional format (0-1)"},
+    },
+    "stress_triage": {
+        "tier_accuracy":       {"max":3.0,"desc":"1pt per correct tier assigned (0-3)"},
+        "priority_ranking":    {"max":2.0,"desc":"2=correct, 1=partially correct, 0=wrong"},
+        "immediate_actions":   {"max":2.0,"desc":"Specific 24h actions proportionate to tier (0-2)"},
+        "medium_term_support": {"max":2.0,"desc":"Realistic 2-week support for each case (0-2)"},
+        "completeness":        {"max":1.0,"desc":"All 3 employees addressed with all 4 elements (0-1)"},
+    },
+    "intervention_plan": {
+        "four_week_structure":  {"max":3.0,"desc":"All 4 weeks with distinct focus (0-3)"},
+        "action_concreteness":  {"max":2.0,"desc":"Actions specific, not vague (0-2)"},
+        "responsibility":       {"max":1.0,"desc":"Responsible party per action (0-1)"},
+        "kpis_quality":         {"max":2.0,"desc":"3 measurable, relevant KPIs (0-2)"},
+        "risk_and_budget":      {"max":1.0,"desc":"Risk realistic + budget category present (0-1)"},
+        "proportionality":      {"max":1.0,"desc":"Plan addresses this team's specific numbers (0-1)"},
+    },
+}
+
+JUDGE_SYSTEM = """You are a clinical rubric evaluator for an AI mental health RL environment.
+Score the agent's response against the rubric. Award marks based on reasoning quality and accuracy — NOT keyword presence alone.
+Return ONLY valid JSON, no markdown fences:
+{"scores": {"dim_name": float, ...}, "feedback": "2-3 sentence critique"}"""
+
+
+def _llm_judge_grade(task_id, scenario, response, ground_truth):
+    rubric = RUBRICS[task_id]
+    total_max = sum(v["max"] for v in rubric.values())
+    rubric_text = "\n".join(f'  "{k}": max={v["max"]} — {v["desc"]}' for k,v in rubric.items())
+
+    prompt = f"""Task: {task_id}
+Scenario: {scenario}
+Ground truth: {json.dumps(ground_truth)}
+Agent response: {response}
+Rubric:
+{rubric_text}
+Score now. JSON only."""
+
+    client = _get_llm_client()
+    if client is None:
+        return _heuristic_grade(task_id, response, ground_truth)
+
+    model = os.environ.get("MODEL_NAME","meta-llama/Llama-3.1-8B-Instruct")
+    try:
+        resp = client.chat.completions.create(
+            model=model,
+            messages=[{"role":"system","content":JUDGE_SYSTEM},
+                      {"role":"user","content":prompt}],
+            max_tokens=400, temperature=0.0,
+        )
+        raw = resp.choices[0].message.content.strip().replace("```json","").replace("```","").strip()
+        parsed = json.loads(raw)
+        scores = parsed.get("scores",{})
+        feedback = parsed.get("feedback","")
+        breakdown, total = {}, 0.0
+        for dim, cfg in rubric.items():
+            s = max(0.0, min(cfg["max"], float(scores.get(dim, 0.0))))
+            breakdown[dim] = round(s/cfg["max"], 3)
+            total += s
+        reward = round(max(0.0, min(1.0, total/total_max)), 3)
+        return reward, breakdown, f"[LLM Judge] {feedback}"
+    except Exception as e:
+        r,b,f = _heuristic_grade(task_id, response, ground_truth)
+        return r, b, f"[Fallback — judge error: {e}] {f}"
+
+
+def _heuristic_grade(task_id, response, ground_truth):
+    """Ground-truth-aware heuristic fallback (better than pure keyword matching)."""
+    r = response.lower()
+    breakdown, score = {}, 0.0
+
+    if task_id == "burnout_detection":
+        dims = ground_truth.get("active_dimensions",[])
+        # Match on a distinctive token per dimension, not just the first word.
+        dim_keys = {
+            "Exhaustion": ["exhaustion","exhausted"],
+            "Depersonalization": ["depersonalization","depersonalisation","cynicism","cynical"],
+            "Reduced Personal Accomplishment": ["reduced personal accomplishment","reduced accomplishment","inefficacy","personal accomplishment"],
+        }
+        dim_hits = sum(1 for d in dims if any(k in r for k in dim_keys.get(d, [d.lower()])))
+        breakdown["dimensions_identified"] = dim_hits/max(len(dims),1)
+        # Severity: exact match = 1.0, adjacent tier = 0.5, otherwise 0.
+        sev_order = ["low","moderate","high","critical"]
+        sev = ground_truth.get("severity","High").lower()
+        mentioned = [s for s in sev_order if s in r]
+        if sev in mentioned:
+            breakdown["severity_accuracy"] = 1.0
+        elif mentioned and sev in sev_order:
+            gt_idx = sev_order.index(sev)
+            best = min(abs(sev_order.index(m) - gt_idx) for m in mentioned)
+            breakdown["severity_accuracy"] = 0.5 if best == 1 else 0.0
+        else:
+            breakdown["severity_accuracy"] = 0.0
+        breakdown["red_flags_quality"] = min(1.0, len(response)/300)
+        esc = ground_truth.get("escalation_needed",True)
+        esc_hit = "yes" in r or "escalat" in r or "immediate" in r
+        breakdown["escalation_reasoning"] = 1.0 if esc==esc_hit else 0.3
+        breakdown["structure_clarity"] = 1.0 if any(h in response for h in ["##","**","1.","1:"]) else 0.3
+
+    elif task_id == "stress_triage":
+        tiers = ground_truth.get("correct_tiers",{})
+        tier_hits = sum(1 for nm,t in tiers.items() if nm.lower() in r and t.lower() in r)
+        breakdown["tier_accuracy"] = tier_hits/max(len(tiers),1)
+        priority = ground_truth.get("priority_order",[])
+        breakdown["priority_ranking"] = 1.0 if (priority and priority[0].lower() in r[:500]) else 0.4
+        breakdown["immediate_actions"] = min(1.0, r.count("24")*0.3 + r.count("immediat")*0.4)
+        breakdown["medium_term_support"] = 1.0 if ("week" in r or "fortnight" in r) else 0.3
+        names = ground_truth.get("names",[])
+        breakdown["completeness"] = 1.0 if all(n.lower() in r for n in names) else 0.4
+
+    elif task_id == "intervention_plan":
+        weeks = sum(1 for w in ["week 1","week 2","week 3","week 4"] if w in r)
+        breakdown["four_week_structure"] = weeks/4.0
+        breakdown["action_concreteness"] = min(1.0, len(response)/600)
+        breakdown["responsibility"] = 1.0 if any(x in r for x in ["hr","manager","eap"]) else 0.0
+        kpi_hits = sum(1 for k in ["kpi","metric","measure","indicator"] if k in r)
+        breakdown["kpis_quality"] = min(1.0, kpi_hits*0.4)
+        breakdown["risk_and_budget"] = 1.0 if ("risk" in r and any(b in r for b in ["low","medium","high","$"])) else 0.3
+        gt_size = str(ground_truth.get("team_size",""))
+        breakdown["proportionality"] = 1.0 if gt_size in response else 0.5
+
+    score = sum(breakdown.values())/max(len(breakdown),1)
+    reward = round(max(0.0, min(1.0, score)), 3)
+    return reward, breakdown, f"[Heuristic] {task_id} = {reward:.2f}. Breakdown: {breakdown}"
+
+
+# ── Environment class ─────────────────────────────────────────────────────────
+class ITMentalHealthEnvironment:
+    """
+    OpenEnv RL environment — IT sector mental health.
+    Every reset() is unique (randomised profiles/scenarios).
+    Graded by LLM-as-judge against clinical rubric.
+    """
+    def __init__(self):
+        self._state = MentalHealthState()
+        self._task_index = 0
+        self._rng = random.Random()
+        self._current_scenarios: dict = {}
+
+    def _generate_all(self):
+        self._current_scenarios = {
+            "burnout_detection": generate_burnout_scenario(self._rng),
+            "stress_triage":     generate_stress_triage_scenario(self._rng),
+            "intervention_plan": generate_intervention_plan_scenario(self._rng),
+        }
+
+    def reset(self, seed=None):
+        actual_seed = seed if seed is not None else random.randint(0, 2**31)
+        self._rng = random.Random(actual_seed)
+        self._task_index = 0
+        self._generate_all()
+        self._state = MentalHealthState(
+            episode_id=str(uuid.uuid4()), step_count=0,
+            current_task=TASK_ORDER[0], cumulative_reward=0.0, tasks_completed=[],
+        )
+        task = TASK_ORDER[0]
+        scenario_text, _ = self._current_scenarios[task]
+        return MentalHealthObservation(
+            scenario=scenario_text, feedback=f"New episode (seed={actual_seed}).",
+            reward=0.0, done=False, score_breakdown={}, task_id=task,
+            metadata={"seed": actual_seed},
+        )
+
+    def step(self, action):
+        # Guard: refuse to grade once the episode is finished.
+        if self._task_index >= len(TASK_ORDER):
+            return MentalHealthObservation(
+                scenario="Episode already finished. Call /reset to start a new one.",
+                feedback="No-op: episode is done.",
+                reward=0.0, done=True, score_breakdown={},
+                task_id=self._state.current_task,
+            )
+
+        self._state.step_count += 1
+        task = self._state.current_task
+        scenario_text, ground_truth = self._current_scenarios.get(task, ("", {}))
+
+        reward, breakdown, feedback = _llm_judge_grade(
+            task_id=task, scenario=scenario_text,
+            response=action.response, ground_truth=ground_truth,
+        )
+        self._state.cumulative_reward += reward
+        self._state.tasks_completed.append(task)
+
+        self._task_index += 1
+        if self._task_index >= len(TASK_ORDER):
+            done = True
+            next_task = task
+            next_scenario = "All tasks complete. Episode finished."
+        else:
+            done = False
+            next_task = TASK_ORDER[self._task_index]
+            self._state.current_task = next_task
+            next_scenario, _ = self._current_scenarios[next_task]
+
+        return MentalHealthObservation(
+            scenario=next_scenario, feedback=feedback,
+            reward=reward, done=done, score_breakdown=breakdown, task_id=next_task,
+        )
+
+    @property
+    def state(self):
+        return self._state

models.py

@@ -0,0 +1,66 @@
+"""
+IT Mental Health OpenEnv - Typed Models
+Action / Observation / State for the IT Burnout & Mental Wellness environment.
+"""
+
+from dataclasses import dataclass, field
+from typing import Optional, Dict, Any, List
+
+
+@dataclass
+class MentalHealthAction:
+    """
+    Action submitted by the agent for each mental health scenario step.
+
+    Fields:
+        response (str): The agent's textual response / intervention recommendation.
+        task_id (str): Which task is being attempted: 'burnout_detection',
+                       'stress_triage', or 'intervention_plan'.
+        confidence (float): Agent's self-reported confidence 0.0–1.0.
+        metadata (dict): Optional extra fields (reasoning chain, flags, etc.)
+    """
+    response: str
+    task_id: str = "burnout_detection"
+    confidence: float = 1.0
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class MentalHealthObservation:
+    """
+    Observation returned after each step.
+
+    Fields:
+        scenario (str): The current scenario description shown to the agent.
+        feedback (str): Evaluator feedback on the last action.
+        reward (float): Reward for the last step (0.0 – 1.0).
+        done (bool): Whether the episode is finished.
+        score_breakdown (dict): Partial scores by rubric dimension.
+        task_id (str): Current task identifier.
+    """
+    scenario: str
+    feedback: str
+    reward: float
+    done: bool
+    score_breakdown: Dict[str, float] = field(default_factory=dict)
+    task_id: str = "burnout_detection"
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class MentalHealthState:
+    """
+    Episode state / metadata.
+
+    Fields:
+        episode_id (str): UUID for the current episode.
+        step_count (int): How many steps have elapsed.
+        current_task (str): Active task identifier.
+        cumulative_reward (float): Total reward accumulated so far.
+        tasks_completed (list): List of task IDs already completed.
+    """
+    episode_id: Optional[str] = None
+    step_count: int = 0
+    current_task: str = "burnout_detection"
+    cumulative_reward: float = 0.0
+    tasks_completed: List[str] = field(default_factory=list)

openenv.yaml

@@ -0,0 +1,68 @@
+spec_version: 1
+
+name: it_mental_health_env
+version: "1.0.0"
+description: >
+  An RL environment for mental health assessment and intervention planning
+  in the IT/software engineering sector. An AI agent faces three progressively
+  harder scenarios: detecting burnout signals (easy), triaging employee stress
+  cases (medium), and designing a structured team-wide intervention plan (hard).
+  Reward is 0.0–1.0 per task based on rubric coverage, structured format, and
+  clinical accuracy.
+
+type: typed          # uses typed Action / Observation / State models
+
+runtime:
+  language: python
+  version: "3.11"
+
+app:
+  module: app
+  object: app
+
+port: 7860
+
+tasks:
+  - id: burnout_detection
+    difficulty: easy
+    description: Identify Maslach burnout dimensions and severity from an employee profile
+    reward_range: [0.0, 1.0]
+
+  - id: stress_triage
+    difficulty: medium
+    description: Triage 3 IT employees by stress tier and recommend immediate actions
+    reward_range: [0.0, 1.0]
+
+  - id: intervention_plan
+    difficulty: hard
+    description: Design a 4-week mental health intervention plan for a burned-out IT team
+    reward_range: [0.0, 1.0]
+
+action_space:
+  type: text
+  fields:
+    response: str
+    task_id: str
+    confidence: float
+    metadata: dict
+
+observation_space:
+  type: text
+  fields:
+    scenario: str
+    feedback: str
+    reward: float
+    done: bool
+    score_breakdown: dict
+    task_id: str
+
+endpoints:
+  reset: POST /reset
+  step:  POST /step
+  state: GET  /state
+  health: GET /health
+  tasks: GET  /tasks
+  schema: GET /schema
+
+author: "IT Mental Health OpenEnv — Scaler x Meta-PyTorch Hackathon 2026"
+license: MIT

requirements.txt

@@ -0,0 +1,6 @@
+fastapi
+uvicorn
+pydantic
+requests
+PyYAML
+openai

requirements_inference.txt

@@ -0,0 +1,2 @@
+requests
+openai

validate.py

@@ -0,0 +1,139 @@
+"""
+validate.py - Pre-submission validator for IT Mental Health OpenEnv
+Run this before submitting: python validate.py
+
+Checks:
+1. openenv.yaml is present and has required fields
+2. /health returns 200
+3. /reset responds correctly
+4. /step responds correctly (all 3 tasks)
+5. /state responds correctly
+6. Rewards are in 0.0-1.0 range
+7. inference.py exists at repo root
+"""
+
+import os
+import sys
+
+import requests
+
+BASE_URL = "http://localhost:7860"
+
+PASS = "[PASS]"
+FAIL = "[FAIL]"
+results = []
+
+
+def check(name: str, ok: bool, detail: str = ""):
+    status = PASS if ok else FAIL
+    msg = f"{status} {name}"
+    if detail:
+        msg += f" - {detail}"
+    print(msg)
+    results.append(ok)
+    return ok
+
+
+def run():
+    print("\n" + "=" * 60)
+    print("  IT Mental Health OpenEnv - Pre-Submission Validator")
+    print("=" * 60 + "\n")
+
+    try:
+        import yaml
+
+        with open("openenv.yaml", encoding="utf-8") as f:
+            cfg = yaml.safe_load(f)
+        required = ["spec_version", "name", "type", "runtime", "app", "port", "tasks"]
+        missing = [k for k in required if k not in cfg]
+        check(
+            "openenv.yaml present & valid",
+            not missing,
+            f"missing: {missing}" if missing else f"name={cfg['name']}",
+        )
+        task_count = len(cfg.get("tasks", []))
+        check("3+ tasks in openenv.yaml", task_count >= 3, f"{task_count} tasks found")
+    except Exception as e:
+        check("openenv.yaml", False, str(e))
+
+    check("inference.py at root", os.path.exists("inference.py"))
+
+    try:
+        r = requests.get(f"{BASE_URL}/health", timeout=10)
+        check("/health returns 200", r.status_code == 200, f"status={r.status_code}")
+    except Exception as e:
+        check("/health", False, str(e))
+
+    try:
+        r = requests.post(f"{BASE_URL}/reset", json={}, timeout=10)
+        ok = r.status_code == 200
+        data = r.json() if ok else {}
+        check("/reset returns 200", ok)
+        check("/reset has 'scenario'", "scenario" in data)
+        check("/reset has 'reward'", "reward" in data)
+        check("/reset has 'done'", "done" in data)
+    except Exception as e:
+        check("/reset", False, str(e))
+
+    try:
+        requests.post(f"{BASE_URL}/reset", json={}, timeout=10)
+        task_ids = ["burnout_detection", "stress_triage", "intervention_plan"]
+        sample_response = (
+            "The employee shows Exhaustion, Depersonalization, and Reduced Personal Accomplishment. "
+            "Severity: High/Critical. Red flags: 70hr weeks, 14 months no leave, disconnection. "
+            "Immediate HR escalation: Yes - employee is at critical burnout risk.\n\n"
+            "Jordan: RED/CRITICAL tier. Riley: RED tier (chest tightness = physiological alarm). "
+            "Sam: AMBER tier. Priority ranking: 1=Riley, 2=Jordan, 3=Sam.\n\n"
+            "Week 1: Immediate on-call freeze, HR 1:1s for all affected. Responsible: HR Manager. "
+            "Week 2: Anonymous team survey and individual 30min check-ins. Responsible: HR. "
+            "Week 3: On-call rotation reform, overtime cap policy. Responsible: Manager. "
+            "Week 4: Bi-weekly 1:1s, EAP enrollment, manager training. Responsible: HR + External EAP. "
+            "KPIs: overtime hours, eNPS score, sick leave frequency. "
+            "Risk: further attrition and possible disability claims. Budget: Medium ($500-$5000)."
+        )
+        for tid in task_ids:
+            r = requests.post(
+                f"{BASE_URL}/step",
+                json={
+                    "response": sample_response,
+                    "task_id": tid,
+                    "confidence": 0.9,
+                },
+                timeout=30,
+            )
+            ok = r.status_code == 200
+            check(f"/step task={tid} returns 200", ok)
+            if ok:
+                d = r.json()
+                reward = d.get("reward", -1)
+                valid = 0.0 <= reward <= 1.0
+                check(f"reward in [0,1] for {tid}", valid, f"reward={reward:.3f}")
+    except Exception as e:
+        check("/step", False, str(e))
+
+    try:
+        r = requests.get(f"{BASE_URL}/state", timeout=10)
+        ok = r.status_code == 200
+        check("/state returns 200", ok)
+        if ok:
+            d = r.json()
+            check("/state has episode_id", "episode_id" in d)
+            check("/state has step_count", "step_count" in d)
+    except Exception as e:
+        check("/state", False, str(e))
+
+    total = len(results)
+    passed = sum(results)
+    print(f"\n{'=' * 60}")
+    print(f"  Result: {passed}/{total} checks passed")
+    if passed == total:
+        print("  ALL CHECKS PASSED - Ready to submit!")
+    else:
+        print("  Fix failing checks before submitting.")
+    print("=" * 60 + "\n")
+
+    sys.exit(0 if passed == total else 1)
+
+
+if __name__ == "__main__":
+    run()