clean initial commit

.gitignore

@@ -0,0 +1,28 @@
+# 🔐 Secrets
+.env
+*.env
+
+# 🐍 Python
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+
+# 🧪 Virtual environment
+.venv/
+venv/
+env/
+
+# 📦 uv
+uv.lock
+
+# 📝 Logs
+*.log
+
+# 💻 OS files
+.DS_Store
+Thumbs.db
+
+# 🧠 IDEs
+.vscode/
+.idea/

README.md

@@ -1,8 +1,8 @@
 ---
-title: Fitscript Environment Server
-emoji: 🎣
-colorFrom: yellow
-colorTo: pink
+title: FitScript Environment Server
+emoji: 🏋️
+colorFrom: blue
+colorTo: green
 sdk: docker
 pinned: false
 app_port: 8000
@@ -11,245 +11,207 @@ tags:
   - openenv
 ---
 
-# Fitscript Environment
+# FitScript Environment
 
-A simple test environment that echoes back messages. Perfect for testing the env APIs as well as demonstrating environment usage patterns.
+## Environment Description
 
-## Quick Start
+FitScript is an **AI fitness prescription environment** built on the OpenEnv framework. It simulates the real-world task of generating, evaluating, and refining personalized workout plans — work typically performed by personal trainers, physiotherapists, and sports coaches.
 
-The simplest way to use the Fitscript environment is through the `FitscriptEnv` class:
+Given a structured client profile (age, fitness level, goal, available equipment, injuries, days available), an agent must produce a JSON workout plan that satisfies evidence-based exercise-science criteria. The environment grades each submitted plan deterministically and provides step-by-step feedback so the agent can iterate and improve.
 
-```python
-from FitScript import FitscriptAction, FitscriptEnv
+## Motivation
 
-try:
-    # Create environment from Docker image
-    FitScriptenv = FitscriptEnv.from_docker_image("FitScript-env:latest")
+Fitness prescription is a genuine, commercially valuable human-expert task with several properties that make it ideal for RL benchmark training:
 
-    # Reset
-    result = FitScriptenv.reset()
-    print(f"Reset: {result.observation.echoed_message}")
+- **Objective grading** — exercise science has deterministic rules: volume, frequency, contraindications, and progression targets are verifiable without human labelers.
+- **Natural difficulty gradient** — tasks range from simple beginner plans to complex periodized powerlifting programs.
+- **Safety constraints** — contraindicated exercises for injured clients introduce hard safety penalties, training agents to respect real-world constraints.
+- **Dense reward signal** — partial scores at every step prevent sparse-reward pathology.
 
-    # Send multiple messages
-    messages = ["Hello, World!", "Testing echo", "Final message"]
+## Action Space
 
-    for msg in messages:
-        result = FitScriptenv.step(FitscriptAction(message=msg))
-        print(f"Sent: '{msg}'")
-        print(f"  → Echoed: '{result.observation.echoed_message}'")
-        print(f"  → Length: {result.observation.message_length}")
-        print(f"  → Reward: {result.reward}")
+Each step the agent submits a `FitscriptAction`:
 
-finally:
-    # Always clean up
-    FitScriptenv.close()
-```
-
-That's it! The `FitscriptEnv.from_docker_image()` method handles:
-- Starting the Docker container
-- Waiting for the server to be ready
-- Connecting to the environment
-- Container cleanup when you call `close()`
-
-## Building the Docker Image
+| Field | Type | Description |
+|-------|------|-------------|
+| `action_type` | `str` | One of `"generate_plan"`, `"modify_plan"`, `"explain_exercise"` |
+| `plan` | `str` | JSON string of the structured workout plan (exercises, sets, reps, rest) |
+| `reasoning` | `str \| None` | Optional agent justification for the plan choices |
 
-Before using the environment, you need to build the Docker image:
-
-```bash
-# From project root
-docker build -t FitScript-env:latest -f server/Dockerfile .
+**Plan JSON schema (basic / injury tasks):**
+```json
+{
+  "days": [
+    {
+      "name": "Day 1 - Lower Body",
+      "focus": "legs",
+      "exercises": [
+        {"name": "Squat", "sets": 3, "reps": 10, "rest_seconds": 60}
+      ]
+    }
+  ]
+}
 ```
 
-## Deploying to Hugging Face Spaces
-
-You can easily deploy your OpenEnv environment to Hugging Face Spaces using the `openenv push` command:
-
-```bash
-# From the environment directory (where openenv.yaml is located)
-openenv push
-
-# Or specify options
-openenv push --namespace my-org --private
+**Plan JSON schema (periodized program task):**
+```json
+{
+  "weeks": [
+    {
+      "week": 1,
+      "intensity": 72.5,
+      "total_sets": 80,
+      "days": [
+        {
+          "name": "Day 1 - Squat",
+          "exercises": [
+            {"name": "Back Squat", "sets": 5, "reps": 5, "intensity_pct": 72.5}
+          ]
+        }
+      ]
+    }
+  ]
+}
 ```
 
