Upload folder using huggingface_hub

README.md

@@ -1,19 +1,21 @@
 ---
-title: OpenEnv Jayesh - Task Manager
-colorFrom: blue
-colorTo: green
+title: OpenEnv Jayesh - Smart Personal Task Manager
+colorFrom: indigo
+colorTo: purple
 sdk: docker
 pinned: false
 app_port: 8000
 tags:
   - openenv
   - task-manager
+  - ai-agent
+  - planning
 base_path: /web
 ---
 
-# OpenEnv Jayesh - Task Manager Environment
+# Smart Personal Task Manager - OpenEnv Jayesh
 
-An AI agent environment for managing tasks across three difficulty levels, built for the OpenEnv Hackathon Round 1.
+> An AI agent environment for managing tasks with priorities, deadlines, and dependencies -- built for the **OpenEnv Hackathon Round 1**.
 
 - HF Space: https://huggingface.co/spaces/jayesh20/openenv_jayesh
 - Python 3.10+
@@ -22,17 +24,19 @@ An AI agent environment for managing tasks across three difficulty levels, built
 
 ## What is this?
 
-A real-world Task Manager environment where an AI agent must add, prioritize, and complete tasks to earn rewards. The environment cycles through Easy, Medium, and Hard difficulty levels, each with stricter goals and richer reward signals.
+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.
+
+This environment targets real-world utility: the kind of task scheduling problems that users, productivity apps, and organizational tools deal with every day.
 
 ---
 
 ## Difficulty Levels
 
-| Level  | Goal |
-|--------|------|
-| Easy   | Add 2 tasks and list them |
-| Medium | Add 3 tasks (mixed priorities), complete all High priority ones |
-| Hard   | Add 4 tasks (at least 2 High priority), complete at least 2 High priority tasks |
+| 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 |
 
 ---
 
@@ -40,54 +44,85 @@ A real-world Task Manager environment where an AI agent must add, prioritize, an
 
 ```python
 TaskManagerAction(
-    command="add",         # "add" | "complete" | "list"
-    title="Fix bug",       # required for add / complete
-    priority="High",       # "Low" | "Normal" | "High"  (optional, default: Normal)
-    deadline="2026-04-01"  # optional
+    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)
 )
 ```
 
+### 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
 
 ```python
 TaskManagerObservation(
-    success=True,          # whether the action succeeded
-    message="Task added",  # status message
-    tasks=[...],           # current task list
-    reward=0.4,            # partial progress score (0.0 to 1.0)
-    done=False             # True when episode goal is achieved
+    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
+    }
 )
 ```
 
+### 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
+### Easy Mode
 | Event | Reward |
 |-------|--------|
-| Add 1st task | +0.4 |
-| Add 2nd task | +0.4 |
-| Call list | +0.2 |
-| Goal complete | 1.0 |
+| Each task added (up to 3) | +0.15 |
+| Calling `list` | +0.20 |
+| **Goal: >=2 tasks added + list called** | **1.0** |
 
-### Medium
+### Medium Mode
 | Event | Reward |
 |-------|--------|
-| Each task added (up to 3) | +0.2 each |
-| Adding a High priority task | +0.1 |
-| Completing High priority tasks | +0.3 (proportional) |
-| Goal complete | 1.0 |
+| 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
+### Hard Mode
 | Event | Reward |
 |-------|--------|
-| Each task added (up to 4) | +0.1 each |
-| Each High priority task added (up to 2) | +0.1 each |
-| Each High priority task completed (up to 2) | +0.2 each |
-| Goal complete | 1.0 |
+| 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** |
 
 ---
 
