Upload folder using huggingface_hub

README.md

@@ -1,248 +1,164 @@
 ---
-title: OpenEnv Jayesh - Smart Personal Task Manager
-colorFrom: indigo
-colorTo: purple
+title: OpenEnv Jayesh - Task Manager
+colorFrom: blue
+colorTo: green
 sdk: docker
 pinned: false
 app_port: 8000
 tags:
   - openenv
   - task-manager
-  - ai-agent
-  - planning
 base_path: /web
 ---
 
-# Smart Personal Task Manager - OpenEnv Jayesh
+# OpenEnv Jayesh - Task Manager Environment
 
-> An AI agent environment for managing tasks with priorities, deadlines, and dependencies -- built for the **OpenEnv Hackathon Round 1**.
+An AI agent environment for managing tasks across three difficulty levels.
 
-- HF Space: https://huggingface.co/spaces/jayesh20/openenv_jayesh
-- Python 3.10+
+HF Space: https://huggingface.co/spaces/jayesh20/openenv_jayesh
 
 ---
 
-## What is this?
+## Difficulty levels
 
-A **real-world Task Manager environment** where an AI agent must add, prioritize, and complete tasks while respecting deadlines and dependency constraints. The environment cycles through three meaningfully distinct difficulty levels -- each demanding progressively more sophisticated planning.
+| Level | Goal | Scoring (summary) |
+|-------|------|---------------------|
+| **Easy** | Add **3** tasks with **at least two different** priority levels among them, then call **`list`** so all current tasks are shown. | Partial credit builds with **~+0.11** per add and **~+0.12** for `list`. **Full reward (1.0)** and **`done=True`** only when there are **3 tasks**, **`list`** was called, and **at least two distinct** priorities appear. If you `list` with three tasks but **only one** priority level, you get a **lower** goal bonus (no full 1.0 / no episode success). |
+| **Medium** | Add **4** tasks, each with a **priority** and **deadline**. **Complete every High-priority task on time** (on or before its deadline). At least **one** High task must exist. | **Gradual** partial credit: small **~+0.07** steps for add / non-Normal / deadline (capped buckets), plus credit for **High** completions on time. **−0.15** per **deadline miss**. **`done=True`** and **1.0** when four tasks are in place, all Highs are done **without** being late, and there are **no** deadline misses. |
+| **Hard** | Add **5** tasks with **priorities**, **deadlines**, and **dependencies**. Complete **all** tasks in valid **topological** order and **respect every deadline** (no dependency violations, no missed deadlines). | **Adds** use slightly smaller per-field steps than Medium (for smoother score), plus **~+0.012** per **dependency edge** when you set `depends_on`. **Clean completes** rise in steps, with a small extra when **dependencies were satisfied**; **topological bonus** when all five finish cleanly. **−0.15** per deadline miss, **−0.18** per dependency violation. **`done=True`** and **1.0** on a perfect run. |
 
-This environment targets real-world utility: the kind of task scheduling problems that users, productivity apps, and organizational tools deal with every day.
+Penalties are constants in `server/openenv_jayesh_environment.py`. Reward stays in **`[0.0, 1.0]`**.
 
 ---
 
-## Difficulty Levels
-
-| Level | Goal | Key Constraints |
-|-------|------|-----------------|
-| **Easy** | Add 2-3 tasks, then `list` them | None -- basic task CRUD |
-| **Medium** | Add 4 tasks with priorities & deadlines; complete all High-priority before deadline | Deadline enforcement, priority management |
-| **Hard** | Add 5 tasks with priorities, deadlines, AND dependencies; complete in valid topological order | Dependency ordering + deadline enforcement + penalty accumulation |
-
----
-
-## Action Space
+## Action space
 
 ```python
 TaskManagerAction(
-    command   = "add",            # "add" | "complete" | "list"
-    title     = "Fix critical bug",  # required for add / complete
-    priority  = "High",           # "Low" | "Normal" | "High"  (default: "Normal")
-    deadline  = "2026-04-15",     # ISO-8601 date (optional; relevant in Medium & Hard)
-    depends_on= ["Reproduce bug"] # list of prerequisite task titles (Hard only)
+    command="add",              # "add" | "complete" | "list"
+    title="Fix bug",
+    priority="High",
+    deadline="2026-04-01",
+    depends_on=["Other task"],
 )
 ```
 
-### Commands
-| Command | Description |
-|---------|-------------|
-| `add` | Create a new task. Returns error if title already exists or dependency is unresolved. |
-| `complete` | Mark a task as done. Checks deadline & dependency constraints and applies penalties. |
-| `list` | Display all current tasks with status, priority, deadline, and dependency info. |
-
----
-
-## Observation Space
+## Observation space
 
 ```python
 TaskManagerObservation(
-    success    = True,                   # whether the last action succeeded
-    message    = "Task 'Fix bug' added", # status message or error description
-    tasks      = [...],                  # full task list snapshot
-    violations = [...],                  # list of rule violations this episode
-    reward     = 0.45,                   # cumulative partial reward (0.0-1.0)
-    done       = False,                  # True when episode goal is achieved
-    metadata   = {
-        "difficulty": "Hard",
-        "step": 7,
-        "tasks_added": 5,
-        "tasks_completed": 3,
-        "deadline_misses": 0,
-        "dependency_violations": 0
-    }
+    success=True,
+    message="...",
+    tasks=[...],
+    violations=[...],
+    reward=0.0,
+    done=False,
 )
 ```
 
-### Task Object Fields
-| Field | Type | Description |
-|-------|------|-------------|
-| `title` | str | Task name |
-| `priority` | str | `"Low"` / `"Normal"` / `"High"` |
-| `deadline` | str | ISO-8601 date or `"none"` |
-| `depends_on` | list[str] | Prerequisite task titles |
-| `completed` | bool | Whether the task is done |
-| `deadline_missed` | bool | True if completed after deadline |
-| `dependency_violation` | bool | True if completed before all prerequisites |
-
 ---
 
