feat: competitive upgrade for hackathon submission

- inference.py: single-task mode via TASK_ID env var; clean warn/exit on invalid IDs
- models.py: add last_step_reward, done, history_entries to HelpdeskTicketState
- environment.py: state tracking, enriched history (title+predicted), ambiguity_note
in observations, extra-field penalty validation, SUPPORTS_CONCURRENT_SESSIONS=True
- reward.py: milestone shaping (+/-0.05 at score thresholds), remove overshoot penalty
- app.py: add GET /web HTML status page
- openenv.yaml: clarify entry_point vs pyproject.toml server script
- dataset.json: add 3 non-default routing tickets (TKT-NONDEFAULT-001/002/003)
- tests: test_competitive_upgrade.py (36 tests) + test_extra_fields_penalty.py (7 tests)

data/dataset.json

@@ -538,6 +538,42 @@
         "resolution_action":  "escalate",
         "ambiguity_note":  null,
         "related_ticket_id":  "ticket-030"
+    },
+    {
+        "ticket_id":  "TKT-NONDEFAULT-001",
+        "title":  "Billing question from free-tier account",
+        "requester":  "user@freetier.io",
+        "description":  "I have a question about my invoice but I am on the free plan and there is no charge. The billing team cannot action this; please route to service desk for general assistance.",
+        "issue_type":  "billing_license",
+        "priority":  "low",
+        "assignment_group":  "service_desk",
+        "resolution_action":  "fulfill",
+        "ambiguity_note":  "Account tier is free; billing team cannot action, routed to service desk",
+        "related_ticket_id":  null
+    },
+    {
+        "ticket_id":  "TKT-NONDEFAULT-002",
+        "title":  "App vulnerability flagged in compliance scan",
+        "requester":  "security@clientcorp.com",
+        "description":  "Our compliance scan flagged a product-specific vulnerability in the application layer. This is not a general security policy issue but an app bug requiring the application team to remediate.",
+        "issue_type":  "security_compliance",
+        "priority":  "high",
+        "assignment_group":  "application_team",
+        "resolution_action":  "escalate",
+        "ambiguity_note":  "Compliance issue is product-specific (app vulnerability), routed to app team",
+        "related_ticket_id":  null
+    },
+    {
+        "ticket_id":  "TKT-NONDEFAULT-003",
+        "title":  "Contractor onboarding blocked by access issue",
+        "requester":  "pm@contractorco.com",
+        "description":  "A new contractor cannot complete onboarding because their account access is blocked by a permissions error. The onboarding team cannot resolve access issues; routing to service desk.",
+        "issue_type":  "onboarding",
+        "priority":  "medium",
+        "assignment_group":  "service_desk",
+        "resolution_action":  "fulfill",
+        "ambiguity_note":  "Contractor onboarding blocked by access issue, routed to service desk",
+        "related_ticket_id":  null
     }
 ]
 

inference.py

@@ -64,7 +64,7 @@ LOCAL_IMAGE_NAME = os.getenv("LOCAL_IMAGE_NAME")
 ENV_URL = os.getenv("ENV_URL", "http://localhost:7860")
 
 SEED = 42
-TASKS = list(TASK_IDS)
+TASK_ID_ENV = os.getenv("TASK_ID")
 
 # ---------------------------------------------------------------------------
 # LLM helper
@@ -134,6 +134,20 @@ def emit_log(tag: str, **payload: Any) -> None:
     print(f"[{tag}] {json.dumps(payload, sort_keys=True, ensure_ascii=True)}")
 
 
+def get_tasks_to_run(available_tasks: dict) -> list[int]:
+    if TASK_ID_ENV:
+        try:
+            task_id = int(TASK_ID_ENV)
+        except ValueError:
+            print(f"[ERROR] TASK_ID={TASK_ID_ENV!r} is not a valid integer", flush=True)
+            raise SystemExit(1)
+        if task_id not in available_tasks:
+            print(f"[WARN] TASK_ID={task_id} not in available tasks {list(available_tasks)}", flush=True)
+            return []
+        return [task_id]
+    return list(TASK_IDS)  # fallback: all tasks (local dev)
+
+
 # ---------------------------------------------------------------------------
 # Heuristic fallback (no LLM needed)
 # ---------------------------------------------------------------------------
@@ -332,7 +346,10 @@ def run() -> None:
 
     all_results: dict[int, dict[str, float | int]] = {}
 
-    for task_id in TASKS:
+    tasks_to_run = get_tasks_to_run(available_tasks)
+    single_task_mode = bool(TASK_ID_ENV)
+
+    for task_id in tasks_to_run:
         if task_id not in available_tasks:
             continue
 
@@ -400,11 +417,12 @@ def run() -> None:
 
     overall = [
         float(all_results[task_id]["final_reward"])
-        for task_id in TASKS
+        for task_id in tasks_to_run
         if task_id in all_results
     ]
-    overall_avg = round(sum(overall) / len(overall), 4) if overall else 0.0
-    emit_log("END", overall_avg=overall_avg, tasks_completed=len(overall))
+    if not single_task_mode:
+        overall_avg = round(sum(overall) / len(overall), 4) if overall else 0.0
+        emit_log("END", overall_avg=overall_avg, tasks_completed=len(overall))
 
 
 if __name__ == "__main__":