@@ -97,49 +132,93 @@ TaskManagerObservation(
 # Install dependencies
 uv sync
 
-# Run the server
+# Start the server
 uvicorn server.app:app --host 127.0.0.1 --port 8000
 
-# In another terminal, run inference
+# In another terminal, run the inference demo
 python inference.py
 ```
 
 ---
 
-## Usage Example
+## Usage Examples
 
+### Easy Mode
 ```python
-from server.openenv_jayesh_environment import OpenenvJayeshEnvironment
-from models import TaskManagerAction
-
 env = OpenenvJayeshEnvironment()
+obs = env.reset()   # cycles to Easy
 
-obs = env.reset()
-print(obs.message)
-# Task Manager started in Easy mode. Goal: Add 2 tasks and list them.
-
-obs = env.step(TaskManagerAction(command="add", title="Buy groceries", priority="Normal"))
-print(obs.reward)  # 0.4
+env.step(TaskManagerAction(command="add", title="Buy groceries", priority="Normal"))
+# reward: 0.15
 
-obs = env.step(TaskManagerAction(command="add", title="Fix bug", priority="High"))
-print(obs.reward)  # 0.8
+env.step(TaskManagerAction(command="add", title="Call dentist", priority="Low"))
+# reward: 0.30
 
 obs = env.step(TaskManagerAction(command="list"))
-print(obs.reward)  # 1.0
-print(obs.done)    # True
+# 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
 
 | URL | Description |
 |-----|-------------|
-| http://127.0.0.1:8000/docs | Swagger UI - interactive API testing |
-| http://127.0.0.1:8000/health | Health check |
-| POST /reset | Start a new episode |
-| POST /step | Execute an action |
-| GET /state | Get current episode state |
+| `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 |
 
 ---
 
@@ -147,21 +226,20 @@ print(obs.done)    # True
 
 ```
 openenv_jayesh/
-├── Dockerfile
-├── openenv.yaml
-├── pyproject.toml
-├── models.py
-├── client.py
-├── inference.py
-└── server/
-    ├── app.py
-    ├── openenv_jayesh_environment.py
-    └── requirements.txt
++-- 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
 ```
 
 ---
 
-## Deploy to Hugging Face Spaces
+## Deploy
 
 ```bash
 openenv push --repo-id jayesh20/openenv_jayesh

inference.py

@@ -1,66 +1,147 @@
+"""
+inference.py – Demonstration of the Smart Personal Task Manager OpenEnv.
+
+Runs all three difficulty scenarios and prints step-by-step reward signals.
+"""
+
 import sys
 import os
-sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 
 from client import OpenenvJayeshEnv
 from models import TaskManagerAction
 
-def run_easy_task(client):
-    print("\n=== Scenario: Easy ===")
+# ---------------------------------------------------------------------------
+# 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):
+    print("\n" + "=" * 70)
+    print("SCENARIO 1 – EASY MODE")
+    print("=" * 70)
     res = client.reset()
-    default_msg = res.observation.message if hasattr(res.observation, 'message') else "No message"
-    print(f"Goal: {default_msg}")
-
-    res = client.step(TaskManagerAction(command="add", title="Buy groceries", priority="Normal"))
-    print(f"Action 'add 1': {res.observation.message} | Score: {res.reward}")
-    res = client.step(TaskManagerAction(command="add", title="Do laundry", priority="Low"))
-    print(f"Action 'add 2': {res.observation.message} | Score: {res.reward}")
-    res = client.step(TaskManagerAction(command="list"))
-    print(f"Action 'list': {res.observation.message} | Score: {res.reward} | Done: {res.done}")
-
-def run_medium_task(client):
-    print("\n=== Scenario: Medium ===")
+    print(f"\nGoal:\n{res.observation.message}\n")
+
+    today = "2026-04-15"
+
+    _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)")
+
+    print()
+
+
+# ---------------------------------------------------------------------------
+# Medium scenario
+# ---------------------------------------------------------------------------
+
+def run_medium(client):
+    print("\n" + "=" * 70)
+    print("SCENARIO 2 – MEDIUM MODE")
+    print("=" * 70)
     res = client.reset()