-The `openenv push` command will:
-1. Validate that the directory is an OpenEnv environment (checks for `openenv.yaml`)
-2. Prepare a custom build for Hugging Face Docker space (enables web interface)
-3. Upload to Hugging Face (ensuring you're logged in)
+## Observation Space
 
-### Prerequisites
+Each step returns a `FitscriptObservation`:
 
-- Authenticate with Hugging Face: The command will prompt for login if not already authenticated
+| Field | Type | Description |
+|-------|------|-------------|
+| `client_profile` | `dict` | Age, fitness level, goal, equipment, injuries, days/week |
+| `feedback` | `str` | Human-readable grader feedback on the submitted plan |
+| `score_breakdown` | `dict[str, float]` | Per-criterion partial scores |
+| `task_id` | `str` | Active task identifier |
+| `step_count` | `int` | Current step within the episode |
+| `done` | `bool` | `True` when task complete or max steps reached |
+| `reward` | `float` | Step reward in `[0.0, 1.0]` |
 
-### Options
+## Task Descriptions
 
-- `--directory`, `-d`: Directory containing the OpenEnv environment (defaults to current directory)
-- `--repo-id`, `-r`: Repository ID in format 'username/repo-name' (defaults to 'username/env-name' from openenv.yaml)
-- `--base-image`, `-b`: Base Docker image to use (overrides Dockerfile FROM)
-- `--private`: Deploy the space as private (default: public)
+### Task 1 — EASY: Basic Plan Generation (`basic_plan`)
 
-### Examples
+**Client:** 35-year-old beginner, no injuries, 3 days/week, home, no equipment.
 
-```bash
-# Push to your personal namespace (defaults to username/env-name from openenv.yaml)
-openenv push
+**Grader criteria (0.25 each):**
+1. Plan contains exactly 3 workout days.
+2. All exercises are bodyweight-only (no equipment required).
+3. Each day has 4–8 exercises with `sets` and `reps` defined.
+4. Beginner-appropriate: reps ≤ 15, no advanced movements (muscle-ups, pistol squats, etc.).
 
-# Push to a specific repository
-openenv push --repo-id my-org/my-env
+**Score formula:** `(criteria_met / 4)` → `[0.0, 1.0]`  
+**Episode ends:** plan submitted OR after 3 steps.
 
-# Push with a custom base image
-openenv push --base-image ghcr.io/meta-pytorch/openenv-base:latest
+---
 
-# Push as a private space
-openenv push --private
+### Task 2 — MEDIUM: Injury-Safe Plan Modification (`injury_safe_modification`)
 
-# Combine options
-openenv push --repo-id my-org/my-env --base-image custom-base:latest --private
-```
+**Client:** 30-year-old intermediate, lower-back injury, pre-generated plan contains back squats, deadlifts, and bent-over rows.
 
-After deployment, your space will be available at:
-`https://huggingface.co/spaces/<repo-id>`
+**Grader criteria (0.25 each):**
+1. Deadlifts removed or replaced (Romanian deadlift / leg press / hip thrust).
+2. Back squats replaced (goblet squat / wall sit / leg press).
+3. Bent-over rows replaced (seated cable row / machine row).
+4. Plan retains same muscle-group targets despite modifications.
 
-The deployed space includes:
-- **Web Interface** at `/web` - Interactive UI for exploring the environment
-- **API Documentation** at `/docs` - Full OpenAPI/Swagger interface
-- **Health Check** at `/health` - Container health monitoring
-- **WebSocket** at `/ws` - Persistent session endpoint for low-latency interactions
+**Score formula:** `(criteria_met / 4)` → `[0.0, 1.0]`  
+**Episode ends:** modification submitted OR after 5 steps.
 
-## Environment Details
+---
 
-### Action
-**FitscriptAction**: Contains a single field
-- `message` (str) - The message to echo back
+### Task 3 — HARD: Periodized 4-Week Program (`periodized_program`)
 
-### Observation
-**FitscriptObservation**: Contains the echo response and metadata
-- `echoed_message` (str) - The message echoed back
-- `message_length` (int) - Length of the message
-- `reward` (float) - Reward based on message length (length × 0.1)
-- `done` (bool) - Always False for echo environment
-- `metadata` (dict) - Additional info like step count
+**Client:** 27-year-old advanced powerlifter, 5 days/week, full gym, competition in 5 weeks, weak points: upper back and lockout strength.
 
-### Reward
-The reward is calculated as: `message_length × 0.1`
-- "Hi" → reward: 0.2
-- "Hello, World!" → reward: 1.3
-- Empty message → reward: 0.0
+**Grader criteria (0.2 each):**
+1. 4 distinct weeks, each with 5 training days.
+2. Weeks 1–3 show progressive overload (increasing intensity/RPE).
+3. Week 4 is a deload: volume reduced ≥ 40% vs week 3.
+4. Competition lifts (squat, bench, deadlift) present as primary movements.
+5. Bonus: accessory work targets weak points (upper back, lockout).
 
-## Advanced Usage
+**Score formula:** `min(1.0, criteria_met * 0.2)` → `[0.0, 1.0]`  
+**Episode ends:** full 4-week program submitted OR after 8 steps.
 
-### Connecting to an Existing Server
+---
 
-If you already have a Fitscript environment server running, you can connect directly:
+## Reward Design
 
-```python
-from FitScript import FitscriptEnv
+- **Per-step reward:** `max(0.0, partial_score − safety_penalty)`
+- **Safety penalty:** −0.3 if contraindicated exercises are present for an injured client.
+- **Empty plan:** reward = 0.0.
+- **Duplicate plan:** reward = 0.0 (no improvement penalty).
+- All rewards are clamped to `[0.0, 1.0]`.
 
-# Connect to existing server
-FitScriptenv = FitscriptEnv(base_url="<ENV_HTTP_URL_HERE>")
+## Setup Instructions
 
-# Use as normal
-result = FitScriptenv.reset()
-result = FitScriptenv.step(FitscriptAction(message="Hello!"))
+### Build the Docker image
+```bash
+docker build -t FitScript-env:latest -f server/Dockerfile .
 ```
 
-Note: When connecting to an existing server, `FitScriptenv.close()` will NOT stop the server.
-
-### Using the Context Manager
-
-The client supports context manager usage for automatic connection management:
-
-```python
-from FitScript import FitscriptAction, FitscriptEnv
-
-# Connect with context manager (auto-connects and closes)
-with FitscriptEnv(base_url="http://localhost:8000") as env:
-    result = env.reset()
-    print(f"Reset: {result.observation.echoed_message}")
-    # Multiple steps with low latency
-    for msg in ["Hello", "World", "!"]:
-        result = env.step(FitscriptAction(message=msg))
-        print(f"Echoed: {result.observation.echoed_message}")
+### Run locally
+```bash
+uvicorn server.app:app --reload --host 0.0.0.0 --port 8000
 ```
 
-The client uses WebSocket connections for:
-- **Lower latency**: No HTTP connection overhead per request
-- **Persistent session**: Server maintains your environment state
-- **Efficient for episodes**: Better for many sequential steps
-
-### Concurrent WebSocket Sessions
-
-The server supports multiple concurrent WebSocket connections. To enable this,
-modify `server/app.py` to use factory mode:
+### Run inference
+```bash
+export API_BASE_URL=https://api.openai.com/v1
+export MODEL_NAME=gpt-4o
+export HF_TOKEN=<your_key>
+export FITSCRIPT_TASK=basic_plan   # or injury_safe_modification / periodized_program
 
-```python
-# In server/app.py - use factory mode for concurrent sessions
-app = create_app(
-    FitscriptEnvironment,  # Pass class, not instance
-    FitscriptAction,
-    FitscriptObservation,
-    max_concurrent_envs=4,  # Allow 4 concurrent sessions
-)
+python inference.py
 ```
 
-Then multiple clients can connect simultaneously:
-
-```python
-from FitScript import FitscriptAction, FitscriptEnv
-from concurrent.futures import ThreadPoolExecutor
-
-def run_episode(client_id: int):
-    with FitscriptEnv(base_url="http://localhost:8000") as env:
-        result = env.reset()
-        for i in range(10):
-            result = env.step(FitscriptAction(message=f"Client {client_id}, step {i}"))
-        return client_id, result.observation.message_length
+### Deploy to Hugging Face Spaces
+```bash
+# From the directory containing openenv.yaml
+openenv push
 
-# Run 4 episodes concurrently
-with ThreadPoolExecutor(max_workers=4) as executor:
-    results = list(executor.map(run_episode, range(4)))
+# With options
+openenv push --repo-id my-org/fitscript-env --private
 ```
 
-## Development & Testing
-
-### Direct Environment Testing
-
-Test the environment logic directly without starting the HTTP server:
+The deployed space exposes:
+- **Web Interface** at `/web`
+- **API Docs** at `/docs`
+- **Health Check** at `/health`
+- **WebSocket** at `/ws`
 
+### Pre-submission validation
 ```bash
-# From the server directory
-python3 server/FitScript_environment.py
+bash validate.sh <HF_SPACE_URL> <REPO_DIR>
+# Step 1: POST /reset returns HTTP 200
+# Step 2: docker build succeeds
+# Step 3: openenv validate passes
 ```
 
-This verifies that:
-- Environment resets correctly
-- Step executes actions properly
-- State tracking works
-- Rewards are calculated correctly
+## Baseline Scores
 
-### Running Locally
+> Run `python inference.py` for each task and record the `[END] score=...` line.
 
-Run the server locally for development:
-
-```bash
-uvicorn server.app:app --reload
-```
+| Task | Difficulty | Baseline Score | Model |
+|------|-----------|---------------|-------|
+| `basic_plan` | Easy | _TBD_ | _fill before submission_ |
+| `injury_safe_modification` | Medium | _TBD_ | _fill before submission_ |
+| `periodized_program` | Hard | _TBD_ | _fill before submission_ |
 
 ## Project Structure
 
 ```
 FitScript/
-├── .dockerignore         # Docker build exclusions
-├── __init__.py            # Module exports
-├── README.md              # This file
-├── openenv.yaml           # OpenEnv manifest
-├── pyproject.toml         # Project metadata and dependencies
-├── uv.lock                # Locked dependencies (generated)
-├── client.py              # FitscriptEnv client
-├── models.py              # Action and Observation models
+├── inference.py               # ← Hackathon entry point (REQUIRED)
+├── openenv.yaml               # OpenEnv manifest with tasks section
+├── pyproject.toml             # Project metadata and dependencies
+├── __init__.py                # Module exports
+├── client.py                  # FitscriptEnv client
+├── models.py                  # FitscriptAction and FitscriptObservation
 └── server/
-    ├── __init__.py        # Server module exports
-    ├── FitScript_environment.py  # Core environment logic
-    ├── app.py             # FastAPI application (HTTP + WebSocket endpoints)
-    └── Dockerfile         # Container image definition
-```
+    ├── __init__.py            # Server module exports
+    ├── FitScript_environment.py   # Core environment + 3 task graders
+    ├── app.py                 # FastAPI application (HTTP + WebSocket)
+    └── Dockerfile             # Multi-stage container definition
+```

client.py

@@ -4,7 +4,7 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
-"""Fitscript Environment Client."""
+"""FitScript Environment Client."""
 
 from typing import Dict
 
@@ -19,27 +19,34 @@ class FitscriptEnv(
     EnvClient[FitscriptAction, FitscriptObservation, State]
 ):
     """
-    Client for the Fitscript Environment.
+    Client for the FitScript Environment.
 
-    This client maintains a persistent WebSocket connection to the environment server,
-    enabling efficient multi-step interactions with lower latency.
+    This client maintains a persistent WebSocket connection to the environment
+    server, enabling efficient multi-step interactions with lower latency.
     Each client instance has its own dedicated environment session on the server.
 
     Example:
         >>> # Connect to a running server
         >>> with FitscriptEnv(base_url="http://localhost:8000") as client:
         ...     result = client.reset()
-        ...     print(result.observation.echoed_message)
+        ...     print(result.observation.client_profile)
         ...
-        ...     result = client.step(FitscriptAction(message="Hello!"))
-        ...     print(result.observation.echoed_message)
+        ...     result = client.step(FitscriptAction(
+        ...         action_type="generate_plan",
+        ...         plan='{"days": [...]}',
+        ...         reasoning="Beginner-safe bodyweight plan"
+        ...     ))
+        ...     print(result.observation.feedback)
+        ...     print(result.reward)
 
     Example with Docker:
-        >>> # Automatically start container and connect
         >>> client = FitscriptEnv.from_docker_image("FitScript-env:latest")
         >>> try:
         ...     result = client.reset()
-        ...     result = client.step(FitscriptAction(message="Test"))
+        ...     result = client.step(FitscriptAction(
+        ...         action_type="generate_plan",
+        ...         plan='{"days": [...]}'
+        ...     ))
         ... finally:
         ...     client.close()
     """
@@ -54,9 +61,13 @@ class FitscriptEnv(
         Returns:
             Dictionary representation suitable for JSON encoding
         """
-        return {
-            "message": action.message,
+        payload = {
+            "action_type": action.action_type,
+            "plan": action.plan,
         }
+        if action.reasoning is not None:
+            payload["reasoning"] = action.reasoning
+        return payload
 
     def _parse_result(self, payload: Dict) -> StepResult[FitscriptObservation]:
         """
@@ -70,8 +81,11 @@ class FitscriptEnv(
         """
         obs_data = payload.get("observation", {})
         observation = FitscriptObservation(
-            echoed_message=obs_data.get("echoed_message", ""),
-            message_length=obs_data.get("message_length", 0),
+            client_profile=obs_data.get("client_profile", {}),
+            feedback=obs_data.get("feedback", ""),
+            score_breakdown=obs_data.get("score_breakdown", {}),
+            task_id=obs_data.get("task_id", ""),
+            step_count=obs_data.get("step_count", 0),
             done=payload.get("done", False),
             reward=payload.get("reward"),
             metadata=obs_data.get("metadata", {}),
@@ -96,4 +110,4 @@ class FitscriptEnv(
         return State(
             episode_id=payload.get("episode_id"),
             step_count=payload.get("step_count", 0),
-        )
+        )

inference.py

@@ -0,0 +1,247 @@
+"""
+FitScript inference.py --- required entry point for hackathon evaluation.
+
+Usage:
+    FITSCRIPT_TASK=basic_plan \\
+    API_BASE_URL=https://api.openai.com/v1 \\
+    MODEL_NAME=gpt-4o \\
+    HF_TOKEN=<your_key> \\
+    python inference.py
+
+Supported FITSCRIPT_TASK values:
+    basic_plan               (easy)
+    injury_safe_modification (medium)
+    periodized_program       (hard)
+
+Output format (stdout, flush=True on every line):
+    [START] task=<task> env=fitscript_env model=<model>
+    [STEP]  step=<N> action=<text> reward=<R:.2f> done=<true|false> error=<null|msg>
+    [END]   success=<true|false> steps=<N> score=<S:.3f> rewards=<r1:.2f,...>
+"""
+
+import asyncio
+import json
+import os
+import sys
+
+from openai import OpenAI
+
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+# ---------------------------------------------------------------------------
+# Required environment variables (hackathon spec §5.1)
+# ---------------------------------------------------------------------------
+API_BASE_URL: str = os.environ["API_BASE_URL"]
+MODEL_NAME: str = os.environ["MODEL_NAME"]
+API_KEY: str = os.environ["HF_TOKEN"]
+
+TASK_NAME: str = os.getenv("FITSCRIPT_TASK", "basic_plan")
+BENCHMARK: str = "fitscript_env"
+IMAGE_NAME: str = os.getenv("FITSCRIPT_IMAGE", "FitScript-env:latest")
+MAX_STEPS: int = int(os.getenv("MAX_STEPS", "8"))
+
+# ---------------------------------------------------------------------------
+# Structured log helpers (hackathon spec §5.2)
+# ---------------------------------------------------------------------------
+
+def log_start(task: str, env: str, model: str) -> None:
+    print(f"[START] task={task} env={env} model={model}", flush=True)
+
+
+def log_step(step: int, action: str, reward: float, done: bool, error) -> None:
+    err = error if error else "null"
+    # Collapse multiline action text to a single safe token for the log line
+    action_token = action.replace("\n", " ").replace("\r", "")[:120]
+    print(
+        f"[STEP] step={step} action={action_token} reward={reward:.2f}"
+        f" done={str(done).lower()} error={err}",
+        flush=True,
+    )
+
+
+def log_end(success: bool, steps: int, score: float, rewards: list) -> None:
+    r = ",".join(f"{r:.2f}" for r in rewards)
+    print(
+        f"[END] success={str(success).lower()} steps={steps}"
+        f" score={score:.3f} rewards={r}",
+        flush=True,
+    )
+
+
+# ---------------------------------------------------------------------------
+# System prompt
+# ---------------------------------------------------------------------------
+
+SYSTEM_PROMPT = """You are an expert personal trainer and exercise scientist.
+You will receive a client profile and must generate a structured workout plan as JSON.
+
+Always respond with ONLY a JSON object representing the workout plan.
+Do NOT include any prose or explanation outside the JSON.
+
+JSON schema for a basic/injury plan:
+{
+  "days": [
+    {
+      "name": "Day 1 - ...",
+      "focus": "...",
+      "exercises": [
+        {"name": "...", "sets": <int>, "reps": <int>, "rest_seconds": <int>}
+      ]
+    }
+  ]
+}
+
+JSON schema for a periodized 4-week program:
+{
+  "weeks": [
+    {
+      "week": 1,
+      "intensity": <float 0-100 representing % 1RM or avg RPE>,
+      "total_sets": <int>,
+      "days": [
+        {
+          "name": "Day 1 - ...",
+          "exercises": [
+            {"name": "...", "sets": <int>, "reps": <int>, "intensity_pct": <float>}
+          ]
+        }
+      ]
+    }
+  ]
+}
+"""
+
+
+# ---------------------------------------------------------------------------
+# LLM agent call
+# ---------------------------------------------------------------------------
+
+def call_llm(client: OpenAI, messages: list) -> str:
+    """Call the LLM and return the text of the first content block."""
+    response = client.chat.completions.create(
+        model=MODEL_NAME,
+        messages=messages,
+        temperature=0.7,
+        max_tokens=2048,
+    )
+    return response.choices[0].message.content or ""
+
+
+def build_user_message(observation) -> str:
+    """Build the user turn from an observation object."""
+    profile = observation.client_profile if hasattr(observation, "client_profile") else {}
+    feedback = observation.feedback if hasattr(observation, "feedback") else ""
+    breakdown = observation.score_breakdown if hasattr(observation, "score_breakdown") else {}
+    task_id = observation.task_id if hasattr(observation, "task_id") else ""
+
+    parts = [
+        f"Task: {task_id}",
+        f"Client profile: {json.dumps(profile, indent=2)}",
+    ]
+    if feedback:
+        parts.append(f"Environment feedback: {feedback}")
+    if breakdown:
+        parts.append(f"Score breakdown: {json.dumps(breakdown, indent=2)}")
+    parts.append("Please generate or revise the workout plan as JSON only.")
+    return "\n\n".join(parts)
+
+
+# ---------------------------------------------------------------------------
+# Episode runner
+# ---------------------------------------------------------------------------
+
+async def run_episode() -> None:
+    from FitScript import FitscriptAction, FitscriptEnv  # local import after path is set
+
+    llm = OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
+
+    log_start(TASK_NAME, BENCHMARK, MODEL_NAME)
+
+    rewards: list = []
+    final_score = 0.0
+    success = False
+    step = 0
+    error_msg = None
+
+    env = None
+    try:
+        env = FitscriptEnv.from_docker_image(IMAGE_NAME)
+
+        # Reset
+        reset_result = env.reset()
+        obs = reset_result.observation
+
+        messages = [{"role": "system", "content": SYSTEM_PROMPT}]
+
+        for step in range(1, MAX_STEPS + 1):
+            # Build user turn from current observation
+            user_content = build_user_message(obs)
+            messages.append({"role": "user", "content": user_content})
+
+            # Call LLM
+            try:
+                assistant_reply = call_llm(llm, messages)
+            except Exception as exc:
+                error_msg = str(exc)
+                log_step(step, "LLM_ERROR", 0.0, True, error_msg)
+                break
+
+            messages.append({"role": "assistant", "content": assistant_reply})
+
+            # Strip markdown fences if present
+            plan_str = assistant_reply.strip()
+            if plan_str.startswith("```"):
+                lines = plan_str.split("\n")
+                plan_str = "\n".join(
+                    line for line in lines
+                    if not line.startswith("```")
+                ).strip()
+
+            # Determine action_type from task
+            if TASK_NAME == "injury_safe_modification":
+                action_type = "modify_plan"
+            elif TASK_NAME == "periodized_program":
+                action_type = "generate_plan"
+            else:
+                action_type = "generate_plan"
+
+            action = FitscriptAction(action_type=action_type, plan=plan_str)
+
+            # Step in environment
+            try:
+                result = env.step(action)
+            except Exception as exc:
+                error_msg = str(exc)
+                log_step(step, action_type, 0.0, True, error_msg)
+                break
+
+            obs = result.observation
+            reward = float(result.reward or 0.0)
+            done = bool(result.done)
+            rewards.append(reward)
+            final_score = reward
+
+            log_step(step, action_type, reward, done, None)
+
+            if done:
+                success = reward >= 0.75
+                break
+
+    except Exception as exc:
+        error_msg = str(exc)
+        print(f"[ERROR] {error_msg}", flush=True, file=sys.stderr)
+    finally:
+        if env is not None:
+            env.close()
+
+    log_end(success, step, final_score, rewards)
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    asyncio.run(run_episode())

models.py

@@ -5,23 +5,55 @@
 # LICENSE file in the root directory of this source tree.
 
 """
-Data models for the Fitscript Environment.
+Data models for the FitScript Environment.
 
-The FitScript environment is a simple test environment that echoes back messages.
+FitScript simulates a real-world AI fitness prescription task:
+generating, evaluating, and refining personalized workout plans.
 """
 
 from openenv.core.env_server.types import Action, Observation
 from pydantic import Field
+from typing import Optional, Dict, Any
 
 
 class FitscriptAction(Action):
-    """Action for the Fitscript environment - just a message to echo."""
-
-    message: str = Field(..., description="Message to echo back")
+    """Action for the FitScript environment --- fitness plan generation/modification."""
+
+    action_type: str = Field(
+        ...,
+        description="One of: 'generate_plan' | 'modify_plan' | 'explain_exercise'"
+    )
+    plan: str = Field(
+        default="",
+        description="JSON string of structured workout plan (exercises, sets, reps, rest)"
+    )
+    reasoning: Optional[str] = Field(
+        default=None,
+        description="Agent justification for the plan choices"
+    )
 
 
 class FitscriptObservation(Observation):
-    """Observation from the Fitscript environment - the echoed message."""
-
-    echoed_message: str = Field(default="", description="The echoed message")
-    message_length: int = Field(default=0, description="Length of the echoed message")
+    """Observation from the FitScript environment --- client profile and plan feedback."""
+
+    client_profile: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Client info: age, fitness_level, goal, equipment, injuries, days_per_week"
+    )
+    feedback: str = Field(
+        default="",
+        description="Environment feedback on the last submitted plan"
+    )
+    score_breakdown: Dict[str, float] = Field(
+        default_factory=dict,
+        description="Partial scores per criterion (safety, completeness, progression)"
+    )
+    task_id: str = Field(
+        default="",
+        description="Current task identifier"
+    )
+    step_count: int = Field(
+        default=0,
+        description="Current step within the episode"
+    )
+    # done and reward are inherited from the Observation base class