-## Reward Function
-
-### Easy Mode
-| Event | Reward |
-|-------|--------|
-| Each task added (up to 3) | +0.15 |
-| Calling `list` | +0.20 |
-| **Goal: >=2 tasks added + list called** | **1.0** |
-
-### Medium Mode
-| Event | Reward |
-|-------|--------|
-| Each task added (up to 4) | +0.15 |
-| Each task with explicit non-Normal priority | +0.10 |
-| Each High-priority task completed **on time** | +0.20 |
-| Deadline missed | **-0.25** |
-| **Goal: 4 tasks, >=2 High, all High completed on time** | **1.0** |
-
-### Hard Mode
-| Event | Reward |
-|-------|--------|
-| Each task added (up to 5) | +0.15 |
-| Each task with non-Normal priority | +0.10 |
-| Each task completed without any violation | +0.25 |
-| Perfect run bonus (all done, zero violations) | **+0.10** |
-| Dependency violation | **-0.30** |
-| Deadline missed | **-0.25** |
-| **Goal: 5 tasks, >=2 High, all completed, zero violations** | **1.0** |
+## Sample inference output
+
+```
+======================================================================
+  Task Manager OpenEnv - Inference Runner
+======================================================================
+
+======================================================================
+EASY MODE  (perfect: 3 tasks + list)
+======================================================================
+Goal: EASY MODE
+
+  add 'Buy groceries' Low                            | score=0.110
+  add 'Call dentist' Normal                          | score=0.220
+  add 'Review PR' High                               | score=0.330
+  list (shows all tasks)                             | score=1.000 [DONE]
+
+======================================================================
+MEDIUM MODE  (one deadline miss on a High task)
+======================================================================
+Goal: MEDIUM MODE
+
+  add 'Fix critical bug' High  deadline=future       | score=0.210
+  add 'Deploy hotfix' High  deadline=PAST            | score=0.420
+  add 'Write release notes' Normal                   | score=0.560
+  add 'Standup prep' Low                             | score=0.770
+  complete 'Fix critical bug' [on-time]              | score=0.860
+  complete 'Deploy hotfix' [DEADLINE MISSED]         | score=0.710
+    (!) DEADLINE MISSED: 'Deploy hotfix' was due 2020-01-01 (completed after deadline).
+    >> Score impact (Medium): -0.15 for this miss (total deadline-miss penalty: 0.15).
+
+======================================================================
+HARD MODE  (perfect topological order, all deadlines met)
+======================================================================
+Goal: HARD MODE
+
+  add 'Reproduce bug' High                           | score=0.186
+  add 'Write tests' Normal                           | score=0.310
+  add 'Write fix' High  (dep: Reproduce bug)         | score=0.508
+  add 'Code review'  (dep: Write fix, Write tests)   | score=0.656
+  add 'Deploy'  (dep: Code review)                   | score=0.804
+
+  complete 'Reproduce bug'                           | score=0.869
+  complete 'Write tests'                             | score=0.946
+  complete 'Write fix'                               | score=0.990
+  complete 'Code review'                             | score=0.990
+  complete 'Deploy'  [goal]                          | score=1.000 [DONE]
+
+  -- Violation demo (fresh Hard episode) --
+  add 'Task A' High                                  | score=0.186
+  add 'Task B'  (dep: Task A)                        | score=0.322
+  WRONG: complete 'Task B' before 'Task A'           | score=0.142
+    (!) DEP VIOLATION: 'Task B' completed before ['Task A'].
+  Score after dep violation: 0.188  (penalty applied)
+
+======================================================================
+  EASY   final score : 1.000
+  MEDIUM final score : 0.710  (deadline miss penalty)
+  HARD   final score : 1.000
+  AVERAGE            : 0.903
+======================================================================
+```
 
 ---
 
-## Quick Start
+## Quick start
 
 ```bash
-# Install dependencies
 uv sync
-
-# Start the server
 uvicorn server.app:app --host 127.0.0.1 --port 8000
-
-# In another terminal, run the inference demo
 python inference.py
 ```
 
----
-
-## Usage Examples
-
-### Easy Mode
-```python
-env = OpenenvJayeshEnvironment()
-obs = env.reset()   # cycles to Easy
-
-env.step(TaskManagerAction(command="add", title="Buy groceries", priority="Normal"))
-# reward: 0.15
-
-env.step(TaskManagerAction(command="add", title="Call dentist", priority="Low"))
-# reward: 0.30
-
-obs = env.step(TaskManagerAction(command="list"))
-# reward: 1.0, done: True
-```
-
-### Medium Mode
-```python
-obs = env.reset()   # cycles to Medium
-
-env.step(TaskManagerAction(command="add", title="Fix critical bug", priority="High", deadline="2026-04-15"))
-env.step(TaskManagerAction(command="add", title="Deploy hotfix",    priority="High", deadline="2026-04-16"))
-env.step(TaskManagerAction(command="add", title="Write release notes", priority="Normal", deadline="2026-04-22"))
-env.step(TaskManagerAction(command="add", title="Team prep",        priority="Low"))
-
-env.step(TaskManagerAction(command="complete", title="Fix critical bug"))   # +0.20 on-time
-obs = env.step(TaskManagerAction(command="complete", title="Deploy hotfix"))  # +0.20 -> done=True, reward=1.0
-```
-
-### Hard Mode (with dependencies)
-```python
-obs = env.reset()   # cycles to Hard
-
-env.step(TaskManagerAction(command="add", title="Reproduce bug", priority="High",   deadline="2026-04-15"))
-env.step(TaskManagerAction(command="add", title="Write tests",   priority="Normal", deadline="2026-04-16"))
-env.step(TaskManagerAction(command="add", title="Write fix",     priority="High",   deadline="2026-04-18",
-    depends_on=["Reproduce bug"]))
-env.step(TaskManagerAction(command="add", title="Code review",   priority="Normal", deadline="2026-04-20",
-    depends_on=["Write fix", "Write tests"]))
-env.step(TaskManagerAction(command="add", title="Deploy",        priority="Low",    deadline="2026-04-22",
-    depends_on=["Code review"]))
-
-# Complete in valid topological order
-env.step(TaskManagerAction(command="complete", title="Reproduce bug"))  # no deps
-env.step(TaskManagerAction(command="complete", title="Write tests"))    # no deps
-env.step(TaskManagerAction(command="complete", title="Write fix"))      # dep met
-env.step(TaskManagerAction(command="complete", title="Code review"))    # deps met
-obs = env.step(TaskManagerAction(command="complete", title="Deploy"))   # done=True, reward=1.0 + bonus
-```
-
----
-
-## Environment Design Rationale
-
-### Why these three levels?
-- **Easy** establishes baseline task CRUD competency -- can the agent perform basic operations?
-- **Medium** adds time pressure and priority trade-offs -- a realistic proxy for real project management.
-- **Hard** requires multi-step planning with constraint satisfaction -- approximates real dependency scheduling (e.g., CI/CD pipelines, project Gantt charts).
-
-### Why partial rewards?
-Smooth, dense reward signals (+0.15 per task, +0.10 per priority, etc.) enable reinforcement learning agents to make meaningful progress even without solving the full episode. This is superior to sparse reward environments where only terminal success counts.
-
-### Why penalties?
-- Deadline misses (-0.25) discourage agents from completing tasks arbitrarily late.
-- Dependency violations (-0.30) teach agents that **order matters** -- a fundamental property of real-world task graphs.
-
----
-
-## API Endpoints
+## API endpoints
 
 | URL | Description |
 |-----|-------------|
-| `GET /health` | Health check |
-| `POST /reset` | Start a new episode |
-| `POST /step` | Execute an action |
-| `GET /state` | Current episode metadata |
-| `GET /docs` | Interactive Swagger UI |
+| http://127.0.0.1:8000/docs | Swagger UI |
+| http://127.0.0.1:8000/health | Health check |
+| POST /reset | Start new episode |
+| POST /step | Execute action |
+| GET /state | Current episode state |
 
----
-
-## Project Structure
+## Project structure
 
 ```
 openenv_jayesh/
-+-- Dockerfile
-+-- openenv.yaml
-+-- pyproject.toml
-+-- models.py                  <- Action + Observation types
-+-- client.py                  <- HTTP client helper
-+-- inference.py               <- End-to-end demo (all 3 levels)
-+-- server/
-    +-- app.py                 <- FastAPI app entry point
-    +-- openenv_jayesh_environment.py  <- Core environment logic
+├── Dockerfile
+├── openenv.yaml
+├── pyproject.toml
+├── models.py
+├── client.py
+├── inference.py
+└── server/
+    ├── app.py
+    ├── openenv_jayesh_environment.py
+    └── requirements.txt
 ```
 
----
-
 ## Deploy
 
 ```bash
 openenv push --repo-id jayesh20/openenv_jayesh
 ```
-
-Live space: https://huggingface.co/spaces/jayesh20/openenv_jayesh

inference.py