-    default_msg = res.observation.message if hasattr(res.observation, 'message') else "No message"
-    print(f"Goal: {default_msg}")
-    
-    res = client.step(TaskManagerAction(command="add", title="Write code", priority="Normal"))
-    print(f"Action 'add Normal': {res.observation.message} | Score: {res.reward}")
-    res = client.step(TaskManagerAction(command="add", title="Review PR", priority="High"))
-    print(f"Action 'add High': {res.observation.message} | Score: {res.reward}")
-    res = client.step(TaskManagerAction(command="add", title="Check emails", priority="Low"))
-    print(f"Action 'add Low': {res.observation.message} | Score: {res.reward}")
-    
-    res = client.step(TaskManagerAction(command="complete", title="Review PR"))
-    print(f"Action 'complete High': {res.observation.message} | Score: {res.reward} | Done: {res.done}")
-
-def run_hard_task(client):
-    print("\n=== Scenario: Hard ===")
+    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]")
+
+    print()
+
+
+# ---------------------------------------------------------------------------
+# Hard scenario
+# ---------------------------------------------------------------------------
+
+def run_hard(client):
+    print("\n" + "=" * 70)
+    print("SCENARIO 3 – HARD MODE (dependencies + deadlines)")
+    print("=" * 70)
     res = client.reset()
-    default_msg = res.observation.message if hasattr(res.observation, 'message') else "No message"
-    print(f"Goal: {default_msg}")
-    
-    res = client.step(TaskManagerAction(command="add", title="Fix prod bug", priority="High"))
-    print(f"Action 'add High 1': {res.observation.message} | Score: {res.reward}")
-    res = client.step(TaskManagerAction(command="add", title="Write incident report", priority="High"))
-    print(f"Action 'add High 2': {res.observation.message} | Score: {res.reward}")
-    res = client.step(TaskManagerAction(command="add", title="Refactor", priority="Normal"))
-    print(f"Action 'add Normal': {res.observation.message} | Score: {res.reward}")
-    res = client.step(TaskManagerAction(command="add", title="Update docs", priority="Low"))
-    print(f"Action 'add Low': {res.observation.message} | Score: {res.reward}")
-    
-    res = client.step(TaskManagerAction(command="complete", title="Fix prod bug"))
-    print(f"Action 'complete High 1': {res.observation.message} | Score: {res.reward}")
-    res = client.step(TaskManagerAction(command="complete", title="Write incident report"))
-    print(f"Action 'complete High 2': {res.observation.message} | Score: {res.reward} | Done: {res.done}")
+    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)")
+
+    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]")
+
+    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()
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
 
 if __name__ == "__main__":
-    print("Connecting to OpenEnv Task Manager Server on http://127.0.0.1:8000...")
+    print("=" * 70)
+    print("Smart Personal Task Manager – OpenEnv Inference Demo")
+    print("Connecting to http://127.0.0.1:8000 ...")
+    print("=" * 70)
+
     try:
         with OpenenvJayeshEnv(base_url="http://127.0.0.1:8000").sync() as client:
-            run_easy_task(client)
-            run_medium_task(client)
-            run_hard_task(client)
+            run_easy(client)
+            run_medium(client)
+            run_hard(client)
+        print("\nAll scenarios completed successfully.")
     except Exception as e:
-        print(f"Error connecting to server. Is it running? {e}")
+        print(f"\nError: Could not connect to server. Is it running?\n  {e}")
+        sys.exit(1)

models.py

@@ -2,22 +2,69 @@
 # All rights reserved.
 
 """
-Data models for the Openenv Jayesh Task Manager Environment.
+Data models for the Smart Personal Task Manager OpenEnv Environment.
+
+Supports three difficulty levels:
+  Easy   – add tasks & list them
+  Medium – priorities + deadlines; complete High-priority tasks before deadline
+  Hard   – priorities + deadlines + dependencies; complete in valid topological order
 """
 
 from typing import Optional, List, Dict, Any
 from openenv.core.env_server.types import Action, Observation
 from pydantic import Field
 
+
 class TaskManagerAction(Action):