openenv.yaml

@@ -5,3 +5,18 @@ runtime: fastapi
 app: server.app:app
 port: 8000
 
+tasks:
+  - id: basic_plan
+    name: Basic Workout Plan Generation
+    difficulty: easy
+    description: Generate a 3-day bodyweight beginner plan with no equipment.
+
+  - id: injury_safe_modification
+    name: Injury-Safe Plan Modification
+    difficulty: medium
+    description: Modify a plan to remove lower-back-stressing exercises.
+
+  - id: periodized_program
+    name: Periodized 4-Week Program
+    difficulty: hard
+    description: Design a 4-week periodized powerlifting block with deload week.

server/FitScript_environment.py

@@ -5,13 +5,16 @@
 # LICENSE file in the root directory of this source tree.
 
 """
-Fitscript Environment Implementation.
+FitScript Environment Implementation.
 
-A simple test environment that echoes back messages sent to it.
-Perfect for testing HTTP server infrastructure.
+Simulates a real-world fitness prescription task: generating, evaluating,
+and refining personalized workout plans. Supports three tasks of increasing
+difficulty with deterministic graders.
 """
 
+import json
 from uuid import uuid4
+from typing import Dict, Any, Tuple
 
 from openenv.core.env_server.interfaces import Environment
 from openenv.core.env_server.types import State