@@ -1,7 +1,11 @@
 """
-inference.py - Demonstration of the Smart Personal Task Manager OpenEnv.
+inference.py - Task Manager OpenEnv standalone test runner.
 
-Runs all three difficulty scenarios and prints step-by-step reward signals.
+Runs three scenarios (no server). Easy and Hard show successful runs; Medium shows one deadline miss.
+Hard includes a separate violation demo episode.
+
+Usage:
+    python inference.py
 """
 
 import sys
@@ -9,139 +13,133 @@ import os
 
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 
-from client import OpenenvJayeshEnv
+from server.openenv_jayesh_environment import OpenenvJayeshEnvironment
 from models import TaskManagerAction
 
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
-def _step(client, action: TaskManagerAction, label: str):
-    res = client.step(action)
-    obs = res.observation
-    done_tag = " [DONE]" if res.done else ""
-    violation_tag = ""
-    if hasattr(obs, "violations") and obs.violations:
-        violation_tag = f"\n      Violations: {obs.violations[-1]}"
-    print(
-        f"  {label:<40} | Score: {res.reward:.3f}{done_tag}"
-        f"\n      -> {obs.message}{violation_tag}"
-    )
-    return res
-
 
-# ---------------------------------------------------------------------------
-# Easy scenario
-# ---------------------------------------------------------------------------
-
-def run_easy(client):
+def step(env, action: TaskManagerAction, label: str):
+    obs = env.step(action)
+    done_tag = " [DONE]" if obs.done else ""
+    print(f"  {label:<50} | score={obs.reward:.3f}{done_tag}")
+    msg = obs.message or ""
+    if obs.violations and (
+        "(!)" in msg
+        or "Score impact (Medium):" in msg
+        or "Score impact (Hard):" in msg
+        or "Dependency violation" in msg
+    ):
+        print(f"    (!) {obs.violations[-1]}")
+    for marker in ("Score impact (Medium):", "Score impact (Hard):"):
+        if marker in msg:
+            sub = msg[msg.index(marker) :]
+            if "). Task" in sub:
+                line = sub.split("). Task", 1)[0] + ")."
+            else:
+                line = sub.strip()
+            print(f"    >> {line}")
+            break
+    return obs
+
+
+def run_easy():
     print("\n" + "=" * 70)
-    print("SCENARIO 1 - EASY MODE")
+    print("EASY MODE  (perfect: 3 tasks + list)")
     print("=" * 70)
-    res = client.reset()
-    print(f"\nGoal:\n{res.observation.message}\n")
-
-    today = "2026-04-15"
+    env = OpenenvJayeshEnvironment()
+    obs = env.reset()
+    print(f"Goal: {obs.message.splitlines()[0]}\n")
 
-    _step(client, TaskManagerAction(command="add", title="Buy groceries", priority="Normal", deadline=today), "add 'Buy groceries' Normal")
-    _step(client, TaskManagerAction(command="add", title="Call the dentist", priority="Low"), "add 'Call the dentist' Low")
-    _step(client, TaskManagerAction(command="add", title="Review meeting notes", priority="Normal"), "add 'Review meeting notes'")
-    _step(client, TaskManagerAction(command="list"), "list (triggers goal completion)")
+    step(env, TaskManagerAction(command="add", title="Buy groceries", priority="Low"), "add 'Buy groceries' Low")
+    step(env, TaskManagerAction(command="add", title="Call dentist", priority="Normal"), "add 'Call dentist' Normal")
+    step(env, TaskManagerAction(command="add", title="Review PR", priority="High"), "add 'Review PR' High")
+    obs = step(env, TaskManagerAction(command="list"), "list (shows all tasks)")
+    return obs.reward
 
-    print()
 
-
-# ---------------------------------------------------------------------------
-# Medium scenario
-# ---------------------------------------------------------------------------
-
-def run_medium(client):
+def run_medium():
     print("\n" + "=" * 70)
-    print("SCENARIO 2 - MEDIUM MODE")
+    print("MEDIUM MODE  (one deadline miss on a High task)")
     print("=" * 70)
-    res = client.reset()
-    print(f"\nGoal:\n{res.observation.message}\n")
-
-    # Use future deadlines so completions are on-time
-    today = "2026-04-15"
-    tomorrow = "2026-04-16"
-    next_week = "2026-04-22"
-
-    _step(client, TaskManagerAction(command="add", title="Fix critical bug", priority="High", deadline=today), "add 'Fix critical bug' High")
-    _step(client, TaskManagerAction(command="add", title="Deploy hotfix", priority="High", deadline=tomorrow), "add 'Deploy hotfix' High")
-    _step(client, TaskManagerAction(command="add", title="Write release notes", priority="Normal", deadline=next_week), "add 'Write release notes' Normal")
-    _step(client, TaskManagerAction(command="add", title="Team standup prep", priority="Low"), "add 'Team standup prep' Low")
-
-    # Complete High-priority tasks on time
-    _step(client, TaskManagerAction(command="complete", title="Fix critical bug"), "complete 'Fix critical bug' [High, on-time]")
-    _step(client, TaskManagerAction(command="complete", title="Deploy hotfix"), "complete 'Deploy hotfix' [High, on-time -> GOAL]")
+    env = OpenenvJayeshEnvironment()
+    env._reset_count = 1
+    obs = env.reset()
+    print(f"Goal: {obs.message.splitlines()[0]}\n")
 
-    print()
+    future = "2099-12-31"
+    past = "2020-01-01"
 
+    step(env, TaskManagerAction(command="add", title="Fix critical bug", priority="High", deadline=future), "add 'Fix critical bug' High  deadline=future")
+    step(env, TaskManagerAction(command="add", title="Deploy hotfix", priority="High", deadline=past), "add 'Deploy hotfix' High  deadline=PAST")
+    step(env, TaskManagerAction(command="add", title="Write release notes", priority="Normal", deadline=future), "add 'Write release notes' Normal")
+    step(env, TaskManagerAction(command="add", title="Standup prep", priority="Low", deadline=future), "add 'Standup prep' Low")
+    step(env, TaskManagerAction(command="complete", title="Fix critical bug"), "complete 'Fix critical bug' [on-time]")
+    obs = step(env, TaskManagerAction(command="complete", title="Deploy hotfix"), "complete 'Deploy hotfix' [DEADLINE MISSED]")
+    return obs.reward
 
-# ---------------------------------------------------------------------------
-# Hard scenario
-# ---------------------------------------------------------------------------
 
-def run_hard(client):
+def run_hard():
     print("\n" + "=" * 70)
-    print("SCENARIO 3 - HARD MODE (dependencies + deadlines)")
+    print("HARD MODE  (perfect topological order, all deadlines met)")
     print("=" * 70)