-    """Action for the Task Manager."""
-    command: str = Field(..., description="The command to execute: 'add', 'complete', 'list'")
-    title: Optional[str] = Field(default=None, description="Task title (for 'add' or 'complete')")
-    priority: Optional[str] = Field(default="Normal", description="Task priority (for 'add')")
-    deadline: Optional[str] = Field(default=None, description="Task deadline (for 'add')")
+    """Action for the Smart Personal Task Manager."""
+
+    command: str = Field(
+        ...,
+        description=(
+            "Command to execute. One of: 'add', 'complete', 'list'. "
+            "'add' – create a new task. "
+            "'complete' – mark an existing task as done. "
+            "'list' – display all current tasks."
+        ),
+    )
+    title: Optional[str] = Field(
+        default=None,
+        description="Human-readable task title. Required for 'add' and 'complete'.",
+    )
+    priority: Optional[str] = Field(
+        default="Normal",
+        description="Task priority. One of: 'Low', 'Normal', 'High'. Used for 'add'.",
+    )
+    deadline: Optional[str] = Field(
+        default=None,
+        description=(
+            "Optional ISO-8601 date string (YYYY-MM-DD) indicating when the task "
+            "must be completed. Used for 'add'. Relevant in Medium and Hard modes."
+        ),
+    )
+    depends_on: Optional[List[str]] = Field(
+        default=None,
+        description=(
+            "List of task titles that must be completed BEFORE this task can be "
+            "completed. Used for 'add'. Relevant in Hard mode only."
+        ),
+    )
+
 
 class TaskManagerObservation(Observation):
-    """Observation from the Task Manager."""
-    success: bool = Field(default=True, description="Whether the action succeeded")
-    message: str = Field(default="", description="System message or error")
-    tasks: List[Dict[str, Any]] = Field(default_factory=list, description="List of tasks in the system")
+    """Observation returned after each step in the Task Manager."""
+
+    success: bool = Field(default=True, description="Whether the last action succeeded.")
+    message: str = Field(default="", description="System status message or error description.")
+    tasks: List[Dict[str, Any]] = Field(
+        default_factory=list,
+        description=(
+            "Snapshot of all tasks. Each entry contains: "
+            "title, priority, deadline, depends_on, completed, "
+            "deadline_missed (bool), dependency_violation (bool)."
+        ),
+    )
+    violations: List[str] = Field(
+        default_factory=list,
+        description="List of rule violations encountered this episode (deadline misses, dependency order errors).",
+    )

server/openenv_jayesh_environment.py

@@ -2,11 +2,36 @@
 # All rights reserved.
 
 """
-Openenv Jayesh Environment Implementation.
-A Simple Task Manager Environment.
+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.
 """
 
-from typing import Optional, Any
+from __future__ import annotations
+
+from datetime import date
+from typing import Any, Dict, List, Optional
 from uuid import uuid4
 
 from openenv.core.env_server.interfaces import Environment
@@ -18,25 +43,82 @@ except (ModuleNotFoundError, ImportError):
     from models import TaskManagerAction, TaskManagerObservation
 
 
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+VALID_PRIORITIES = {"Low", "Normal", "High"}
+PRIORITY_RANK = {"Low": 0, "Normal": 1, "High": 2}
+
+
+def _parse_date(dt_str: Optional[str]) -> Optional[date]:
+    """Parse an ISO-8601 date string; return None on failure."""
+    if not dt_str:
+        return None
+    try:
+        return date.fromisoformat(dt_str)
+    except ValueError:
+        return None
+
+
+def _today() -> date:
+    return date.today()
+
+
+# ---------------------------------------------------------------------------
+# Environment
+# ---------------------------------------------------------------------------
+
 class OpenenvJayeshEnvironment(Environment):
-    """A Task Manager environment with 3 difficulty modes."""
+    """
+    Smart Personal Task Manager with three distinct difficulty levels.
+
+    Easy   → add tasks + list
+    Medium → deadlines + priority management
+    Hard   → deadlines + priority + dependency ordering
+    """
 
     SUPPORTS_CONCURRENT_SESSIONS: bool = True
 