@@ -22,83 +25,605 @@ except ImportError:
     from models import FitscriptAction, FitscriptObservation
 
 
+# ---------------------------------------------------------------------------
+# Grader base class
+# ---------------------------------------------------------------------------
+
+class BaseTask:
+    """Base class for all FitScript tasks."""
+
+    client_profile: dict = {}
+    max_steps: int = 5
+
+    def grade(
+        self, action: FitscriptAction, step: int
+    ) -> Tuple[float, Dict[str, float], str]:
+        """
+        Returns (score: float in [0,1], breakdown: dict, feedback: str).
+        Must be implemented by every concrete task.
+        """
+        raise NotImplementedError
+
+
+# ---------------------------------------------------------------------------
+# Task 1 - EASY: Basic Plan Generation
+# ---------------------------------------------------------------------------
+
+class BasicPlanTask(BaseTask):
+    """
+    Scenario: 35-year-old beginner, no injuries, 3 days/week, home, no equipment.
+    Grader: 4 criteria worth 0.25 each.
+    Episode ends when plan submitted OR after 3 steps.
+    """
+
+    client_profile = {
+        "age": 35,
+        "fitness_level": "beginner",
+        "goal": "general fitness",
+        "equipment": [],
+        "injuries": [],
+        "days_per_week": 3,
+    }
+    max_steps = 3
+
+    # Exercises that require equipment --- flag any appearance
+    EQUIPMENT_EXERCISES = {
+        "barbell", "dumbbell", "kettlebell", "cable", "machine",
+        "bench press", "squat rack", "pull-up bar", "resistance band",
+        "treadmill", "stationary bike",
+    }
+
+    # Advanced movements not appropriate for beginners
+    ADVANCED_MOVEMENTS = {
+        "muscle-up", "muscle up", "handstand push-up", "handstand pushup",
+        "pistol squat", "one-arm push-up", "planche", "front lever",
+        "back lever", "dragon flag",
+    }
+
+    def grade(self, action: FitscriptAction, step: int) -> Tuple[float, Dict[str, float], str]:
+        scores: Dict[str, float] = {}
+        feedback_parts = []
+
+        try:
+            plan = json.loads(action.plan) if action.plan else {}
+        except json.JSONDecodeError:
+            plan = {}
+
+        # Criterion 1: Plan contains exactly 3 workout days
+        days = plan.get("days", plan.get("workout_days", []))
+        if isinstance(days, list) and len(days) == 3:
+            scores["three_days"] = 0.25
+            feedback_parts.append("✓ Plan has exactly 3 workout days.")
+        else:
+            scores["three_days"] = 0.0
+            found = len(days) if isinstance(days, list) else "unknown"
+            feedback_parts.append(f"✗ Expected 3 workout days, found {found}.")
+
+        # Criterion 2: All exercises are bodyweight-only
+        all_exercises = _extract_exercises(plan)
+        plan_text_lower = action.plan.lower()
+        equipment_found = [e for e in self.EQUIPMENT_EXERCISES if e in plan_text_lower]
+        if not equipment_found:
+            scores["bodyweight_only"] = 0.25
+            feedback_parts.append("✓ No equipment required --- all bodyweight exercises.")
+        else:
+            scores["bodyweight_only"] = 0.0
+            feedback_parts.append(f"✗ Equipment-dependent exercises found: {equipment_found[:3]}.")
+
+        # Criterion 3: Each day has 4-8 exercises with sets and reps defined
+        if isinstance(days, list) and len(days) > 0:
+            days_ok = 0
+            for day in days:
+                exs = day.get("exercises", [])
+                if 4 <= len(exs) <= 8 and all(
+                    e.get("sets") and e.get("reps") for e in exs
+                ):
+                    days_ok += 1
+            if days_ok == len(days) and len(days) > 0:
+                scores["exercise_structure"] = 0.25
+                feedback_parts.append("✓ Each day has 4-8 exercises with sets and reps defined.")
+            else:
+                scores["exercise_structure"] = 0.0
+                feedback_parts.append(
+                    f"✗ {days_ok}/{len(days)} days have 4-8 exercises with sets+reps. "
+                    "Ensure every exercise has 'sets' and 'reps' fields."
+                )
+        else:
+            scores["exercise_structure"] = 0.0
+            feedback_parts.append("✗ Cannot evaluate exercise structure: no days found.")
+
+        # Criterion 4: Beginner-appropriate (reps <= 15, no advanced movements)
+        advanced_found = [m for m in self.ADVANCED_MOVEMENTS if m in plan_text_lower]
+        reps_too_high = _check_reps_exceed(plan, max_reps=15)
+        if not advanced_found and not reps_too_high:
+            scores["beginner_appropriate"] = 0.25
+            feedback_parts.append("✓ Plan is beginner-appropriate (no advanced movements, reps ≤ 15).")
+        else:
+            scores["beginner_appropriate"] = 0.0
+            if advanced_found:
+                feedback_parts.append(f"✗ Advanced movements not suitable for beginners: {advanced_found}.")
+            if reps_too_high:
+                feedback_parts.append("✗ Some exercises have reps > 15 --- too high for a beginner.")
+
+        score = sum(scores.values())
+        feedback = " ".join(feedback_parts)
+        return score, scores, feedback
+
+
+# ---------------------------------------------------------------------------
+# Task 2 - MEDIUM: Injury-Safe Plan Modification
+# ---------------------------------------------------------------------------
+
+class InjurySafeTask(BaseTask):
+    """
+    Scenario: Intermediate client with lower-back injury. Pre-generated plan
+    contains back squats, deadlifts, and bent-over rows. Agent must modify safely.
+    Episode ends when modification submitted OR after 5 steps.
+    """
+
+    client_profile = {
+        "age": 30,
+        "fitness_level": "intermediate",
+        "goal": "strength maintenance",
+        "equipment": ["barbell", "dumbbells", "cables", "machines"],
+        "injuries": ["lower back"],
+        "days_per_week": 4,
+        "initial_plan": {
+            "days": [
+                {
+                    "name": "Day 1 - Lower Body",
+                    "exercises": [
+                        {"name": "Back Squat", "sets": 4, "reps": 8},
+                        {"name": "Deadlift", "sets": 3, "reps": 5},
+                        {"name": "Leg Press", "sets": 3, "reps": 10},
+                        {"name": "Calf Raises", "sets": 4, "reps": 15},
+                    ],
+                },
+                {
+                    "name": "Day 2 - Upper Body",
+                    "exercises": [
+                        {"name": "Bench Press", "sets": 4, "reps": 8},
+                        {"name": "Bent-Over Row", "sets": 4, "reps": 8},
+                        {"name": "Overhead Press", "sets": 3, "reps": 10},
+                        {"name": "Pull-Up", "sets": 3, "reps": "max"},
+                    ],
+                },
+            ]
+        },
+    }
+    max_steps = 5
+
+    DEADLIFT_REPLACEMENTS = {
+        "romanian deadlift", "rdl", "leg press", "leg curl",
+        "hip thrust", "glute bridge", "trap bar deadlift",
+    }
+    SQUAT_REPLACEMENTS = {
+        "goblet squat", "wall sit", "wall squat", "leg press",
+        "box squat", "safety bar squat", "hack squat",
+    }
+    ROW_REPLACEMENTS = {
+        "seated cable row", "seated row", "machine row",
+        "chest-supported row", "chest supported row",
+        "t-bar row", "seal row",
+    }
+    ORIGINAL_MUSCLE_GROUPS = {"quads", "hamstrings", "glutes", "back", "chest", "shoulders"}
+
+    def grade(self, action: FitscriptAction, step: int) -> Tuple[float, Dict[str, float], str]:
+        scores: Dict[str, float] = {}
+        feedback_parts = []
+        plan_text_lower = action.plan.lower()
+
+        # Criterion 1: Deadlifts removed or replaced with safe alternatives
+        has_deadlift = "deadlift" in plan_text_lower and not any(
+            r in plan_text_lower for r in self.DEADLIFT_REPLACEMENTS
+        )
+        raw_deadlift = "deadlift" in plan_text_lower and "romanian" not in plan_text_lower and "rdl" not in plan_text_lower
+        if not raw_deadlift:
+            scores["deadlift_removed"] = 0.25
+            feedback_parts.append("✓ Conventional deadlift removed or replaced safely.")
+        else:
+            scores["deadlift_removed"] = 0.0
+            feedback_parts.append(
+                "✗ Conventional deadlift still present. Replace with Romanian deadlift, leg press, or hip thrust."
+            )
+
+        # Criterion 2: Back squats replaced with safe alternatives
+        has_back_squat = "back squat" in plan_text_lower
+        if not has_back_squat:
+            scores["squat_replaced"] = 0.25
+            feedback_parts.append("✓ Back squat removed or replaced safely.")
+        else:
+            scores["squat_replaced"] = 0.0
+            feedback_parts.append(
+                "✗ Back squat still present. Replace with goblet squat, wall sit, or leg press."
+            )
+
+        # Criterion 3: Bent-over rows replaced with seated/machine variants
+        has_bent_over_row = "bent-over row" in plan_text_lower or "bent over row" in plan_text_lower
+        if not has_bent_over_row:
+            scores["rows_replaced"] = 0.25
+            feedback_parts.append("✓ Bent-over rows removed or replaced with spine-neutral variant.")
+        else:
+            scores["rows_replaced"] = 0.0
+            feedback_parts.append(
+                "✗ Bent-over rows still present. Replace with seated cable rows or machine rows."
+            )
+
+        # Criterion 4: Plan retains same muscle group targets
+        # Proxy: check that back/leg work still appears in the plan
+        back_work = any(
+            t in plan_text_lower
+            for t in ["row", "pull", "lat", "back", "rhomboid"]
+        )
+        leg_work = any(
+            t in plan_text_lower
+            for t in ["squat", "press", "lunge", "hip", "glute", "quad", "hamstring", "leg"]
+        )
+        if back_work and leg_work:
+            scores["muscle_targets_retained"] = 0.25
+            feedback_parts.append("✓ Original muscle groups (back, legs) still targeted despite modifications.")
+        else:
+            scores["muscle_targets_retained"] = 0.0
+            missing = []
+            if not back_work:
+                missing.append("back")
+            if not leg_work:
+                missing.append("legs")
+            feedback_parts.append(
+                f"✗ Missing muscle group coverage: {missing}. Ensure modifications keep the same target areas."
+            )
+
+        score = sum(scores.values())
+        feedback = " ".join(feedback_parts)
+        return score, scores, feedback
+
+
+# ---------------------------------------------------------------------------
+# Task 3 - HARD: Periodized 4-Week Program
+# ---------------------------------------------------------------------------
+
+class PeriodizedProgramTask(BaseTask):
+    """
+    Scenario: Advanced powerlifter, 5 days/week, full gym, competition in 5 weeks.
+    Needs 4-week block with deload in week 4.
+    Episode ends when full program submitted OR after 8 steps.
+    """
+
+    client_profile = {
+        "age": 27,
+        "fitness_level": "advanced",
+        "goal": "powerlifting competition prep",
+        "equipment": ["full gym", "barbell", "squat rack", "bench", "deadlift platform"],
+        "injuries": [],
+        "days_per_week": 5,
+        "competition_weeks_out": 5,
+        "weak_points": ["upper back", "lockout strength"],
+        "current_maxes": {"squat": 180, "bench": 120, "deadlift": 220},
+    }
+    max_steps = 8
+
+    COMPETITION_LIFTS = {"squat", "bench", "bench press", "deadlift"}
+
+    def grade(self, action: FitscriptAction, step: int) -> Tuple[float, Dict[str, float], str]:
+        scores: Dict[str, float] = {}
+        feedback_parts = []
+
+        try:
+            plan = json.loads(action.plan) if action.plan else {}
+        except json.JSONDecodeError:
+            plan = {}
+
+        weeks = plan.get("weeks", [])
+
+        # Criterion 1: 4 distinct weeks, each with 5 training days
+        if isinstance(weeks, list) and len(weeks) == 4:
+            all_five_days = all(
+                len(w.get("days", w.get("training_days", []))) == 5
+                for w in weeks
+            )
+            if all_five_days:
+                scores["week_structure"] = 0.2
+                feedback_parts.append("✓ 4 weeks present, each with 5 training days.")
+            else:
+                scores["week_structure"] = 0.1
+                feedback_parts.append(
+                    "~ 4 weeks present but not all weeks have exactly 5 training days."
+                )
+        else:
+            scores["week_structure"] = 0.0
+            found_weeks = len(weeks) if isinstance(weeks, list) else "unknown"
+            feedback_parts.append(
+                f"✗ Expected 4 weeks with 5 days each. Found {found_weeks} weeks."
+            )
+
+        # Criterion 2: Weeks 1-3 show progressive overload
+        if isinstance(weeks, list) and len(weeks) >= 3:
+            intensities = []
+            for w in weeks[:3]:
+                # Accept intensity as explicit field or infer from RPE/percentage keywords
+                intensity = w.get("intensity") or w.get("avg_rpe") or w.get("percentage")
+                if intensity is None:
+                    # Try to infer from week label/description
+                    desc = str(w).lower()
+                    if "heavy" in desc or "high" in desc:
+                        intensity = 85
+                    elif "moderate" in desc or "medium" in desc:
+                        intensity = 75
+                    else:
+                        intensity = None
+                intensities.append(intensity)
+
+            if all(i is not None for i in intensities) and intensities[0] < intensities[1] < intensities[2]:
+                scores["progressive_overload"] = 0.2
+                feedback_parts.append("✓ Weeks 1-3 show clear progressive overload (increasing intensity).")
+            elif all(i is not None for i in intensities):
+                scores["progressive_overload"] = 0.1
+                feedback_parts.append(
+                    "~ Intensity values present but progressive overload pattern not clearly ascending across weeks 1-3."
+                )
+            else:
+                scores["progressive_overload"] = 0.0
+                feedback_parts.append(
+                    "✗ Cannot verify progressive overload. Add 'intensity', 'avg_rpe', or 'percentage' fields to each week."
+                )
+        else:
+            scores["progressive_overload"] = 0.0
+            feedback_parts.append("✗ Fewer than 3 weeks present; cannot verify progressive overload.")
+
+        # Criterion 3: Week 4 is a deload (volume reduced >= 40% vs week 3)
+        if isinstance(weeks, list) and len(weeks) == 4:
+            w3 = weeks[2]
+            w4 = weeks[3]
+            w3_vol = _estimate_volume(w3)
+            w4_vol = _estimate_volume(w4)
+            is_deload_label = "deload" in str(w4).lower()
+            if w3_vol > 0 and w4_vol > 0:
+                reduction = (w3_vol - w4_vol) / w3_vol
+                if reduction >= 0.40:
+                    scores["deload_week"] = 0.2
+                    feedback_parts.append(
+                        f"✓ Week 4 deload: volume reduced by {reduction*100:.0f}% vs week 3."
+                    )
+                elif is_deload_label:
+                    scores["deload_week"] = 0.1
+                    feedback_parts.append(
+                        "~ Week 4 labeled as deload but volume reduction < 40%. Reduce total sets/volume further."
+                    )
+                else:
+                    scores["deload_week"] = 0.0
+                    feedback_parts.append(
+                        f"✗ Week 4 volume only reduced by {reduction*100:.0f}%. Deload requires >= 40% reduction."
+                    )
+            elif is_deload_label:
+                scores["deload_week"] = 0.1
+                feedback_parts.append(
+                    "~ Week 4 labeled as deload but no volume data to verify the 40% reduction threshold."
+                )
+            else:
+                scores["deload_week"] = 0.0
+                feedback_parts.append(
+                    "✗ Week 4 not identified as a deload and volume data insufficient to verify."
+                )
+        else:
+            scores["deload_week"] = 0.0
+            feedback_parts.append("✗ Fewer than 4 weeks present; cannot evaluate deload week.")
+
+        # Criterion 4: Competition lifts appear as primary movements on separate days
+        plan_text_lower = action.plan.lower()
+        squat_present = "squat" in plan_text_lower
+        bench_present = "bench" in plan_text_lower
+        deadlift_present = "deadlift" in plan_text_lower
+        if squat_present and bench_present and deadlift_present:
+            scores["competition_lifts"] = 0.2
+            feedback_parts.append("✓ All three competition lifts (squat, bench, deadlift) present as primary movements.")
+        else:
+            missing = []
+            if not squat_present:
+                missing.append("squat")
+            if not bench_present:
+                missing.append("bench press")
+            if not deadlift_present:
+                missing.append("deadlift")
+            scores["competition_lifts"] = 0.0
+            feedback_parts.append(f"✗ Missing competition lifts: {missing}.")
+
+        # Criterion 5 (bonus): Accessory work targets weak points (upper back, lockout)
+        weak_point_keywords = ["face pull", "upper back", "row", "rdl", "pause", "lockout", "band pull apart", "rear delt"]
+        accessory_bonus = sum(1 for kw in weak_point_keywords if kw in plan_text_lower)
+        if accessory_bonus >= 3:
+            scores["accessory_weak_points"] = 0.2
+            feedback_parts.append("✓ Accessory work targets weak points (upper back, lockout strength).")
+        elif accessory_bonus >= 1:
+            scores["accessory_weak_points"] = 0.1
+            feedback_parts.append("~ Some accessory work present but weak points (upper back, lockout) not fully addressed.")
+        else:
+            scores["accessory_weak_points"] = 0.0
+            feedback_parts.append("✗ No accessory work targeting weak points (upper back, lockout strength).")
+
+        score = min(1.0, sum(scores.values()))
+        feedback = " ".join(feedback_parts)
+        return score, scores, feedback
+
+
+# ---------------------------------------------------------------------------
+# Helper utilities
+# ---------------------------------------------------------------------------
+
+def _extract_exercises(plan: dict) -> list:
+    """Flatten all exercises from all days in a plan."""
+    exercises = []
+    for day in plan.get("days", plan.get("workout_days", [])):
+        if isinstance(day, dict):
+            exercises.extend(day.get("exercises", []))
+    return exercises
+
+
+def _check_reps_exceed(plan: dict, max_reps: int) -> bool:
+    """Return True if any exercise in the plan has reps > max_reps."""
+    for ex in _extract_exercises(plan):
+        reps = ex.get("reps")
+        if isinstance(reps, (int, float)) and reps > max_reps:
+            return True
+    return False
+
+
+def _estimate_volume(week: dict) -> float:
+    """Estimate total volume (sets × reps) across all days in a week."""
+    total = 0
+    for day in week.get("days", week.get("training_days", [])):
+        if isinstance(day, dict):
+            for ex in day.get("exercises", []):
+                sets = ex.get("sets", 0)
+                reps = ex.get("reps", 0)
+                if isinstance(sets, (int, float)) and isinstance(reps, (int, float)):
+                    total += sets * reps
+    # Also accept a flat 'total_sets' key on the week
+    if total == 0:
+        total = week.get("total_sets", 0) * 8  # assume ~8 reps avg if only sets given
+    return float(total)
+
+
+# ---------------------------------------------------------------------------
+# Task registry
+# ---------------------------------------------------------------------------
+
+TASKS: Dict[str, BaseTask] = {
+    "basic_plan": BasicPlanTask(),
+    "injury_safe_modification": InjurySafeTask(),
+    "periodized_program": PeriodizedProgramTask(),
+}
+
+
+# ---------------------------------------------------------------------------
+# Main environment class
+# ---------------------------------------------------------------------------
+
 class FitscriptEnvironment(Environment):
     """
-    A simple echo environment that echoes back messages.
-
-    This environment is designed for testing the HTTP server infrastructure.
-    It maintains minimal state and simply echoes back whatever message it receives.
-
-    Example:
-        >>> env = FitscriptEnvironment()
-        >>> obs = env.reset()
-        >>> print(obs.echoed_message)  # "Fitscript environment ready!"
-        >>>
-        >>> obs = env.step(FitscriptAction(message="Hello"))
-        >>> print(obs.echoed_message)  # "Hello"
-        >>> print(obs.message_length)  # 5
+    FitScript fitness prescription environment.
+
+    Three tasks of increasing difficulty:
+      - basic_plan (easy): generate a 3-day bodyweight beginner plan
+      - injury_safe_modification (medium): modify a plan for a lower-back-injured client
+      - periodized_program (hard): design a 4-week periodized powerlifting block
+
+    Rewards are always in [0.0, 1.0]. Episodes terminate on task completion
+    (score >= 0.99) or when max_steps is reached.
     """
 