-    res = client.reset()
-    print(f"\nGoal:\n{res.observation.message}\n")
-
-    t1  = "2026-04-15"
-    t2  = "2026-04-16"
-    t3  = "2026-04-18"
-    t4  = "2026-04-20"
-    t5  = "2026-04-22"
-
-    # Build dependency graph:
-    #   Reproduce bug  ---> Write fix  ---> Code review  ---> Deploy
-    #   Write tests    ---> Code review
-    _step(client, TaskManagerAction(command="add", title="Reproduce bug", priority="High", deadline=t1), "add 'Reproduce bug' High")
-    _step(client, TaskManagerAction(command="add", title="Write tests", priority="Normal", deadline=t2), "add 'Write tests' Normal")
-    _step(client, TaskManagerAction(command="add", title="Write fix", priority="High", deadline=t3, depends_on=["Reproduce bug"]), "add 'Write fix' High (depends: Reproduce bug)")
-    _step(client, TaskManagerAction(command="add", title="Code review", priority="Normal", deadline=t4, depends_on=["Write fix", "Write tests"]), "add 'Code review' Normal (depends: Write fix, Write tests)")
-    _step(client, TaskManagerAction(command="add", title="Deploy to production", priority="Low", deadline=t5, depends_on=["Code review"]), "add 'Deploy to prod' Low (depends: Code review)")
+    env = OpenenvJayeshEnvironment()
+    env._reset_count = 2
+    obs = env.reset()
+    print(f"Goal: {obs.message.splitlines()[0]}\n")
+
+    future = "2099-12-31"
+
+    step(env, TaskManagerAction(command="add", title="Reproduce bug", priority="High", deadline=future), "add 'Reproduce bug' High")
+    step(env, TaskManagerAction(command="add", title="Write tests", priority="Normal", deadline=future), "add 'Write tests' Normal")
+    step(
+        env,
+        TaskManagerAction(command="add", title="Write fix", priority="High", deadline=future, depends_on=["Reproduce bug"]),
+        "add 'Write fix' High  (dep: Reproduce bug)",
+    )
+    step(
+        env,
+        TaskManagerAction(command="add", title="Code review", priority="Normal", deadline=future, depends_on=["Write fix", "Write tests"]),
+        "add 'Code review'  (dep: Write fix, Write tests)",
+    )
+    step(
+        env,
+        TaskManagerAction(command="add", title="Deploy to production", priority="Low", deadline=future, depends_on=["Code review"]),
+        "add 'Deploy'  (dep: Code review)",
+    )
 
     print()
-    print("  -- Completing in CORRECT topological order --")
-    _step(client, TaskManagerAction(command="complete", title="Reproduce bug"), "complete 'Reproduce bug' [no deps, on-time]")
-    _step(client, TaskManagerAction(command="complete", title="Write tests"), "complete 'Write tests' [no deps, on-time]")
-    _step(client, TaskManagerAction(command="complete", title="Write fix"), "complete 'Write fix' [dep met, on-time]")
-    _step(client, TaskManagerAction(command="complete", title="Code review"), "complete 'Code review' [deps met, on-time]")
-    _step(client, TaskManagerAction(command="complete", title="Deploy to production"), "complete 'Deploy to prod' [all deps met -> GOAL]")
+    step(env, TaskManagerAction(command="complete", title="Reproduce bug"), "complete 'Reproduce bug'")
+    step(env, TaskManagerAction(command="complete", title="Write tests"), "complete 'Write tests'")
+    step(env, TaskManagerAction(command="complete", title="Write fix"), "complete 'Write fix'")
+    step(env, TaskManagerAction(command="complete", title="Code review"), "complete 'Code review'")
+    obs = step(env, TaskManagerAction(command="complete", title="Deploy to production"), "complete 'Deploy'  [goal]")
 
     print()
-    print("  -- Violations demo (new reset, same Hard mode) --")
-    res = client.reset()  # same Hard cycle
-    print(f"  (Re-reset into: {res.observation.message.splitlines()[0]})")
-
-    _step(client, TaskManagerAction(command="add", title="Task A", priority="High", deadline=t1), "add 'Task A' High")
-    _step(client, TaskManagerAction(command="add", title="Task B", priority="Normal", deadline=t2, depends_on=["Task A"]), "add 'Task B' Normal (depends: Task A)")
-    res = _step(client, TaskManagerAction(command="complete", title="Task B"), "WRONG: complete 'Task B' before 'Task A'")
-    print(f"      Score after violation: {res.reward:.3f}")
+    print("  -- Violation demo (fresh Hard episode) --")
+    env2 = OpenenvJayeshEnvironment()
+    env2._reset_count = 2
+    env2.reset()
+    step(env2, TaskManagerAction(command="add", title="Task A", priority="High", deadline=future), "add 'Task A' High")
+    step(env2, TaskManagerAction(command="add", title="Task B", priority="Normal", deadline=future, depends_on=["Task A"]), "add 'Task B'  (dep: Task A)")
+    obs2 = step(env2, TaskManagerAction(command="complete", title="Task B"), "WRONG: complete 'Task B' before 'Task A'")
+    print(f"  Score after dep violation: {obs2.reward:.3f}  (penalty applied)")
 
-    print()
+    return obs.reward
 
 
-# ---------------------------------------------------------------------------
-# Entry point
-# ---------------------------------------------------------------------------
-
 if __name__ == "__main__":
     print("=" * 70)
-    print("Smart Personal Task Manager - OpenEnv Inference Demo")
-    print("Connecting to http://127.0.0.1:8000 ...")
+    print("  Task Manager OpenEnv - Inference Runner")
     print("=" * 70)
 
-    try:
-        with OpenenvJayeshEnv(base_url="http://127.0.0.1:8000").sync() as client:
-            run_easy(client)
-            run_medium(client)
-            run_hard(client)
-        print("\nAll scenarios completed successfully.")
-    except Exception as e:
-        print(f"\nError: Could not connect to server. Is it running?\n  {e}")
-        sys.exit(1)
+    easy_score = run_easy()
+    medium_score = run_medium()
+    hard_score = run_hard()
+
+    avg = (easy_score + medium_score + hard_score) / 3
+
+    print("\n" + "=" * 70)
+    print(f"  EASY   final score : {easy_score:.3f}")
+    print(f"  MEDIUM final score : {medium_score:.3f}  (deadline miss penalty)")
+    print(f"  HARD   final score : {hard_score:.3f}")
+    print(f"  AVERAGE            : {avg:.3f}")
+    print("=" * 70)

server/Dockerfile