-    def __init__(self):
+    # ------------------------------------------------------------------
+    # 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"]
-        
-        # Internal state
-        self.tasks = []
-        self.difficulty = "Easy"
-        self.goal_completed = False
-        self.tasks_added = 0
-        self.high_priority_added = 0
-        self.high_priority_completed = 0
-        self.list_called = False
+        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.violations: List[str] = []
+
+        # Target counts per difficulty
+        self.target_tasks: int = 2
+        self.target_high: int = 0
+
+    # ------------------------------------------------------------------
+    # reset
+    # ------------------------------------------------------------------
 
     def reset(
         self,
@@ -44,141 +126,337 @@ class OpenenvJayeshEnvironment(Environment):
         episode_id: Optional[str] = None,
         **kwargs: Any,
     ) -> TaskManagerObservation:
-        """Reset the environment."""
         self._state = State(episode_id=episode_id or str(uuid4()), step_count=0)
-        
+        self._init_episode_state()
+
         idx = self._reset_count % len(self._scenarios)
         self.difficulty = self._scenarios[idx]
         self._reset_count += 1
-        
-        self.tasks = []
-        self.goal_completed = False
-        self.tasks_added = 0
-        self.high_priority_added = 0
-        self.high_priority_completed = 0
-        self.list_called = False
-        
-        message = f"Task Manager started in {self.difficulty} mode. "
+
         if self.difficulty == "Easy":
-            message += "Goal: Add 2 tasks and list them."
+            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":
-            message += "Goal: Add 3 tasks (mixed priorities) and complete all High priority ones."
-        elif self.difficulty == "Hard":
-            message += "Goal: Add 4 tasks (at least 2 High) and complete at least 2 High priority tasks."
-            
+            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."
+            )
+
         return TaskManagerObservation(
             success=True,
-            message=message,
-            tasks=self.tasks,
+            message=msg,
+            tasks=[],
+            violations=[],
             done=False,
-            reward=0.0
+            reward=0.0,
         )
 
+    # ------------------------------------------------------------------
+    # step
+    # ------------------------------------------------------------------
+
     def step(
         self,
         action: TaskManagerAction,
         timeout_s: Optional[float] = None,
         **kwargs: Any,
-    ) -> TaskManagerObservation:  # type: ignore[override]
-        """Execute a step."""
+    ) -> TaskManagerObservation:
         self._state.step_count += 1
-        
-        cmd = action.command.lower()
+        cmd = (action.command or "").strip().lower()
         success = True
         message = ""
-        
+
         if cmd == "add":
-            if not action.title:
-                success = False
-                message = "Title is required to add a task."
-            else:
-                prio = action.priority or "Normal"
-                new_task = {
-                    "title": action.title,
-                    "priority": prio,
-                    "deadline": action.deadline or "N/A",
-                    "completed": False
-                }
-                self.tasks.append(new_task)
-                self.tasks_added += 1
-                if prio == "High":
-                    self.high_priority_added += 1
-                message = f"Task '{action.title}' added successfully. (Priority: {prio})"
+            success, message = self._handle_add(action)
         elif cmd == "complete":
-            if not action.title:
-                success = False
-                message = "Title is required to complete a task."
-            else:
-                found = False
-                for t in self.tasks:
-                    if t["title"] == action.title:
-                        if not t["completed"]:
-                            t["completed"] = True
-                            if t["priority"] == "High":
-                                self.high_priority_completed += 1
-                        found = True
-                        message = f"Task '{action.title}' marked as completed."
-                        break
-                if not found:
-                    success = False
-                    message = f"Task '{action.title}' not found."
+            success, message = self._handle_complete(action)
         elif cmd == "list":
             self.list_called = True
-            message = f"Listed {len(self.tasks)} current tasks."
+            message = self._format_task_list()
         else:
             success = False
-            message = f"Unknown command: '{cmd}'"
-            
+            message = f"Unknown command '{cmd}'. Valid commands: 'add', 'complete', 'list'."
+
         reward = self._calculate_reward()