-    # Enable concurrent WebSocket sessions.
-    # Set to True if your environment isolates state between instances.
-    # When True, multiple WebSocket clients can connect simultaneously, each
-    # getting their own environment instance (when using factory mode in app.py).
     SUPPORTS_CONCURRENT_SESSIONS: bool = True
 
-    def __init__(self):
-        """Initialize the FitScript environment."""
+    def __init__(self, task_id: str = "basic_plan"):
+        """
+        Initialize the FitScript environment.
+
+        Args:
+            task_id: One of 'basic_plan', 'injury_safe_modification', 'periodized_program'.
+        """
+        if task_id not in TASKS:
+            raise ValueError(
+                f"Unknown task_id '{task_id}'. Valid options: {list(TASKS.keys())}"
+            )
+        self._task_id = task_id
         self._state = State(episode_id=str(uuid4()), step_count=0)
-        self._reset_count = 0
+        self._last_plan: str = ""
 
     def reset(self) -> FitscriptObservation:
         """
-        Reset the environment.
+        Reset the environment for the current task.
 
         Returns:
-            FitscriptObservation with a ready message
+            FitscriptObservation with the client profile and welcome message.
         """
         self._state = State(episode_id=str(uuid4()), step_count=0)
-        self._reset_count += 1
+        self._last_plan = ""
+
+        task = TASKS[self._task_id]
 
         return FitscriptObservation(
-            echoed_message="Fitscript environment ready!",
-            message_length=0,
+            client_profile=task.client_profile,
+            feedback="Welcome! Review the client profile and generate a plan.",
+            score_breakdown={},
+            task_id=self._task_id,
+            step_count=0,
             done=False,
             reward=0.0,
         )
 
     def step(self, action: FitscriptAction) -> FitscriptObservation:  # type: ignore[override]
         """
-        Execute a step in the environment by echoing the message.
+        Execute a step: grade the submitted plan and return feedback.
 
         Args:
-            action: FitscriptAction containing the message to echo
+            action: FitscriptAction with action_type, plan JSON string, and optional reasoning.
 
         Returns:
-            FitscriptObservation with the echoed message and its length
+            FitscriptObservation with score breakdown and feedback.
         """
         self._state.step_count += 1