models.py

@@ -112,3 +112,6 @@ class HelpdeskTicketState(State):
     current_ticket_index: int = 0
     per_ticket_scores: list[float] = Field(default_factory=list)
     total_reward: float = 0.0
+    last_step_reward: Optional[float] = None
+    done: bool = False
+    history_entries: list[dict] = Field(default_factory=list)

openenv.yaml

@@ -7,6 +7,9 @@ author: Hackstreet Boys - Roopal Guha Neogi, Suyash Kumar
 
 environment:
   type: openenv
+  # entry_point identifies the Environment class for the OpenEnv validator.
+  # The HTTP server entrypoint for deployment is defined separately in
+  # pyproject.toml under [project.scripts] as: server = "server.app:main"
   entry_point: server.environment:HelpdeskTicketRoutingEnvironment
   action_model: models:HelpdeskTicketAction
   observation_model: models:HelpdeskTicketObservation

server/app.py

@@ -6,6 +6,7 @@ _repo_root = str(Path(__file__).resolve().parent.parent)
 if _repo_root not in sys.path:
     sys.path.insert(0, _repo_root)
 
+from fastapi.responses import HTMLResponse
 from openenv.core.env_server import create_app
 
 from models import HelpdeskTicketAction, HelpdeskTicketObservation
@@ -37,6 +38,25 @@ def list_tasks():
     }
 
 
+@app.get("/web", response_class=HTMLResponse)
+def web_ui():
+    task_rows = "".join(
+        f"<tr><td>{t['id']}</td><td>{t['name']}</td><td>{t['difficulty']}</td></tr>"
+        for t in TASKS.values()
+    )
+    html = f"""<!DOCTYPE html>
+<html><head><title>{APP_ENV_NAME}</title></head>
+<body>
+<h1>{APP_ENV_NAME}</h1>
+<p>Version: 0.1.0 | <a href="/health">Health</a> | <a href="/docs">API Docs</a></p>
+<h2>Tasks</h2>
+<table border="1"><tr><th>ID</th><th>Name</th><th>Difficulty</th></tr>
+{task_rows}
+</table>
+</body></html>"""
+    return HTMLResponse(content=html)
+
+
 def main() -> None:
     import uvicorn
 

server/environment.py

@@ -36,6 +36,8 @@ def _coerce_optional_int(value: Any, field_name: str) -> Optional[int]:
 class HelpdeskTicketRoutingEnvironment(
     Environment[HelpdeskTicketAction, HelpdeskTicketObservation, HelpdeskTicketState]
 ):
+    SUPPORTS_CONCURRENT_SESSIONS = True
+
     def __init__(self) -> None:
         super().__init__()
         self._dataset = load_dataset()