-        done = self.goal_completed
-        
+
         return TaskManagerObservation(
             success=success,
             message=message,
-            tasks=self.tasks,
-            done=done,
+            tasks=list(self.tasks),
+            violations=list(self.violations),
+            done=self.goal_completed,
             reward=reward,
-            metadata={"difficulty": self.difficulty, "step": self._state.step_count}
+            metadata={
+                "difficulty": self.difficulty,
+                "step": self._state.step_count,
+                "tasks_added": self.tasks_added,
+                "tasks_completed": self.tasks_completed,
+                "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
+        if any(t["title"] == title for t in self.tasks):
+            return False, f"Error: A task titled '{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)
+
+        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.",
+                    )
+
+        task: Dict[str, Any] = {
+            "title": title,
+            "priority": priority,
+            "deadline": deadline_str or "none",
+            "depends_on": depends_on,
+            "completed": False,
+            "deadline_missed": False,
+            "dependency_violation": False,
+            "added_step": self._state.step_count,
+        }
+        self.tasks.append(task)
+        self.tasks_added += 1
+        if priority == "High":
+            self.high_tasks_added += 1
+
+        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."
+        if task["completed"]:
+            return False, f"Task '{title}' is already completed."
+
+        # ---- Dependency check ----
+        dep_violation = False
+        unmet = [
+            dep for dep in task["depends_on"]
+            if not any(t["title"] == dep 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
+        dl = _parse_date(task["deadline"])
+        if dl is not None and _today() > dl:
+            deadline_missed = 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)
+
+        # ---- 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:
-        reward = 0.0
         self.goal_completed = False
-        
+        reward = 0.0
+
         if self.difficulty == "Easy":
-            # Add 2 tasks (0.4 each) + list them (0.2)
-            reward += min(0.8, self.tasks_added * 0.4)
-            if self.list_called:
-                reward += 0.2
-                
-            if self.tasks_added >= 2 and self.list_called:
-                reward = 1.0
-                self.goal_completed = True
-                
+            reward = self._reward_easy()
         elif self.difficulty == "Medium":
-            # Add 3 tasks (0.2 each) + Add High (0.1) + Complete High (0.3 ratio)
-            reward += min(0.6, self.tasks_added * 0.2)
-            if self.high_priority_added >= 1:
-                reward += 0.1
-                completion_ratio = self.high_priority_completed / self.high_priority_added
-                reward += min(0.3, completion_ratio * 0.3)
-                    
-            if self.tasks_added >= 3 and self.high_priority_added >= 1:
-                if self.high_priority_completed >= self.high_priority_added:
-                    reward = 1.0
-                    self.goal_completed = True
-                    
-        elif self.difficulty == "Hard":
-            # Add 4 tasks (0.1 each) + Add 2 High (0.1 each) + Complete 2 High (0.2 each)
-            reward += min(0.4, self.tasks_added * 0.1)
-            reward += min(0.2, self.high_priority_added * 0.1)
-            reward += min(0.4, self.high_priority_completed * 0.2)
-            
-            if self.tasks_added >= 4 and self.high_priority_added >= 2 and self.high_priority_completed >= 2:
-                reward = 1.0
-                self.goal_completed = True
-        
-        return round(min(1.0, reward), 2)
+            reward = self._reward_medium()
+        else:
+            reward = self._reward_hard()
+
+        return round(min(1.0, max(0.0, reward)), 3)
+
+    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
+        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
+        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"
+        )
+        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
+            self.goal_completed = True
+        return r
+
+    # ------------------------------------------------------------------
+    # Helpers
+    # ------------------------------------------------------------------
+
+    def _format_task_list(self) -> str:
+        if not self.tasks:
+            return "No tasks in the system."
+        lines = [f"Current tasks ({len(self.tasks)} total):"]
+        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})"
+            )
+        return "\n".join(lines)
+
+    # ------------------------------------------------------------------
+    # State property
+    # ------------------------------------------------------------------
 
     @property
     def state(self) -> State:

validate_final.txt

@@ -0,0 +1 @@
+[OK] openenv_jayesh: Ready for multi-mode deployment