@@ -1,80 +1,80 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the BSD-style license found in the
-# LICENSE file in the root directory of this source tree.
-
-# Multi-stage build using openenv-base
-# This Dockerfile is flexible and works for both:
-# - In-repo environments (with local OpenEnv sources)
-# - Standalone environments (with openenv from PyPI/Git)
-# The build script (openenv build) handles context detection and sets appropriate build args.
-
-ARG BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest
-FROM ${BASE_IMAGE} AS builder
-
-WORKDIR /app
-
-# Ensure git is available (required for installing dependencies from VCS)
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends git && \
-    rm -rf /var/lib/apt/lists/*
-
-# Build argument to control whether we're building standalone or in-repo
-ARG BUILD_MODE=in-repo
-ARG ENV_NAME=openenv_jayesh
-
-# Copy environment code (always at root of build context)
-COPY . /app/env
-
-# For in-repo builds, openenv is already vendored in the build context
-# For standalone builds, openenv will be installed via pyproject.toml
-WORKDIR /app/env
-
-# Ensure uv is available (for local builds where base image lacks it)
-RUN if ! command -v uv >/dev/null 2>&1; then \
-        curl -LsSf https://astral.sh/uv/install.sh | sh && \
-        mv /root/.local/bin/uv /usr/local/bin/uv && \
-        mv /root/.local/bin/uvx /usr/local/bin/uvx; \
-    fi
-    
-# Install dependencies using uv sync
-# If uv.lock exists, use it; otherwise resolve on the fly
-RUN --mount=type=cache,target=/root/.cache/uv \
-    if [ -f uv.lock ]; then \
-        uv sync --frozen --no-install-project --no-editable; \
-    else \
-        uv sync --no-install-project --no-editable; \
-    fi
-
-RUN --mount=type=cache,target=/root/.cache/uv \
-    if [ -f uv.lock ]; then \
-        uv sync --frozen --no-editable; \
-    else \
-        uv sync --no-editable; \
-    fi
-
-# Final runtime stage
-FROM ${BASE_IMAGE}
-
-WORKDIR /app
-
-# Copy the virtual environment from builder
-COPY --from=builder /app/env/.venv /app/.venv
-
-# Copy the environment code
-COPY --from=builder /app/env /app/env
-
-# Set PATH to use the virtual environment
-ENV PATH="/app/.venv/bin:$PATH"
-
-# Set PYTHONPATH so imports work correctly
-ENV PYTHONPATH="/app/env:$PYTHONPATH"
-
-# Health check
-HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
-    CMD curl -f http://localhost:8000/health || exit 1
-
-# Run the FastAPI server
-# The module path is constructed to work with the /app/env structure
-CMD ["sh", "-c", "cd /app/env && uvicorn server.app:app --host 0.0.0.0 --port 8000"]
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# Multi-stage build using openenv-base
+# This Dockerfile is flexible and works for both:
+# - In-repo environments (with local OpenEnv sources)
+# - Standalone environments (with openenv from PyPI/Git)
+# The build script (openenv build) handles context detection and sets appropriate build args.
+
+ARG BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest
+FROM ${BASE_IMAGE} AS builder
+
+WORKDIR /app
+
+# Ensure git is available (required for installing dependencies from VCS)
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends git && \
+    rm -rf /var/lib/apt/lists/*
+
+# Build argument to control whether we're building standalone or in-repo
+ARG BUILD_MODE=in-repo
+ARG ENV_NAME=openenv_jayesh
+
+# Copy environment code (always at root of build context)
+COPY . /app/env
+
+# For in-repo builds, openenv is already vendored in the build context
+# For standalone builds, openenv will be installed via pyproject.toml
+WORKDIR /app/env
+
+# Ensure uv is available (for local builds where base image lacks it)
+RUN if ! command -v uv >/dev/null 2>&1; then \
+        curl -LsSf https://astral.sh/uv/install.sh | sh && \
+        mv /root/.local/bin/uv /usr/local/bin/uv && \
+        mv /root/.local/bin/uvx /usr/local/bin/uvx; \
+    fi
+    
+# Install dependencies using uv sync
+# If uv.lock exists, use it; otherwise resolve on the fly
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-install-project --no-editable; \
+    else \
+        uv sync --no-install-project --no-editable; \
+    fi
+
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-editable; \
+    else \
+        uv sync --no-editable; \
+    fi
+
+# Final runtime stage
+FROM ${BASE_IMAGE}
+
+WORKDIR /app
+
+# Copy the virtual environment from builder
+COPY --from=builder /app/env/.venv /app/.venv
+
+# Copy the environment code
+COPY --from=builder /app/env /app/env
+
+# Set PATH to use the virtual environment
+ENV PATH="/app/.venv/bin:$PATH"
+
+# Set PYTHONPATH so imports work correctly
+ENV PYTHONPATH="/app/env:$PYTHONPATH"
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+# Run the FastAPI server
+# The module path is constructed to work with the /app/env structure
+CMD ["sh", "-c", "cd /app/env && uvicorn server.app:app --host 0.0.0.0 --port 8000"]

server/openenv_jayesh_environment.py

@@ -1,31 +1,12 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-
 """
-Smart Personal Task Manager - OpenEnv Environment Implementation.
-
-Three difficulty tiers:
-
-Easy (reset 0, 3, 6 ...)
-  Goal: Add 2-3 tasks of any priority, then call 'list'.
-  Reward: +0.15 per task added (up to 3), +0.20 for listing. Full 1.0 on completion.
-
-Medium (reset 1, 4, 7 ...)
-  Goal: Add 4 tasks with mixed priorities AND deadlines.
-        Complete ALL High-priority tasks before their deadlines.
-  Reward: +0.15 per task added (up to 4), +0.10 per correct priority label,
-          +0.20 per High-priority task completed on time.
-          -0.25 penalty per deadline miss.
-          Full 1.0 on completion.
-
-Hard (reset 2, 5, 8 ...)
-  Goal: Add 5 tasks with priorities, deadlines, AND dependencies.
-        Complete tasks in valid dependency order; respect all deadlines.
-  Reward: +0.15 per task added (up to 5), +0.10 per correct priority,
-          +0.25 per task completed without violation.
-          Bonus +0.10 for achieving perfect (optimal) topological ordering.
-          -0.30 per dependency violation, -0.25 per deadline miss.
-          Full 1.0 on perfect completion.
+Smart Personal Task Manager - OpenEnv Environment
+
+Easy: three tasks + list; full 1.0 when at least 2 distinct priorities; else partial credit.
+Medium: small +0.07 signals; deadline miss −0.15.
+Hard: +0.018 per dep edge on add; rising clean completes; dep-satisfied micro-bonus; topo bonus;
+      deadline miss −0.15, dependency violation −0.18.
+
+Reward clamp [0.0, 1.0].
 """
 
 from __future__ import annotations
@@ -42,21 +23,19 @@ try:
 except (ModuleNotFoundError, ImportError):
     from models import TaskManagerAction, TaskManagerObservation
 
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
 VALID_PRIORITIES = {"Low", "Normal", "High"}
-PRIORITY_RANK = {"Low": 0, "Normal": 1, "High": 2}
+
+# Fair penalties (requested ranges)
+MEDIUM_DEADLINE_MISS_PENALTY = 0.15   # -0.12 … -0.18
+HARD_DEADLINE_MISS_PENALTY = 0.15     # -0.12 … -0.18
+HARD_DEP_VIOLATION_PENALTY = 0.18     # -0.15 … -0.20
 
 
-def _parse_date(dt_str: Optional[str]) -> Optional[date]:
-    """Parse an ISO-8601 date string; return None on failure."""
-    if not dt_str:
+def _parse_date(s: Optional[str]) -> Optional[date]:
+    if not s:
         return None
     try:
-        return date.fromisoformat(dt_str)
+        return date.fromisoformat(s)
     except ValueError:
         return None
 
@@ -65,60 +44,38 @@ def _today() -> date:
     return date.today()
 
 
-# ---------------------------------------------------------------------------
-# Environment
-# ---------------------------------------------------------------------------
-
 class OpenenvJayeshEnvironment(Environment):
-    """
-    Smart Personal Task Manager with three distinct difficulty levels.
-
-    Easy   -> add tasks + list
-    Medium -> deadlines + priority management
-    Hard   -> deadlines + priority + dependency ordering
-    """
+    """Task Manager with Easy / Medium / Hard difficulty levels."""
 
     SUPPORTS_CONCURRENT_SESSIONS: bool = True
 
-    # ------------------------------------------------------------------
-    # Lifecycle
-    # ------------------------------------------------------------------
-
     def __init__(self) -> None:
         super().__init__()
-        self._state = State(episode_id=str(uuid4()), step_count=0)
         self._reset_count = 0
         self._scenarios = ["Easy", "Medium", "Hard"]
-        self._init_episode_state()
-
-    def _init_episode_state(self) -> None:
-        """Zero all mutable per-episode state."""
-        self.tasks: List[Dict[str, Any]] = []       # ordered list of task dicts
-        self.difficulty: str = "Easy"
-        self.goal_completed: bool = False
-
-        # Counters
-        self.tasks_added: int = 0
-        self.tasks_completed: int = 0
-        self.high_tasks_added: int = 0
-        self.high_tasks_completed_on_time: int = 0
-        self.deadline_misses: int = 0
-        self.dependency_violations: int = 0
-        self.completion_order: List[str] = []       # titles in completion order
-
-        # Episode-level flag
-        self.list_called: bool = False
-
-        # Violations log (for observation)
+        self._state = State(episode_id=str(uuid4()), step_count=0)
+        self._init_state()
+
+    def _init_state(self) -> None:
+        self.tasks: List[Dict[str, Any]] = []
+        self.difficulty = "Easy"
+        self.goal_completed = False
+        self.list_called = False
         self.violations: List[str] = []
 
-        # Target counts per difficulty
-        self.target_tasks: int = 2
-        self.target_high: int = 0
+        self.tasks_added = 0
+        self.high_added = 0
+        self.high_on_time = 0
+        self.clean_completions = 0
+        self.deadline_misses = 0
+        self.dep_violations = 0
 
-    # ------------------------------------------------------------------
-    # reset
-    # ------------------------------------------------------------------
+        self._r_add = 0.0
+        self._r_priority = 0.0
+        self._r_deadline_set = 0.0
+        self._r_complete = 0.0
+        self._r_hard_dep_ok = 0.0
+        self._r_hard_edge = 0.0
 
     def reset(
         self,
@@ -127,61 +84,41 @@ class OpenenvJayeshEnvironment(Environment):
         **kwargs: Any,
     ) -> TaskManagerObservation:
         self._state = State(episode_id=episode_id or str(uuid4()), step_count=0)
-        self._init_episode_state()
+        self._init_state()
 
-        idx = self._reset_count % len(self._scenarios)
-        self.difficulty = self._scenarios[idx]
+        self.difficulty = self._scenarios[self._reset_count % 3]
         self._reset_count += 1
 
-        if self.difficulty == "Easy":
-            self.target_tasks = 2
-            self.target_high = 0
-            msg = (
-                "=== EASY MODE ===\n"
-                "Goal: Add 2-3 tasks of any priority, then call 'list' to review them.\n"
-                "Rewards: +0.15 per task added (max 3), +0.20 for calling list.\n"
-                "Complete the goal to receive full reward (1.0)."
-            )
-        elif self.difficulty == "Medium":
-            self.target_tasks = 4
-            self.target_high = 2
-            msg = (
-                "=== MEDIUM MODE ===\n"
-                "Goal: Add 4 tasks with priorities AND deadlines.\n"
-                "      Complete ALL High-priority tasks before their deadlines.\n"
-                "Tips: Include at least 2 High-priority tasks.\n"
-                "      Use deadline='YYYY-MM-DD' (today or future date for on-time credit).\n"
-                "Rewards: +0.15/task added, +0.10/correct priority, +0.20/High completed on time.\n"
-                "Penalty: -0.25 per deadline miss."
-            )
-        else:  # Hard
-            self.target_tasks = 5
-            self.target_high = 2
-            msg = (
-                "=== HARD MODE ===\n"
-                "Goal: Add 5 tasks with priorities, deadlines, AND dependencies.\n"
-                "      Complete tasks in valid dependency order (dependencies first).\n"
-                "      Respect all deadlines.\n"
-                "Tips: Use depends_on=['Task Title'] when adding a dependent task.\n"
-                "      Complete prerequisite tasks before their dependents.\n"
-                "Rewards: +0.15/task, +0.10/priority, +0.25/completion without violation.\n"
-                "         +0.10 bonus for perfect topological ordering.\n"
-                "Penalty: -0.30/dependency violation, -0.25/deadline miss."
-            )
-
+        msgs = {
+            "Easy": (
+                "EASY MODE\n"
+                "Goal: Add 3 tasks with at least 2 different priorities, then call 'list'.\n"
+                "Full score (1.0) when 3 tasks + list + 2+ priority levels; "
+                "otherwise partial credit if you list without enough variety."
+            ),
+            "Medium": (
+                "MEDIUM MODE\n"
+                "Goal: Add 4 tasks with priorities and deadlines. Every High task on time.\n"
+                "Rewards: small steps (~+0.07 per signal) for smooth partial credit.\n"
+                f"Penalty: -{MEDIUM_DEADLINE_MISS_PENALTY:.2f} per deadline miss."
+            ),
+            "Hard": (
+                "HARD MODE\n"
+                "Goal: 5 tasks with deps + deadlines; valid order; no misses.\n"
+                "Rewards: tiny edge credit when linking deps on add; rising clean completes; "
+                "small bonus when deps satisfied at complete.\n"
+                f"Penalties: -{HARD_DEP_VIOLATION_PENALTY:.2f} dependency, -{HARD_DEADLINE_MISS_PENALTY:.2f} deadline miss."
+            ),
+        }
         return TaskManagerObservation(
             success=True,
-            message=msg,
+            message=msgs[self.difficulty],
             tasks=[],
             violations=[],
             done=False,
             reward=0.0,
         )
 
-    # ------------------------------------------------------------------
-    # step
-    # ------------------------------------------------------------------
-
     def step(
         self,
         action: TaskManagerAction,
@@ -190,25 +127,22 @@ class OpenenvJayeshEnvironment(Environment):
     ) -> TaskManagerObservation:
         self._state.step_count += 1
         cmd = (action.command or "").strip().lower()
-        success = True
-        message = ""
 
         if cmd == "add":
-            success, message = self._handle_add(action)
+            success, msg = self._add(action)
         elif cmd == "complete":
-            success, message = self._handle_complete(action)
+            success, msg = self._complete(action)
         elif cmd == "list":
             self.list_called = True
-            message = self._format_task_list()
+            success, msg = True, self._fmt_list()
         else:
-            success = False
-            message = f"Unknown command '{cmd}'. Valid commands: 'add', 'complete', 'list'."
+            success, msg = False, f"Unknown command '{cmd}'. Use: add | complete | list."
 
-        reward = self._calculate_reward()
+        reward = self._score()
 
         return TaskManagerObservation(
             success=success,
-            message=message,
+            message=msg,
             tasks=list(self.tasks),
             violations=list(self.violations),
             done=self.goal_completed,
@@ -217,247 +151,224 @@ class OpenenvJayeshEnvironment(Environment):
                 "difficulty": self.difficulty,
                 "step": self._state.step_count,
                 "tasks_added": self.tasks_added,
-                "tasks_completed": self.tasks_completed,
+                "clean_completions": self.clean_completions,
+                "dep_violations": self.dep_violations,
                 "deadline_misses": self.deadline_misses,
-                "dependency_violations": self.dependency_violations,
             },
         )
 
-    # ------------------------------------------------------------------
-    # Command handlers
-    # ------------------------------------------------------------------
-
-    def _handle_add(self, action: TaskManagerAction):
-        if not action.title or not action.title.strip():
-            return False, "Error: 'title' is required for the 'add' command."
-
-        title = action.title.strip()
-
-        # Duplicate check
+    def _add(self, action: TaskManagerAction):
+        title = (action.title or "").strip()
+        if not title:
+            return False, "Error: 'title' is required for add."
         if any(t["title"] == title for t in self.tasks):
-            return False, f"Error: A task titled '{title}' already exists."
+            return False, f"Error: task '{title}' already exists."
 
         priority = (action.priority or "Normal").strip()
         if priority not in VALID_PRIORITIES:
             priority = "Normal"
 
-        deadline_str = action.deadline
-        deadline_obj = _parse_date(deadline_str)
+        deadline_str = (action.deadline or "").strip() or None
 
         depends_on: List[str] = []
-        if action.depends_on:
-            for dep in action.depends_on:
-                dep = dep.strip()
-                if dep and any(t["title"] == dep for t in self.tasks):
-                    depends_on.append(dep)
-                elif dep:
-                    return (
-                        False,
-                        f"Error: Dependency '{dep}' does not exist yet. "
-                        "Add prerequisite tasks first.",
-                    )
+        for dep in (action.depends_on or []):
+            dep = dep.strip()
+            if not dep:
+                continue
+            if not any(t["title"] == dep for t in self.tasks):
+                return False, f"Error: dependency '{dep}' not found. Add it first."
+            depends_on.append(dep)
 
         task: Dict[str, Any] = {
             "title": title,
             "priority": priority,
-            "deadline": deadline_str or "none",
+            "deadline": deadline_str,
             "depends_on": depends_on,
             "completed": False,
             "deadline_missed": False,
-            "dependency_violation": False,
-            "added_step": self._state.step_count,
+            "dep_violation": False,
         }
         self.tasks.append(task)
         self.tasks_added += 1
         if priority == "High":
-            self.high_tasks_added += 1
+            self.high_added += 1
+
+        if self.difficulty == "Medium":
+            # Smaller per-signal steps (~0.07) so scores rise gradually (avoid large single-step jumps)
+            self._r_add += 0.07
+            if priority != "Normal":
+                self._r_priority += 0.07
+            if deadline_str:
+                self._r_deadline_set += 0.07
+        elif self.difficulty == "Hard":
+            # Slightly smaller per-signal steps than Medium to smooth the last adds (e.g. Deploy)
+            inc = 0.062
+            self._r_add += inc
+            if priority != "Normal":
+                self._r_priority += inc
+            if deadline_str:
+                self._r_deadline_set += inc
+            if depends_on:
+                self._r_hard_edge += 0.012 * float(len(depends_on))
+
+        parts = [f"Task '{title}' added (priority={priority}"]
+        if deadline_str:
+            parts[0] += f", deadline={deadline_str}"
+        if depends_on:
+            parts[0] += f", depends_on={depends_on}"
+        parts[0] += ")."
+        return True, " ".join(parts)
+
+    def _complete(self, action: TaskManagerAction):
+        title = (action.title or "").strip()
+        if not title:
+            return False, "Error: 'title' is required for complete."
 
-        msg = (
-            f"Task added: '{title}' | Priority: {priority}"
-            + (f" | Deadline: {deadline_str}" if deadline_str else "")
-            + (f" | Depends on: {depends_on}" if depends_on else "")
-        )
-        return True, msg
-
-    def _handle_complete(self, action: TaskManagerAction):
-        if not action.title or not action.title.strip():
-            return False, "Error: 'title' is required for the 'complete' command."
-
-        title = action.title.strip()
         task = next((t for t in self.tasks if t["title"] == title), None)
-
         if task is None:
-            return False, f"Error: Task '{title}' not found."
+            return False, f"Error: task '{title}' not found."
         if task["completed"]:
             return False, f"Task '{title}' is already completed."
 
-        # ---- Dependency check ----
-        dep_violation = False
+        msgs = []
+        dep_viol = False
+        dl_miss = False
+
         unmet = [
-            dep for dep in task["depends_on"]
-            if not any(t["title"] == dep and t["completed"] for t in self.tasks)
+            d for d in task["depends_on"]
+            if not any(t["title"] == d and t["completed"] for t in self.tasks)
         ]
         if unmet:
-            dep_violation = True
-            task["dependency_violation"] = True
-            self.dependency_violations += 1
-            violation_msg = (
-                f"DEPENDENCY VIOLATION: Completed '{title}' before prerequisites: {unmet}. "
-                "Penalty applied."
-            )
-            self.violations.append(violation_msg)
-
-        # ---- Deadline check ----
-        deadline_missed = False
+            dep_viol = True
+            task["dep_violation"] = True
+            self.dep_violations += 1
+            v = f"DEP VIOLATION: '{title}' completed before {unmet}."
+            self.violations.append(v)
+            msgs.append("(!) Dependency violation — penalty applied.")
+
         dl = _parse_date(task["deadline"])
-        if dl is not None and _today() > dl:
-            deadline_missed = True
+        if dl and _today() > dl:
+            dl_miss = True
             task["deadline_missed"] = True
             self.deadline_misses += 1
-            violation_msg = (
-                f"DEADLINE MISSED: '{title}' was due {task['deadline']} "
-                f"but completed on {_today().isoformat()}. Penalty applied."
-            )
-            self.violations.append(violation_msg)
+            v = f"DEADLINE MISSED: '{title}' was due {task['deadline']} (completed after deadline)."
+            self.violations.append(v)
+            msgs.append("(!) Deadline missed — penalty applied.")
+            if self.difficulty == "Medium":
+                msgs.append(
+                    f"Score impact (Medium): -{MEDIUM_DEADLINE_MISS_PENALTY:.2f} for this miss "
+                    f"(total deadline-miss penalty: "
+                    f"{self.deadline_misses * MEDIUM_DEADLINE_MISS_PENALTY:.2f})."
+                )
+            elif self.difficulty == "Hard":
+                msgs.append(
+                    f"Score impact (Hard): -{HARD_DEADLINE_MISS_PENALTY:.2f} for this miss "
+                    f"(total: {self.deadline_misses * HARD_DEADLINE_MISS_PENALTY:.2f})."
+                )
 
-        # ---- Mark completed ----
         task["completed"] = True
-        self.tasks_completed += 1
-        self.completion_order.append(title)
-
-        if task["priority"] == "High" and not deadline_missed:
-            self.high_tasks_completed_on_time += 1
-
-        msg_parts = [f"Task '{title}' marked complete."]
-        if dep_violation:
-            msg_parts.append("(!) Dependency violation penalty applied.")
-        if deadline_missed:
-            msg_parts.append("(!) Deadline miss penalty applied.")
-        if not dep_violation and not deadline_missed:
-            msg_parts.append("Clean completion -- no penalties.")
-
-        return True, " ".join(msg_parts)
-
-    # ------------------------------------------------------------------
-    # Reward calculation
-    # ------------------------------------------------------------------
-
-    def _calculate_reward(self) -> float:
-        self.goal_completed = False
-        reward = 0.0
 
-        if self.difficulty == "Easy":
-            reward = self._reward_easy()
-        elif self.difficulty == "Medium":
-            reward = self._reward_medium()
+        if not dep_viol and not dl_miss:
+            order_idx = self.clean_completions
+            self.clean_completions += 1
+            if task["priority"] == "High":
+                self.high_on_time += 1
+            msgs.append(f"Task '{title}' completed cleanly.")
+            if self.difficulty == "Medium":
+                if task["priority"] == "High":
+                    self._r_complete += 0.09
+            elif self.difficulty == "Hard":
+                # Rising reward each clean step; tiny extra when prerequisites were satisfied
+                step_r = 0.065 + 0.012 * float(order_idx)
+                self._r_complete += min(0.125, step_r)
+                if task["depends_on"]:
+                    self._r_hard_dep_ok += 0.025
         else:
-            reward = self._reward_hard()
+            msgs.append(f"Task '{title}' completed with violations.")
 
-        return round(min(1.0, max(0.0, reward)), 3)
+        return True, " ".join(msgs)
 
-    def _reward_easy(self) -> float:
-        r = 0.0
-        # +0.15 per task added, up to 3 tasks
-        r += min(3, self.tasks_added) * 0.15
-        # +0.20 for calling list
+    def _score(self) -> float:
+        if self.difficulty == "Easy":
+            return self._score_easy()
+        if self.difficulty == "Medium":
+            return self._score_medium()
+        return self._score_hard()
+
+    def _easy_has_two_priorities(self) -> bool:
+        if len(self.tasks) < 3:
+            return False
+        return len({t["priority"] for t in self.tasks}) >= 2
+
+    def _score_easy(self) -> float:
+        # Partial: ~+0.11/add, ~+0.12/list. Full 1.0 + done only with 2+ distinct priorities + list.
+        r = min(3, self.tasks_added) * 0.11
         if self.list_called:
-            r += 0.20
-        # Goal: >=2 tasks added + list called
-        if self.tasks_added >= 2 and self.list_called:
-            r = 1.0
-            self.goal_completed = True
-        return r
-
-    def _reward_medium(self) -> float:
-        r = 0.0
-        # +0.15 per task added, up to 4
-        r += min(4, self.tasks_added) * 0.15
-        # +0.10 per task that has an explicit priority label (not default "Normal" by omission)
-        explicit_priority_tasks = sum(
-            1 for t in self.tasks
-            if t["priority"] != "Normal" or t.get("priority_explicit", False)
-        )
-        r += min(4, explicit_priority_tasks) * 0.10
-        # +0.20 per High-priority task completed on time
-        r += self.high_tasks_completed_on_time * 0.20
-        # Penalties
-        r -= self.deadline_misses * 0.25
-        # Goal: >=4 tasks, >=2 High added, ALL High completed on time, no deadline misses
+            r += 0.12
+        if self.tasks_added >= 3 and self.list_called:
+            if self._easy_has_two_priorities():
+                r += 0.55
+                self.goal_completed = True
+            else:
+                r += 0.40
+        return round(min(1.0, r), 3)
+
+    def _score_medium(self) -> float:
+        # Softer caps match smaller increments (4×0.07 ≈ 0.28 per bucket)
+        r = min(0.28, self._r_add)
+        r += min(0.28, self._r_priority)
+        r += min(0.28, self._r_deadline_set)
+        r += min(0.22, self._r_complete)
+        r -= self.deadline_misses * MEDIUM_DEADLINE_MISS_PENALTY
+
         high_tasks = [t for t in self.tasks if t["priority"] == "High"]
-        all_high_done = all(t["completed"] and not t["deadline_missed"] for t in high_tasks)
-        if (
-            self.tasks_added >= 4
-            and self.high_tasks_added >= 2
-            and all_high_done
-            and self.deadline_misses == 0
-        ):
-            r = 1.0
-            self.goal_completed = True
-        return r
-
-    def _reward_hard(self) -> float:
-        r = 0.0
-        # +0.15 per task added, up to 5
-        r += min(5, self.tasks_added) * 0.15
-        # +0.10 per task with non-Normal or explicit priority
-        explicit_priority_tasks = sum(
-            1 for t in self.tasks if t["priority"] != "Normal"
+        all_high_on_time = (
+            len(high_tasks) >= 1
+            and all(t["completed"] and not t["deadline_missed"] for t in high_tasks)
         )
-        r += min(5, explicit_priority_tasks) * 0.10
-        # +0.25 per task completed without any violation
-        clean_completions = sum(
-            1 for t in self.tasks
-            if t["completed"] and not t["deadline_missed"] and not t["dependency_violation"]
-        )
-        r += clean_completions * 0.25
-        # Penalty
-        r -= self.dependency_violations * 0.30
-        r -= self.deadline_misses * 0.25
-        # Bonus: optimal ordering (no violations at all + all done)
-        all_done = all(t["completed"] for t in self.tasks)
-        if all_done and self.dependency_violations == 0 and self.deadline_misses == 0:
-            r += 0.10  # perfect-run bonus
-        # Goal: >=5 tasks, >=2 High, all completed, zero violations
-        high_tasks = [t for t in self.tasks if t["priority"] == "High"]
-        if (
-            self.tasks_added >= 5
-            and self.high_tasks_added >= 2
-            and len(self.tasks) == self.tasks_completed
-            and self.dependency_violations == 0
-            and self.deadline_misses == 0
-        ):
-            r = 1.0
+        if self.tasks_added >= 4 and all_high_on_time and self.deadline_misses == 0:
             self.goal_completed = True
-        return r
-
-    # ------------------------------------------------------------------
-    # Helpers
-    # ------------------------------------------------------------------
+            return 1.0
+        return round(min(0.94, max(0.0, r)), 3)
+
+    def _score_hard(self) -> float:
+        # Caps aligned with 0.062 increments (~0.31 over 5 adds) to avoid one huge step on task 5
+        r = min(0.34, self._r_add)
+        r += min(0.26, self._r_priority)
+        r += min(0.26, self._r_deadline_set)
+        r += min(0.42, self._r_complete)
+        r += min(0.14, self._r_hard_dep_ok)
+        r += min(0.08, self._r_hard_edge)
+        topo_bonus = 0.0
+        if self.clean_completions == 5 and self.dep_violations == 0:
+            topo_bonus = 0.055
+        r += topo_bonus
+        r -= self.dep_violations * HARD_DEP_VIOLATION_PENALTY
+        r -= self.deadline_misses * HARD_DEADLINE_MISS_PENALTY
+
+        all_done = self.tasks_added >= 5 and all(t["completed"] for t in self.tasks)
+        if all_done and self.dep_violations == 0 and self.deadline_misses == 0:
+            self.goal_completed = True
+            return 1.0
+        return round(min(0.99, max(0.0, r)), 3)
 
-    def _format_task_list(self) -> str:
+    def _fmt_list(self) -> str:
         if not self.tasks:
-            return "No tasks in the system."
-        lines = [f"Current tasks ({len(self.tasks)} total):"]
+            return "No tasks yet."
+        lines = [f"Tasks ({len(self.tasks)}):"]
         for i, t in enumerate(self.tasks, 1):
             status = "DONE" if t["completed"] else "PENDING"
             flags = []
             if t.get("deadline_missed"):
                 flags.append("LATE")
-            if t.get("dependency_violation"):
-                flags.append("DEP-VIOLATION")
-            flag_str = f" [{', '.join(flags)}]" if flags else ""
-            dep_str = f" | Deps: {t['depends_on']}" if t["depends_on"] else ""
-            dl_str = f" | Due: {t['deadline']}" if t["deadline"] != "none" else ""
-            lines.append(
-                f"  {i}. [{status}]{flag_str} {t['title']} "
-                f"(Priority: {t['priority']}{dl_str}{dep_str})"
-            )
+            if t.get("dep_violation"):
+                flags.append("DEP-ERR")
+            flag_str = f" [{','.join(flags)}]" if flags else ""
+            dl = f" due={t['deadline']}" if t["deadline"] else ""
+            dep = f" deps={t['depends_on']}" if t["depends_on"] else ""
+            lines.append(f"  {i}. [{status}]{flag_str} {t['title']} ({t['priority']}{dl}{dep})")
         return "\n".join(lines)
 
-    # ------------------------------------------------------------------
-    # State property
-    # ------------------------------------------------------------------
-
     @property
     def state(self) -> State:
         return self._state