first commit

.dockerignore

@@ -0,0 +1,13 @@
+.venv
+.env
+frontend/node_modules
+frontend/.cache
+frontend/build
+**/__pycache__
+**/*.pyc
+**/*.pyo
+.git
+.gitignore
+pyproject.toml
+uv.lock
+server/

.gitignore

@@ -0,0 +1,11 @@
+.env
+.venv/
+__pycache__/
+**/__pycache__/
+*.pyc
+*.pyo
+frontend/node_modules/
+frontend/.cache/
+frontend/build/
+inference_stderr.txt
+*.log

Dockerfile

@@ -0,0 +1,44 @@
+# =====================================================
+# AI Executive Operations Manager
+# Single-container build: React frontend + FastAPI backend
+# Port: 7860
+# =====================================================
+
+# Stage 1: Build React frontend
+FROM node:18-slim AS frontend-builder
+WORKDIR /app/frontend
+
+# Install dependencies first (cached layer)
+COPY frontend/package.json frontend/package-lock.json* ./
+RUN npm install --legacy-peer-deps
+
+# Copy source and build
+COPY frontend/ ./
+ENV GENERATE_SOURCEMAP=false
+RUN npm run build
+
+# Stage 2: Python runtime
+FROM python:3.11-slim AS runtime
+
+WORKDIR /app
+
+# Install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY env/ ./env/
+COPY app.py inference.py openenv.yaml ./
+
+# Copy pre-built React frontend from Stage 1
+COPY --from=frontend-builder /app/frontend/build ./frontend/build
+
+# Expose port
+EXPOSE 7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=15s --retries=3 \
+  CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:7860/reset')" || exit 1
+
+# Start FastAPI server
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1"]

README.md

