Upload 2 files

environment.py

@@ -0,0 +1,432 @@
+"""Core OpenEnv email triage environment implementation."""
+
+import os
+from typing import cast
+
+from pydantic import ValidationError
+
+from graders import grade_easy, grade_hard, grade_medium_step
+from models import (
+    EmailObservation,
+    EnvironmentState,
+    ResetResult,
+    RewardResult,
+    StepResult,
+    TriageAction,
+)
+from tasks import get_task_definition
+
+
+class EmailTriageEnv:
+    """Deterministic email triage environment implementing reset, step, and state."""
+
+    def __init__(
+        self,
+        task_id: str,
+        scenario_index: int = 0,
+        split: str | None = None,
+        runtime_options: dict[str, object] | None = None,
+    ) -> None:
+        """Initialize environment with a selected task.
+
+        Args:
+            task_id: Task identifier such as task_easy, task_medium, or task_hard.
+            scenario_index: Deterministic scenario index within the task pool.
+            split: Scenario split, either public or private_eval.
+            runtime_options: Optional deterministic runtime controls for task generation.
+        """
+        self.task_id = task_id
+        self._episode_index = max(0, scenario_index)
+        self.split = split or os.getenv("OPENENV_EVAL_SPLIT", "public")
+        self.runtime_options = runtime_options or {}
+        self._task_definition = get_task_definition(
+            task_id,
+            self._episode_index,
+            self.split,
+            self.runtime_options,
+        )
+        self._scenario_id = str(self._task_definition.get("scenario_id", "unknown"))
+        self._emails = cast(list[dict[str, object]], self._task_definition.get("emails", []))
+        self._ground_truth = cast(
+            list[dict[str, object]], self._task_definition.get("ground_truth", [])
+        )
+
+        self._current_index = 0
+        self._current_step = 0
+        self._done = False
+        self._max_steps = max(10, len(self._emails) + 5)
+        self._action_history: list[TriageAction] = []
+        self._reward_history: list[float] = []
+        self._base_score_history: list[float] = []
+        self._generated_followups = 0
+        self._max_generated_followups = 4
+        self._followup_quality_threshold = 0.7
+        self._configure_runtime_controls()
+
+    def reset(self) -> ResetResult:
+        """Reset episode state and return the first observation.
+
+        Returns:
+            ResetResult containing first observation and metadata.
+        """
+        self._task_definition = get_task_definition(
+            self.task_id,
+            self._episode_index,
+            self.split,
+            self.runtime_options,
+        )
+        self._scenario_id = str(self._task_definition.get("scenario_id", "unknown"))
+        self._emails = cast(list[dict[str, object]], self._task_definition.get("emails", []))
+        self._ground_truth = cast(
+            list[dict[str, object]], self._task_definition.get("ground_truth", [])
+        )
+
+        self._current_index = 0
+        self._current_step = 0
+        self._done = False
+        self._max_steps = max(10, len(self._emails) + 5)
+        self._action_history = []
+        self._reward_history = []
+        self._base_score_history = []
+        self._generated_followups = 0
+        self._configure_runtime_controls()
+        self._episode_index += 1
+
+        first_observation = self._build_observation(self._current_index)
+        return ResetResult(
+            observation=first_observation,
+            info={
+                "task_id": self.task_id,
+                "scenario_id": self._scenario_id,
+                "split": self.split,
+                "step": self._current_step,
+                "emails_total": len(self._emails),
+                "task_description": str(self._task_definition.get("description", "")),
+            },
+        )
+
+    def step(self, action: TriageAction) -> StepResult:
+        """Apply an action and return StepResult.
+
+        Args:
+            action: Proposed triage action.
+
+        Returns:
+            StepResult with next observation, reward, done flag, and metadata.
+        """
+        if self._done:
+            return StepResult(
+                observation=self._terminal_observation(),
+                reward=0.0,
+                done=True,
+                info={
+                    "task_id": self.task_id,
+                    "scenario_id": self._scenario_id,
+                    "split": self.split,
+                    "step": self._current_step,
+                    "already_done": True,
+                },
+            )
+
+        try:
+            validated_action = TriageAction.model_validate(action)
+        except ValidationError as validation_error:
+            self._current_step += 1
+            self._reward_history.append(0.0)
+            self._done = self._current_step >= self._max_steps
+            return StepResult(
+                observation=self._build_observation(self._current_index),
+                reward=0.0,
+                done=self._done,
+                info={
+                    "task_id": self.task_id,
+                    "scenario_id": self._scenario_id,
+                    "split": self.split,
+                    "step": self._current_step,
+                    "emails_total": len(self._emails),
+                    "emails_processed": self._current_index,
+                    "emails_remaining": max(len(self._emails) - self._current_index, 0),
+                    "validation_error": str(validation_error),
+                },
+            )
+
+        base_result = self._grade_current_step(validated_action)
+        base_score = base_result.score
+
+        truth_for_step = (
+            self._ground_truth[min(self._current_index, len(self._ground_truth) - 1)]
+            if self._ground_truth
+            else {}
+        )
+        self._maybe_enqueue_follow_up(validated_action, truth_for_step, base_score)
+
+        self._action_history.append(validated_action)
+        self._base_score_history.append(base_score)
+        self._current_step += 1
+
+        penalties = self._compute_penalties(validated_action)
+        trajectory_bonus = self._compute_trajectory_bonus()
+        final_reward = self._clip_reward(
+            base_score - (self._current_step * 0.01) + trajectory_bonus - penalties
+        )
+
+        self._reward_history.append(final_reward)
+
+        if self._current_index < len(self._emails):
+            self._current_index += 1
+
+        all_emails_processed = self._current_index >= len(self._emails)
+        self._done = all_emails_processed or self._current_step >= self._max_steps
+
+        next_observation = (
+            self._terminal_observation()
+            if self._done
+            else self._build_observation(self._current_index)
+        )
+
+        info = {
+            "task_id": self.task_id,
+            "scenario_id": self._scenario_id,
+            "split": self.split,
+            "step": self._current_step,
+            "emails_total": len(self._emails),
+            "emails_processed": min(self._current_index, len(self._emails)),
+            "emails_remaining": max(len(self._emails) - self._current_index, 0),
+            "base_score": round(base_score, 4),
+            "penalties": round(penalties, 4),
+            "trajectory_bonus": round(trajectory_bonus, 4),
+            "grading_feedback": base_result.feedback,
+        }
+        for breakdown_key, breakdown_value in base_result.breakdown.items():
+            if isinstance(breakdown_value, (int, float)):
+                info[f"grade_{breakdown_key}"] = round(float(breakdown_value), 4)
+
+        return StepResult(
+            observation=next_observation,
+            reward=final_reward,
+            done=self._done,
+            info=info,
+        )
+
+    def _maybe_enqueue_follow_up(
+        self,
+        action: TriageAction,
+        truth: dict[str, object],
+        base_score: float,
+    ) -> None:
+        """Insert deterministic escalation follow-up emails for production mode."""
+        if self.task_id != "task_production":
+            return
+        if self._generated_followups >= self._max_generated_followups:
+            return
+        if not self._emails:
+            return
+
+        expected_label = str(truth.get("label", ""))
+        expected_route = str(truth.get("route_to", "general"))
+        is_missed_critical = (
+            expected_label == "urgent"
+            and (action.label != "urgent" or expected_route not in action.route_to.lower())
+        )
+        if not is_missed_critical and base_score >= self._followup_quality_threshold:
+            return
+
+        source_email = self._emails[min(self._current_index, len(self._emails) - 1)]
+        source_subject = str(source_email.get("subject", "Inbox incident"))
+        source_timestamp = str(source_email.get("timestamp", "2026-04-03T00:00:00Z"))
+
+        followup_email = {
+            "email_id": f"followup-{self._scenario_id}-{self._generated_followups + 1}",
+            "subject": f"Escalation follow-up: {source_subject}",
+            "body": (
+                "Automated escalation triggered because prior triage appears incomplete. "
+                "Please route to the responsible team and provide a clear summary now."
+            ),
+            "sender": "incident-control@acme-enterprise.com",
+            "timestamp": source_timestamp,
+            "thread_history": [f"Previous message subject: {source_subject}"],
+        }
+        followup_truth = {
+            "label": "urgent",
+            "route_to": expected_route,
+            "priority_weight": min(max(float(truth.get("priority_weight", 1.5)) + 0.2, 1.5), 2.0),
+            "summary_keywords": ["escalation", "follow-up", expected_route],
+        }
+
+        insert_at = min(self._current_index + 1, len(self._emails))
+        self._emails.insert(insert_at, followup_email)
+        self._ground_truth.insert(insert_at, followup_truth)
+        self._generated_followups += 1
+
+    def _configure_runtime_controls(self) -> None:
+        """Apply deterministic runtime control options for production simulator."""
+        if self.task_id != "task_production":
+            self._max_generated_followups = 4
+            self._followup_quality_threshold = 0.7
+            return
+
+        escalation_mode = str(self.runtime_options.get("escalation_mode", "normal")).lower()
+        escalation_map = {
+            "low": (2, 0.55),
+            "normal": (4, 0.7),
+            "high": (8, 0.85),
+        }
+        max_followups, threshold = escalation_map.get(escalation_mode, escalation_map["normal"])
+        self._max_generated_followups = max_followups
+        self._followup_quality_threshold = threshold
+
+    def state(self) -> EnvironmentState:
+        """Return read-only snapshot of full internal state.
+
+        Returns:
+            EnvironmentState with progress and history.
+        """
+        return EnvironmentState(
+            task_id=self.task_id,
+            current_step=self._current_step,
+            total_steps=self._max_steps,
+            done=self._done,
+            action_history=list(self._action_history),
+            reward_history=list(self._reward_history),
+        )
+
+    def _build_observation(self, email_index: int) -> EmailObservation:
+        """Build observation for the email at a given index.
+
+        Args:
+            email_index: Zero-based email index.
+
+        Returns:
+            EmailObservation for the selected email or terminal placeholder.
+        """
+        if not self._emails:
+            return self._terminal_observation()
+
+        safe_index = min(max(email_index, 0), len(self._emails) - 1)
+        email_payload = self._emails[safe_index]
+
+        return EmailObservation(
+            email_id=str(email_payload.get("email_id", "")),
+            subject=str(email_payload.get("subject", "")),
+            body=str(email_payload.get("body", "")),
+            sender=str(email_payload.get("sender", "")),
+            timestamp=str(email_payload.get("timestamp", "")),
+            thread_history=[str(item) for item in email_payload.get("thread_history", [])],
+            task_id=self.task_id,
+            step_number=self._current_step,
+            total_emails=len(self._emails),
+        )
+
+    def _terminal_observation(self) -> EmailObservation:
+        """Build terminal observation returned when episode is complete.
+
+        Returns:
+            Terminal EmailObservation payload.
+        """
+        return EmailObservation(
+            email_id="terminal",
+            subject="Episode complete",
+            body="No further emails remain for this task.",
+            sender="system",
+            timestamp="",
+            thread_history=[],
+            task_id=self.task_id,
+            step_number=self._current_step,
+            total_emails=len(self._emails),
+        )
+
+    def _grade_current_step(self, action: TriageAction) -> RewardResult:
+        """Select deterministic grader based on task and current progress.
+
+        Args:
+            action: Validated action for the current step.
+
+        Returns:
+            RewardResult from task-specific grader.
+        """
+        if not self._ground_truth:
+            return RewardResult(
+                score=0.0,
+                breakdown={"missing_ground_truth": 1.0},
+                feedback="Missing ground truth for task.",
+            )
+
+        if self.task_id == "task_easy":
+            truth = self._ground_truth[min(self._current_index, len(self._ground_truth) - 1)]
+            return grade_easy(action, truth)
+
+        if self.task_id == "task_medium":
+            truth = self._ground_truth[min(self._current_index, len(self._ground_truth) - 1)]
+            return grade_medium_step(action, truth)
+
+        truth = self._ground_truth[min(self._current_index, len(self._ground_truth) - 1)]
+        return grade_hard(action, truth)
+
+    def _compute_penalties(self, action: TriageAction) -> float:
+        """Compute deterministic penalties according to reward policy.
+
+        Args:
+            action: Validated action for the step.
+
+        Returns:
+            Total penalty value for current step.
+        """
+        penalty_total = 0.0
+
+        summary_too_short = len(action.summary.strip()) < 10
+        if action.label == "archive" and summary_too_short:
+            penalty_total += 0.5
+
+        if self._is_repeated_action_pattern(action):
+            penalty_total += 0.3
+
+        return penalty_total
+
+    def _compute_trajectory_bonus(self) -> float:
+        """Return trajectory bonus when episode completion quality is high.
+
+        Returns:
+            0.2 when mean base score is above threshold at completion, else 0.0.
+        """
+        if not self._base_score_history:
+            return 0.0
+
+        all_emails_done_after_step = self._current_index + 1 >= len(self._emails)
+        if not all_emails_done_after_step:
+            return 0.0
+
+        mean_base = sum(self._base_score_history) / len(self._base_score_history)
+        return 0.2 if mean_base > 0.8 else 0.0
+
+    def _is_repeated_action_pattern(self, action: TriageAction) -> bool:
+        """Detect whether same action appears three times consecutively.
+
+        Args:
+            action: Current action.
+
+        Returns:
+            True when repeated label and route occur three times in a row.
+        """
+        if len(self._action_history) < 2:
+            return False
+
+        previous_action = self._action_history[-1]
+        older_action = self._action_history[-2]
+
+        return (
+            previous_action.label == older_action.label == action.label
+            and previous_action.route_to.strip().lower()
+            == older_action.route_to.strip().lower()
+            == action.route_to.strip().lower()
+        )
+
+    def _clip_reward(self, reward_value: float) -> float:
+        """Clip reward to the inclusive range [-1.0, 1.0].
+
+        Args:
+            reward_value: Raw reward value.
+
+        Returns:
+            Clipped reward.
+        """
+        return max(-1.0, min(1.0, reward_value))