@@ -94,16 +96,43 @@ class HelpdeskTicketRoutingEnvironment(
         task_id = self._state.current_task_id
         task = get_task_definition(task_id)
 
+        submitted_fields = {
+            f for f, v in action.model_dump(exclude_none=True).items() if v is not None
+        }
+        allowed = set(task["allowed_fields"])
+        extra_fields = submitted_fields - allowed
+        if extra_fields:
+            # Penalty: record score 0.0, advance index, return penalty observation
+            self._state.per_ticket_scores.append(0.0)
+            self._state.history_entries.append({
+                "ticket_id": current_ticket.ticket_id,
+                "title": current_ticket.title,
+                "predicted": action.model_dump(exclude_none=True),
+                "score": 0.0,
+                "breakdown": {},
+                "penalty_reason": f"extra_fields: {sorted(extra_fields)}",
+            })
+            self._state.step_count += 1
+            self._state.current_ticket_index += 1
+            is_done = self._state.current_ticket_index >= len(self._queue)
+            self._state.last_step_reward = 0.0
+            self._state.done = is_done
+            if is_done:
+                traj_reward = compute_trajectory_reward(
+                    self._state.per_ticket_scores, len(self._queue), self._state.step_count
+                )
+                self._state.total_reward = traj_reward
+            return self._build_observation(task, done=is_done, reward=0.0)
+
         score, breakdown = grade_action(action, current_ticket, task_id)
         step_reward = compute_step_reward(score)
 
-        self._state.per_ticket_scores.append(score)
-        self._state.step_count += 1
-        self._state.current_ticket_index += 1
-
-        is_done = self._state.current_ticket_index >= len(self._queue)
+        is_done = (self._state.current_ticket_index + 1) >= len(self._queue)
 
         if is_done:
+            self._state.per_ticket_scores.append(score)
+            self._state.step_count += 1
+            self._state.current_ticket_index += 1
             traj_reward = compute_trajectory_reward(
                 self._state.per_ticket_scores,
                 len(self._queue),
@@ -112,20 +141,24 @@ class HelpdeskTicketRoutingEnvironment(
             self._state.total_reward = traj_reward
             final_reward = traj_reward
         else:
+            self._state.per_ticket_scores.append(score)
+            self._state.step_count += 1
+            self._state.current_ticket_index += 1
             final_reward = step_reward
 
         history_entry = {
             "ticket_id": current_ticket.ticket_id,
+            "title": current_ticket.title,
+            "predicted": action.model_dump(exclude_none=True),
             "score": score,
             "breakdown": breakdown,
         }
+        self._state.history_entries.append(history_entry)
 
-        return self._build_observation(
-            task,
-            done=is_done,
-            reward=final_reward,
-            extra_history=history_entry,
-        )
+        self._state.last_step_reward = final_reward
+        self._state.done = is_done
+
+        return self._build_observation(task, done=is_done, reward=final_reward)
 
     @property
     def state(self) -> HelpdeskTicketState:
@@ -140,27 +173,26 @@ class HelpdeskTicketRoutingEnvironment(
         task: dict,
         done: bool = False,
         reward: float | None = None,
-        extra_history: dict | None = None,
     ) -> HelpdeskTicketObservation:
         idx = self._state.current_ticket_index
         queue_size = len(self._queue)
 
         if idx < queue_size:
             ticket = self._queue[idx]
-            ticket_view = {
+            ticket_view: dict[str, Any] = {
                 "ticket_id": ticket.ticket_id,
                 "title": ticket.title,
                 "requester": ticket.requester,
                 "description": ticket.description,
             }
+            if ticket.ambiguity_note is not None:
+                ticket_view["ambiguity_note"] = ticket.ambiguity_note
+            if ticket.related_ticket_id is not None:
+                ticket_view["related_ticket_id"] = ticket.related_ticket_id
         else:
             ticket_view = None
 
-        history: list[dict] = []
-        for i, s in enumerate(self._state.per_ticket_scores):
-            history.append({"step": i + 1, "score": s})
-        if extra_history and history:
-            history[-1] = {"step": len(history), **extra_history}
+        history = list(self._state.history_entries)
 
         return HelpdeskTicketObservation(
             done=done,
@@ -172,6 +204,7 @@ class HelpdeskTicketRoutingEnvironment(
             allowed_fields=list(task["allowed_fields"]),
             current_ticket=ticket_view,
             queue_size=queue_size,
+            # tickets_remaining: count of tickets not yet processed after this step
             tickets_remaining=max(0, queue_size - idx),
             tickets_processed=idx,
             history=history,

server/reward.py

@@ -1,8 +1,18 @@
 from __future__ import annotations
 
+MILESTONE_HIGH_THRESHOLD = 0.8
+MILESTONE_LOW_THRESHOLD = 0.2
+MILESTONE_BONUS = 0.05
+MILESTONE_PENALTY = 0.05
+
 
 def compute_step_reward(score: float) -> float:
-    return max(0.0, min(1.0, score))
+    base = max(0.0, min(1.0, score))
+    if score >= MILESTONE_HIGH_THRESHOLD:
+        return min(1.0, base + MILESTONE_BONUS)
+    if score < MILESTONE_LOW_THRESHOLD:
+        return max(0.0, base - MILESTONE_PENALTY)
+    return base
 
 
 def compute_trajectory_reward(
@@ -11,6 +21,4 @@ def compute_trajectory_reward(
     if not per_ticket_scores:
         return 0.0
     avg = sum(per_ticket_scores) / len(per_ticket_scores)
-    overshoot = max(0, steps_taken - queue_size)
-    penalty = overshoot * 0.03
-    return max(0.0, min(1.0, avg - penalty))
+    return max(0.0, min(1.0, avg))

tests/test_competitive_upgrade.py

@@ -0,0 +1,468 @@
+"""
+Tests for the helpdesk-competitive-upgrade spec (Task 9).
+
+Covers:
+  9.1  test_inference_single_task_mode
+  9.2  test_state_has_reward_and_done
+  9.3  test_history_has_title_and_predicted
+  9.4  test_milestone_reward_shaping
+  9.5  test_trajectory_reward_no_overshoot
+  9.6  test_ambiguity_note_in_observation
+  9.7  test_dataset_nondefault_routing
+  9.9  test_concurrent_sessions_flag
+  9.10 test_web_ui_endpoint
+
+Run with:
+    pytest tests/test_competitive_upgrade.py
+"""
+from __future__ import annotations
+
+import os
+import sys
+import types as _types
+import unittest
+
+# Ensure repo root is on sys.path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+import openenv_test_stubs  # noqa: F401  — must come before any openenv imports
+
+# Patch in the interfaces module so environment.py can import Environment.
+if "openenv.core.env_server.interfaces" not in sys.modules:
+    _interfaces_mod = _types.ModuleType("openenv.core.env_server.interfaces")
+
+    class _Environment:
+        """Minimal stub matching the openenv-core Environment base class."""
+
+        def __init__(self) -> None:
+            pass
+
+        def __init_subclass__(cls, **kwargs: object) -> None:
+            super().__init_subclass__(**kwargs)
+
+        @classmethod
+        def __class_getitem__(cls, item: object) -> type:
+            return cls
+
+    _interfaces_mod.Environment = _Environment  # type: ignore[attr-defined]
+    sys.modules["openenv.core.env_server.interfaces"] = _interfaces_mod
+
+
+from models import HelpdeskTicketAction, HelpdeskTicketObservation, HelpdeskTicketState
+from server.environment import HelpdeskTicketRoutingEnvironment
+from server.reward import compute_step_reward, compute_trajectory_reward
+from server.tasks import load_dataset
+from vocabulary import ISSUE_TYPES, PRIORITIES, ASSIGNMENT_GROUPS, RESOLUTION_ACTIONS, TASK_IDS
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _make_env() -> HelpdeskTicketRoutingEnvironment:
+    return HelpdeskTicketRoutingEnvironment()
+
+
+def _heuristic_action(obs: HelpdeskTicketObservation) -> HelpdeskTicketAction:
+    allowed = obs.allowed_fields
+    kwargs: dict = {}
+    if "issue_type" in allowed:
+        kwargs["issue_type"] = ISSUE_TYPES[0]
+    if "priority" in allowed:
+        kwargs["priority"] = PRIORITIES[0]
+    if "assignment_group" in allowed:
+        kwargs["assignment_group"] = ASSIGNMENT_GROUPS[0]
+    if "resolution_action" in allowed:
+        kwargs["resolution_action"] = RESOLUTION_ACTIONS[0]
+    return HelpdeskTicketAction(**kwargs)
+
+
+# ---------------------------------------------------------------------------
+# 9.1 — Inference single-task mode
+# ---------------------------------------------------------------------------
+
+def _get_tasks_to_run_impl(task_id_env: str | None, available_tasks: dict) -> list[int]:
+    """
+    Standalone re-implementation of inference.get_tasks_to_run() logic for testing.
+
+    This mirrors the logic in inference.py without importing the full module
+    (which has heavy dependencies like openai, httpx, and client.py).
+    """
+    if task_id_env:
+        try:
+            task_id = int(task_id_env)
+        except ValueError:
+            raise SystemExit(1)
+        if task_id not in available_tasks:
+            return []
+        return [task_id]
+    return list(TASK_IDS)
+
+
+class TestInferenceSingleTaskMode(unittest.TestCase):
+    """9.1 — get_tasks_to_run() respects TASK_ID env var."""
+
+    def test_task_id_set_to_valid_id_returns_single_element_list(self) -> None:
+        available = {1: {}, 2: {}, 3: {}}
+        result = _get_tasks_to_run_impl("1", available)
+        self.assertEqual(result, [1])
+
+    def test_task_id_set_to_unavailable_id_returns_empty_list(self) -> None:
+        available = {1: {}, 2: {}, 3: {}}
+        result = _get_tasks_to_run_impl("999", available)
+        self.assertEqual(result, [])
+
+    def test_task_id_unset_returns_all_task_ids(self) -> None:
+        available = {1: {}, 2: {}, 3: {}}
+        result = _get_tasks_to_run_impl(None, available)
+        self.assertEqual(sorted(result), sorted(list(TASK_IDS)))
+
+    def test_task_id_set_to_2_returns_only_task_2(self) -> None:
+        available = {1: {}, 2: {}, 3: {}}
+        result = _get_tasks_to_run_impl("2", available)
+        self.assertEqual(result, [2])
+
+    def test_task_id_set_to_3_returns_only_task_3(self) -> None:
+        available = {1: {}, 2: {}, 3: {}}
+        result = _get_tasks_to_run_impl("3", available)
+        self.assertEqual(result, [3])
+
+
+# ---------------------------------------------------------------------------
+# 9.2 — State has last_step_reward and done after step()
+# ---------------------------------------------------------------------------
+
+class TestStateHasRewardAndDone(unittest.TestCase):
+    """9.2 — state.last_step_reward and state.done are set after step()."""
+
+    def test_last_step_reward_is_none_after_reset(self) -> None:
+        env = _make_env()
+        env.reset(seed=42, task_id=1)
+        self.assertIsNone(env.state.last_step_reward)
+
+    def test_done_is_false_after_reset(self) -> None:
+        env = _make_env()
+        env.reset(seed=42, task_id=1)
+        self.assertFalse(env.state.done)
+
+    def test_last_step_reward_set_after_step(self) -> None:
+        env = _make_env()
+        obs = env.reset(seed=42, task_id=1)
+        action = _heuristic_action(obs)
+        env.step(action)
+        state = env.state
+        self.assertIsNotNone(state.last_step_reward)
+        self.assertGreaterEqual(state.last_step_reward, 0.0)
+        self.assertLessEqual(state.last_step_reward, 1.0)
+
+    def test_done_is_true_after_last_ticket(self) -> None:
+        env = _make_env()
+        obs = env.reset(seed=42, task_id=1)
+        while not obs.done:
+            obs = env.step(_heuristic_action(obs))
+        self.assertTrue(env.state.done)
+
+    def test_done_is_false_before_last_ticket(self) -> None:
+        env = _make_env()
+        obs = env.reset(seed=42, task_id=1)
+        if obs.queue_size > 1:
+            obs = env.step(_heuristic_action(obs))
+            self.assertFalse(env.state.done)
+
+
+# ---------------------------------------------------------------------------
+# 9.3 — History entry contains title and predicted
+# ---------------------------------------------------------------------------
+
+class TestHistoryHasTitleAndPredicted(unittest.TestCase):
+    """9.3 — observation.history[0] contains 'title' and 'predicted' keys."""
+
+    def test_history_entry_has_title(self) -> None:
+        env = _make_env()
+        obs = env.reset(seed=42, task_id=1)
+        action = _heuristic_action(obs)
+        obs2 = env.step(action)
+        self.assertEqual(len(obs2.history), 1)
+        self.assertIn("title", obs2.history[0])
+        self.assertIsInstance(obs2.history[0]["title"], str)
+        self.assertTrue(obs2.history[0]["title"])  # non-empty
+
+    def test_history_entry_has_predicted(self) -> None:
+        env = _make_env()
+        obs = env.reset(seed=42, task_id=1)
+        action = _heuristic_action(obs)
+        obs2 = env.step(action)
+        self.assertIn("predicted", obs2.history[0])
+        self.assertIsInstance(obs2.history[0]["predicted"], dict)
+
+    def test_history_predicted_matches_action(self) -> None:
+        env = _make_env()
+        obs = env.reset(seed=42, task_id=1)
+        action = _heuristic_action(obs)
+        obs2 = env.step(action)
+        predicted = obs2.history[0]["predicted"]
+        action_dict = action.model_dump(exclude_none=True)
+        self.assertEqual(predicted, action_dict)
+
+    def test_history_entry_has_ticket_id_and_score(self) -> None:
+        env = _make_env()
+        obs = env.reset(seed=42, task_id=1)
+        obs2 = env.step(_heuristic_action(obs))
+        entry = obs2.history[0]
+        self.assertIn("ticket_id", entry)
+        self.assertIn("score", entry)
+
+
+# ---------------------------------------------------------------------------
+# 9.4 — Milestone reward shaping
+# ---------------------------------------------------------------------------
+
+class TestMilestoneRewardShaping(unittest.TestCase):
+    """9.4 — compute_step_reward applies bonus at high scores, penalty at low scores."""
+
+    def test_high_score_gets_bonus(self) -> None:
+        # score=0.9 >= 0.8 threshold → base=0.9, bonus=0.05 → 0.95
+        result = compute_step_reward(0.9)
+        self.assertAlmostEqual(result, 0.95, places=9)
+
+    def test_low_score_gets_penalty(self) -> None:
+        # score=0.1 < 0.2 threshold → base=0.1, penalty=0.05 → 0.05
+        result = compute_step_reward(0.1)
+        self.assertAlmostEqual(result, 0.05, places=9)
+
+    def test_mid_score_is_neutral(self) -> None:
+        # score=0.5 is in [0.2, 0.8) → no shaping → 0.5
+        result = compute_step_reward(0.5)
+        self.assertAlmostEqual(result, 0.5, places=9)
+
+    def test_boundary_high_threshold_gets_bonus(self) -> None:
+        # score=0.8 exactly → bonus applies → 0.85
+        result = compute_step_reward(0.8)
+        self.assertAlmostEqual(result, 0.85, places=9)
+
+    def test_boundary_low_threshold_is_neutral(self) -> None:
+        # score=0.2 exactly → not < 0.2, so neutral → 0.2
+        result = compute_step_reward(0.2)
+        self.assertAlmostEqual(result, 0.2, places=9)
+
+    def test_reward_clamped_to_unit_interval(self) -> None:
+        # score=1.0 → base=1.0, bonus would push to 1.05 → clamped to 1.0
+        result = compute_step_reward(1.0)
+        self.assertLessEqual(result, 1.0)
+        self.assertGreaterEqual(result, 0.0)
+
+    def test_zero_score_clamped_to_zero(self) -> None:
+        # score=0.0 < 0.2 → base=0.0, penalty → max(0.0, -0.05) = 0.0
+        result = compute_step_reward(0.0)
+        self.assertGreaterEqual(result, 0.0)
+
+
+# ---------------------------------------------------------------------------
+# 9.5 — Trajectory reward has no overshoot penalty
+# ---------------------------------------------------------------------------
+
+class TestTrajectoryRewardNoOvershoot(unittest.TestCase):
+    """9.5 — compute_trajectory_reward does not penalise when steps > queue_size."""
+
+    def test_no_penalty_when_steps_exceed_queue_size(self) -> None:
+        scores = [0.8, 0.9, 0.7]
+        queue_size = 3
+        steps_taken = 10  # more steps than queue_size
+        result = compute_trajectory_reward(scores, queue_size, steps_taken)
+        expected_avg = sum(scores) / len(scores)
+        self.assertAlmostEqual(result, expected_avg, places=9)
+
+    def test_result_equals_average_regardless_of_steps(self) -> None:
+        scores = [0.5, 0.6]
+        for steps in [1, 2, 5, 100]:
+            result = compute_trajectory_reward(scores, len(scores), steps)
+            self.assertAlmostEqual(result, 0.55, places=9,
+                                   msg=f"Failed for steps={steps}")
+
+    def test_empty_scores_returns_zero(self) -> None:
+        self.assertEqual(compute_trajectory_reward([], 3, 3), 0.0)
+
+    def test_result_in_unit_interval(self) -> None:
+        scores = [0.9, 1.0, 0.95]
+        result = compute_trajectory_reward(scores, 3, 3)
+        self.assertGreaterEqual(result, 0.0)
+        self.assertLessEqual(result, 1.0)
+
+
+# ---------------------------------------------------------------------------
+# 9.6 — ambiguity_note appears in current_ticket observation
+# ---------------------------------------------------------------------------
+
+class TestAmbiguityNoteInObservation(unittest.TestCase):
+    """9.6 — current_ticket includes ambiguity_note when the ticket has one."""
+
+    def _find_seed_with_ambiguity_note(self, task_id: int = 3) -> int | None:
+        """Try seeds 0..999 to find one where the first ticket has ambiguity_note."""
+        env = _make_env()
+        for seed in range(1000):
+            obs = env.reset(seed=seed, task_id=task_id)
+            if obs.current_ticket and obs.current_ticket.get("ambiguity_note"):
+                return seed
+        return None
+
+    def test_ambiguity_note_present_when_ticket_has_one(self) -> None:
+        """Force a ticket with ambiguity_note by patching the dataset."""
+        from unittest.mock import patch
+        from server.tasks import load_dataset
+
+        dataset = load_dataset()
+        # Find a ticket with ambiguity_note
+        ambiguous_tickets = [t for t in dataset if t.ambiguity_note is not None]
+        self.assertGreater(len(ambiguous_tickets), 0, "No tickets with ambiguity_note in dataset")
+
+        target = ambiguous_tickets[0]
+
+        env = _make_env()
+        # Patch the dataset to only contain the ambiguous ticket
+        with patch.object(env, "_dataset", [target]):
+            obs = env.reset(seed=0, task_id=3)
+
+        self.assertIsNotNone(obs.current_ticket)
+        self.assertIn("ambiguity_note", obs.current_ticket)
+        self.assertEqual(obs.current_ticket["ambiguity_note"], target.ambiguity_note)
+
+    def test_ambiguity_note_absent_when_ticket_has_none(self) -> None:
+        """Tickets without ambiguity_note should not expose the key."""
+        from unittest.mock import patch
+        from server.tasks import load_dataset
+
+        dataset = load_dataset()
+        non_ambiguous = [t for t in dataset if t.ambiguity_note is None]
+        self.assertGreater(len(non_ambiguous), 0)
+
+        target = non_ambiguous[0]
+        env = _make_env()
+        with patch.object(env, "_dataset", [target]):
+            obs = env.reset(seed=0, task_id=3)
+
+        self.assertIsNotNone(obs.current_ticket)
+        self.assertNotIn("ambiguity_note", obs.current_ticket)
+
+    def test_tkt_nondefault_001_has_ambiguity_note(self) -> None:
+        """TKT-NONDEFAULT-001 specifically has ambiguity_note set."""
+        from unittest.mock import patch
+        from server.tasks import load_dataset
+
+        dataset = load_dataset()
+        ticket = next((t for t in dataset if t.ticket_id == "TKT-NONDEFAULT-001"), None)
+        self.assertIsNotNone(ticket, "TKT-NONDEFAULT-001 not found in dataset")
+        self.assertIsNotNone(ticket.ambiguity_note)
+
+        env = _make_env()
+        with patch.object(env, "_dataset", [ticket]):
+            obs = env.reset(seed=0, task_id=3)
+
+        self.assertIn("ambiguity_note", obs.current_ticket)
+
+
+# ---------------------------------------------------------------------------
+# 9.7 — Dataset has >= 3 non-default routing tickets
+# ---------------------------------------------------------------------------
+
+class TestDatasetNonDefaultRouting(unittest.TestCase):
+    """9.7 — Dataset contains at least 3 tickets with non-default assignment_group."""
+
+    def test_at_least_three_nondefault_routing_tickets(self) -> None:
+        from vocabulary import ISSUE_TYPE_TO_ASSIGNMENT_GROUP
+
+        dataset = load_dataset()
+        non_default = [
+            t for t in dataset
+            if t.assignment_group != ISSUE_TYPE_TO_ASSIGNMENT_GROUP.get(t.issue_type)
+        ]
+        self.assertGreaterEqual(
+            len(non_default), 3,
+            f"Expected >= 3 non-default routing tickets, found {len(non_default)}: "
+            + str([(t.ticket_id, t.issue_type, t.assignment_group) for t in non_default])
+        )
+
+    def test_tkt_nondefault_tickets_exist(self) -> None:
+        dataset = load_dataset()
+        ids = {t.ticket_id for t in dataset}
+        for expected_id in ("TKT-NONDEFAULT-001", "TKT-NONDEFAULT-002", "TKT-NONDEFAULT-003"):
+            self.assertIn(expected_id, ids, f"{expected_id} not found in dataset")
+
+
+# ---------------------------------------------------------------------------
+# 9.9 — SUPPORTS_CONCURRENT_SESSIONS is True
+# ---------------------------------------------------------------------------
+
+class TestConcurrentSessionsFlag(unittest.TestCase):
+    """9.9 — HelpdeskTicketRoutingEnvironment.SUPPORTS_CONCURRENT_SESSIONS is True."""
+
+    def test_supports_concurrent_sessions_is_true(self) -> None:
+        self.assertTrue(HelpdeskTicketRoutingEnvironment.SUPPORTS_CONCURRENT_SESSIONS)
+
+    def test_flag_is_boolean_true(self) -> None:
+        flag = HelpdeskTicketRoutingEnvironment.SUPPORTS_CONCURRENT_SESSIONS
+        self.assertIs(flag, True)
+
+
+# ---------------------------------------------------------------------------
+# 9.10 — GET /web returns 200 with HTML content
+# ---------------------------------------------------------------------------
+
+def _build_web_test_app():
+    """Build a minimal FastAPI app with only the /web route for testing."""
+    from fastapi import FastAPI
+    from fastapi.responses import HTMLResponse
+    from server.tasks import TASKS
+    from vocabulary import APP_ENV_NAME
+
+    _app = FastAPI()
+
+    @_app.get("/web", response_class=HTMLResponse)
+    def web_ui():
+        task_rows = "".join(
+            f"<tr><td>{t['id']}</td><td>{t['name']}</td><td>{t['difficulty']}</td></tr>"
+            for t in TASKS.values()
+        )
+        html = f"""<!DOCTYPE html>
+<html><head><title>{APP_ENV_NAME}</title></head>
+<body>
+<h1>{APP_ENV_NAME}</h1>
+<p>Version: 0.1.0 | <a href="/health">Health</a> | <a href="/docs">API Docs</a></p>
+<h2>Tasks</h2>
+<table border="1"><tr><th>ID</th><th>Name</th><th>Difficulty</th></tr>
+{task_rows}
+</table>
+</body></html>"""
+        return HTMLResponse(content=html)
+
+    return _app
+
+
+class TestWebUIEndpoint(unittest.TestCase):
+    """9.10 — GET /web returns HTTP 200 with HTML content."""
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        from starlette.testclient import TestClient
+        app = _build_web_test_app()
+        cls.client = TestClient(app)
+
+    def test_web_returns_200(self) -> None:
+        response = self.client.get("/web")
+        self.assertEqual(response.status_code, 200)
+
+    def test_web_returns_html_content_type(self) -> None:
+        response = self.client.get("/web")
+        self.assertIn("text/html", response.headers.get("content-type", ""))
+
+    def test_web_response_contains_html_tag(self) -> None:
+        response = self.client.get("/web")
+        self.assertIn("<!DOCTYPE html>", response.text)
+
+    def test_web_response_contains_env_name(self) -> None:
+        from vocabulary import APP_ENV_NAME
+        response = self.client.get("/web")
+        self.assertIn(APP_ENV_NAME, response.text)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_extra_fields_penalty.py

@@ -0,0 +1,183 @@
+"""
+Tests for action field validation (Task 4) in HelpdeskTicketRoutingEnvironment.step().
+
+Validates Requirement 7: Step Validates Action Fields Against Task Contract.
+"""
+from __future__ import annotations
+
+import sys
+import os
+import unittest
+import types as _types
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+import openenv_test_stubs  # noqa: F401
+
+if "openenv.core.env_server.interfaces" not in sys.modules:
+    _interfaces_mod = _types.ModuleType("openenv.core.env_server.interfaces")
+
+    class _Environment:
+        def __init__(self) -> None:
+            pass
+
+        def __init_subclass__(cls, **kwargs: object) -> None:
+            super().__init_subclass__(**kwargs)
+
+        @classmethod
+        def __class_getitem__(cls, item: object) -> type:
+            return cls
+
+    _interfaces_mod.Environment = _Environment  # type: ignore[attr-defined]
+    sys.modules["openenv.core.env_server.interfaces"] = _interfaces_mod
+
+from models import HelpdeskTicketAction, HelpdeskTicketObservation
+from server.environment import HelpdeskTicketRoutingEnvironment
+from server.tasks import TASKS
+from vocabulary import ISSUE_TYPES, PRIORITIES, ASSIGNMENT_GROUPS, RESOLUTION_ACTIONS
+
+
+def _make_env() -> HelpdeskTicketRoutingEnvironment:
+    return HelpdeskTicketRoutingEnvironment()
+
+
+class TestExtraFieldsPenalty(unittest.TestCase):
+    """Requirement 7: step() rejects actions with fields outside the task's allowed_fields."""
+
+    def test_extra_fields_returns_reward_zero(self) -> None:
+        """Task 1 only allows issue_type and priority; submitting assignment_group triggers penalty."""
+        env = _make_env()
+        obs = env.reset(seed=42, task_id=1)
+
+        # Task 1 allowed_fields should NOT include assignment_group
+        self.assertNotIn("assignment_group", obs.allowed_fields)
+
+        # Submit an action with an extra field (assignment_group) not in task 1's allowed_fields
+        action = HelpdeskTicketAction(
+            issue_type=ISSUE_TYPES[0],
+            priority=PRIORITIES[0],
+            assignment_group=ASSIGNMENT_GROUPS[0],  # extra field
+        )
+        penalty_obs = env.step(action)
+
+        self.assertIsInstance(penalty_obs, HelpdeskTicketObservation)
+        self.assertEqual(penalty_obs.reward, 0.0)
+
+    def test_extra_fields_advances_ticket_index(self) -> None:
+        """Penalty step must advance tickets_processed by 1."""
+        env = _make_env()
+        obs = env.reset(seed=42, task_id=1)
+        self.assertEqual(obs.tickets_processed, 0)
+
+        action = HelpdeskTicketAction(
+            issue_type=ISSUE_TYPES[0],
+            assignment_group=ASSIGNMENT_GROUPS[0],  # extra field for task 1
+        )
+        penalty_obs = env.step(action)
+
+        self.assertEqual(penalty_obs.tickets_processed, 1)
+
+    def test_extra_fields_records_score_zero(self) -> None:
+        """per_ticket_scores must contain 0.0 after a penalty step."""
+        env = _make_env()
+        env.reset(seed=42, task_id=1)
+
+        action = HelpdeskTicketAction(
+            issue_type=ISSUE_TYPES[0],
+            assignment_group=ASSIGNMENT_GROUPS[0],  # extra field
+        )
+        env.step(action)
+
+        state = env.state
+        self.assertEqual(len(state.per_ticket_scores), 1)
+        self.assertEqual(state.per_ticket_scores[0], 0.0)
+
+    def test_extra_fields_history_entry_has_penalty_reason(self) -> None:
+        """History entry for a penalty step must include penalty_reason."""
+        env = _make_env()
+        env.reset(seed=42, task_id=1)
+
+        action = HelpdeskTicketAction(
+            issue_type=ISSUE_TYPES[0],
+            assignment_group=ASSIGNMENT_GROUPS[0],  # extra field
+        )
+        penalty_obs = env.step(action)
+
+        self.assertEqual(len(penalty_obs.history), 1)
+        entry = penalty_obs.history[0]
+        self.assertIn("penalty_reason", entry)
+        self.assertIn("assignment_group", entry["penalty_reason"])
+        self.assertEqual(entry["score"], 0.0)
+
+    def test_no_extra_fields_grades_normally(self) -> None:
+        """When action fields are within allowed_fields, grading proceeds normally (reward != forced 0.0)."""
+        env = _make_env()
+        obs = env.reset(seed=42, task_id=1)
+
+        # Build action using only allowed fields
+        allowed = obs.allowed_fields
+        action_kwargs = {}
+        if "issue_type" in allowed:
+            action_kwargs["issue_type"] = ISSUE_TYPES[0]
+        if "priority" in allowed:
+            action_kwargs["priority"] = PRIORITIES[0]
+
+        action = HelpdeskTicketAction(**action_kwargs)
+        result_obs = env.step(action)
+
+        # Should be a valid observation; reward may be any value in [0.0, 1.0]
+        self.assertIsInstance(result_obs, HelpdeskTicketObservation)
+        self.assertIsNotNone(result_obs.reward)
+        # No penalty_reason in history
+        self.assertEqual(len(result_obs.history), 1)
+        self.assertNotIn("penalty_reason", result_obs.history[0])
+
+    def test_extra_fields_no_exception_raised(self) -> None:
+        """Requirement 7.4: extra fields must not raise an unhandled exception."""
+        env = _make_env()
+        env.reset(seed=42, task_id=1)
+
+        action = HelpdeskTicketAction(
+            issue_type=ISSUE_TYPES[0],
+            priority=PRIORITIES[0],
+            assignment_group=ASSIGNMENT_GROUPS[0],
+            resolution_action=RESOLUTION_ACTIONS[0],  # multiple extra fields
+        )
+        try:
+            obs = env.step(action)
+        except Exception as exc:  # noqa: BLE001
+            self.fail(f"step() raised an unexpected exception: {exc}")
+
+        self.assertIsInstance(obs, HelpdeskTicketObservation)
+
+    def test_extra_fields_done_flag_set_correctly_on_last_ticket(self) -> None:
+        """When the penalty step is on the last ticket, done must be True."""
+        env = _make_env()
+        # Use a queue of size 1 by controlling the seed — find a seed that gives queue_size=1
+        # Instead, exhaust all but the last ticket normally, then trigger penalty on last
+        obs = env.reset(seed=42, task_id=1)
+        queue_size = obs.queue_size
+
+        # Process all tickets except the last one normally
+        for _ in range(queue_size - 1):
+            allowed = obs.allowed_fields
+            action_kwargs = {}
+            if "issue_type" in allowed:
+                action_kwargs["issue_type"] = ISSUE_TYPES[0]
+            if "priority" in allowed:
+                action_kwargs["priority"] = PRIORITIES[0]
+            obs = env.step(HelpdeskTicketAction(**action_kwargs))
+
+        # Now trigger penalty on the last ticket
+        action = HelpdeskTicketAction(
+            issue_type=ISSUE_TYPES[0],
+            assignment_group=ASSIGNMENT_GROUPS[0],  # extra field
+        )
+        final_obs = env.step(action)
+
+        self.assertTrue(final_obs.done)
+        self.assertEqual(final_obs.reward, 0.0)
+
+
+if __name__ == "__main__":
+    unittest.main()