+        task = TASKS[self._task_id]
 
-        message = action.message
-        length = len(message)
+        # Penalty: empty or null plan
+        if not action.plan or action.plan.strip() in ("", "null", "{}"):
+            return FitscriptObservation(
+                client_profile=task.client_profile,
+                feedback="✗ Empty or null plan submitted. Please provide a structured workout plan.",
+                score_breakdown={},
+                task_id=self._task_id,
+                step_count=self._state.step_count,
+                done=self._state.step_count >= task.max_steps,
+                reward=0.0,
+            )
 
-        # Simple reward: longer messages get higher rewards
-        reward = length * 0.1
+        # Penalty: identical plan submitted twice in a row
+        if action.plan == self._last_plan:
+            return FitscriptObservation(
+                client_profile=task.client_profile,
+                feedback="✗ Identical plan submitted twice. Please revise based on the previous feedback.",
+                score_breakdown={},
+                task_id=self._task_id,
+                step_count=self._state.step_count,
+                done=self._state.step_count >= task.max_steps,
+                reward=0.0,
+            )
+
+        self._last_plan = action.plan
+
+        # Grade the plan
+        score, breakdown, feedback = task.grade(action, self._state.step_count)
+
+        # Safety penalty: contraindicated exercises for injured clients
+        injuries = task.client_profile.get("injuries", [])
+        if injuries:
+            plan_lower = action.plan.lower()
+            CONTRAINDICATED = {
+                "lower back": ["deadlift", "back squat", "good morning", "bent-over row"],
+                "knee": ["lunge", "leg press", "deep squat", "box jump"],
+                "shoulder": ["overhead press", "upright row", "behind neck"],
+            }
+            for injury in injuries:
+                banned = CONTRAINDICATED.get(injury, [])
+                if any(b in plan_lower for b in banned):
+                    score = max(0.0, score - 0.3)
+                    feedback += " ⚠️ Safety penalty applied: plan contains exercises contraindicated for the client's injury."
+                    break
+
+        # Clamp to [0.0, 1.0]
+        score = max(0.0, min(1.0, score))
+
+        done = score >= 0.99 or self._state.step_count >= task.max_steps
 
         return FitscriptObservation(
-            echoed_message=message,
-            message_length=length,
-            done=False,
-            reward=reward,
-            metadata={"original_message": message, "step": self._state.step_count},
+            client_profile=task.client_profile,
+            feedback=feedback,
+            score_breakdown=breakdown,
+            task_id=self._task_id,
+            step_count=self._state.step_count,
+            done=done,
+            reward=score,
         )
 
     @property
     def state(self) -> State:
-        """
-        Get the current environment state.
-
-        Returns:
-            Current State with episode_id and step_count
-        """
-        return self._state
+        """Get the current environment state."""
+        return self._state