server.py

@@ -0,0 +1,775 @@
+"""Flask server wrapper for the OpenEnv email triage environment."""
+
+import os
+
+from flask import Flask, Response, jsonify, request
+
+from environment import EmailTriageEnv
+from tasks import get_task_scenario_count, list_task_ids
+
+FRONTEND_HTML = """<!doctype html>
+<html lang="en">
+<head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Inbox Helper Practice</title>
+    <style>
+        @import url('https://fonts.googleapis.com/css2?family=Space+Grotesk:wght@400;600;700&family=IBM+Plex+Mono:wght@400;500&display=swap');
+
+        :root {
+            --bg: #f5f1e9;
+            --paper: #fffaf2;
+            --ink: #102433;
+            --accent: #ea6a2a;
+            --accent-soft: #ffd6bf;
+            --line: #d7cabb;
+            --ok: #0f7b6c;
+            --warn: #9a3a12;
+            --radius: 14px;
+        }
+
+        * { box-sizing: border-box; }
+
+        body {
+            margin: 0;
+            font-family: 'Space Grotesk', sans-serif;
+            color: var(--ink);
+            background:
+                radial-gradient(1100px 460px at -10% -20%, #f2bc9f 0%, transparent 60%),
+                radial-gradient(1100px 520px at 120% 115%, #b8d7cf 0%, transparent 62%),
+                var(--bg);
+            min-height: 100vh;
+        }
+
+        .wrap {
+            max-width: 1100px;
+            margin: 28px auto;
+            padding: 0 16px;
+            animation: reveal .45s ease-out;
+        }
+
+        @keyframes reveal {
+            from { opacity: 0; transform: translateY(10px); }
+            to { opacity: 1; transform: translateY(0); }
+        }
+
+        .title {
+            display: flex;
+            justify-content: space-between;
+            align-items: baseline;
+            gap: 14px;
+            margin-bottom: 14px;
+        }
+
+        h1 {
+            margin: 0;
+            font-size: clamp(1.5rem, 2vw, 2.2rem);
+            letter-spacing: .4px;
+        }
+
+        .subtitle {
+            margin: 6px 0 0;
+            font-size: .95rem;
+            opacity: .8;
+        }
+
+        .badge {
+            background: var(--accent-soft);
+            border: 1px solid #f2b693;
+            color: #7f2e0b;
+            padding: 6px 10px;
+            border-radius: 999px;
+            font-size: .85rem;
+            font-weight: 600;
+        }
+
+        .grid {
+            display: grid;
+            grid-template-columns: 1fr;
+            gap: 14px;
+        }
+
+        @media (min-width: 900px) {
+            .grid { grid-template-columns: 1fr 1fr; }
+            .wide { grid-column: span 2; }
+        }
+
+        .card {
+            background: var(--paper);
+            border: 1px solid var(--line);
+            border-radius: var(--radius);
+            padding: 14px;
+            box-shadow: 0 8px 28px rgba(16, 36, 51, 0.08);
+        }
+
+        .card h2 {
+            margin: 0 0 10px;
+            font-size: 1rem;
+            text-transform: uppercase;
+            letter-spacing: .08em;
+            opacity: .86;
+        }
+
+        .row {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 8px;
+            align-items: center;
+            margin-bottom: 10px;
+        }
+
+        select, input, textarea, button {
+            font-family: inherit;
+            font-size: .95rem;
+        }
+
+        select, input, textarea {
+            width: 100%;
+            border: 1px solid #cdbba6;
+            border-radius: 10px;
+            padding: 9px 10px;
+            background: #fff;
+            color: var(--ink);
+        }
+
+        textarea {
+            min-height: 92px;
+            resize: vertical;
+        }
+
+        button {
+            border: 0;
+            border-radius: 10px;
+            padding: 9px 12px;
+            font-weight: 700;
+            background: var(--ink);
+            color: #fff;
+            cursor: pointer;
+            transition: transform .12s ease, opacity .12s ease;
+        }
+
+        button.secondary {
+            background: #285066;
+        }
+
+        button.accent {
+            background: var(--accent);
+        }
+
+        button:hover { transform: translateY(-1px); }
+        button:active { transform: translateY(0); opacity: .92; }
+
+        .status {
+            padding: 8px 10px;
+            border-radius: 10px;
+            background: #eef7f5;
+            border: 1px solid #c7e4de;
+            color: var(--ok);
+            font-weight: 600;
+            min-height: 40px;
+            display: flex;
+            align-items: center;
+        }
+
+        .status.error {
+            background: #fff1ea;
+            border-color: #ffc8ae;
+            color: var(--warn);
+        }
+
+        pre {
+            margin: 0;
+            white-space: pre-wrap;
+            background: #0f1b24;
+            color: #d9efe9;
+            border-radius: 10px;
+            padding: 12px;
+            max-height: 340px;
+            overflow: auto;
+            font-family: 'IBM Plex Mono', monospace;
+            font-size: .85rem;
+            border: 1px solid #21313f;
+        }
+
+        .email-block {
+            background: #fff;
+            border: 1px solid #d9ccbc;
+            border-radius: 10px;
+            padding: 12px;
+        }
+
+        .email-row {
+            margin-bottom: 8px;
+            font-size: .95rem;
+            line-height: 1.35;
+        }
+
+        .email-row strong {
+            display: inline-block;
+            min-width: 66px;
+        }
+
+        .help {
+            margin: 0 0 10px;
+            font-size: .9rem;
+            opacity: .8;
+        }
+
+        .metric {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 8px;
+            padding-bottom: 6px;
+            border-bottom: 1px dashed #dbcfbe;
+            font-size: .95rem;
+        }
+
+        .metric strong {
+            font-weight: 700;
+        }
+
+        .coach {
+            background: #fff7ed;
+            border: 1px solid #f2caa9;
+            border-radius: 10px;
+            padding: 10px;
+            min-height: 74px;
+            line-height: 1.4;
+            font-size: .92rem;
+        }
+
+        .chip-row {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 8px;
+            margin-top: 10px;
+        }
+
+        .chip {
+            background: #eaf3ff;
+            border: 1px solid #b9d1ef;
+            color: #184469;
+            border-radius: 999px;
+            padding: 6px 10px;
+            font-size: .84rem;
+            cursor: pointer;
+            font-weight: 600;
+        }
+    </style>
+</head>
+<body>
+    <div class="wrap">
+        <div class="title">
+            <div>
+                <h1>Inbox Helper Practice</h1>
+                <p class="subtitle">Practice deciding priority, category, and who should handle each email.</p>
+            </div>
+            <span class="badge" id="badge">connecting...</span>
+        </div>
+
+        <div class="grid">
+            <section class="card">
+                <h2>Start a Scenario</h2>
+                <p class="help">Pick a difficulty, then click Start.</p>
+                <div class="row">
+                    <select id="taskId">
+                        <option value="task_easy">Easy: one clear email</option>
+                        <option value="task_medium">Medium: mixed inbox</option>
+                        <option value="task_hard">Hard: high-risk complaint</option>
+                        <option value="task_production">Production: full inbox simulator</option>
+                    </select>
+                </div>
+                <div id="productionControls" style="display:none;">
+                    <div class="row">
+                        <select id="productionProfile">
+                            <option value="light">Workload: Light</option>
+                            <option value="standard" selected>Workload: Standard</option>
+                            <option value="heavy">Workload: Heavy</option>
+                        </select>
+                    </div>
+                    <div class="row">
+                        <select id="businessHoursMode">
+                            <option value="false" selected>Time Profile: 24x7 inbox</option>
+                            <option value="true">Time Profile: business hours focus</option>
+                        </select>
+                    </div>
+                    <div class="row">
+                        <select id="escalationMode">
+                            <option value="low">Escalation: Low</option>
+                            <option value="normal" selected>Escalation: Normal</option>
+                            <option value="high">Escalation: High</option>
+                        </select>
+                    </div>
+                </div>
+                <div class="row">
+                    <button class="accent" id="btnReset">Start</button>
+                    <button class="secondary" id="btnState">Check Progress</button>
+                </div>
+                <div class="status" id="status">Ready. Start a scenario.</div>
+            </section>
+
+            <section class="card">
+                <h2>Your Decision</h2>
+                <p class="help">Choose priority, who should handle it, and a short reason.</p>
+                <div class="row">
+                    <select id="label">
+                        <option value="urgent">Urgent</option>
+                        <option value="normal" selected>Normal</option>
+                        <option value="spam">Spam</option>
+                        <option value="archive">Archive</option>
+                    </select>
+                </div>
+                <div class="row">
+                    <input id="routeTo" placeholder="Who should handle this? (billing, safety, engineering, support)" value="general" />
+                </div>
+                <div class="row">
+                    <textarea id="summary" placeholder="Write one clear sentence with key clues from the email.">Needs review.</textarea>
+                </div>
+                <div class="row">
+                    <button id="btnStep">Send Decision</button>
+                </div>
+            </section>
+
+            <section class="card wide">
+                <h2>Current Email</h2>
+                <div class="email-block">
+                    <div class="email-row"><strong>Subject:</strong> <span id="mailSubject">No email loaded yet.</span></div>
+                    <div class="email-row"><strong>From:</strong> <span id="mailSender">-</span></div>
+                    <div class="email-row"><strong>Message:</strong> <span id="mailBody">Start a scenario to load an email.</span></div>
+                </div>
+            </section>
+
+            <section class="card">
+                <h2>Live Progress</h2>
+                <div class="metric"><span>Task</span><strong id="insightTask">-</strong></div>
+                <div class="metric"><span>Scenario</span><strong id="insightScenario">-</strong></div>
+                <div class="metric"><span>Progress</span><strong id="insightProgress">0/0</strong></div>
+                <div class="metric"><span>Last Reward</span><strong id="insightReward">-</strong></div>
+                <div class="metric"><span>Base Score</span><strong id="insightBase">-</strong></div>
+            </section>
+
+            <section class="card">
+                <h2>Coach Notes</h2>
+                <p class="help">Use this to improve your next triage action.</p>
+                <div class="coach" id="coachNotes">Start a scenario and submit one decision to get feedback.</div>
+                <div class="chip-row">
+                    <button class="chip" id="chipSafety">Quick Fill: Urgent + Safety</button>
+                    <button class="chip" id="chipBilling">Quick Fill: Normal + Billing</button>
+                    <button class="chip" id="chipSpam">Quick Fill: Spam + General</button>
+                </div>
+            </section>
+
+            <section class="card wide">
+                <h2>Details (Advanced)</h2>
+                <pre id="output">Waiting for your first action...</pre>
+            </section>
+        </div>
+    </div>
+
+    <script>
+        const statusEl = document.getElementById('status');
+        const badgeEl = document.getElementById('badge');
+        const outEl = document.getElementById('output');
+        const mailSubjectEl = document.getElementById('mailSubject');
+        const mailSenderEl = document.getElementById('mailSender');
+        const mailBodyEl = document.getElementById('mailBody');
+        const taskIdEl = document.getElementById('taskId');
+        const productionControlsEl = document.getElementById('productionControls');
+        const insightTaskEl = document.getElementById('insightTask');
+        const insightScenarioEl = document.getElementById('insightScenario');
+        const insightProgressEl = document.getElementById('insightProgress');
+        const insightRewardEl = document.getElementById('insightReward');
+        const insightBaseEl = document.getElementById('insightBase');
+        const coachNotesEl = document.getElementById('coachNotes');
+
+        function setStatus(msg, isError = false) {
+            statusEl.textContent = msg;
+            statusEl.classList.toggle('error', isError);
+        }
+
+        function writeOutput(value) {
+            outEl.textContent = typeof value === 'string' ? value : JSON.stringify(value, null, 2);
+        }
+
+        function updateEmailPanel(data) {
+            if (!data || !data.observation) {
+                return;
+            }
+            const obs = data.observation;
+            mailSubjectEl.textContent = obs.subject || 'No subject';
+            mailSenderEl.textContent = obs.sender || '-';
+            mailBodyEl.textContent = obs.body || '';
+        }
+
+        function updateProductionControlsVisibility() {
+            const isProduction = taskIdEl.value === 'task_production';
+            productionControlsEl.style.display = isProduction ? 'block' : 'none';
+        }
+
+        function safeNumber(value) {
+            return typeof value === 'number' && !Number.isNaN(value) ? value : null;
+        }
+
+        function updateInsights(data) {
+            const info = (data && data.info) ? data.info : {};
+            const taskValue = info.task_id || data.task_id || (data.observation && data.observation.task_id) || '-';
+            const scenarioValue = info.scenario_id || '-';
+
+            insightTaskEl.textContent = taskValue;
+            insightScenarioEl.textContent = scenarioValue;
+
+            const emailsProcessed = safeNumber(info.emails_processed);
+            const emailsTotal = safeNumber(info.emails_total);
+            if (emailsProcessed !== null && emailsTotal !== null) {
+                insightProgressEl.textContent = `${emailsProcessed}/${emailsTotal}`;
+            } else if (safeNumber(data.current_step) !== null && safeNumber(data.total_steps) !== null) {
+                insightProgressEl.textContent = `${data.current_step}/${data.total_steps}`;
+            }
+
+            const rewardValue = safeNumber(data.reward);
+            insightRewardEl.textContent = rewardValue !== null ? rewardValue.toFixed(2) : '-';
+
+            const baseScoreValue = safeNumber(info.base_score);
+            insightBaseEl.textContent = baseScoreValue !== null ? baseScoreValue.toFixed(2) : '-';
+
+            const tips = [];
+            if (info.validation_error) {
+                tips.push('Action format is invalid. Keep label/summary/route_to filled correctly.');
+            }
+
+            const routeNoise = safeNumber(info.grade_route_noise_penalty);
+            if (routeNoise !== null && routeNoise > 0.01) {
+                tips.push('Route to one best owner team. Avoid sending to many teams at once.');
+            }
+
+            const summaryMatch = safeNumber(info.grade_summary_match);
+            if (summaryMatch !== null && summaryMatch < 0.6) {
+                tips.push('Summary is weak. Include concrete clues from subject/body/thread.');
+            }
+
+            const labelMatch = safeNumber(info.grade_label_match);
+            if (labelMatch !== null && labelMatch < 1.0) {
+                tips.push('Priority label may be off. Re-check urgency and risk signals.');
+            }
+
+            const routeMatch = safeNumber(info.grade_route_match);
+            if (routeMatch !== null && routeMatch < 1.0) {
+                tips.push('Routing looks off. Pick the team that directly owns this issue.');
+            }
+
+            const urgencyComponent = safeNumber(info.grade_urgency_component);
+            if (urgencyComponent !== null && urgencyComponent < 0.2) {
+                tips.push('For high-risk complaints, mark urgent and route to safety first.');
+            }
+
+            if (!tips.length && typeof info.grading_feedback === 'string' && info.grading_feedback) {
+                tips.push(info.grading_feedback);
+            }
+
+            coachNotesEl.textContent = tips.length
+                ? tips.join(' ')
+                : 'Looks good. Keep your next route precise and your summary evidence-based.';
+        }
+
+        function prefillAction(label, routeTo, summary) {
+            document.getElementById('label').value = label;
+            document.getElementById('routeTo').value = routeTo;
+            document.getElementById('summary').value = summary;
+        }
+
+        async function postJson(path, payload) {
+            const response = await fetch(path, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload || {}),
+            });
+            const text = await response.text();
+            let data = text;
+            try { data = JSON.parse(text); } catch (e) {}
+            if (!response.ok) {
+                throw new Error('HTTP ' + response.status + ' - ' + text);
+            }
+            return data;
+        }
+
+        async function warmup() {
+            try {
+                const res = await fetch('/meta');
+                const data = await res.json();
+                badgeEl.textContent = data.status === 'ok' ? 'ready' : 'check service';
+            } catch (e) {
+                badgeEl.textContent = 'offline';
+            }
+        }
+
+        document.getElementById('btnReset').addEventListener('click', async () => {
+            const taskId = taskIdEl.value;
+            setStatus('Starting a new scenario...');
+            try {
+                const payload = { task_id: taskId };
+                if (taskId === 'task_production') {
+                    payload.production_profile = document.getElementById('productionProfile').value;
+                    payload.business_hours_mode = document.getElementById('businessHoursMode').value === 'true';
+                    payload.escalation_mode = document.getElementById('escalationMode').value;
+                }
+                const data = await postJson('/reset', payload);
+                setStatus('Scenario started. Read the email below.');
+                updateEmailPanel(data);
+                updateInsights(data);
+                writeOutput(data);
+            } catch (e) {
+                setStatus('Could not start scenario. See details below.', true);
+                writeOutput(String(e));
+            }
+        });
+
+        document.getElementById('btnState').addEventListener('click', async () => {
+            setStatus('Checking progress...');
+            try {
+                const data = await postJson('/state', {});
+                setStatus('Progress updated.');
+                updateInsights(data);
+                writeOutput(data);
+            } catch (e) {
+                setStatus('Could not fetch progress. See details below.', true);
+                writeOutput(String(e));
+            }
+        });
+
+        document.getElementById('btnStep').addEventListener('click', async () => {
+            const payload = {
+                label: document.getElementById('label').value,
+                summary: document.getElementById('summary').value,
+                route_to: document.getElementById('routeTo').value,
+            };
+            setStatus('Sending your decision...');
+            try {
+                const data = await postJson('/step', payload);
+                setStatus('Decision saved.');
+                updateEmailPanel(data);
+                updateInsights(data);
+                writeOutput(data);
+            } catch (e) {
+                setStatus('Could not submit decision. See details below.', true);
+                writeOutput(String(e));
+            }
+        });
+
+        document.getElementById('chipSafety').addEventListener('click', () => {
+            prefillAction('urgent', 'safety', 'Potential safety risk with immediate escalation needed.');
+        });
+
+        document.getElementById('chipBilling').addEventListener('click', () => {
+            prefillAction('normal', 'billing', 'Customer billing issue needs finance team review and response.');
+        });
+
+        document.getElementById('chipSpam').addEventListener('click', () => {
+            prefillAction('spam', 'general', 'Likely phishing or irrelevant message with suspicious external request.');
+        });
+
+        taskIdEl.addEventListener('change', updateProductionControlsVisibility);
+
+        updateProductionControlsVisibility();
+        warmup();
+    </script>
+</body>
+</html>
+"""
+
+app = Flask(__name__)
+current_env = EmailTriageEnv(task_id="task_easy")
+SCENARIO_COUNTERS = {task_id: 0 for task_id in list_task_ids()}
+DEFAULT_EVAL_SPLIT = os.getenv("OPENENV_EVAL_SPLIT", "public")
+ALLOW_CLIENT_EVAL_OVERRIDE = (
+    os.getenv("OPENENV_ALLOW_CLIENT_EVAL_OVERRIDE", "false").strip().lower() == "true"
+)
+
+
+@app.get("/")
+def root_page():
+    """Render a lightweight frontend for interacting with the environment."""
+    return Response(FRONTEND_HTML, mimetype="text/html")
+
+
+@app.get("/meta")
+def root_endpoint():
+    """Return service metadata for health checks and machine clients."""
+    return jsonify(
+        {
+            "name": "email-triage-env",
+            "status": "ok",
+            "endpoints": {
+                "reset": {"method": "POST", "path": "/reset"},
+                "step": {"method": "POST", "path": "/step"},
+                "state": {"method": "POST", "path": "/state"},
+            },
+            "scenario_pools": {
+                "public": {
+                    task_id: get_task_scenario_count(task_id, "public")
+                    for task_id in list_task_ids()
+                },
+            },
+            "eval_split": DEFAULT_EVAL_SPLIT,
+            "production_runtime_controls": {
+                "production_profile": ["light", "standard", "heavy"],
+                "business_hours_mode": [True, False],
+                "escalation_mode": ["low", "normal", "high"],
+            },
+        }
+    )
+
+
+@app.post("/reset")
+def reset_endpoint():
+    """Reset the environment with a selected task and return ResetResult JSON.
+
+    Returns:
+        Flask response containing reset payload.
+    """
+    global current_env
+    global SCENARIO_COUNTERS
+
+    payload = request.get_json(silent=True)
+    if payload is None:
+        payload = {}
+    elif not isinstance(payload, dict):
+        return jsonify({"error": "Malformed JSON payload."}), 400
+
+    task_id = payload.get("task_id", "task_easy")
+    if not isinstance(task_id, str):
+        return jsonify({"error": "Field 'task_id' must be a string."}), 400
+
+    runtime_options: dict[str, object] = {}
+    if task_id == "task_production":
+        production_profile = payload.get("production_profile", "standard")
+        if not isinstance(production_profile, str) or production_profile not in {
+            "light",
+            "standard",
+            "heavy",
+        }:
+            return (
+                jsonify(
+                    {
+                        "error": (
+                            "Field 'production_profile' must be one of "
+                            "light/standard/heavy."
+                        )
+                    }
+                ),
+                400,
+            )
+
+        escalation_mode = payload.get("escalation_mode", "normal")
+        if not isinstance(escalation_mode, str) or escalation_mode not in {
+            "low",
+            "normal",
+            "high",
+        }:
+            return (
+                jsonify(
+                    {
+                        "error": (
+                            "Field 'escalation_mode' must be one of "
+                            "low/normal/high."
+                        )
+                    }
+                ),
+                400,
+            )
+
+        business_hours_mode = payload.get("business_hours_mode", False)
+        if isinstance(business_hours_mode, str):
+            business_hours_mode = business_hours_mode.strip().lower() in {
+                "1",
+                "true",
+                "yes",
+                "on",
+            }
+        elif not isinstance(business_hours_mode, bool):
+            return jsonify({"error": "Field 'business_hours_mode' must be boolean."}), 400
+
+        runtime_options = {
+            "production_profile": production_profile,
+            "business_hours_mode": business_hours_mode,
+            "escalation_mode": escalation_mode,
+        }
+
+    if not ALLOW_CLIENT_EVAL_OVERRIDE and (
+        "eval_split" in payload or "scenario_index" in payload
+    ):
+        return jsonify(
+            {
+                "error": (
+                    "Client overrides for eval_split/scenario_index are disabled "
+                    "by server policy."
+                )
+            }
+        ), 400
+
+    eval_split = DEFAULT_EVAL_SPLIT
+    if ALLOW_CLIENT_EVAL_OVERRIDE:
+        requested_split = payload.get("eval_split", DEFAULT_EVAL_SPLIT)
+        if not isinstance(requested_split, str):
+            return jsonify({"error": "Field 'eval_split' must be a string."}), 400
+        eval_split = requested_split
+
+    requested_index = payload.get("scenario_index") if ALLOW_CLIENT_EVAL_OVERRIDE else None
+    if requested_index is not None and (not isinstance(requested_index, int) or requested_index < 0):
+        return jsonify({"error": "Field 'scenario_index' must be a non-negative integer."}), 400
+
+    try:
+        scenario_count = get_task_scenario_count(task_id, eval_split)
+        if requested_index is None:
+            scenario_index = SCENARIO_COUNTERS.get(task_id, 0)
+            if scenario_count > 0:
+                SCENARIO_COUNTERS[task_id] = (scenario_index + 1) % scenario_count
+        else:
+            scenario_index = requested_index
+
+        current_env = EmailTriageEnv(
+            task_id=task_id,
+            scenario_index=scenario_index,
+            split=eval_split,
+            runtime_options=runtime_options,
+        )
+        reset_result = current_env.reset()
+    except KeyError as error:
+        return jsonify({"error": str(error)}), 400
+
+    return jsonify(reset_result.model_dump())
+
+
+@app.post("/step")
+def step_endpoint():
+    """Advance environment by one action and return StepResult JSON.
+
+    Returns:
+        Flask response containing step payload.
+    """
+    payload = request.get_json(silent=True)
+    if payload is None:
+        return jsonify({"error": "Malformed JSON payload."}), 400
+
+    step_result = current_env.step(payload)
+    return jsonify(step_result.model_dump())
+
+
+@app.post("/state")
+def state_endpoint():
+    """Return read-only EnvironmentState JSON snapshot.
+
+    Returns:
+        Flask response containing state payload.
+    """
+    state_result = current_env.state()
+    return jsonify(state_result.model_dump())
+
+
+def main() -> None:
+    """Run the Flask app for local and script-based launches."""
+    app.run(host="0.0.0.0", port=7860)
+
+
+if __name__ == "__main__":
+    main()