@@ -0,0 +1,276 @@
+---
+title: AI Executive Operations Manager
+emoji: ⚡
+colorFrom: blue
+colorTo: purple
+sdk: docker
+app_port: 7860
+pinned: false
+tags:
+  - openenv
+---
+
+# AI Executive Operations Manager
+
+An OpenEnv-compliant reinforcement learning environment where an AI agent plays the role of **Alex Rivera**, CEO of **NovaTech AI** - a fictional Series B AI infrastructure startup with ~80 employees. The agent manages a realistic executive inbox under time pressure, making triage decisions with real business consequences.
+
+---
+
+## What is this?
+
+The agent's job is to read emails, decide what to act on, and choose *how* to act. Every choice has consequences. The clock is ticking and there is always more to do than time allows.
+
+Each email has a **priority** (1-5) and a **decaying urgency** score. The agent picks one of four actions per step:
+
+| Action | When to use |
+|--------|-------------|
+| `reply` | CEO must personally handle - investor relations, legal deadlines, critical incidents |
+| `schedule` | Needs a meeting - strategic discussions, relationship-building |
+| `delegate` | Can be handled by the team - operational, low-stakes items |
+| `ignore` | Truly trivial - only safe when no critical items are unhandled |
+
+**Format:** `{"type": "reply|schedule|delegate|ignore", "email_id": "<id>"}`
+
+---
+
+## The Core Challenge
+
+Good decisions require real prioritization - not just doing the most urgent thing first, but understanding *what matters most* and *what can be handed off*.
+
+**You cannot do everything.** Every step costs time. The hardest scenario is designed so a perfect score is mathematically impossible - the agent must triage ruthlessly and decide what to sacrifice.
+
+### Why it's hard
+
+- **Conflicting priorities** - Two fires at once, one CEO
+- **Urgency vs. importance** - Something loud is not always something critical
+- **Delegation trade-offs** - Some things only you can do; others you shouldn't touch
+- **Time decay** - Urgency drops 0.15 per step; waiting on critical items costs you
+- **Impossible situations** - The hard scenario cannot be perfectly solved. The score reflects *which* crises the agent chose to address
+
+---
+
+## The Three Scenarios
+
+### Easy - "Monday Morning Catchup"
+4 emails, 6 steps. Priorities are clear. Designed to establish a baseline - a competent agent handles everything well.
+
+Key decisions:
+- Approve a production deploy to fix a live memory leak costing $3K/hour
+- Sign off on a $1.2M GlobalBank enterprise contract before a competitor swoops in
+- Delegate new hire onboarding paperwork to HR
+- Ignore the office snack order
+
+**Expected score:** 0.70 - 1.00
+
+---
+
+### Medium - "Investor Demo Day Prep"
+7 emails, 8 steps. NovaTech's Series B pitch is today. Multiple high-priority items compete for the same limited time. Requires smart scheduling and knowing what to delegate.
+
+Key decisions:
+- Schedule a pre-demo call with the lead Sequoia investor
+- Align with the CTO on architecture before investors ask about scaling
+- Sign an NDA legally required before the presentation
+- Approve an offer letter for a senior ML engineer before they go to OpenAI
+- Manage the CFO's runway concerns (8.5 months left, down from 11)
+
+**Expected score:** 0.45 - 0.85
+
+---
+
+### Hard - "Series B Crisis Day"
+10 emails, 8 steps, 7 goals. Four simultaneous P5 crises. **A perfect score is intentionally impossible.** A top agent scores around 0.65-0.75.
+
+The crises hitting all at once:
+- Lead investor threatening to pull an $18M term sheet before 4PM
+- Production database corruption affecting 23 enterprise customers ($85K/hour revenue impact)
+- TechCrunch publishing a false security breach story in 90 minutes
+- Key engineer resigning to join Anthropic - mid Series B
+- GDPR data deletion deadline expiring at 5PM (20M euro fine risk)
+- AWS contract expiring at midnight (cost jumps from $180K to $340K/month)
+- Co-founder publicly disagreeing on strategy before the board meeting
+- Microsoft acquisition inquiry ($400-600M range)
+
+The agent must decide what to sacrifice.
+
+**Expected score:** 0.20 - 0.75
+
+---
+
+## Observation Space
+
+Each observation is a JSON dict:
+
+```json
+{
+  "time": "10:00 AM",
+  "step": 2,
+  "max_steps": 8,
+  "steps_remaining": 6,
+  "inbox": [
+    {
+      "id": "e1",
+      "sender": "Sarah Chen <s.chen@novatech.ai>",
+      "subject": "URGENT: Production deploy approval",
+      "body": "...",
+      "priority": 5,
+      "urgency": 0.65,
+      "handled": false,
+      "action_taken": null
+    }
+  ],
+  "calendar": [
+    {"time_slot": 3, "title": "Board Sync", "attendee": "Board of Directors", "locked": true}
+  ],
+  "goals": [
+    {
+      "id": "g1",
+      "description": "Approve production deploy to fix memory leak",
+      "priority": 5,
+      "required_action": "reply",
+      "target_email_id": "e1",
+      "completed": false
+    }
+  ],
+  "pending_goals": [
+    {
+      "id": "g1",
+      "description": "Approve production deploy to fix memory leak",
+      "priority": 5,
+      "required_action": "reply",
+      "target_email_id": "e1",
+      "completed": false
+    }
+  ],
+  "total_reward": 0.498,
+  "done": false
+}
+```
+
+- `priority`: 1 (minimal) to 5 (critical)
+- `urgency`: 0.0-1.0, decays by 0.15 each step - act fast on high-urgency items
+- `goals`: all goals with completion status
+- `pending_goals`: only incomplete goals
+
+---
+
+## Reward Function
+
+Per-step continuous reward, clamped to `[-0.3, 0.5]`:
+
+| Signal | Value |
+|--------|-------|
+| Goal completion | `+0.30 x (priority / 5)` |
+| Urgency bonus | `+0.15 x urgency` (if urgency > 0.5, not ignoring) |
+| Correct action type | `+0.10` (matches goal's required action) |
+| Smart delegation (P1-P2) | `+0.05` |
+| Ignore critical (P4-P5) | `-0.25` |
+| Waste step on trivial when crises pending | `-0.10` |
+| Per-step cost | `-0.02` |
+
+---
+
+## Grader
+
+Deterministic. Score in [0.0, 1.0]:
+
+```
+score = 0.60 x goal_completion_rate  (priority-weighted)
+      + 0.25 x email_handling_rate   (priority-weighted)
+      + 0.15 x efficiency_bonus      (only if all high-priority goals done)
+```
+
+Goals carry 60% of the weight because completing the right goal (saving an $18M term sheet) matters far more than handling any random email. Efficiency only rewards speed *after* critical goals are met - it never trumps correctness.
+
+---
+
+## What makes a good agent?
+
+1. **Triage instinct** - Identify the two or three things that absolutely cannot wait
+2. **Delegation confidence** - Know what doesn't need the CEO's personal attention
+3. **Urgency sensitivity** - Act on time-decaying items before they expire
+4. **Sacrifice awareness** - In the hard scenario, explicitly choose what to drop
+
+The environment rewards agents that think like an actual executive under pressure - not agents that just process emails in order.
+
+---
+
+## Setup & Running
+
+### Docker (Recommended)
+
+```bash
+docker build -t exec-ops-manager .
+docker run -p 7860:7860 exec-ops-manager
+# Open http://localhost:7860
+```
+
+### Local Development
+
+```bash
+pip install -r requirements.txt
+uvicorn app:app --port 7860 --reload
+```
+
+### Running Inference / Demo Script
+
+`inference.py` runs an LLM agent through all 3 tasks and prints structured logs.
+
+```bash
+export API_BASE_URL="https://api.openai.com/v1"
+export MODEL_NAME="gpt-4o-mini"
+export HF_TOKEN="your-key"
+python inference.py
+```
+
+Output format:
+```
+[START] task=easy env=exec-ops model=gpt-4o-mini
+[STEP] step=1 action=reply('e1') reward=0.50 done=false error=null
+[STEP] step=2 action=reply('e2') reward=0.41 done=false error=null
+[STEP] step=3 action=delegate('e3') reward=0.26 done=true error=null
+[END] success=true steps=3 score=0.906 rewards=0.50,0.41,0.26
+```
+
+---
+
+## API Endpoints
+
+| Endpoint | Method | Description |
+|----------|--------|-------------|
+| `/` | GET | Serves React dashboard (200 OK) |
+| `/reset?task=easy` | GET/POST | Reset environment, returns initial observation |
+| `/step` | POST | Execute one action, returns observation + reward |
+| `/state` | GET | Full current environment state |
+| `/grade` | GET | Current score (0.0-1.0) |
+| `/tasks` | GET | List all available tasks |
+
+---
+
+## Baseline Results
+
+*Model: `gpt-4o-mini` via OpenAI API*
+
+| Task | Score | Steps used |
+|------|-------|------------|
+| easy | 0.906 | 3 / 6 |
+| medium | 0.866 | 5 / 8 |
+| hard | 0.681 | 8 / 8 |
+| **Average** | **0.818** | |
+
+---
+
+## Architecture
+
+```
+Single Docker container (port 7860)
+├── FastAPI (app.py)          - API + static file serving
+├── env/                      - Pure Python RL environment
+│   ├── models.py             - Pydantic data models
+│   ├── tasks.py              - 3 task definitions
+│   ├── reward.py             - Per-step reward function
+│   ├── grader.py             - Deterministic final grader
+│   └── environment.py        - ExecOpsEnv state machine
+├── frontend/build/           - Pre-built React dashboard
+└── inference.py              - LLM agent baseline script
+```

app.py

@@ -0,0 +1,168 @@
+import os
+from fastapi import FastAPI, Query, HTTPException
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+
+from env import ExecOpsEnv, Action, grade
+
+app = FastAPI(title="AI Executive Operations Manager", version="1.0.0")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Global environment instance (single session)
+env = ExecOpsEnv("easy")
+
+
+@app.api_route("/reset", methods=["GET", "POST"])
+def reset(task: str = Query("easy")):
+    """Reset the environment to a fresh state for the given task."""
+    global env
+    valid_tasks = ["easy", "medium", "hard"]
+    if task not in valid_tasks:
+        raise HTTPException(status_code=400, detail=f"Invalid task. Choose from: {valid_tasks}")
+    env = ExecOpsEnv(task)
+    return env.reset()
+
+
+@app.post("/step")
+def step(action: Action):
+    """Execute one action step in the environment."""
+    global env
+    try:
+        result = env.step(action)
+        return result
+    except (ValueError, RuntimeError) as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@app.get("/state")
+def get_state():
+    """Return the full current environment state."""
+    global env
+    return env.get_state()
+
+
+@app.get("/grade")
+def get_grade():
+    """Return the current grade score (0.0-1.0)."""
+    global env
+    return {"score": grade(env._state), "task_id": env.task_id}
+
+
+@app.get("/health")
+def health():
+    """OpenEnv runtime health check."""
+    return {"status": "healthy"}
+
+
+@app.get("/metadata")
+def metadata():
+    """OpenEnv runtime metadata."""
+    return {
+        "name": "ai-executive-ops-manager",
+        "description": (
+            "Simulates a startup CEO's operational day. An AI agent manages a realistic "
+            "executive inbox under time pressure, making triage decisions - reply, schedule, "
+            "delegate, or ignore - to handle conflicting priorities and cascading crises."
+        ),
+        "version": "1.0.0",
+        "tasks": ["easy", "medium", "hard"],
+    }
+
+
+@app.get("/schema")
+def schema():
+    """OpenEnv runtime schema for action, observation, and state."""
+    return {
+        "action": {
+            "type": "object",
+            "properties": {
+                "type": {"type": "string", "enum": ["reply", "schedule", "delegate", "ignore"]},
+                "email_id": {"type": "string", "description": "ID of the email to act on (e.g. 'e1')"},
+            },
+            "required": ["type", "email_id"],
+        },
+        "observation": {
+            "type": "object",
+            "properties": {
+                "time": {"type": "string"},
+                "step": {"type": "integer"},
+                "max_steps": {"type": "integer"},
+                "steps_remaining": {"type": "integer"},
+                "inbox": {"type": "array", "items": {"type": "object"}},
+                "calendar": {"type": "array", "items": {"type": "object"}},
+                "goals": {"type": "array", "items": {"type": "object"}},
+                "pending_goals": {"type": "array", "items": {"type": "object"}},
+                "total_reward": {"type": "number"},
+                "done": {"type": "boolean"},
+            },
+        },
+        "state": {
+            "type": "object",
+            "properties": {
+                "current_step": {"type": "integer"},
+                "max_steps": {"type": "integer"},
+                "current_time": {"type": "string"},
+                "inbox": {"type": "array"},
+                "calendar": {"type": "array"},
+                "goals": {"type": "array"},
+                "history": {"type": "array"},
+                "total_reward": {"type": "number"},
+                "done": {"type": "boolean"},
+                "task_id": {"type": "string"},
+            },
+        },
+    }
+
+
+@app.post("/mcp")
+def mcp(request: dict = None):
+    """Minimal MCP/JSON-RPC endpoint for OpenEnv runtime compliance."""
+    return {"jsonrpc": "2.0", "result": {"tools": []}, "id": None}
+
+
+@app.get("/tasks")
+def list_tasks():
+    """Return available task descriptions."""
+    return {
+        "tasks": [
+            {
+                "id": "easy",
+                "name": "Monday Morning Catchup",
+                "difficulty": "Easy",
+                "description": "A manageable Monday inbox. Priorities are clear.",
+                "max_steps": 6,
+            },
+            {
+                "id": "medium",
+                "name": "Investor Demo Day Prep",
+                "difficulty": "Medium",
+                "description": "Conflicting priorities on demo day. Scheduling required.",
+                "max_steps": 8,
+            },
+            {
+                "id": "hard",
+                "name": "Series B Crisis Day",
+                "difficulty": "Hard",
+                "description": "Cascading crises. Impossible to handle everything.",
+                "max_steps": 8,
+            },
+        ]
+    }
+
+
+# Serve React frontend - MUST come after all API routes
+FRONTEND_DIR = os.path.join(os.path.dirname(__file__), "frontend", "build")
+if os.path.exists(FRONTEND_DIR):
+    app.mount("/", StaticFiles(directory=FRONTEND_DIR, html=True), name="frontend")
+else:
+    # Fallback: return health check at root if frontend not built yet
+    @app.get("/")
+    def root():
+        return {"status": "ok", "message": "AI Executive Operations Manager API", "frontend": "not built"}

env/__init__.py

@@ -0,0 +1,5 @@
+from .environment import ExecOpsEnv
+from .models import Action, EnvState, StepResult, Email, Goal, CalendarEvent
+from .grader import grade
+
+__all__ = ["ExecOpsEnv", "Action", "EnvState", "StepResult", "Email", "Goal", "CalendarEvent", "grade"]

env/environment.py

@@ -0,0 +1,214 @@
+"""
+Core environment: ExecOpsEnv
+Manages the CEO simulation state machine.
+"""
+
+from typing import Optional
+from .models import Action, Email, CalendarEvent, Goal, EnvState, StepResult
+from .tasks import get_task
+from .reward import compute_reward
+
+# 30-minute time slots starting at 9:00 AM
+TIME_SLOTS = [
+    "9:00 AM", "9:30 AM", "10:00 AM", "10:30 AM",
+    "11:00 AM", "11:30 AM", "12:00 PM", "12:30 PM",
+    "1:00 PM", "1:30 PM", "2:00 PM", "2:30 PM",
+    "3:00 PM", "3:30 PM", "4:00 PM", "4:30 PM",
+    "5:00 PM",
+]
+
+URGENCY_DECAY = 0.15  # Urgency drops by this amount each step
+
+
+class ExecOpsEnv:
+    def __init__(self, task_id: str = "easy"):
+        self.task_id = task_id
+        self._task_data = get_task(task_id)
+        self._state: Optional[EnvState] = None
+        self.reset()
+
+    def reset(self) -> dict:
+        """Reinitialize state from task definition. Returns initial observation."""
+        task = get_task(self.task_id)
+
+        emails = [Email(**e) for e in task["emails"]]
+        calendar = [CalendarEvent(**c) for c in task["calendar"]]
+        goals = [Goal(**g) for g in task["goals"]]
+
+        self._state = EnvState(
+            current_step=0,
+            max_steps=task["max_steps"],
+            current_time=TIME_SLOTS[task.get("start_time_slot", 0)],
+            inbox=emails,
+            calendar=calendar,
+            goals=goals,
+            history=[],
+            total_reward=0.0,
+            done=False,
+        )
+        return self._build_observation()
+
+    def step(self, action: Action) -> dict:
+        """
+        Execute one step of the environment.
+        Order: validate → apply → update state → advance time → decay urgency
+               → compute reward → check done → return StepResult
+        """
+        if self._state is None:
+            raise RuntimeError("Environment not initialized. Call reset() first.")
+        if self._state.done:
+            raise RuntimeError("Environment is done. Call reset() to restart.")
+
+        # 1. Validate action
+        valid_action_types = {"reply", "schedule", "delegate", "ignore"}
+        if action.type not in valid_action_types:
+            raise ValueError(
+                f"Invalid action type '{action.type}'. Must be one of: {sorted(valid_action_types)}"
+            )
+        if not action.email_id:
+            raise ValueError("Action is missing required field 'email_id'.")
+        email = self._find_email(action.email_id)
+        if email is None:
+            raise ValueError(f"Email '{action.email_id}' not found in inbox.")
+        if email.handled:
+            raise ValueError(f"Email '{action.email_id}' is already handled.")
+
+        # 2. Apply action
+        email.handled = True
+        email.action_taken = action.type
+
+        # Update calendar if scheduling
+        if action.type == "schedule":
+            self._add_to_calendar(email)
+
+        # 3. Record action in history
+        step_entry = {
+            "step": self._state.current_step,
+            "time": self._state.current_time,
+            "action": action.type,
+            "email_id": action.email_id,
+            "email_subject": email.subject,
+            "email_priority": email.priority,
+        }
+
+        # 6. Compute reward BEFORE marking goals complete (so reward fn sees pending goals)
+        reward = compute_reward(action, email, self._state.goals, self._state)
+
+        # Now mark goals completed
+        for goal in self._state.goals:
+            if goal.target_email_id == action.email_id and not goal.completed:
+                if goal.required_action == action.type:
+                    goal.completed = True
+        step_entry["reward"] = reward
+        self._state.total_reward += reward
+        self._state.history.append(step_entry)
+
+        # 4. Advance time
+        self._advance_time()
+
+        # 5. Decay urgency on unhandled emails
+        self._decay_urgency()
+
+        # 7. Check termination
+        self._state.current_step += 1
+        self._check_done()
+
+        obs = self._build_observation()
+        return {
+            "observation": obs,
+            "reward": reward,
+            "done": self._state.done,
+            "info": {
+                "step": self._state.current_step,
+                "total_reward": self._state.total_reward,
+                "action_applied": action.type,
+                "email_subject": email.subject,
+            },
+        }
+
+    def get_state(self) -> dict:
+        """Return full serialized state."""
+        if self._state is None:
+            raise RuntimeError("Environment not initialized.")
+        return {
+            "current_step": self._state.current_step,
+            "max_steps": self._state.max_steps,
+            "current_time": self._state.current_time,
+            "inbox": [e.model_dump() for e in self._state.inbox],
+            "calendar": [c.model_dump() for c in self._state.calendar],
+            "goals": [g.model_dump() for g in self._state.goals],
+            "history": self._state.history,
+            "total_reward": self._state.total_reward,
+            "done": self._state.done,
+            "task_id": self.task_id,
+            "task_name": self._task_data.get("task_name", ""),
+            "task_description": self._task_data.get("description", ""),
+        }
+
+    # -------------------------
+    # Private helpers
+    # -------------------------
+
+    def _build_observation(self) -> dict:
+        """Build the observation dict that the agent sees."""
+        unhandled = [e for e in self._state.inbox if not e.handled]
+        pending_goals = [g for g in self._state.goals if not g.completed]
+        return {
+            "time": self._state.current_time,
+            "step": self._state.current_step,
+            "max_steps": self._state.max_steps,
+            "steps_remaining": self._state.max_steps - self._state.current_step,
+            "inbox": [e.model_dump() for e in self._state.inbox],
+            "unhandled_count": len(unhandled),
+            "calendar": [c.model_dump() for c in self._state.calendar],
+            "goals": [g.model_dump() for g in self._state.goals],
+            "pending_goals": [g.model_dump() for g in pending_goals],
+            "total_reward": self._state.total_reward,
+            "done": self._state.done,
+            "task_id": self.task_id,
+            "task_name": self._task_data.get("task_name", ""),
+        }
+
+    def _find_email(self, email_id: str) -> Optional[Email]:
+        for email in self._state.inbox:
+            if email.id == email_id:
+                return email
+        return None
+
+    def _advance_time(self):
+        """Move to the next 30-minute time slot."""
+        try:
+            idx = TIME_SLOTS.index(self._state.current_time)
+            if idx + 1 < len(TIME_SLOTS):
+                self._state.current_time = TIME_SLOTS[idx + 1]
+        except ValueError:
+            pass
+
+    def _decay_urgency(self):
+        """Reduce urgency of all unhandled emails."""
+        for email in self._state.inbox:
+            if not email.handled:
+                email.urgency = max(0.0, email.urgency - URGENCY_DECAY)
+
+    def _check_done(self):
+        """Mark done if max steps reached or all goals completed."""
+        all_goals_done = all(g.completed for g in self._state.goals)
+        if self._state.current_step >= self._state.max_steps or all_goals_done:
+            self._state.done = True
+
+    def _add_to_calendar(self, email: Email):
+        """Add a scheduling event to the calendar for scheduled emails."""
+        # Find next available slot
+        locked_slots = {c.time_slot for c in self._state.calendar if c.locked}
+        used_slots = {c.time_slot for c in self._state.calendar}
+        for slot in range(len(TIME_SLOTS)):
+            if slot not in used_slots and slot not in locked_slots:
+                self._state.calendar.append(
+                    CalendarEvent(
+                        time_slot=slot,
+                        title=f"Scheduled: {email.subject[:40]}",
+                        attendee=email.sender.split("<")[0].strip(),
+                        locked=False,
+                    )
+                )
+                break

env/grader.py

@@ -0,0 +1,60 @@
+"""
+Deterministic final grader.
+Returns a score in [0.0, 1.0] based on the terminal state.
+"""
+
+from .models import EnvState
+
+
+def grade(state: EnvState) -> float:
+    """
+    Deterministic final score for the environment state.
+
+    Score = weighted combination:
+      60% - goal completion rate (weighted by goal priority)
+            Goals are the explicit objectives defined per task. They carry the
+            highest weight because completing the right goal (e.g. saving a $18M
+            term sheet) matters far more than handling any random email.
+      25% - priority-weighted email handling rate
+            Measures breadth of coverage across the inbox. Ensures the agent
+            doesn't only cherry-pick goal emails while ignoring other important items.
+      15% - efficiency bonus (only awarded if all high-priority goals are done)
+            Rewards faster completion, but only after critical goals are met -
+            efficiency never trumps correctness.
+
+    Returns: float in [0.0, 1.0]
+    """
+    goals = state.goals
+    inbox = state.inbox
+
+    # --- 60%: Goal completion (priority-weighted) ---
+    goal_score = 0.0
+    if goals:
+        total_priority = sum(g.priority for g in goals)
+        completed_priority = sum(g.priority for g in goals if g.completed)
+        goal_score = completed_priority / total_priority if total_priority > 0 else 0.0
+
+    # --- 25%: Priority-weighted email handling ---
+    email_score = 0.0
+    if inbox:
+        total_email_priority = sum(e.priority for e in inbox)
+        handled_email_priority = sum(e.priority for e in inbox if e.handled)
+        email_score = handled_email_priority / total_email_priority if total_email_priority > 0 else 0.0
+
+    # --- 15%: Efficiency bonus ---
+    efficiency_score = 0.0
+    high_priority_goals = [g for g in goals if g.priority >= 4]
+    all_high_priority_done = all(g.completed for g in high_priority_goals)
+    if all_high_priority_done and high_priority_goals:
+        steps_used = state.current_step
+        steps_ratio = steps_used / state.max_steps if state.max_steps > 0 else 1.0
+        efficiency_score = max(0.0, 1.0 - steps_ratio)
+
+    # --- Weighted combination ---
+    final_score = (
+        0.60 * goal_score +
+        0.25 * email_score +
+        0.15 * efficiency_score
+    )
+
+    return max(0.0, min(1.0, final_score))

env/models.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+from typing import List, Optional, Literal
+from pydantic import BaseModel, Field
+
+
+class Email(BaseModel):
+    id: str
+    sender: str
+    subject: str
+    body: str
+    priority: int = Field(..., ge=1, le=5)  # 1=low, 5=critical
+    urgency: float = Field(default=1.0, ge=0.0, le=1.0)  # decays each step
+    received_at: int = 0  # step number when received
+    handled: bool = False
+    action_taken: Optional[str] = None
+
+
+class CalendarEvent(BaseModel):
+    time_slot: int  # slot number (0-based)
+    title: str
+    attendee: Optional[str] = None
+    locked: bool = False  # locked = CEO must attend, can't move
+
+
+class Goal(BaseModel):
+    id: str
+    description: str
+    completed: bool = False
+    priority: int = Field(..., ge=1, le=5)
+    required_action: str  # "reply", "schedule", "delegate", "ignore"
+    target_email_id: str
+
+
+class Action(BaseModel):
+    type: Literal["reply", "schedule", "delegate", "ignore"]
+    email_id: str
+    note: Optional[str] = None
+
+
+class StepResult(BaseModel):
+    observation: dict
+    reward: float
+    done: bool
+    info: dict
+
+
+class EnvState(BaseModel):
+    current_step: int = 0
+    max_steps: int = 6
+    current_time: str = "9:00 AM"
+    inbox: List[Email] = Field(default_factory=list)
+    calendar: List[CalendarEvent] = Field(default_factory=list)
+    goals: List[Goal] = Field(default_factory=list)
+    history: List[dict] = Field(default_factory=list)
+    total_reward: float = 0.0
+    done: bool = False

env/reward.py

@@ -0,0 +1,75 @@
+"""
+Per-step continuous reward function.
+Rewards are given each step based on the quality of the action taken.
+"""
+
+from typing import List, Optional
+from .models import Action, Email, Goal, EnvState
+
+
+def compute_reward(
+    action: Action,
+    email: Email,
+    goals: List[Goal],
+    state: EnvState,
+) -> float:
+    """
+    Compute per-step reward for taking `action` on `email`.
+
+    Component breakdown (for interpretability):
+    ┌─ POSITIVE ──────────────────────────────────────────────────────────┐
+    │ goal_completion    +0.30 * (priority/5)  Completing a defined goal  │
+    │ action_match       +0.10                 Correct action type chosen  │
+    │ urgency_bonus      +0.15 * urgency       Acting fast on urgent items │
+    │ delegation_bonus   +0.05                 Smart delegation of P1-P2   │
+    ├─ NEGATIVE ──────────────────────────────────────────────────────────┤
+    │ step_cost          -0.02                 Baseline cost per step      │
+    │ ignore_critical    -0.25                 Ignoring P4-P5 emails       │
+    │ wasted_step        -0.10                 Replying to P1 over P4+     │
+    └─────────────────────────────────────────────────────────────────────┘
+
+    Returns: reward clamped to [-0.3, 0.5]
+    """
+    reward = 0.0
+
+    # --- Per-step cost (encourages efficiency) ---
+    reward -= 0.02
+
+    # --- Find if this action completes a goal ---
+    completed_goal: Optional[Goal] = None
+    for goal in goals:
+        if goal.target_email_id == email.id and not goal.completed:
+            if goal.required_action == action.type:
+                completed_goal = goal
+                break
+
+    # --- Goal completion reward ---
+    if completed_goal is not None:
+        reward += 0.30 * (completed_goal.priority / 5.0)
+
+    # --- Urgency bonus: act fast on high-urgency items ---
+    if action.type != "ignore" and email.urgency > 0.5:
+        reward += 0.15 * email.urgency
+
+    # --- Efficiency: delegating low-priority items is smart ---
+    if action.type == "delegate" and email.priority <= 2:
+        reward += 0.05
+
+    # --- Appropriate action bonus ---
+    if completed_goal is not None:
+        reward += 0.10
+
+    # --- Penalty: ignoring critical emails ---
+    if action.type == "ignore" and email.priority >= 4:
+        reward -= 0.25
+
+    # --- Penalty: wasting steps on low-priority when high-priority unhandled ---
+    if email.priority <= 2:
+        unhandled_critical = [
+            e for e in state.inbox
+            if not e.handled and e.priority >= 4 and e.id != email.id
+        ]
+        if unhandled_critical and action.type == "reply":
+            reward -= 0.10
+
+    return max(-0.3, min(0.5, reward))

env/tasks.py

@@ -0,0 +1,495 @@
+"""
+Task definitions for NovaTech AI - Series B AI infrastructure startup.
+CEO: Alex Rivera. Company: NovaTech AI (AI infrastructure, ~80 employees).
+"""
+
+from typing import Dict, Any
+
+
+def get_task_easy() -> Dict[str, Any]:
+    """
+    Monday Morning Catchup
+    A calm Monday with a few clear priorities. Good agent handles everything well.
+    max_steps: 6
+    """
+    return {
+        "task_id": "easy",
+        "task_name": "Monday Morning Catchup",
+        "description": "A manageable Monday inbox. Priorities are clear - handle critical items first.",
+        "objective": "Handle all 3 critical goals: approve production deploy, respond to GlobalBank contract, delegate onboarding signatures.",
+        "constraints": "6 steps maximum. One trivial email can safely be ignored.",
+        "success_condition": "All 3 goals completed. Score >= 0.85 indicates strong performance.",
+        "max_steps": 6,
+        "start_time_slot": 0,
+        "emails": [
+            {
+                "id": "e1",
+                "sender": "Sarah Chen <s.chen@novatech.ai>",
+                "subject": "URGENT: Production deploy approval needed",
+                "body": (
+                    "Alex, we need your sign-off on the production deploy for v2.4.1. "
+                    "It fixes the memory leak that's been degrading API latency by 40% since Friday. "
+                    "Engineering is standing by - every hour of delay costs us $3K in compute waste. "
+                    "Please reply with approval ASAP so we can push before the morning traffic spike."
+                ),
+                "priority": 5,
+                "urgency": 0.95,
+            },
+            {
+                "id": "e2",
+                "sender": "David Park <d.park@novatech.ai>",
+                "subject": "Enterprise contract - GlobalBank review needed",
+                "body": (
+                    "Alex, the GlobalBank contract ($1.2M ARR) is ready for your review. "
+                    "Legal has signed off. Their procurement team needs a response by EOD Tuesday "
+                    "or they go to a competitor. I've attached the redlines - just need your go-ahead "
+                    "to execute. This would be our largest enterprise customer."
+                ),
+                "priority": 4,
+                "urgency": 0.75,
+            },
+            {
+                "id": "e3",
+                "sender": "Priya Nair <p.nair@novatech.ai>",
+                "subject": "New hire onboarding docs - your signature needed",
+                "body": (
+                    "Hi Alex, we have 3 new engineers starting next Monday. "
+                    "I just need your digital signature on the offer letters and NDA templates "
+                    "to complete their onboarding packets. No rush today, but would love to have "
+                    "these by Wednesday so HR can send welcome packages in time."
+                ),
+                "priority": 3,
+                "urgency": 0.50,
+            },
+            {
+                "id": "e4",
+                "sender": "Jake Martinez <j.martinez@novatech.ai>",
+                "subject": "Office snack order - preferences?",
+                "body": (
+                    "Hey Alex! Planning the monthly office snack order. "
+                    "Do you have any preferences for the break room this month? "
+                    "I was thinking maybe some healthier options alongside the usual stuff. "
+                    "Let me know by Friday, totally non-urgent!"
+                ),
+                "priority": 1,
+                "urgency": 0.10,
+            },
+        ],
+        "calendar": [
+            {"time_slot": 3, "title": "Board Sync", "attendee": "Board of Directors", "locked": True},
+        ],
+        "goals": [
+            {
+                "id": "g1",
+                "description": "Approve production deploy to fix memory leak",
+                "priority": 5,
+                "required_action": "reply",
+                "target_email_id": "e1",
+            },
+            {
+                "id": "g2",
+                "description": "Review and approve GlobalBank enterprise contract",
+                "priority": 4,
+                "required_action": "reply",
+                "target_email_id": "e2",
+            },
+            {
+                "id": "g3",
+                "description": "Handle new hire onboarding signatures",
+                "priority": 3,
+                "required_action": "delegate",
+                "target_email_id": "e3",
+            },
+        ],
+    }
+
+
+def get_task_medium() -> Dict[str, Any]:
+    """
+    Investor Demo Day Prep
+    Conflicting high-priority items on demo day. Requires triage and smart delegation.
+    max_steps: 8
+    """
+    return {
+        "task_id": "medium",
+        "task_name": "Investor Demo Day Prep",
+        "description": (
+            "NovaTech's Series B investor demo is today. Multiple P5 items are competing "
+            "for your attention. Smart scheduling and delegation required."
+        ),
+        "objective": "Balance 5 competing goals on investor demo day: schedule investor pre-call, resolve architecture with CTO, align with CFO on runway, sign Sequoia NDA, and approve ML engineer offer.",
+        "constraints": "8 steps for 7 emails. Two locked calendar events limit scheduling windows. Conflicts between P5 items force tradeoffs.",
+        "success_condition": "All 5 goals completed within 8 steps. Score >= 0.80 indicates strong prioritization.",
+        "max_steps": 8,
+        "start_time_slot": 0,
+        "emails": [
+            {
+                "id": "e1",
+                "sender": "Marcus Williams <m.williams@sequoiacap.com>",
+                "subject": "URGENT: Pre-demo call - need 30 min before 2PM",
+                "body": (
+                    "Alex, before today's full demo I need a quick 30-min call with you. "
+                    "Specifically about the competitive landscape - one of your direct competitors "
+                    "just announced a major funding round this morning. I want to hear your positioning "
+                    "before I brief my partners. This is important for the partnership discussion."
+                ),
+                "priority": 5,
+                "urgency": 0.95,
+            },
+            {
+                "id": "e2",
+                "sender": "Sarah Chen <s.chen@novatech.ai>",
+                "subject": "CRITICAL: Architecture review - infra decisions before demo",
+                "body": (
+                    "Alex, I've flagged this twice already - we need a decision on the multi-region "
+                    "architecture BEFORE the demo. Investors will ask about our scaling story. "
+                    "If we say the wrong thing, it'll contradict the technical deck. "
+                    "Need 45 minutes with you today. Can we slot this in the morning?"
+                ),
+                "priority": 5,
+                "urgency": 0.90,
+            },
+            {
+                "id": "e3",
+                "sender": "Rachel Torres <r.torres@novatech.ai>",
+                "subject": "CFO: Runway concern - cash position update",
+                "body": (
+                    "Alex, reviewed our burn rate with the updated headcount projections. "
+                    "We have 8.5 months of runway at current rate, down from 11 months last quarter. "
+                    "Before you take on any new commitments in the investor conversation today, "
+                    "I need to align with you on the bridge financing contingency. Can we connect?"
+                ),
+                "priority": 4,
+                "urgency": 0.80,
+            },
+            {
+                "id": "e4",
+                "sender": "Legal <legal@novatech.ai>",
+                "subject": "NDA with Sequoia - needs signature today",
+                "body": (
+                    "Hi Alex, standard NDA with Sequoia Capital needs your signature before "
+                    "the demo meeting. This is required before we can share our technical roadmap "
+                    "and customer data in the presentation. Please sign via DocuSign - link below. "
+                    "Takes 2 minutes and is legally necessary."
+                ),
+                "priority": 4,
+                "urgency": 0.85,
+            },
+            {
+                "id": "e5",
+                "sender": "Tom Bradley <t.bradley@novatech.ai>",
+                "subject": "Designer needs brand approval for pitch deck",
+                "body": (
+                    "Hey, our external designer has the final pitch deck revisions ready. "
+                    "She needs your approval on the updated brand treatment - specifically the "
+                    "new color palette and logo placement on slides 3, 7, and 12. "
+                    "Can someone on your team give a thumbs up? I can handle if you delegate."
+                ),
+                "priority": 3,
+                "urgency": 0.60,
+            },
+            {
+                "id": "e6",
+                "sender": "Amy Liu <a.liu@novatech.ai>",
+                "subject": "Offer letter approval - senior ML engineer",
+                "body": (
+                    "Alex, I have a verbal offer pending for Dr. James Okafor (senior ML engineer, "
+                    "ex-Google Brain). He has a competing offer from OpenAI and needs our written "
+                    "offer by tomorrow morning. Compensation is within approved bands. "
+                    "Just need your approval to proceed - HR can handle the paperwork."
+                ),
+                "priority": 3,
+                "urgency": 0.65,
+            },
+            {
+                "id": "e7",
+                "sender": "Office Manager <office@novatech.ai>",
+                "subject": "Catering confirmation for demo - allergies list",
+                "body": (
+                    "Hi Alex, just need to confirm the catering order for today's investor visit. "
+                    "We have the standard setup but wanted to check if Sequoia team has dietary restrictions. "
+                    "I'll just go ahead with the usual if I don't hear back. No action needed from you!"
+                ),
+                "priority": 1,
+                "urgency": 0.15,
+            },
+        ],
+        "calendar": [
+            {"time_slot": 1, "title": "Team Standup", "attendee": "Engineering Team", "locked": True},
+            {"time_slot": 4, "title": "Sequoia Demo Presentation", "attendee": "Marcus Williams", "locked": True},
+        ],
+        "goals": [
+            {
+                "id": "g1",
+                "description": "Schedule pre-demo call with Marcus Williams (Sequoia)",
+                "priority": 5,
+                "required_action": "schedule",
+                "target_email_id": "e1",
+            },
+            {
+                "id": "g2",
+                "description": "Address architecture decision with CTO before demo",
+                "priority": 5,
+                "required_action": "reply",
+                "target_email_id": "e2",
+            },
+            {
+                "id": "g3",
+                "description": "Align with CFO on runway and bridge contingency",
+                "priority": 4,
+                "required_action": "delegate",
+                "target_email_id": "e3",
+            },
+            {
+                "id": "g4",
+                "description": "Sign NDA with Sequoia Capital",
+                "priority": 4,
+                "required_action": "reply",
+                "target_email_id": "e4",
+            },
+            {
+                "id": "g5",
+                "description": "Approve offer letter for Dr. James Okafor",
+                "priority": 3,
+                "required_action": "delegate",
+                "target_email_id": "e6",
+            },
+        ],
+    }
+
+
+def get_task_hard() -> Dict[str, Any]:
+    """
+    Series B Crisis Day
+    Cascading crises. Multiple P5 items. Impossible to handle everything perfectly.
+    A great agent scores ~0.65-0.75. Perfect score is intentionally unachievable.
+    max_steps: 8
+
+    DESIGN NOTE: This task is intentionally unsolvable to a perfect score.
+    With 7 goals across 10 emails in only 8 steps, no agent can complete everything.
+    This forces meaningful prioritization decisions - the score reflects *which* crises
+    the agent chose to address, not whether it completed all tasks.
+    A score of 0.65-0.75 represents excellent triage under impossible constraints.
+    """
+    return {
+        "task_id": "hard",
+        "task_name": "Series B Crisis Day",
+        "description": (
+            "Everything is happening at once. Four P5 crises are competing for your "
+            "8 available steps. Ruthless triage is required. You CANNOT handle everything."
+        ),
+        "objective": "Triage 7 competing goals across 10 emails in 8 steps. Prioritize by impact: investor term sheet > DB rollback > PR crisis > GDPR deadline.",
+        "constraints": (
+            "8 steps for 10 emails with 7 goals - mathematically impossible to complete all. "
+            "This is intentional: the task measures ruthless prioritization, not completion rate. "
+            "Perfect score is not achievable by design. Score 0.65-0.75 = excellent performance."
+        ),
+        "success_condition": "Handle the 4 highest-priority P5 goals (investor, DB, PR, GDPR). Score >= 0.65 indicates strong triage.",
+        "max_steps": 8,
+        "start_time_slot": 0,
+        "emails": [
+            {
+                "id": "e1",
+                "sender": "Marcus Williams <m.williams@sequoiacap.com>",
+                "subject": "URGENT: Term sheet - pulling out unless we talk TODAY",
+                "body": (
+                    "Alex, I'm going to be direct. After this morning's news about Vertex AI's "
+                    "competitive product launch, my partners are getting cold feet on NovaTech. "
+                    "I need to speak with you TODAY - before 4PM - to understand your differentiation "
+                    "strategy or we are pulling the $18M term sheet. This is not a negotiating tactic. "
+                    "Please call me immediately: +1-415-555-0142."
+                ),
+                "priority": 5,
+                "urgency": 0.98,
+            },
+            {
+                "id": "e2",
+                "sender": "Sarah Chen <s.chen@novatech.ai>",
+                "subject": "CRITICAL: Production database corruption - customers affected",
+                "body": (
+                    "Alex, we have a P0 incident. PostgreSQL replication lag caused data inconsistency "
+                    "on our primary cluster. 23 enterprise customers are experiencing incorrect API responses. "
+                    "We've isolated the issue but need your authorization to execute the emergency rollback "
+                    "procedure - it will take the platform offline for ~45 minutes. Revenue impact: ~$85K/hour. "
+                    "Awaiting your go-ahead. The longer we wait, the worse the customer impact."
+                ),
+                "priority": 5,
+                "urgency": 0.97,
+            },
+            {
+                "id": "e3",
+                "sender": "Jordan Kim <j.kim@novatech.ai>",
+                "subject": "I'm resigning - effective in 2 weeks",
+                "body": (
+                    "Alex, I've decided to accept an offer at Anthropic. I know the timing is terrible "
+                    "with the Series B, but I need to do what's right for my career. I'll give you a "
+                    "full 2 weeks and do everything I can to transition my work - I'm leading the "
+                    "inference optimization project and the enterprise API roadmap. I'm happy to discuss "
+                    "how to minimize impact. Please let me know when you can talk."
+                ),
+                "priority": 5,
+                "urgency": 0.85,
+            },
+            {
+                "id": "e4",
+                "sender": "PR Crisis Line <pr@novatech.ai>",
+                "subject": "TechCrunch article going live in 2 hours - security breach allegation",
+                "body": (
+                    "Alex - TechCrunch is publishing an article in 2 hours alleging NovaTech had "
+                    "a security breach exposing customer model weights. This appears to be based on "
+                    "a disgruntled former contractor's claims, which are false. However, without a "
+                    "statement from you, they will publish uncontested. We need a quote from the CEO "
+                    "within 90 minutes. Legal is on standby. Please respond immediately."
+                ),
+                "priority": 5,
+                "urgency": 0.96,
+            },
+            {
+                "id": "e5",
+                "sender": "Elena Vasquez <e.vasquez@novatech.ai>",
+                "subject": "Co-founder disagreement - need to resolve before board meeting",
+                "body": (
+                    "Alex, I need to talk before the board meeting Thursday. I fundamentally disagree "
+                    "with the enterprise pivot - I think we're abandoning the developer community that "
+                    "got us here for short-term ARR. I've prepared a counter-proposal. If we can't align, "
+                    "I may need to raise this in front of the board. Can we get 30 minutes this week?"
+                ),
+                "priority": 4,
+                "urgency": 0.70,
+            },
+            {
+                "id": "e6",
+                "sender": "Legal <legal@novatech.ai>",
+                "subject": "GDPR data deletion request - 72-hour deadline expires at 5PM",
+                "body": (
+                    "Alex, we have a GDPR Article 17 data deletion request from EU customer Hoffmann GmbH. "
+                    "The 72-hour response clock expires at 5PM today. Failure to respond opens us to "
+                    "a €20M fine or 4% of annual revenue. Engineering needs your authorization to "
+                    "execute the deletion script in production. This is a legal obligation - not optional."
+                ),
+                "priority": 4,
+                "urgency": 0.92,
+            },
+            {
+                "id": "e7",
+                "sender": "Vendor Relations <vendor@novatech.ai>",
+                "subject": "AWS contract renewal - expires midnight tonight",
+                "body": (
+                    "Alex, our AWS Enterprise Agreement expires tonight at midnight. If we don't renew, "
+                    "we revert to on-demand pricing - cost jumps from $180K/mo to $340K/mo immediately. "
+                    "Procurement needs a signed PO before 6PM. I've reviewed the terms and they're "
+                    "acceptable. Just need your authorization to proceed."
+                ),
+                "priority": 3,
+                "urgency": 0.80,
+            },
+            {
+                "id": "e8",
+                "sender": "BD Team <bd@novatech.ai>",
+                "subject": "Acquisition offer from Microsoft - NDA required to review",
+                "body": (
+                    "Alex, Microsoft's Corp Dev team has reached out about an acquisition conversation. "
+                    "They've indicated interest in the $400-600M range based on public info. "
+                    "They want us to sign an NDA to share more details. I know the timing with Series B "
+                    "is complex, but wanted you to know this exists. Your call on how to proceed."
+                ),
+                "priority": 3,
+                "urgency": 0.40,
+            },
+            {
+                "id": "e9",
+                "sender": "People Ops <hr@novatech.ai>",
+                "subject": "Employee complaint escalation - needs response by EOW",
+                "body": (
+                    "Alex, we've received a formal complaint from two engineers about management practices "
+                    "in the infrastructure team. This has been escalated past the manager level and now "
+                    "requires executive acknowledgment. I can handle the investigation entirely - "
+                    "just need you to sign off that it's being addressed officially. No urgency today."
+                ),
+                "priority": 2,
+                "urgency": 0.30,
+            },
+            {
+                "id": "e10",
+                "sender": "Office Manager <office@novatech.ai>",
+                "subject": "Office lease renewal - decision needed this month",
+                "body": (
+                    "Hi Alex, our SF office lease is up for renewal in 6 weeks. Landlord wants a "
+                    "decision on whether we're renewing (3-year term, 8% increase) or vacating. "
+                    "With the Series B timeline, I'm not sure what our headcount plans are. "
+                    "Can we schedule time this week to discuss? No rush today."
+                ),
+                "priority": 1,
+                "urgency": 0.10,
+            },
+        ],
+        "calendar": [
+            {"time_slot": 1, "title": "Incident Review (P0)", "attendee": "Engineering", "locked": True},
+            {"time_slot": 3, "title": "Investor Check-in", "attendee": "Marcus Williams", "locked": True},
+            {"time_slot": 5, "title": "Board Prep Call", "attendee": "Board", "locked": True},
+        ],
+        "goals": [
+            {
+                "id": "g1",
+                "description": "Respond to Sequoia investor to save the $18M term sheet",
+                "priority": 5,
+                "required_action": "reply",
+                "target_email_id": "e1",
+            },
+            {
+                "id": "g2",
+                "description": "Authorize emergency DB rollback to stop customer impact",
+                "priority": 5,
+                "required_action": "reply",
+                "target_email_id": "e2",
+            },
+            {
+                "id": "g3",
+                "description": "Provide PR statement to stop TechCrunch breach article",
+                "priority": 5,
+                "required_action": "reply",
+                "target_email_id": "e4",
+            },
+            {
+                "id": "g4",
+                "description": "Authorize GDPR deletion before 5PM legal deadline",
+                "priority": 4,
+                "required_action": "reply",
+                "target_email_id": "e6",
+            },
+            {
+                "id": "g5",
+                "description": "Authorize AWS contract renewal before midnight",
+                "priority": 3,
+                "required_action": "delegate",
+                "target_email_id": "e7",
+            },
+            {
+                "id": "g6",
+                "description": "Acknowledge co-founder disagreement before board meeting",
+                "priority": 4,
+                "required_action": "schedule",
+                "target_email_id": "e5",
+            },
+            {
+                "id": "g7",
+                "description": "Respond to key engineer resignation",
+                "priority": 5,
+                "required_action": "reply",
+                "target_email_id": "e3",
+            },
+        ],
+    }
+
+
+TASKS = {
+    "easy": get_task_easy,
+    "medium": get_task_medium,
+    "hard": get_task_hard,
+}
+
+
+def get_task(task_id: str) -> Dict[str, Any]:
+    if task_id not in TASKS:
+        raise ValueError(f"Unknown task: {task_id}. Valid: {list(TASKS.keys())}")
+    return TASKS[task_id]()

frontend/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "exec-ops-dashboard",
+  "version": "1.0.0",
+  "private": true,
+  "dependencies": {
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "react-scripts": "5.0.1"
+  },
+  "scripts": {
+    "start": "react-scripts start",
+    "build": "react-scripts build",
+    "test": "react-scripts test"
+  },
+  "eslintConfig": {
+    "extends": ["react-app"]
+  },
+  "browserslist": {
+    "production": [">0.2%", "not dead", "not op_mini all"],
+    "development": ["last 1 chrome version", "last 1 firefox version", "last 1 safari version"]
+  }
+}

frontend/public/index.html

@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta name="theme-color" content="#0f172a" />
+    <meta name="description" content="AI Executive Operations Manager — CEO Simulation Dashboard" />
+    <title>AI Exec Ops Manager</title>
+    <style>
+      body { margin: 0; background: #0f172a; }
+      #root { min-height: 100vh; }
+    </style>
+  </head>
+  <body>
+    <noscript>You need to enable JavaScript to run this app.</noscript>
+    <div id="root"></div>
+  </body>
+</html>

frontend/src/App.css

@@ -0,0 +1,504 @@
+/* =====================================================
+   AI Executive Operations Manager — Dark Executive Theme
+   ===================================================== */
+
+*, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+
+:root {
+  --bg:           #0b1120;
+  --bg2:          #0f172a;
+  --panel-bg:     #1a2540;
+  --panel-border: #2d3f5e;
+  --text-primary: #f1f5f9;
+  --text-secondary: #94a3b8;
+  --text-muted:   #4b6180;
+  --accent:       #3b82f6;
+  --success:      #22c55e;
+  --warning:      #f59e0b;
+  --danger:       #ef4444;
+  --purple:       #8b5cf6;
+  --orange:       #f97316;
+}
+
+html, body, #root {
+  height: 100%;
+  background: var(--bg);
+  color: var(--text-primary);
+  font-family: 'Segoe UI', system-ui, -apple-system, sans-serif;
+  font-size: 14px;
+  line-height: 1.5;
+}
+
+/* ─── Scrollbars ──────────────────────────────────── */
+::-webkit-scrollbar { width: 5px; height: 5px; }
+::-webkit-scrollbar-track { background: transparent; }
+::-webkit-scrollbar-thumb { background: rgba(148,163,184,0.18); border-radius: 3px; }
+::-webkit-scrollbar-thumb:hover { background: rgba(148,163,184,0.32); }
+
+/* ─── Loading ─────────────────────────────────────── */
+.loading-screen {
+  display: flex; flex-direction: column; align-items: center;
+  justify-content: center; height: 100vh; gap: 18px;
+  color: var(--text-secondary);
+  background: radial-gradient(ellipse at center, #0f1e38 0%, var(--bg) 70%);
+}
+.loading-spinner {
+  width: 44px; height: 44px;
+  border: 3px solid rgba(59,130,246,0.15);
+  border-top-color: var(--accent);
+  border-radius: 50%;
+  animation: spin 0.75s linear infinite;
+}
+@keyframes spin { to { transform: rotate(360deg); } }
+.loading-text { font-size: 15px; letter-spacing: 0.06em; color: var(--text-secondary); }
+
+/* ─── App layout ──────────────────────────────────── */
+.app {
+  display: flex; flex-direction: column;
+  min-height: 100vh; background: var(--bg);
+}
+.app--autorunning { --panel-border: #2d4a7a; }
+.app--autorunning .panel { box-shadow: 0 0 0 1px rgba(59,130,246,0.12); }
+
+.main-grid {
+  display: grid;
+  grid-template-columns: 1fr 290px 270px;
+  gap: 8px;
+  padding: 8px;
+  flex: 1;
+  min-height: 0;
+}
+.left-col, .center-col, .right-col {
+  display: flex; flex-direction: column; gap: 8px; min-width: 0;
+}
+.bottom-row {
+  padding: 0 8px 8px;
+  height: 230px;
+  flex-shrink: 0;
+}
+
+/* ─── Panel base ──────────────────────────────────── */
+.panel {
+  background: var(--panel-bg);
+  border: 1px solid var(--panel-border);
+  border-radius: 10px;
+  display: flex; flex-direction: column;
+  overflow: hidden;
+  transition: border-color 0.3s, box-shadow 0.3s;
+}
+.panel-header {
+  display: flex; align-items: center; justify-content: space-between;
+  padding: 10px 14px;
+  border-bottom: 1px solid var(--panel-border);
+  flex-shrink: 0;
+  background: rgba(255,255,255,0.018);
+}
+.panel-title {
+  font-size: 11px; font-weight: 700; letter-spacing: 0.08em;
+  text-transform: uppercase; color: var(--text-secondary);
+}
+.panel-badge {
+  font-size: 11px; background: rgba(148,163,184,0.1);
+  color: var(--text-secondary); padding: 2px 9px;
+  border-radius: 100px; border: 1px solid rgba(148,163,184,0.12);
+}
+
+/* ─── Simulation controls (top bar) ──────────────── */
+.sim-controls {
+  display: flex; align-items: center; justify-content: space-between;
+  padding: 10px 18px;
+  background: linear-gradient(180deg, #101d36 0%, #0d1829 100%);
+  border-bottom: 1px solid #1e3352;
+  gap: 20px; flex-shrink: 0;
+  box-shadow: 0 2px 12px rgba(0,0,0,0.4);
+}
+.sim-controls-left  { display: flex; align-items: center; gap: 14px; }
+.sim-controls-center { display: flex; align-items: center; gap: 28px; }
+.sim-controls-right { display: flex; align-items: center; gap: 16px; }
+
+.brand { display: flex; align-items: center; gap: 9px; }
+.brand-icon { font-size: 20px; filter: drop-shadow(0 0 6px rgba(59,130,246,0.7)); }
+.brand-text { display: flex; flex-direction: column; }
+.brand-name { font-size: 15px; font-weight: 800; color: var(--text-primary); letter-spacing: -0.01em; line-height: 1.1; }
+.brand-sub  { font-size: 10px; color: var(--text-muted); letter-spacing: 0.05em; text-transform: uppercase; }
+
+.divider-v { width: 1px; height: 28px; background: var(--panel-border); }
+
+.task-select {
+  background: rgba(15,23,42,0.7);
+  border: 1px solid var(--panel-border);
+  color: var(--text-primary);
+  border-radius: 7px; padding: 6px 11px;
+  font-size: 13px; cursor: pointer; outline: none;
+  transition: border-color 0.2s;
+}
+.task-select:hover:not(:disabled) { border-color: var(--accent); }
+.task-select option { background: #1a2540; }
+
+.btn {
+  border: none; border-radius: 7px; padding: 7px 14px;
+  font-size: 12px; font-weight: 600; cursor: pointer;
+  transition: all 0.15s; font-family: inherit;
+}
+.btn:disabled { opacity: 0.38; cursor: not-allowed; }
+.btn-reset {
+  background: rgba(59,130,246,0.1); color: #93c5fd;
+  border: 1px solid rgba(59,130,246,0.25);
+}
+.btn-reset:hover:not(:disabled) { background: rgba(59,130,246,0.2); border-color: rgba(59,130,246,0.5); }
+
+/* stat blocks */
+.stat-label {
+  font-size: 9px; letter-spacing: 0.12em;
+  color: var(--text-muted); text-transform: uppercase;
+  display: block; margin-bottom: 3px;
+}
+
+.time-display { display: flex; flex-direction: column; align-items: center; }
+.time-value {
+  font-size: 22px; font-weight: 800; color: var(--text-primary);
+  font-variant-numeric: tabular-nums; letter-spacing: -0.02em; line-height: 1;
+}
+
+.step-display { display: flex; flex-direction: column; align-items: center; gap: 4px; }
+.step-value { font-size: 14px; font-weight: 700; color: var(--text-secondary); font-variant-numeric: tabular-nums; }
+.step-sep { color: var(--text-muted); }
+.step-bar { width: 90px; height: 3px; background: rgba(255,255,255,0.07); border-radius: 2px; overflow: hidden; }
+.step-bar-fill { height: 100%; border-radius: 2px; transition: width 0.5s ease; }
+
+.reward-display { display: flex; flex-direction: column; align-items: center; }
+.reward-value {
+  font-size: 18px; font-weight: 800;
+  font-variant-numeric: tabular-nums; line-height: 1;
+  transition: color 0.4s;
+}
+
+/* speed group */
+.speed-group { display: flex; flex-direction: column; align-items: center; }
+.speed-btns { display: flex; gap: 3px; }
+.speed-btn {
+  padding: 4px 10px; font-size: 11px; font-weight: 600;
+  background: rgba(255,255,255,0.05); border: 1px solid rgba(255,255,255,0.1);
+  color: var(--text-muted); border-radius: 5px; cursor: pointer;
+  transition: all 0.15s; font-family: inherit;
+}
+.speed-btn:hover:not(:disabled) { background: rgba(59,130,246,0.15); color: #93c5fd; border-color: rgba(59,130,246,0.3); }
+.speed-btn.active { background: rgba(59,130,246,0.2); color: var(--accent); border-color: rgba(59,130,246,0.5); }
+.speed-btn:disabled { opacity: 0.35; cursor: not-allowed; }
+
+/* auto-run button */
+.btn-autorun {
+  display: flex; align-items: center; gap: 8px;
+  padding: 9px 20px; border-radius: 8px; cursor: pointer;
+  font-size: 13px; font-weight: 700; font-family: inherit;
+  border: none; transition: all 0.2s;
+  background: linear-gradient(135deg, #1d4ed8, #2563eb);
+  color: #fff;
+  box-shadow: 0 2px 12px rgba(37,99,235,0.4);
+}
+.btn-autorun:hover:not(:disabled) {
+  background: linear-gradient(135deg, #2563eb, #3b82f6);
+  box-shadow: 0 4px 20px rgba(59,130,246,0.5);
+  transform: translateY(-1px);
+}
+.btn-autorun:active:not(:disabled) { transform: translateY(0); }
+.btn-autorun.running {
+  background: linear-gradient(135deg, #991b1b, #dc2626);
+  box-shadow: 0 2px 12px rgba(220,38,38,0.4);
+  animation: pulse-run 1.8s ease-in-out infinite;
+}
+.btn-autorun.running:hover {
+  background: linear-gradient(135deg, #dc2626, #ef4444);
+  box-shadow: 0 4px 20px rgba(239,68,68,0.5);
+}
+.btn-autorun:disabled { opacity: 0.4; cursor: not-allowed; transform: none; }
+@keyframes pulse-run {
+  0%, 100% { box-shadow: 0 2px 12px rgba(220,38,38,0.4); }
+  50%       { box-shadow: 0 2px 24px rgba(220,38,38,0.7); }
+}
+.autorun-icon { font-size: 12px; }
+
+/* status badge */
+.status-badge {
+  font-size: 11px; font-weight: 700; padding: 5px 11px;
+  border-radius: 100px; letter-spacing: 0.05em;
+  white-space: nowrap;
+}
+.status-badge.active { background: rgba(34,197,94,0.1); color: #86efac; border: 1px solid rgba(34,197,94,0.2); }
+.status-badge.done   { background: rgba(59,130,246,0.1); color: #93c5fd; border: 1px solid rgba(59,130,246,0.2); }
+.status-badge.auto   {
+  background: rgba(59,130,246,0.15); color: var(--accent);
+  border: 1px solid rgba(59,130,246,0.35);
+  animation: badge-pulse 1.5s ease-in-out infinite;
+}
+@keyframes badge-pulse {
+  0%, 100% { opacity: 1; }
+  50%       { opacity: 0.65; }
+}
+
+/* ─── Inbox panel ─────────────────────────────────── */
+.inbox-panel { flex: 1; min-height: 0; }
+.email-list {
+  flex: 1; overflow-y: auto; padding: 8px;
+  display: flex; flex-direction: column; gap: 6px;
+}
+.email-card {
+  border-radius: 8px; padding: 11px 13px;
+  transition: all 0.2s; cursor: pointer;
+  animation: fadeSlideIn 0.3s ease both;
+}
+@keyframes fadeSlideIn {
+  from { opacity: 0; transform: translateY(-5px); }
+  to   { opacity: 1; transform: translateY(0); }
+}
+.email-card:hover:not(.handled):not(.no-pointer) { filter: brightness(1.12); transform: translateX(2px); }
+.email-card.selected { outline: 2px solid rgba(59,130,246,0.6); outline-offset: -1px; }
+.email-card.handled  { opacity: 0.45; cursor: default; }
+.email-card.no-pointer { cursor: default; }
+
+.email-card.ai-focus {
+  outline: 2px solid rgba(59,130,246,0.8);
+  box-shadow: 0 0 18px rgba(59,130,246,0.25);
+  animation: ai-selecting 0.5s ease;
+}
+@keyframes ai-selecting {
+  0%   { box-shadow: 0 0 0 rgba(59,130,246,0); }
+  50%  { box-shadow: 0 0 24px rgba(59,130,246,0.45); }
+  100% { box-shadow: 0 0 18px rgba(59,130,246,0.25); }
+}
+
+.email-header   { display: flex; align-items: center; justify-content: space-between; margin-bottom: 5px; }
+.email-meta     { display: flex; align-items: center; gap: 6px; }
+
+.priority-badge {
+  font-size: 10px; font-weight: 800; padding: 2px 8px;
+  border-radius: 100px; letter-spacing: 0.05em;
+}
+.action-taken-badge {
+  font-size: 10px; color: var(--text-muted);
+  background: rgba(148,163,184,0.08); padding: 2px 7px; border-radius: 100px;
+}
+.handled-check { color: var(--success); font-size: 15px; }
+
+.urgency-ring-wrapper {
+  position: relative; width: 38px; height: 38px;
+  display: flex; align-items: center; justify-content: center; flex-shrink: 0;
+}
+.urgency-pct {
+  position: absolute; font-size: 9px; font-weight: 800;
+  font-variant-numeric: tabular-nums;
+}
+.email-sender  { font-size: 12px; font-weight: 700; margin-bottom: 2px; }
+.email-subject { font-size: 13px; line-height: 1.4; }
+.email-body {
+  margin-top: 9px; font-size: 12px; color: var(--text-secondary);
+  line-height: 1.6; border-top: 1px solid rgba(148,163,184,0.12);
+  padding-top: 9px; animation: fadeSlideIn 0.2s ease;
+}
+
+/* ─── Action panel ────────────────────────────────── */
+.action-panel { flex-shrink: 0; }
+.selected-email-preview {
+  padding: 11px 14px; border-bottom: 1px solid var(--panel-border);
+}
+.selected-label { font-size: 9px; letter-spacing: 0.1em; color: var(--text-muted); text-transform: uppercase; margin-bottom: 4px; }
+.selected-subject { font-size: 13px; font-weight: 700; color: var(--text-primary); line-height: 1.3; margin-bottom: 2px; }
+.selected-sender  { font-size: 11px; color: var(--text-secondary); }
+
+.no-selection {
+  display: flex; flex-direction: column; align-items: center;
+  justify-content: center; padding: 18px 14px; gap: 7px;
+  color: var(--text-muted); text-align: center; font-size: 13px;
+  line-height: 1.6; border-bottom: 1px solid var(--panel-border);
+}
+.no-selection-icon { font-size: 22px; }
+
+.action-buttons { display: flex; flex-direction: column; gap: 6px; padding: 8px; }
+.action-btn {
+  display: flex; align-items: center; gap: 11px;
+  padding: 11px 13px; border-radius: 7px; border: 1px solid;
+  transition: all 0.15s; font-family: inherit; cursor: pointer;
+}
+.action-btn-icon  { font-size: 17px; flex-shrink: 0; width: 22px; text-align: center; }
+.action-btn-text  { display: flex; flex-direction: column; align-items: flex-start; }
+.action-btn-label { font-size: 13px; font-weight: 700; }
+.action-btn-desc  { font-size: 10px; opacity: 0.65; }
+.action-btn.active { animation: btn-pulse 0.28s ease; }
+@keyframes btn-pulse {
+  0%   { transform: scale(1); }
+  40%  { transform: scale(0.94); }
+  100% { transform: scale(1); }
+}
+.done-overlay {
+  display: flex; flex-direction: column; align-items: center;
+  padding: 14px; gap: 5px;
+  background: rgba(34,197,94,0.07); border-top: 1px solid rgba(34,197,94,0.2);
+}
+.done-icon { font-size: 22px; color: var(--success); }
+.done-text { font-size: 12px; color: var(--success); font-weight: 700; }
+
+/* ─── Calendar panel ──────────────────────────────── */
+.calendar-panel  { flex-shrink: 0; }
+.calendar-list   { padding: 8px; display: flex; flex-direction: column; gap: 4px; }
+.calendar-event  {
+  display: flex; align-items: center; gap: 8px;
+  padding: 7px 10px; border-radius: 6px; font-size: 12px;
+}
+.calendar-event.locked    { background: rgba(239,68,68,0.08);  border: 1px solid rgba(239,68,68,0.2); }
+.calendar-event.scheduled { background: rgba(139,92,246,0.08); border: 1px solid rgba(139,92,246,0.2); }
+.cal-time   { color: var(--text-muted); font-size: 10px; min-width: 44px; }
+.cal-title  { flex: 1; color: var(--text-secondary); font-size: 11px; }
+.cal-locked { font-size: 10px; }
+
+/* ─── Score panel ─────────────────────────────────── */
+.score-panel      { flex: 1; overflow-y: auto; min-height: 0; }
+.score-section    {
+  display: flex; align-items: center; gap: 14px;
+  padding: 13px 14px; border-bottom: 1px solid var(--panel-border);
+}
+.score-gauge {
+  position: relative; flex-shrink: 0;
+  display: flex; align-items: center; justify-content: center;
+}
+.score-gauge-text {
+  position: absolute;
+  display: flex; flex-direction: column; align-items: center;
+}
+.score-value      { font-size: 22px; font-weight: 900; font-variant-numeric: tabular-nums; }
+.score-pct-label  { font-size: 9px; color: var(--text-muted); }
+.score-meta       { display: flex; flex-direction: column; gap: 5px; }
+.score-label-main { font-size: 9px; letter-spacing: 0.1em; color: var(--text-muted); text-transform: uppercase; }
+.score-completion { font-size: 14px; font-weight: 700; color: var(--text-primary); }
+
+.completion-bar-wrapper { display: flex; align-items: center; gap: 7px; }
+.completion-bar { width: 84px; height: 5px; background: rgba(255,255,255,0.07); border-radius: 3px; overflow: hidden; }
+.completion-bar-fill { height: 100%; border-radius: 3px; transition: width 0.6s ease; }
+.completion-pct { font-size: 11px; color: var(--text-muted); font-variant-numeric: tabular-nums; }
+
+.goals-list   { padding: 8px; display: flex; flex-direction: column; gap: 4px; }
+.goals-header {
+  font-size: 9px; letter-spacing: 0.1em; color: var(--text-muted);
+  text-transform: uppercase; margin-bottom: 3px; padding: 0 6px;
+}
+.goal-item {
+  display: flex; align-items: flex-start; gap: 9px;
+  padding: 8px 9px; border-radius: 7px;
+  background: rgba(255,255,255,0.025); transition: all 0.35s;
+}
+.goal-item.goal-done { background: rgba(34,197,94,0.06); }
+.goal-checkbox {
+  width: 17px; height: 17px; border-radius: 4px; border: 2px solid;
+  flex-shrink: 0; margin-top: 1px;
+  display: flex; align-items: center; justify-content: center; transition: all 0.3s;
+}
+.goal-check   { font-size: 10px; color: #fff; font-weight: 900; }
+.goal-text    { display: flex; flex-direction: column; gap: 2px; }
+.goal-desc    { font-size: 11px; line-height: 1.45; transition: color 0.3s; }
+.goal-priority-tag { font-size: 10px; font-weight: 700; }
+
+.final-score-banner {
+  margin: 10px; padding: 14px; border-radius: 8px; border: 1px solid;
+  display: flex; flex-direction: column; align-items: center; gap: 5px;
+  animation: fadeSlideIn 0.5s ease;
+}
+.final-score-title { font-size: 14px; font-weight: 700; color: var(--text-primary); }
+.final-score-num   { font-size: 28px; font-weight: 900; font-variant-numeric: tabular-nums; }
+
+/* ─── Timeline panel ──────────────────────────────── */
+.timeline-panel { height: 100%; }
+
+.timeline-scroll {
+  flex: 1; overflow-x: auto; overflow-y: hidden;
+  padding: 10px 14px 10px;
+  display: flex; align-items: flex-start;
+}
+
+.timeline-empty {
+  display: flex; align-items: center; gap: 10px;
+  color: var(--text-muted); font-size: 13px;
+  width: 100%; justify-content: center; padding: 16px 0;
+}
+.timeline-empty-icon { font-size: 20px; }
+
+.timeline-track {
+  display: flex; align-items: flex-start; gap: 0;
+  position: relative; padding-bottom: 4px;
+}
+
+.timeline-entry {
+  display: flex; align-items: flex-start; flex-shrink: 0;
+  animation: fadeSlideIn 0.3s ease both;
+}
+.timeline-entry.latest .timeline-card {
+  border-color: rgba(59,130,246,0.5);
+  box-shadow: 0 0 12px rgba(59,130,246,0.15);
+}
+
+.timeline-line {
+  width: 20px; height: 2px;
+  align-self: center; flex-shrink: 0; margin-top: -38px;
+  border-radius: 1px;
+}
+
+.timeline-step {
+  width: 24px; height: 24px; border-radius: 50%;
+  display: flex; align-items: center; justify-content: center;
+  font-size: 11px; font-weight: 800; color: #fff;
+  flex-shrink: 0; align-self: flex-start; margin-top: 8px;
+  box-shadow: 0 2px 8px rgba(0,0,0,0.4);
+  z-index: 1;
+}
+
+.timeline-card {
+  background: rgba(255,255,255,0.04);
+  border: 1px solid var(--panel-border);
+  border-radius: 7px; padding: 8px 11px;
+  min-width: 170px; max-width: 210px;
+  margin-left: 6px; flex-shrink: 0;
+}
+.timeline-card-top {
+  display: flex; align-items: center; gap: 6px;
+  margin-bottom: 5px; flex-wrap: wrap;
+}
+.tl-time   { font-size: 10px; color: var(--text-muted); }
+.tl-action { font-size: 12px; font-weight: 700; }
+.tl-reward { font-size: 12px; font-weight: 800; margin-left: auto; font-variant-numeric: tabular-nums; }
+.timeline-card-body {
+  display: flex; align-items: flex-start; gap: 6px;
+}
+.tl-dot    { width: 7px; height: 7px; border-radius: 50%; flex-shrink: 0; margin-top: 4px; }
+.tl-subject { font-size: 11px; color: var(--text-secondary); line-height: 1.4; }
+
+/* ─── Reward popups ───────────────────────────────── */
+.reward-popups {
+  position: fixed; top: 82px; right: 20px;
+  display: flex; flex-direction: column; gap: 6px;
+  z-index: 1000; pointer-events: none;
+}
+.reward-popup {
+  display: flex; flex-direction: column; align-items: flex-end;
+  background: rgba(26,37,64,0.96);
+  border: 1px solid var(--panel-border);
+  border-radius: 9px; padding: 9px 15px;
+  animation: floatUp 2.2s ease forwards;
+  box-shadow: 0 6px 24px rgba(0,0,0,0.5);
+  backdrop-filter: blur(8px);
+}
+@keyframes floatUp {
+  0%   { opacity: 0; transform: translateY(8px) scale(0.92); }
+  18%  { opacity: 1; transform: translateY(0)   scale(1); }
+  72%  { opacity: 1; transform: translateY(-12px); }
+  100% { opacity: 0; transform: translateY(-22px); }
+}
+.popup-reward { font-size: 20px; font-weight: 900; font-variant-numeric: tabular-nums; line-height: 1; }
+.reward-popup.positive .popup-reward { color: var(--success); }
+.reward-popup.negative .popup-reward { color: var(--danger); }
+.popup-label  { font-size: 10px; color: var(--text-muted); max-width: 160px; text-align: right; margin-top: 2px; }
+
+/* ─── Error banner ────────────────────────────────── */
+.error-banner {
+  background: rgba(239,68,68,0.12); border-bottom: 1px solid rgba(239,68,68,0.25);
+  color: #fca5a5; padding: 9px 18px;
+  display: flex; align-items: center; justify-content: space-between; font-size: 13px;
+}
+.error-banner button { background: none; border: none; color: #fca5a5; cursor: pointer; font-size: 15px; padding: 0 4px; }

frontend/src/App.js

@@ -0,0 +1,289 @@
+import React, { useState, useEffect, useCallback, useRef } from 'react';
+import './App.css';
+import SimulationControls from './components/SimulationControls';
+import InboxPanel from './components/InboxPanel';
+import ActionPanel from './components/ActionPanel';
+import TimelinePanel from './components/TimelinePanel';
+import ScorePanel from './components/ScorePanel';
+import { resetEnv, stepEnv, getGrade } from './api';
+
+const STEP_DELAY = 1400; // ~0.5× — realistic LLM response cadence
+
+/* Greedy agent: match pending goals first, then highest priority*urgency */
+function pickBestAction(obs) {
+  if (!obs) return null;
+  const unhandled = (obs.inbox || []).filter(e => !e.handled);
+  if (!unhandled.length) return null;
+
+  const pendingGoals = [...(obs.pending_goals || [])].sort((a, b) => b.priority - a.priority);
+  for (const goal of pendingGoals) {
+    const email = unhandled.find(e => e.id === goal.target_email_id);
+    if (email) return { type: goal.required_action, email_id: email.id };
+  }
+
+  const best = [...unhandled].sort(
+    (a, b) => b.priority * b.urgency - a.priority * a.urgency
+  )[0];
+  return { type: best.priority <= 2 ? 'delegate' : 'reply', email_id: best.id };
+}
+
+const sleep = ms => new Promise(r => setTimeout(r, ms));
+
+export default function App() {
+  const [obs, setObs]               = useState(null);
+  const [history, setHistory]       = useState([]);
+  const [selectedEmail, setSelectedEmail] = useState(null);
+  const [taskId, setTaskId]         = useState('easy');
+  const [score, setScore]           = useState(0);
+  const [loading, setLoading]       = useState(false);
+  const [error, setError]           = useState(null);
+  const [isAutoRunning, setIsAutoRunning] = useState(false);
+  const [rewardPopups, setRewardPopups] = useState([]);
+  const [firstLoad, setFirstLoad]   = useState(true); // eslint-disable-line no-unused-vars
+
+  const obsRef        = useRef(obs);
+  const autoRunRef    = useRef(false);
+  const popupIdRef    = useRef(0);
+
+  useEffect(() => { obsRef.current = obs; }, [obs]);
+
+  /* ── helpers ─────────────────────────────────────── */
+  const showRewardPopup = (reward, subject) => {
+    const id = ++popupIdRef.current;
+    setRewardPopups(prev => [...prev.slice(-4), { id, reward, label: subject?.slice(0, 32) }]);
+    setTimeout(() => setRewardPopups(prev => prev.filter(p => p.id !== id)), 2200);
+  };
+
+  /* ── reset ───────────────────────────────────────── */
+  const handleReset = useCallback(async (task = taskId) => {
+    autoRunRef.current = false;
+    setIsAutoRunning(false);
+    setLoading(true);
+    setError(null);
+    try {
+      const fresh = await resetEnv(task);
+      setObs(fresh);
+      setHistory([]);
+      setSelectedEmail(null);
+      setScore(0);
+      setRewardPopups([]);
+      setFirstLoad(false);
+    } catch {
+      setError('Cannot connect to server.');
+    } finally {
+      setLoading(false);
+    }
+  }, [taskId]);
+
+  const handleTaskChange = useCallback((t) => {
+    setTaskId(t);
+    handleReset(t);
+  }, [handleReset]);
+
+  useEffect(() => { handleReset('easy'); }, []); // eslint-disable-line
+
+  /* ── single step (returns new obs or null) ────────── */
+  const executeStep = useCallback(async (action, currentObs) => {
+    try {
+      const result = await stepEnv(action);
+      const newObs = result.observation || result;
+      if (!('done' in newObs)) newObs.done = result.done ?? false;
+
+      const entry = {
+        step:           currentObs.step ?? 0,
+        time:           currentObs.time,
+        action:         action.type,
+        email_id:       action.email_id,
+        email_subject:  result.info?.email_subject ?? action.email_id,
+        email_priority: (currentObs.inbox || []).find(e => e.id === action.email_id)?.priority,
+        reward:         result.reward ?? 0,
+      };
+
+      setObs(newObs);
+      setHistory(h => [...h, entry]);
+      showRewardPopup(result.reward, entry.email_subject);
+
+      if (newObs.done) {
+        const g = await getGrade().catch(() => null);
+        if (g) setScore(g.score);
+      }
+
+      return newObs;
+    } catch (e) {
+      setError(e?.detail || 'Step failed.');
+      return null;
+    }
+  }, []);
+
+  /* ── manual action ────────────────────────────────── */
+  const handleAction = useCallback(async (action) => {
+    if (!obs || obs.done || loading || isAutoRunning) return;
+    setLoading(true);
+    setError(null);
+    await executeStep(action, obs);
+    setSelectedEmail(null);
+    setLoading(false);
+  }, [obs, loading, isAutoRunning, executeStep]);
+
+  /* ── auto-run ─────────────────────────────────────── */
+  const handleAutoRun = useCallback(async () => {
+    if (autoRunRef.current) {
+      autoRunRef.current = false;
+      setIsAutoRunning(false);
+      return;
+    }
+
+    autoRunRef.current = true;
+    setIsAutoRunning(true);
+    setError(null);
+
+
+    let current = obsRef.current;
+
+    // Auto-reset if episode already finished
+    if (current?.done) {
+      setLoading(true);
+      try {
+        const fresh = await resetEnv(taskId);
+        setObs(fresh);
+        setHistory([]);
+        setScore(0);
+        setRewardPopups([]);
+        setSelectedEmail(null);
+        obsRef.current = fresh;
+        current = fresh;
+        await sleep(600);
+      } finally {
+        setLoading(false);
+      }
+    }
+
+    while (autoRunRef.current && current && !current.done) {
+      const action = pickBestAction(current);
+      if (!action) break;
+
+      // Highlight email briefly — looks like AI "thinking"
+      const email = (current.inbox || []).find(e => e.id === action.email_id);
+      if (email) {
+        setSelectedEmail(email);
+        await sleep(STEP_DELAY * 0.4);
+      }
+      if (!autoRunRef.current) break;
+
+      current = await executeStep(action, current);
+      if (!current) break;
+
+      setSelectedEmail(null);
+      await sleep(STEP_DELAY * 0.6);
+    }
+
+    autoRunRef.current = false;
+    setIsAutoRunning(false);
+    setSelectedEmail(null);
+  }, [taskId, executeStep]);
+
+  /* ── render ───────────────────────────────────────── */
+  if (!obs && !error) {
+    return (
+      <div className="loading-screen">
+        <div className="loading-spinner" />
+        <div className="loading-text">Initializing NovaTech AI — CEO Simulation</div>
+      </div>
+    );
+  }
+
+  const inbox    = obs?.inbox    || [];
+  const goals    = obs?.goals    || [];
+  const calendar = obs?.calendar || [];
+
+  return (
+    <div className={`app ${isAutoRunning ? 'app--autorunning' : ''}`}>
+
+      {/* Floating reward popups */}
+      <div className="reward-popups">
+        {rewardPopups.map(p => (
+          <div key={p.id} className={`reward-popup ${p.reward >= 0 ? 'positive' : 'negative'}`}>
+            <span className="popup-reward">{p.reward >= 0 ? '+' : ''}{p.reward.toFixed(3)}</span>
+            <span className="popup-label">{p.label}</span>
+          </div>
+        ))}
+      </div>
+
+      {error && (
+        <div className="error-banner">
+          ⚠ {error}
+          <button onClick={() => setError(null)}>✕</button>
+        </div>
+      )}
+
+      <SimulationControls
+        taskId={taskId}
+        currentTime={obs?.time || '9:00 AM'}
+        currentStep={obs?.step || 0}
+        maxSteps={obs?.max_steps || 6}
+        totalReward={obs?.total_reward || 0}
+        done={obs?.done || false}
+        taskName={obs?.task_name || ''}
+        onReset={() => handleReset(taskId)}
+        onTaskChange={handleTaskChange}
+        loading={loading}
+        isAutoRunning={isAutoRunning}
+        onAutoRun={handleAutoRun}
+      />
+
+      <div className="main-grid">
+        <div className="left-col">
+          <InboxPanel
+            emails={inbox}
+            selectedEmailId={selectedEmail?.id}
+            onSelect={setSelectedEmail}
+            isAutoRunning={isAutoRunning}
+          />
+        </div>
+
+        <div className="center-col">
+          <ActionPanel
+            selectedEmail={selectedEmail}
+            onAction={handleAction}
+            done={obs?.done || false}
+            loading={loading || isAutoRunning}
+          />
+
+          {calendar.length > 0 && (
+            <div className="panel calendar-panel">
+              <div className="panel-header">
+                <span className="panel-title">📅 Calendar</span>
+              </div>
+              <div className="calendar-list">
+                {[...calendar]
+                  .sort((a, b) => a.time_slot - b.time_slot)
+                  .map((ev, i) => (
+                    <div key={i} className={`calendar-event ${ev.locked ? 'locked' : 'scheduled'}`}>
+                      <span className="cal-time">Slot {ev.time_slot + 1}</span>
+                      <span className="cal-title">{ev.title}</span>
+                      {ev.locked && <span className="cal-locked">🔒</span>}
+                    </div>
+                  ))}
+              </div>
+            </div>
+          )}
+        </div>
+
+        <div className="right-col">
+          <ScorePanel
+            goals={goals}
+            score={score}
+            done={obs?.done || false}
+            totalReward={obs?.total_reward || 0}
+            currentStep={obs?.step || 0}
+            maxSteps={obs?.max_steps || 6}
+          />
+        </div>
+      </div>
+
+      <div className="bottom-row">
+        <TimelinePanel history={history} />
+      </div>
+    </div>
+  );
+}

frontend/src/api.js

@@ -0,0 +1,23 @@
+const BASE = '';  // Same origin — FastAPI serves both API and frontend
+
+export const resetEnv = (task = 'easy') =>
+  fetch(`${BASE}/reset?task=${task}`).then(r => r.json());
+
+export const stepEnv = (action) =>
+  fetch(`${BASE}/step`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(action),
+  }).then(r => {
+    if (!r.ok) return r.json().then(e => Promise.reject(e));
+    return r.json();
+  });
+
+export const getState = () =>
+  fetch(`${BASE}/state`).then(r => r.json());
+
+export const getGrade = () =>
+  fetch(`${BASE}/grade`).then(r => r.json());
+
+export const getTasks = () =>
+  fetch(`${BASE}/tasks`).then(r => r.json());

frontend/src/components/ActionPanel.js

@@ -0,0 +1,118 @@
+import React, { useState } from 'react';
+
+const ACTIONS = [
+  {
+    type: 'reply',
+    icon: '↩',
+    label: 'Reply',
+    desc: 'Personally respond and handle',
+    color: '#3b82f6',
+    bg: 'rgba(59,130,246,0.15)',
+    hoverBg: 'rgba(59,130,246,0.25)',
+  },
+  {
+    type: 'schedule',
+    icon: '📅',
+    label: 'Schedule',
+    desc: 'Book a meeting slot',
+    color: '#8b5cf6',
+    bg: 'rgba(139,92,246,0.15)',
+    hoverBg: 'rgba(139,92,246,0.25)',
+  },
+  {
+    type: 'delegate',
+    icon: '→',
+    label: 'Delegate',
+    desc: 'Assign to team member',
+    color: '#f97316',
+    bg: 'rgba(249,115,22,0.15)',
+    hoverBg: 'rgba(249,115,22,0.25)',
+  },
+  {
+    type: 'ignore',
+    icon: '✕',
+    label: 'Ignore',
+    desc: 'Skip this item',
+    color: '#64748b',
+    bg: 'rgba(100,116,139,0.15)',
+    hoverBg: 'rgba(100,116,139,0.25)',
+  },
+];
+
+export default function ActionPanel({ selectedEmail, onAction, done, loading }) {
+  const [hoveredAction, setHoveredAction] = useState(null);
+  const [lastAction, setLastAction] = useState(null);
+
+  const handleAction = (actionType) => {
+    if (!selectedEmail || done || loading) return;
+    setLastAction(actionType);
+    onAction({ type: actionType, email_id: selectedEmail.id });
+    setTimeout(() => setLastAction(null), 600);
+  };
+
+  const isDisabled = !selectedEmail || done || loading;
+
+  return (
+    <div className="panel action-panel">
+      <div className="panel-header">
+        <span className="panel-title">⚡ Actions</span>
+      </div>
+
+      {selectedEmail ? (
+        <div className="selected-email-preview">
+          <div className="selected-label">SELECTED</div>
+          <div className="selected-subject">{selectedEmail.subject}</div>
+          <div className="selected-sender">{selectedEmail.sender.split('<')[0].trim()}</div>
+        </div>
+      ) : (
+        <div className="no-selection">
+          <span className="no-selection-icon">👆</span>
+          <span>Select an email<br />from the inbox</span>
+        </div>
+      )}
+
+      <div className="action-buttons">
+        {ACTIONS.map(action => {
+          const isActive = lastAction === action.type;
+          const isHovered = hoveredAction === action.type;
+          return (
+            <button
+              key={action.type}
+              className={`action-btn ${isActive ? 'active' : ''}`}
+              style={{
+                borderColor: isDisabled ? 'rgba(148,163,184,0.15)' : action.color,
+                background: isDisabled
+                  ? 'rgba(148,163,184,0.05)'
+                  : isActive
+                  ? action.color
+                  : isHovered
+                  ? action.hoverBg
+                  : action.bg,
+                color: isDisabled ? '#475569' : isActive ? '#fff' : action.color,
+                transform: isActive ? 'scale(0.96)' : 'scale(1)',
+                cursor: isDisabled ? 'not-allowed' : 'pointer',
+              }}
+              disabled={isDisabled}
+              onClick={() => handleAction(action.type)}
+              onMouseEnter={() => setHoveredAction(action.type)}
+              onMouseLeave={() => setHoveredAction(null)}
+            >
+              <span className="action-btn-icon">{action.icon}</span>
+              <div className="action-btn-text">
+                <span className="action-btn-label">{action.label}</span>
+                <span className="action-btn-desc">{action.desc}</span>
+              </div>
+            </button>
+          );
+        })}
+      </div>
+
+      {done && (
+        <div className="done-overlay">
+          <span className="done-icon">✓</span>
+          <span className="done-text">Simulation Complete</span>
+        </div>
+      )}
+    </div>
+  );
+}

frontend/src/components/InboxPanel.js

@@ -0,0 +1,110 @@
+import React from 'react';
+
+const PRIORITY_CONFIG = {
+  5: { color: '#ef4444', bg: 'rgba(239,68,68,0.12)', label: 'CRITICAL', textColor: '#fca5a5' },
+  4: { color: '#f59e0b', bg: 'rgba(245,158,11,0.12)', label: 'HIGH', textColor: '#fcd34d' },
+  3: { color: '#eab308', bg: 'rgba(234,179,8,0.10)', label: 'MEDIUM', textColor: '#fde047' },
+  2: { color: '#22c55e', bg: 'rgba(34,197,94,0.10)', label: 'LOW', textColor: '#86efac' },
+  1: { color: '#94a3b8', bg: 'rgba(148,163,184,0.08)', label: 'MINIMAL', textColor: '#cbd5e1' },
+};
+
+const ACTION_ICONS = {
+  reply: '↩',
+  schedule: '📅',
+  delegate: '→',
+  ignore: '✕',
+};
+
+function UrgencyRing({ urgency, priority }) {
+  const pct = Math.max(0, Math.min(1, urgency));
+  const size = 36;
+  const stroke = 3;
+  const r = (size - stroke * 2) / 2;
+  const circ = 2 * Math.PI * r;
+  const dash = circ * pct;
+  const color = PRIORITY_CONFIG[priority]?.color || '#94a3b8';
+
+  return (
+    <div className="urgency-ring-wrapper" title={`Urgency: ${(urgency * 100).toFixed(0)}%`}>
+      <svg width={size} height={size} style={{ transform: 'rotate(-90deg)' }}>
+        <circle cx={size / 2} cy={size / 2} r={r} fill="none" stroke="rgba(255,255,255,0.08)" strokeWidth={stroke} />
+        <circle
+          cx={size / 2} cy={size / 2} r={r}
+          fill="none"
+          stroke={color}
+          strokeWidth={stroke}
+          strokeDasharray={`${dash} ${circ}`}
+          strokeLinecap="round"
+          style={{ transition: 'stroke-dasharray 0.6s ease, stroke 0.3s' }}
+          opacity={0.3 + pct * 0.7}
+        />
+      </svg>
+      <span className="urgency-pct" style={{ color }}>{(urgency * 100).toFixed(0)}</span>
+    </div>
+  );
+}
+
+export default function InboxPanel({ emails, selectedEmailId, onSelect, isAutoRunning }) {
+  const sorted = [...emails].sort((a, b) => {
+    if (a.handled !== b.handled) return a.handled ? 1 : -1;
+    if (b.priority !== a.priority) return b.priority - a.priority;
+    return b.urgency - a.urgency;
+  });
+
+  return (
+    <div className="panel inbox-panel">
+      <div className="panel-header">
+        <span className="panel-title">📥 Inbox</span>
+        <span className="panel-badge">{emails.filter(e => !e.handled).length} unhandled</span>
+      </div>
+      <div className="email-list">
+        {sorted.map(email => {
+          const cfg = PRIORITY_CONFIG[email.priority] || PRIORITY_CONFIG[1];
+          const isSelected = email.id === selectedEmailId;
+          const isHandled = email.handled;
+          const isAiFocus = isSelected && isAutoRunning;
+
+          return (
+            <div
+              key={email.id}
+              className={`email-card ${isSelected ? 'selected' : ''} ${isHandled ? 'handled' : ''} ${isAiFocus ? 'ai-focus' : ''}`}
+              style={{
+                borderLeft: `3px solid ${isHandled ? 'rgba(148,163,184,0.3)' : cfg.color}`,
+                background: isSelected ? `${cfg.bg}` : isHandled ? 'rgba(15,23,42,0.4)' : cfg.bg,
+                cursor: isHandled || isAutoRunning ? 'default' : 'pointer',
+              }}
+              onClick={() => !isHandled && !isAutoRunning && onSelect && onSelect(email)}
+            >
+              <div className="email-header">
+                <div className="email-meta">
+                  <span
+                    className="priority-badge"
+                    style={{ background: isHandled ? 'rgba(148,163,184,0.15)' : cfg.color, color: isHandled ? '#64748b' : '#fff' }}
+                  >
+                    P{email.priority} {cfg.label}
+                  </span>
+                  {isHandled && (
+                    <span className="action-taken-badge">
+                      {ACTION_ICONS[email.action_taken]} {email.action_taken}
+                    </span>
+                  )}
+                </div>
+                {!isHandled && <UrgencyRing urgency={email.urgency} priority={email.priority} />}
+                {isHandled && <span className="handled-check">✓</span>}
+              </div>
+              <div className="email-sender" style={{ color: isHandled ? '#475569' : cfg.textColor }}>
+                {email.sender.split('<')[0].trim()}
+              </div>
+              <div className="email-subject" style={{ color: isHandled ? '#475569' : '#f1f5f9' }}>
+                {email.subject}
+              </div>
+              {isSelected && !isHandled && (
+                <div className="email-body">{email.body}</div>
+              )}
+            </div>
+          );
+        })}
+      </div>
+    </div>
+  );
+}

frontend/src/components/ScorePanel.js

@@ -0,0 +1,119 @@
+import React from 'react';
+
+const PRIORITY_CONFIG = {
+  5: { color: '#ef4444', label: 'CRITICAL' },
+  4: { color: '#f59e0b', label: 'HIGH' },
+  3: { color: '#eab308', label: 'MEDIUM' },
+  2: { color: '#22c55e', label: 'LOW' },
+  1: { color: '#94a3b8', label: 'MINIMAL' },
+};
+
+function ScoreGauge({ score }) {
+  const pct = Math.max(0, Math.min(1, score));
+  const color = pct >= 0.75 ? '#22c55e' : pct >= 0.5 ? '#f59e0b' : pct >= 0.25 ? '#f97316' : '#ef4444';
+  const size = 100;
+  const stroke = 8;
+  const r = (size - stroke * 2) / 2;
+  const circ = 2 * Math.PI * r;
+  const dash = circ * pct;
+
+  return (
+    <div className="score-gauge">
+      <svg width={size} height={size} style={{ transform: 'rotate(-90deg)' }}>
+        <circle cx={size / 2} cy={size / 2} r={r} fill="none" stroke="rgba(255,255,255,0.07)" strokeWidth={stroke} />
+        <circle
+          cx={size / 2} cy={size / 2} r={r}
+          fill="none"
+          stroke={color}
+          strokeWidth={stroke}
+          strokeDasharray={`${dash} ${circ}`}
+          strokeLinecap="round"
+          style={{ transition: 'stroke-dasharray 0.8s ease' }}
+        />
+      </svg>
+      <div className="score-gauge-text">
+        <span className="score-value" style={{ color }}>{(score * 100).toFixed(0)}</span>
+        <span className="score-pct-label">/ 100</span>
+      </div>
+    </div>
+  );
+}
+
+export default function ScorePanel({ goals, score, done, totalReward, currentStep, maxSteps }) {
+  const completedGoals = goals.filter(g => g.completed);
+  const completionPct = goals.length > 0 ? (completedGoals.length / goals.length) * 100 : 0;
+
+  return (
+    <div className="panel score-panel">
+      <div className="panel-header">
+        <span className="panel-title">🎯 Goals & Score</span>
+      </div>
+
+      {/* Score gauge */}
+      <div className="score-section">
+        <ScoreGauge score={score} />
+        <div className="score-meta">
+          <div className="score-label-main">{done ? 'FINAL SCORE' : 'LIVE SCORE'}</div>
+          <div className="score-completion">
+            {completedGoals.length}/{goals.length} goals done
+          </div>
+          <div className="completion-bar-wrapper">
+            <div className="completion-bar">
+              <div
+                className="completion-bar-fill"
+                style={{
+                  width: `${completionPct}%`,
+                  background: completionPct >= 75 ? '#22c55e' : completionPct >= 50 ? '#f59e0b' : '#ef4444'
+                }}
+              />
+            </div>
+            <span className="completion-pct">{completionPct.toFixed(0)}%</span>
+          </div>
+        </div>
+      </div>
+
+      {/* Goal checklist */}
+      <div className="goals-list">
+        <div className="goals-header">OBJECTIVES</div>
+        {goals.map(goal => {
+          const cfg = PRIORITY_CONFIG[goal.priority] || PRIORITY_CONFIG[1];
+          return (
+            <div key={goal.id} className={`goal-item ${goal.completed ? 'goal-done' : ''}`}>
+              <div
+                className="goal-checkbox"
+                style={{
+                  borderColor: goal.completed ? cfg.color : 'rgba(148,163,184,0.3)',
+                  background: goal.completed ? cfg.color : 'transparent',
+                }}
+              >
+                {goal.completed && <span className="goal-check">✓</span>}
+              </div>
+              <div className="goal-text">
+                <span className="goal-desc" style={{ color: goal.completed ? '#64748b' : '#e2e8f0' }}>
+                  {goal.description}
+                </span>
+                <span className="goal-priority-tag" style={{ color: cfg.color }}>
+                  P{goal.priority} • {cfg.label}
+                </span>
+              </div>
+            </div>
+          );
+        })}
+      </div>
+
+      {done && (
+        <div className="final-score-banner" style={{
+          background: score >= 0.7 ? 'rgba(34,197,94,0.1)' : score >= 0.4 ? 'rgba(245,158,11,0.1)' : 'rgba(239,68,68,0.1)',
+          borderColor: score >= 0.7 ? '#22c55e' : score >= 0.4 ? '#f59e0b' : '#ef4444',
+        }}>
+          <div className="final-score-title">
+            {score >= 0.8 ? '🏆 Excellent' : score >= 0.6 ? '✅ Good' : score >= 0.4 ? '⚠️ Adequate' : '❌ Poor'}
+          </div>
+          <div className="final-score-num" style={{ color: score >= 0.7 ? '#22c55e' : score >= 0.4 ? '#f59e0b' : '#ef4444' }}>
+            {score.toFixed(4)}
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}

frontend/src/components/SimulationControls.js

@@ -0,0 +1,118 @@
+import React from 'react';
+
+const TASK_OPTIONS = [
+  { value: 'easy',   label: 'Easy — Monday Morning',  color: '#22c55e' },
+  { value: 'medium', label: 'Medium — Demo Day Prep',  color: '#f59e0b' },
+  { value: 'hard',   label: 'Hard — Series B Crisis',  color: '#ef4444' },
+];
+
+export default function SimulationControls({
+  taskId, currentTime, currentStep, maxSteps, totalReward,
+  done, onReset, onTaskChange, loading,
+  isAutoRunning, onAutoRun,
+}) {
+  const progressPct = maxSteps > 0 ? (currentStep / maxSteps) * 100 : 0;
+  const task = TASK_OPTIONS.find(t => t.value === taskId) || TASK_OPTIONS[0];
+
+  return (
+    <div className="sim-controls">
+
+      {/* ── Left: brand + task ── */}
+      <div className="sim-controls-left">
+        <div className="brand">
+          <span className="brand-icon">⚡</span>
+          <div className="brand-text">
+            <span className="brand-name">ExecOps AI</span>
+            <span className="brand-sub">CEO Simulation</span>
+          </div>
+        </div>
+
+        <div className="divider-v" />
+
+        <select
+          className="task-select"
+          value={taskId}
+          onChange={e => onTaskChange(e.target.value)}
+          disabled={isAutoRunning || loading}
+          style={{ borderColor: `${task.color}55` }}
+        >
+          {TASK_OPTIONS.map(t => (
+            <option key={t.value} value={t.value}>{t.label}</option>
+          ))}
+        </select>
+
+        <button
+          className="btn btn-reset"
+          onClick={onReset}
+          disabled={isAutoRunning || loading}
+          title="Reset to initial state"
+        >
+          ↺ Reset
+        </button>
+      </div>
+
+      {/* ── Center: time + steps ── */}
+      <div className="sim-controls-center">
+        <div className="time-display">
+          <span className="stat-label">CEO TIME</span>
+          <span className="time-value">{currentTime}</span>
+        </div>
+
+        <div className="step-display">
+          <span className="stat-label">STEPS</span>
+          <span className="step-value">
+            {currentStep} <span className="step-sep">/</span> {maxSteps}
+          </span>
+          <div className="step-bar">
+            <div
+              className="step-bar-fill"
+              style={{
+                width: `${progressPct}%`,
+                background: progressPct >= 100
+                  ? '#22c55e'
+                  : `linear-gradient(90deg, #3b82f6, #8b5cf6)`,
+              }}
+            />
+          </div>
+        </div>
+
+        <div className="reward-display">
+          <span className="stat-label">REWARD</span>
+          <span
+            className="reward-value"
+            style={{ color: totalReward >= 0 ? '#22c55e' : '#ef4444' }}
+          >
+            {totalReward >= 0 ? '+' : ''}{totalReward.toFixed(3)}
+          </span>
+        </div>
+      </div>
+
+      {/* ── Right: auto-run + status ── */}
+      <div className="sim-controls-right">
+        {/* Auto-run button */}
+        <button
+          className={`btn-autorun ${isAutoRunning ? 'running' : ''}`}
+          onClick={onAutoRun}
+          disabled={loading && !isAutoRunning}
+          title={isAutoRunning ? 'Stop simulation' : 'Watch AI play through this scenario'}
+        >
+          {isAutoRunning ? (
+            <>
+              <span className="autorun-icon">■</span>
+              <span>Stop</span>
+            </>
+          ) : (
+            <>
+              <span className="autorun-icon">▶</span>
+              <span>Watch AI Play</span>
+            </>
+          )}
+        </button>
+
+        <div className={`status-badge ${done ? 'done' : isAutoRunning ? 'auto' : 'active'}`}>
+          {done ? '✓ COMPLETE' : isAutoRunning ? '◈ AI RUNNING' : '● READY'}
+        </div>
+      </div>
+    </div>
+  );
+}

frontend/src/components/TimelinePanel.js

@@ -0,0 +1,79 @@
+import React, { useEffect, useRef } from 'react';
+
+const ACTION_CONFIG = {
+  reply:    { icon: '↩', color: '#3b82f6', label: 'Reply' },
+  schedule: { icon: '📅', color: '#8b5cf6', label: 'Schedule' },
+  delegate: { icon: '→', color: '#f97316', label: 'Delegate' },
+  ignore:   { icon: '✕', color: '#64748b', label: 'Ignore' },
+};
+
+const PRIORITY_COLORS = { 5: '#ef4444', 4: '#f59e0b', 3: '#eab308', 2: '#22c55e', 1: '#94a3b8' };
+
+export default function TimelinePanel({ history }) {
+  const endRef = useRef(null);
+
+  useEffect(() => {
+    endRef.current?.scrollIntoView({ behavior: 'smooth', block: 'nearest', inline: 'end' });
+  }, [history.length]);
+
+  return (
+    <div className="panel timeline-panel">
+      <div className="panel-header">
+        <span className="panel-title">📊 Action Timeline</span>
+        <span className="panel-badge">{history.length} actions</span>
+      </div>
+
+      <div className="timeline-scroll">
+        {history.length === 0 ? (
+          <div className="timeline-empty">
+            <span className="timeline-empty-icon">⏱</span>
+            <span>No actions yet — click <strong>Watch AI Play</strong> or select an email above</span>
+          </div>
+        ) : (
+          <div className="timeline-track">
+            {history.map((entry, i) => {
+              const cfg = ACTION_CONFIG[entry.action] || ACTION_CONFIG.ignore;
+              const positive = entry.reward >= 0;
+              const isLast = i === history.length - 1;
+              return (
+                <div key={i} className={`timeline-entry ${isLast ? 'latest' : ''}`}>
+                  {/* Connector line */}
+                  {i > 0 && <div className="timeline-line" style={{ background: `${cfg.color}40` }} />}
+
+                  {/* Step badge */}
+                  <div className="timeline-step" style={{ background: cfg.color }}>
+                    {entry.step + 1}
+                  </div>
+
+                  {/* Card */}
+                  <div className="timeline-card" style={{ borderColor: `${cfg.color}40` }}>
+                    <div className="timeline-card-top">
+                      <span className="tl-time">{entry.time}</span>
+                      <span className="tl-action" style={{ color: cfg.color }}>
+                        {cfg.icon} {cfg.label}
+                      </span>
+                      <span
+                        className="tl-reward"
+                        style={{ color: positive ? '#22c55e' : '#ef4444' }}
+                      >
+                        {positive ? '+' : ''}{entry.reward.toFixed(3)}
+                      </span>
+                    </div>
+                    <div className="timeline-card-body">
+                      <span
+                        className="tl-dot"
+                        style={{ background: PRIORITY_COLORS[entry.email_priority] || '#94a3b8' }}
+                      />
+                      <span className="tl-subject">{entry.email_subject}</span>
+                    </div>
+                  </div>
+                </div>
+              );
+            })}
+            <div ref={endRef} />
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}

frontend/src/index.js

@@ -0,0 +1,7 @@
+import React from 'react';
+import ReactDOM from 'react-dom/client';
+import './App.css';
+import App from './App';
+
+const root = ReactDOM.createRoot(document.getElementById('root'));
+root.render(<App />);

inference.py

@@ -0,0 +1,246 @@
+"""
+inference.py - AI Executive Operations Manager
+Runs all 3 tasks using an LLM agent and prints structured logs.
+
+Environment variables:
+  API_BASE_URL  - OpenAI-compatible API base URL
+  MODEL_NAME    - Model to use (e.g., "gpt-4o-mini", "meta-llama/Llama-3.1-8B-Instruct")
+  HF_TOKEN      - API key / HuggingFace token
+
+STDOUT format (strict):
+  [START] task=<task_id> env=exec-ops model=<model>
+  [STEP]  step=<n> action=<type>('<id>') reward=<0.00> done=<true|false> error=<msg|null>
+  [END]   success=<true|false> steps=<n> score=<0.00> rewards=<r1,r2,...>
+"""
+
+import os
+import json
+import sys
+import dotenv
+
+# Force UTF-8 output on Windows
+if sys.stdout.encoding != "utf-8":
+    sys.stdout.reconfigure(encoding="utf-8")
+
+from openai import OpenAI
+from env import ExecOpsEnv, Action
+from env.grader import grade
+
+# -------------------------------------------------------
+# Configuration from environment
+# -------------------------------------------------------
+dotenv.load_dotenv()
+API_BASE_URL = os.getenv("API_BASE_URL", "https://api.openai.com/v1")
+MODEL_NAME = os.getenv("MODEL_NAME", "gpt-4o-mini")
+HF_TOKEN = os.getenv("HF_TOKEN")
+LOCAL_IMAGE_NAME = os.getenv("LOCAL_IMAGE_NAME")
+
+client = OpenAI(base_url=API_BASE_URL, api_key=HF_TOKEN)
+
+SYSTEM_PROMPT = """You are an expert AI assistant helping a startup CEO (Alex Rivera at NovaTech AI) manage their inbox efficiently.
+
+Your job: Given the current environment state, choose ONE action for ONE email.
+
+Triage principles:
+1. Handle the highest PRIORITY * URGENCY emails first
+2. Reply to items requiring personal CEO attention (investor relations, critical incidents, legal deadlines)
+3. Delegate items that can be handled by team members (HR, finance, operations)
+4. Schedule items requiring a meeting
+5. Ignore truly trivial items only when critical items remain
+
+You MUST respond with ONLY valid JSON, no explanation:
+{"type": "reply|schedule|delegate|ignore", "email_id": "<id>"}
+
+IMPORTANT: email_id MUST be one of the ids from the "unhandled_emails" list (e.g. "e1", "e2").
+Do NOT use goal_id values (e.g. "g1", "g2") as the email_id.
+
+Choose wisely - you have limited steps. Ignoring P4-P5 items is heavily penalized."""
+
+
+def _log(msg: str) -> None:
+    """Print a structured log line to stdout."""
+    print(msg, flush=True)
+
+
+def _err(msg: str) -> None:
+    """Print diagnostic info to stderr - never pollutes stdout."""
+    print(msg, file=sys.stderr, flush=True)
+
+
+def _clean_error(msg: str) -> str:
+    """Collapse error message to a single line safe for the log format."""
+    return msg.replace("\n", " ").replace("\r", "").strip()[:120]
+
+
+def parse_action_from_response(text: str) -> dict:
+    """Extract JSON action from LLM response, handling markdown code blocks."""
+    text = text.strip()
+    if "```json" in text:
+        text = text.split("```json")[1].split("```")[0].strip()
+    elif "```" in text:
+        parts = text.split("```")
+        for part in parts[1::2]:
+            part = part.strip()
+            if part.startswith("{"):
+                text = part
+                break
+    start = text.find("{")
+    end = text.rfind("}") + 1
+    if start >= 0 and end > start:
+        text = text[start:end]
+    return json.loads(text)
+
+
+def get_fallback_action(obs: dict) -> Action:
+    """Fallback: pick highest priority * urgency unhandled email and reply or delegate."""
+    inbox = obs.get("inbox", [])
+    unhandled = [e for e in inbox if not e.get("handled", False)]
+    if not unhandled:
+        return None
+    best = max(unhandled, key=lambda e: e.get("priority", 1) * e.get("urgency", 0.5))
+    action_type = "delegate" if best.get("priority", 1) <= 2 else "reply"
+    return Action(type=action_type, email_id=best["id"])
+
+
+def run_task(task_id: str) -> float:
+    """Run a single task with the LLM agent. Returns final grade in [0, 1]."""
+    _log(f"[START] task={task_id} env=exec-ops model={MODEL_NAME}")
+
+    step_count = 0
+    rewards: list[float] = []
+    pending_step_log = None  # deferred so we can force done=true on the last step
+    final_score = 0.0
+    env = None
+
+    try:
+        env = ExecOpsEnv(task_id)
+        obs = env.reset()
+        max_steps = obs.get("max_steps", 10)
+
+        while not obs.get("done", False) and step_count < max_steps:
+            unhandled = [e for e in obs.get("inbox", []) if not e.get("handled", False)]
+            if not unhandled:
+                break
+
+            # Flush previous buffered step - it is not the last, so done=false
+            if pending_step_log is not None:
+                _log(pending_step_log.replace("_DONE_", "false"))
+                pending_step_log = None
+
+            prompt_state = {
+                "time": obs.get("time"),
+                "steps_remaining": obs.get("steps_remaining", max_steps - step_count),
+                "unhandled_emails": [
+                    {
+                        "id": e["id"],
+                        "sender": e["sender"].split("<")[0].strip(),
+                        "subject": e["subject"],
+                        "priority": e["priority"],
+                        "urgency": round(e["urgency"], 2),
+                    }
+                    for e in sorted(unhandled, key=lambda x: -(x["priority"] * x["urgency"]))
+                ],
+                "pending_goals": [
+                    {"goal_id": g["id"], "description": g["description"], "priority": g["priority"]}
+                    for g in obs.get("pending_goals", [])
+                ],
+            }
+
+            # --- Get action from LLM (with fallback) ---
+            step_error = None
+            action = None
+            try:
+                response = client.chat.completions.create(
+                    model=MODEL_NAME,
+                    messages=[
+                        {"role": "system", "content": SYSTEM_PROMPT},
+                        {"role": "user", "content": f"Current state:\n{json.dumps(prompt_state, indent=2)}\n\nChoose your action (JSON only):"}
+                    ],
+                    temperature=0.1,
+                    max_tokens=80,
+                )
+                action_text = response.choices[0].message.content
+                action_data = parse_action_from_response(action_text)
+                action = Action(type=action_data["type"], email_id=action_data["email_id"])
+
+                valid_ids = {e["id"] for e in unhandled}
+                if action.email_id not in valid_ids:
+                    raise ValueError(f"Invalid email_id: {action.email_id}")
+
+            except Exception as e:
+                step_error = _clean_error(str(e))
+                _err(f"[fallback] LLM error ({task_id} step {step_count+1}): {type(e).__name__}: {e}")
+                action = get_fallback_action(obs)
+                if action is None:
+                    break
+
+            # --- Execute step; retry with fallback on failure ---
+            candidates = [action]
+            fb = get_fallback_action(obs)
+            if fb is not None and (action is None or fb.email_id != action.email_id):
+                candidates.append(fb)
+
+            executed = False
+            for attempt in candidates:
+                try:
+                    result = env.step(attempt)
+                    reward = result.get("reward", 0.0)
+                    done = result.get("done", False)
+                    obs = result.get("observation", result)
+                    if "done" not in obs:
+                        obs["done"] = done
+                    step_count += 1
+                    rewards.append(reward)
+                    action_str = f"{attempt.type}('{attempt.email_id}')"
+                    error_field = step_error if step_error else "null"
+                    pending_step_log = (
+                        f"[STEP] step={step_count} action={action_str} "
+                        f"reward={reward:.2f} done=_DONE_ error={error_field}"
+                    )
+                    executed = True
+                    break
+                except Exception as e:
+                    step_error = _clean_error(str(e))
+                    _err(f"[fallback] Step error ({task_id} step {step_count+1}): {type(e).__name__}: {e}")
+
+            if not executed:
+                break
+
+    except Exception as e:
+        _err(f"[error] Unexpected error in task '{task_id}': {e}")
+
+    finally:
+        # Flush the final buffered step - always done=true
+        if pending_step_log is not None:
+            _log(pending_step_log.replace("_DONE_", "true"))
+
+        try:
+            final_score = grade(env._state) if env is not None else 0.0
+        except Exception:
+            final_score = 0.0
+        success = "true" if final_score >= 0.5 else "false"
+        rewards_str = ",".join(f"{r:.2f}" for r in rewards) if rewards else "0.00"
+        _log(f"[END] success={success} steps={step_count} score={final_score:.3f} rewards={rewards_str}")
+
+    return final_score
+
+
+def main():
+    tasks = ["easy", "medium", "hard"]
+    scores = {}
+
+    for task_id in tasks:
+        try:
+            score = run_task(task_id)
+            scores[task_id] = score
+        except Exception as e:
+            _err(f"[error] Task '{task_id}' failed: {e}")
+            scores[task_id] = 0.0
+            _log(f"[END] success=false steps=0 score=0.000 rewards=0.00")
+
+    return sum(scores.values()) / len(scores) if scores else 0.0
+
+
+if __name__ == "__main__":
+    avg = main()
+    sys.exit(0)

openenv.yaml

@@ -0,0 +1,85 @@
+name: ai-executive-ops-manager
+version: "1.0.0"
+description: >
+  Simulates a startup CEO's (Alex Rivera, NovaTech AI) operational day.
+  An AI agent must manage a realistic executive inbox under time pressure,
+  making triage decisions - reply, schedule, delegate, or ignore - to
+  handle conflicting priorities, cascading crises, and stakeholder demands.
+  Tests prioritization, urgency sensitivity, and decision quality.
+
+entrypoint: inference.py
+
+tasks:
+  - id: easy
+    name: Monday Morning Catchup
+    difficulty: easy
+    description: >
+      A manageable Monday inbox with 4 emails and clear priority separation.
+      Optimal play: approve production deploy (P5), handle enterprise contract (P4),
+      delegate onboarding (P3), ignore snack order (P1).
+    max_steps: 6
+    expected_score_range: [0.7, 1.0]
+
+  - id: medium
+    name: Investor Demo Day Prep
+    difficulty: medium
+    description: >
+      Series B investor demo day. 7 emails with genuine scheduling conflicts -
+      CTO architecture crisis competes with investor prep. Requires smart
+      delegation and scheduling around locked calendar slots.
+    max_steps: 8
+    expected_score_range: [0.45, 0.85]
+
+  - id: hard
+    name: Series B Crisis Day
+    difficulty: hard
+    description: >
+      Cascading crises: investor pulling term sheet, production DB corruption,
+      key engineer resignation, TechCrunch security breach article going live,
+      GDPR deadline, and more. 10 emails, 4 P5 items, 8 steps - ruthless
+      triage required. Perfect score is intentionally unachievable.
+    max_steps: 8
+    expected_score_range: [0.2, 0.75]
+
+observation_space:
+  description: >
+    Dict with time (str), step (int), max_steps (int), steps_remaining (int),
+    inbox (list of Email objects), calendar (list of CalendarEvent objects),
+    goals (list of all Goal objects with completion status),
+    pending_goals (list of incomplete Goal objects), total_reward (float), done (bool).
+  email_fields:
+    - id: str
+    - sender: str
+    - subject: str
+    - body: str
+    - priority: "int 1-5 (1=minimal, 5=critical)"
+    - urgency: "float 0.0-1.0, decays by 0.15 each step"
+    - handled: bool
+    - action_taken: "str or null"
+
+action_space:
+  type: discrete
+  actions:
+    - reply: "Personally respond to the email (best for high-priority items requiring CEO attention)"
+    - schedule: "Book a meeting slot for this item (good for relationship/strategic items)"
+    - delegate: "Assign to a team member (good for operational P1-P3 items)"
+    - ignore: "Skip this item (only appropriate for P1 items when critical items are unhandled)"
+  format: '{"type": "reply|schedule|delegate|ignore", "email_id": "<id>"}'
+
+reward:
+  type: continuous
+  per_step: true
+  range: "[-0.3, 0.5] per step"
+  components:
+    - goal_completion: "+0.30 * (goal_priority / 5) for completing a goal"
+    - urgency_bonus: "+0.15 * urgency if urgency > 0.5 and not ignoring"
+    - efficiency: "+0.05 for delegating P1-P2 items"
+    - action_match: "+0.10 if action matches goal's required action"
+    - ignore_penalty: "-0.25 for ignoring P4-P5 emails"
+    - waste_penalty: "-0.10 for replying to P1 when P4+ unhandled"
+    - step_cost: "-0.02 per step (encourages efficiency)"
+
+grader:
+  type: deterministic
+  score_range: [0.0, 1.0]
+  formula: "0.60 * goal_completion_rate + 0.25 * email_handling_rate + 0.15 * efficiency_bonus"

pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "exec-ops-env"
+version = "1.0.0"
+description = "AI Executive Operations Manager - OpenEnv environment simulating a startup CEO inbox"
+requires-python = ">=3.11"
+dependencies = [
+    "fastapi>=0.109.0",
+    "uvicorn[standard]>=0.27.0",
+    "pydantic>=2.6.0",
+    "openai>=1.12.0",
+    "python-multipart>=0.0.9",
+    "python-dotenv>=1.0.0",
+    "openenv-core>=0.2.0",
+]
+
+[project.scripts]
+server = "server.app:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

requirements.txt

@@ -0,0 +1,6 @@
+fastapi==0.109.2
+uvicorn[standard]==0.27.1
+pydantic==2.6.1
+openai==1.12.0
+python-multipart==0.0.9
+python-dotenv==1.0.1

server/app.py

@@ -0,0 +1,20 @@
+"""
+server/app.py - Entry point for `uv run server` and openenv multi-mode deployment.
+Delegates to the root app.py FastAPI application.
+"""
+
+import os
+import sys
+
+# Ensure project root is on the Python path
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import uvicorn
+
+
+def main():
+    uvicorn.run("app:app", host="0.0.0.0", port=7860, workers=1)
+
+
+if __name__ == "__main__":
+    main()