Strengthen queue benchmark and refresh landing page

README.md

@@ -65,7 +65,7 @@ The environment classes and vocabulary are intentionally frozen to keep collabor
 
 ## Lightweight Policy Improvement Loop
 
-The repo includes a local policy runner in `policy_learning.py`. It still does not update model weights, but it now does more than cosmetic search: it evaluates repeated seeded rollouts, learns cue-conditioned tool preferences for investigation, uses the same planning-aware deterministic submit logic as `inference.py`, and ranks policies by terminal rubric reward first, with lower planning penalty as the tie-breaker.
+The repo includes a local policy runner in `policy_learning.py`. It still does not update model weights, but it now does more than cosmetic search: it evaluates repeated seeded rollouts, learns cue-conditioned tool preferences for investigation, uses the same planning-aware deterministic submit logic as `inference.py`, and ranks policies by terminal rubric reward first, then queue-management quality, with lower planning penalty as the next tie-breaker.
 
 That gives the project a meaningful improvement loop for judge demos:
 
@@ -99,7 +99,7 @@ The default submit policy inside this runner stays deterministic and local. It r
 | ID | Name | Difficulty | Required Fields | What The Agent Must Do |
 |----|------|------------|-----------------|-------------------------|
 | 1 | Guided Full Routing | Easy | `issue_type`, `priority`, `assignment_group`, `resolution_action` | route a mostly visible ticket correctly |
-| 2 | Contextual Full Routing | Medium | `issue_type`, `priority`, `assignment_group`, `resolution_action` | route under partial observability with investigation and clarification |
+| 2 | Contextual Full Routing | Medium | `issue_type`, `priority`, `assignment_group`, `resolution_action` | route under partial observability with investigation, clarification, and moderate queue carry-over |
 | 3 | Adaptive Queue Routing | Hard | `issue_type`, `priority`, `assignment_group`, `resolution_action` | route while managing queue pressure, incidents, clustered follow-ons, deferrals, and downstream follow-ups |
 
 ## Locked Vocabulary
@@ -158,6 +158,7 @@ Visible ticket fields:
 - optional `routing_options`
 - optional `capacity_state`
 - optional `operational_context`
+- optional `cluster_summary`
 - optional `generated_from_ticket_id`
 
 Each observation also includes:
@@ -181,7 +182,7 @@ Each observation also includes:
 - `last_reward_components`
 - `rubric_reward` on terminal observations
 - `metadata.last_feedback_summary` for compact reward / penalty feedback
-- `metadata.capacity_state` and `metadata.future_queue_demand` on hard-task episodes
+- `metadata.capacity_state` on hard-task episodes
 - `metadata.planning_penalty_total` and `metadata.planning_penalty_applied`
 - standard OpenEnv fields such as `done` and `reward`
 
@@ -204,6 +205,8 @@ The internal `HelpdeskTicketState` tracks:
 - `planning_penalty_total`
 - `incident_gap_total`
 - `sla_breach_count`
+- `queue_management_score`
+- `queue_management_breakdown`
 - `dynamic_queue_events`
 
 ## Grading And Reward
@@ -232,6 +235,7 @@ Hard-task investigation behavior:
 - linked-ticket previews and internal routing notes stay hidden until the matching tool is used
 - capacity-sensitive tickets can expose queue pressure, future demand, and alternate routing options through `lookup_queue_capacity_forecast`
 - cluster-sensitive tickets can expose future related tickets, shared-requester load, and active incident coverage through `lookup_queue_cluster_summary`
+- detailed cluster counts and future queue-demand breakdowns stay hidden until the matching queue tool is used
 - only useful investigation steps return a small positive shaping reward
 - blind or repeated probing does not pay by default
 - premature hard-task submission can incur a shaping penalty even when the visible text looks plausible
@@ -260,7 +264,7 @@ Task weights:
 Final episode rubric reward is queue-based:
 
 ```text
-clamp(average(per_ticket_scores) + trajectory bonuses - planning penalties - extra investigation penalties)
+clamp(route_trajectory_reward * route_weight + queue_management_score * queue_weight - extra investigation penalties)
 ```
 
 Both `reward` and `rubric_reward` now use the closed interval `[0.0, 1.0]`.
@@ -273,6 +277,7 @@ To make the environment more RL-friendly, each observation now also surfaces str
 
 - `last_reward_components` exposes ticket score, shaped step reward, milestone adjustment, trajectory reward when applicable, and any investigation penalty applied
 - `average_score_so_far` and `progress_fraction` expose trajectory progress without leaking future labels
+- medium and hard telemetry now also exposes terminal `queue_management_score` plus a queue-management breakdown
 - hard-task telemetry includes planning penalties, capacity usage, and the post-action capacity snapshot
 - `history` retains the same reward components plus a compact `feedback_summary` string for downstream agents
 

inference.py

@@ -581,6 +581,7 @@ def build_routing_text(ticket: dict) -> str:
     last_tool_result = ticket.get("last_tool_result") or {}
     routing_options = ticket.get("routing_options") or []
     operational_context = ticket.get("operational_context") or {}
+    cluster_summary = ticket.get("cluster_summary") or {}
     return " ".join(
         [
             ticket.get("title", ""),
@@ -593,6 +594,7 @@ def build_routing_text(ticket: dict) -> str:
             json.dumps(last_tool_result, sort_keys=True),
             json.dumps(routing_options, sort_keys=True),
             json.dumps(operational_context, sort_keys=True),
+            json.dumps(cluster_summary, sort_keys=True),
             json.dumps(ticket.get("capacity_state") or {}, sort_keys=True),
             json.dumps(ticket.get("future_queue_demand") or {}, sort_keys=True),
         ]
@@ -1013,9 +1015,11 @@ def should_investigate(
         )
     )
     operational_context = ticket.get("operational_context") or {}
+    cluster_summary = ticket.get("cluster_summary") or {}
     cluster_signal = (
-        int(operational_context.get("future_cluster_ticket_count", 0) or 0) > 0
-        or int(operational_context.get("shared_requester_count", 0) or 0) > 1
+        bool(operational_context.get("cluster_coordination_hint"))
+        or int(cluster_summary.get("future_cluster_ticket_count", 0) or 0) > 0
+        or int(cluster_summary.get("shared_requester_count", 0) or 0) > 1
         or any(
             phrase in routing_text
             for phrase in (
@@ -1103,6 +1107,15 @@ def merge_ticket_context(ticket: dict, observation: Any) -> dict:
     merged_ticket = dict(ticket)
     if getattr(observation, "last_tool_result", None) is not None:
         merged_ticket["last_tool_result"] = observation.last_tool_result
+        if observation.last_tool_result.get("tool_name") == "lookup_queue_capacity_forecast":
+            if observation.last_tool_result.get("future_queue_demand") is not None:
+                merged_ticket["future_queue_demand"] = observation.last_tool_result[
+                    "future_queue_demand"
+                ]
+            if observation.last_tool_result.get("capacity_state") is not None:
+                merged_ticket["capacity_state"] = observation.last_tool_result[
+                    "capacity_state"
+                ]
     merged_ticket["recent_history"] = list(getattr(observation, "history", []))
     merged_ticket["queue_position"] = getattr(observation, "queue_position", None)
     merged_ticket["tickets_remaining"] = getattr(observation, "tickets_remaining", None)

models.py

@@ -214,6 +214,8 @@ class HelpdeskTicketState(State):
     escalation_slots_remaining: int = 0
     planning_penalty_total: float = 0.0
     capacity_pressure_tickets_resolved: int = 0
+    cluster_stabilizations_total: int = 0
+    cluster_destabilizations_total: int = 0
     ticket_request_info_usage: dict[str, int] = Field(default_factory=dict)
     ticket_defer_counts: dict[str, int] = Field(default_factory=dict)
     open_incident_ticket_ids: list[str] = Field(default_factory=list)
@@ -226,4 +228,6 @@ class HelpdeskTicketState(State):
     spawned_follow_up_ticket_ids: list[str] = Field(default_factory=list)
     spawned_follow_up_source_ids: list[str] = Field(default_factory=list)
     dynamic_queue_events: list[dict[str, Any]] = Field(default_factory=list)
+    queue_management_score: float = 0.0
+    queue_management_breakdown: dict[str, Any] = Field(default_factory=dict)
     history_entries: list[dict] = Field(default_factory=list)

policy_learning.py

@@ -249,6 +249,7 @@ def _routing_text(ticket: dict[str, Any]) -> str:
         json.dumps(ticket.get("last_tool_result") or {}, sort_keys=True),
         json.dumps(ticket.get("routing_options") or [], sort_keys=True),
         json.dumps(ticket.get("operational_context") or {}, sort_keys=True),
+        json.dumps(ticket.get("cluster_summary") or {}, sort_keys=True),
         json.dumps(ticket.get("capacity_state") or {}, sort_keys=True),
         json.dumps(ticket.get("future_queue_demand") or {}, sort_keys=True),
     ]
@@ -284,8 +285,11 @@ def infer_ticket_cue(ticket: dict[str, Any]) -> str:
     ):
         return "capacity_planning"
     if (
-        int((ticket.get("operational_context") or {}).get("future_cluster_ticket_count", 0) or 0)
+        bool((ticket.get("operational_context") or {}).get("cluster_coordination_hint"))
+        or int((ticket.get("cluster_summary") or {}).get("future_cluster_ticket_count", 0) or 0)
         > 0
+        or int((ticket.get("cluster_summary") or {}).get("shared_requester_count", 0) or 0)
+        > 1
         or any(
             phrase in text
             for phrase in (
@@ -471,6 +475,43 @@ def choose_operational_action(
     return None, None
 
 
+def merge_ticket_context(
+    ticket: dict[str, Any],
+    observation: HelpdeskTicketObservation,
+) -> dict[str, Any]:
+    merged_ticket = dict(ticket)
+    if getattr(observation, "last_tool_result", None) is not None:
+        merged_ticket["last_tool_result"] = observation.last_tool_result
+        if observation.last_tool_result.get("tool_name") == "lookup_queue_capacity_forecast":
+            if observation.last_tool_result.get("future_queue_demand") is not None:
+                merged_ticket["future_queue_demand"] = observation.last_tool_result[
+                    "future_queue_demand"
+                ]
+            if observation.last_tool_result.get("capacity_state") is not None:
+                merged_ticket["capacity_state"] = observation.last_tool_result[
+                    "capacity_state"
+                ]
+    merged_ticket["recent_history"] = list(getattr(observation, "history", []) or [])
+    merged_ticket["queue_position"] = getattr(observation, "queue_position", None)
+    merged_ticket["tickets_remaining"] = getattr(observation, "tickets_remaining", None)
+    merged_ticket["tickets_after_current"] = getattr(observation, "tickets_after_current", None)
+    merged_ticket["available_tools"] = list(getattr(observation, "available_tools", []) or [])
+    merged_ticket["available_action_types"] = list(
+        getattr(observation, "available_action_types", []) or []
+    )
+    merged_ticket["last_reward_components"] = dict(
+        getattr(observation, "last_reward_components", {}) or {}
+    )
+    observation_metadata = getattr(observation, "metadata", {}) or {}
+    if observation_metadata.get("last_feedback_summary"):
+        merged_ticket["feedback_summary"] = observation_metadata["last_feedback_summary"]
+    if observation_metadata.get("capacity_state") is not None:
+        merged_ticket["capacity_state"] = observation_metadata["capacity_state"]
+    if observation_metadata.get("future_queue_demand") is not None:
+        merged_ticket["future_queue_demand"] = observation_metadata["future_queue_demand"]
+    return merged_ticket
+
+
 def choose_policy_action(
     policy: PolicyConfig,
     observation: HelpdeskTicketObservation,
@@ -480,7 +521,7 @@ def choose_policy_action(
     used_tools_by_ticket: dict[str, set[str]] | None = None,
     adaptive_bandit: AdaptiveToolBandit | None = None,
 ) -> tuple[HelpdeskTicketAction, str, str | None]:
-    ticket = observation.current_ticket or {}
+    ticket = merge_ticket_context(observation.current_ticket or {}, observation)
     ticket_id = str(ticket.get("ticket_id", ""))
     ticket_investigations = investigations_by_ticket.get(ticket_id, 0)
     used_tools = set()
@@ -588,7 +629,7 @@ def rollout_episode(
     trajectories: list[dict[str, Any]] = []
 
     while not observation.done:
-        ticket = observation.current_ticket or {}
+        ticket = merge_ticket_context(observation.current_ticket or {}, observation)
         ticket_id = str(ticket.get("ticket_id", ""))
         action, action_source, action_cue = choose_policy_action(
             policy,
@@ -660,6 +701,7 @@ def rollout_episode(
         "terminal_reward": terminal_reward,
         "terminal_rubric_reward": terminal_rubric_reward,
         "average_ticket_score": env.state.average_score_so_far,
+        "queue_management_score": env.state.queue_management_score,
         "planning_penalty_total": env.state.planning_penalty_total,
         "capacity_pressure_tickets_resolved": env.state.capacity_pressure_tickets_resolved,
         "per_ticket_scores": list(env.state.per_ticket_scores),
@@ -700,6 +742,9 @@ def summarize_policy_episodes(
             "avg_terminal_rubric_reward": _safe_mean(
                 [float(episode["terminal_rubric_reward"]) for episode in task_episodes]
             ),
+            "avg_queue_management_score": _safe_mean(
+                [float(episode["queue_management_score"]) for episode in task_episodes]
+            ),
             "avg_planning_penalty_total": _safe_mean(
                 [float(episode["planning_penalty_total"]) for episode in task_episodes]
             ),
@@ -730,6 +775,9 @@ def summarize_policy_episodes(
         "avg_terminal_rubric_reward": _safe_mean(
             [float(episode["terminal_rubric_reward"]) for episode in episode_summaries]
         ),
+        "avg_queue_management_score": _safe_mean(
+            [float(episode["queue_management_score"]) for episode in episode_summaries]
+        ),
         "avg_planning_penalty_total": _safe_mean(
             [float(episode["planning_penalty_total"]) for episode in episode_summaries]
         ),
@@ -788,9 +836,10 @@ def evaluate_policy(
     return result
 
 
-def _selection_tuple(summary: dict[str, Any]) -> tuple[float, float, float, float, float]:
+def _selection_tuple(summary: dict[str, Any]) -> tuple[float, float, float, float, float, float]:
     return (
         float(summary["avg_terminal_rubric_reward"]),
+        float(summary["avg_queue_management_score"]),
         -float(summary["avg_planning_penalty_total"]),
         float(summary["avg_episode_return"]),
         float(summary["avg_normalized_return"]),
@@ -849,7 +898,9 @@ def compare_policies(
         "mode": "compare",
         "task_ids": task_ids,
         "seeds": seeds,
-        "selection_metric": "avg_terminal_rubric_reward_then_lower_planning_penalty",
+        "selection_metric": (
+            "avg_terminal_rubric_reward_then_queue_management_then_lower_planning_penalty"
+        ),
         "baseline_policy": baseline_run["policy"],
         "best_policy": best_run["policy"],
         "improvement_vs_baseline": {
@@ -867,6 +918,11 @@ def compare_policies(
                 baseline_run["summary"],
                 "avg_terminal_rubric_reward",
             ),
+            "avg_queue_management_score": _delta(
+                best_run["summary"],
+                baseline_run["summary"],
+                "avg_queue_management_score",
+            ),
             "avg_planning_penalty_total": _delta(
                 best_run["summary"],
                 baseline_run["summary"],
@@ -966,7 +1022,9 @@ def search_policies(
         "task_ids": task_ids,
         "train_seeds": train_seeds,
         "eval_seeds": eval_seeds,
-        "selection_metric": "avg_terminal_rubric_reward_then_lower_planning_penalty",
+        "selection_metric": (
+            "avg_terminal_rubric_reward_then_queue_management_then_lower_planning_penalty"
+        ),
         "candidate_policies": [policy.name for policy in candidate_policies],
         "selected_policy": selected_policy.name,
         "baseline_policy": baseline_policy.name,
@@ -997,6 +1055,11 @@ def search_policies(
                 eval_baseline["summary"],
                 "avg_terminal_rubric_reward",
             ),
+            "avg_queue_management_score": _delta(
+                eval_selected["summary"],
+                eval_baseline["summary"],
+                "avg_queue_management_score",
+            ),
             "avg_planning_penalty_total": _delta(
                 eval_selected["summary"],
                 eval_baseline["summary"],

server/app.py

@@ -1,4 +1,5 @@
 import sys
+from html import escape
 from pathlib import Path
 from typing import Any
 
@@ -16,7 +17,7 @@ from models import HelpdeskTicketAction, HelpdeskTicketObservation
 from server.environment import HelpdeskTicketRoutingEnvironment
 from server.grader import grade_action
 from server.tasks import TASKS, load_dataset
-from vocabulary import APP_ENV_NAME
+from vocabulary import APP_ENV_NAME, PROJECT_TITLE, TEAM_NAME
 
 app = create_app(
     HelpdeskTicketRoutingEnvironment,
@@ -55,20 +56,758 @@ 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>"
+    dataset = load_dataset()
+    dataset_size = len(dataset)
+    alternate_route_count = sum(
+        1 for ticket in dataset if ticket.alternate_route_score_multiplier > 0.0
+    )
+    clustered_case_count = sum(1 for ticket in dataset if ticket.service_cluster_id)
+    hidden_context_case_count = sum(
+        1
+        for ticket in dataset
+        if ticket.ambiguity_note
+        or ticket.related_ticket_id
+        or ticket.planning_note
+        or ticket.customer_update_note
+    )
+    incident_sensitive_count = sum(1 for ticket in dataset if ticket.incident_recommended)
+
+    difficulty_labels = {
+        "easy": "Guided",
+        "medium": "Contextual",
+        "hard": "Adaptive",
+    }
+    task_cards = "".join(
+        f"""
+        <article class="task-card difficulty-{escape(t['difficulty'])}">
+          <div class="task-head">
+            <span class="task-id">Task {t['id']}</span>
+            <span class="difficulty-pill">{escape(difficulty_labels.get(t['difficulty'], t['difficulty']).upper())}</span>
+          </div>
+          <h3>{escape(t['name'])}</h3>
+          <p>{escape(t['instructions'])}</p>
+          <div class="field-row">
+            {''.join(f'<span class="field-chip">{escape(field)}</span>' for field in t['allowed_fields'])}
+          </div>
+        </article>
+        """
         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>"""
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>{escape(APP_ENV_NAME)}</title>
+    <style>
+      :root {{
+        --bg: #07131b;
+        --bg-soft: #0b1c27;
+        --panel: rgba(15, 32, 44, 0.84);
+        --panel-strong: rgba(12, 26, 37, 0.94);
+        --line: rgba(173, 215, 230, 0.16);
+        --line-strong: rgba(173, 215, 230, 0.28);
+        --text: #ecf5f7;
+        --muted: #97aeb7;
+        --accent: #4fd1c5;
+        --accent-strong: #1cb0a4;
+        --accent-warm: #ffb454;
+        --success: #7fdf9f;
+        --shadow: 0 28px 80px rgba(0, 0, 0, 0.32);
+        --radius-xl: 28px;
+        --radius-lg: 20px;
+        --radius-md: 14px;
+      }}
+
+      * {{
+        box-sizing: border-box;
+      }}
+
+      html {{
+        scroll-behavior: smooth;
+      }}
+
+      body {{
+        margin: 0;
+        min-height: 100vh;
+        color: var(--text);
+        background:
+          radial-gradient(circle at 12% 18%, rgba(79, 209, 197, 0.18), transparent 26%),
+          radial-gradient(circle at 82% 20%, rgba(255, 180, 84, 0.16), transparent 22%),
+          radial-gradient(circle at 50% 100%, rgba(79, 209, 197, 0.12), transparent 35%),
+          linear-gradient(180deg, #07131b 0%, #0b1821 52%, #07131b 100%);
+        font-family: "Aptos", "Segoe UI Variable Text", "Trebuchet MS", sans-serif;
+      }}
+
+      body::before {{
+        content: "";
+        position: fixed;
+        inset: 0;
+        pointer-events: none;
+        background-image:
+          linear-gradient(rgba(255, 255, 255, 0.03) 1px, transparent 1px),
+          linear-gradient(90deg, rgba(255, 255, 255, 0.03) 1px, transparent 1px);
+        background-size: 36px 36px;
+        mask-image: linear-gradient(180deg, rgba(0, 0, 0, 0.9), transparent 92%);
+      }}
+
+      .shell {{
+        width: min(1180px, calc(100vw - 32px));
+        margin: 0 auto;
+        padding: 28px 0 56px;
+      }}
+
+      .topbar {{
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        gap: 18px;
+        margin-bottom: 22px;
+        padding: 16px 20px;
+        border: 1px solid var(--line);
+        border-radius: 999px;
+        background: rgba(10, 23, 32, 0.68);
+        backdrop-filter: blur(14px);
+      }}
+
+      .brand {{
+        display: flex;
+        align-items: center;
+        gap: 14px;
+      }}
+
+      .brand-mark {{
+        width: 42px;
+        height: 42px;
+        border-radius: 14px;
+        background:
+          linear-gradient(145deg, rgba(79, 209, 197, 0.96), rgba(28, 176, 164, 0.75));
+        box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.32);
+        position: relative;
+      }}
+
+      .brand-mark::after {{
+        content: "";
+        position: absolute;
+        inset: 10px;
+        border-radius: 10px;
+        border: 2px solid rgba(7, 19, 27, 0.75);
+      }}
+
+      .eyebrow {{
+        margin: 0 0 4px;
+        color: var(--accent);
+        font-size: 0.78rem;
+        letter-spacing: 0.18em;
+        text-transform: uppercase;
+      }}
+
+      .brand h1 {{
+        margin: 0;
+        font-family: "Bahnschrift", "Aptos Display", "Trebuchet MS", sans-serif;
+        font-size: 1.05rem;
+        letter-spacing: 0.03em;
+      }}
+
+      .nav-links {{
+        display: flex;
+        flex-wrap: wrap;
+        gap: 10px;
+      }}
+
+      .nav-links a,
+      .button {{
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        gap: 8px;
+        text-decoration: none;
+        color: var(--text);
+        border-radius: 999px;
+        border: 1px solid var(--line);
+        padding: 11px 16px;
+        font-size: 0.94rem;
+        transition: transform 160ms ease, border-color 160ms ease, background 160ms ease;
+      }}
+
+      .nav-links a:hover,
+      .button:hover {{
+        transform: translateY(-1px);
+        border-color: var(--line-strong);
+      }}
+
+      .button.primary {{
+        background: linear-gradient(135deg, rgba(79, 209, 197, 0.22), rgba(28, 176, 164, 0.18));
+        border-color: rgba(79, 209, 197, 0.35);
+      }}
+
+      .button.secondary {{
+        background: linear-gradient(135deg, rgba(255, 180, 84, 0.14), rgba(255, 180, 84, 0.08));
+        border-color: rgba(255, 180, 84, 0.25);
+      }}
+
+      .hero {{
+        position: relative;
+        overflow: hidden;
+        display: grid;
+        grid-template-columns: minmax(0, 1.3fr) minmax(300px, 0.9fr);
+        gap: 24px;
+        padding: 36px;
+        border: 1px solid var(--line);
+        border-radius: var(--radius-xl);
+        background:
+          linear-gradient(160deg, rgba(15, 33, 44, 0.92), rgba(8, 21, 29, 0.9)),
+          radial-gradient(circle at top right, rgba(255, 180, 84, 0.16), transparent 28%);
+        box-shadow: var(--shadow);
+      }}
+
+      .hero::after {{
+        content: "";
+        position: absolute;
+        inset: auto -8% -32% 44%;
+        height: 340px;
+        background: radial-gradient(circle, rgba(79, 209, 197, 0.2), transparent 62%);
+        pointer-events: none;
+      }}
+
+      .hero-copy,
+      .hero-panel {{
+        position: relative;
+        z-index: 1;
+      }}
+
+      .hero-copy h2 {{
+        margin: 0 0 14px;
+        max-width: 10.5ch;
+        font-family: "Bahnschrift", "Aptos Display", "Trebuchet MS", sans-serif;
+        font-size: clamp(2.7rem, 6vw, 4.8rem);
+        line-height: 0.95;
+        letter-spacing: -0.05em;
+      }}
+
+      .hero-copy p {{
+        margin: 0;
+        max-width: 62ch;
+        color: var(--muted);
+        font-size: 1.02rem;
+        line-height: 1.7;
+      }}
+
+      .hero-kickers {{
+        display: flex;
+        flex-wrap: wrap;
+        gap: 10px;
+        margin: 18px 0 22px;
+      }}
+
+      .kicker {{
+        padding: 9px 14px;
+        border-radius: 999px;
+        border: 1px solid var(--line);
+        background: rgba(255, 255, 255, 0.04);
+        color: #d5e4e9;
+        font-size: 0.9rem;
+      }}
+
+      .hero-actions {{
+        display: flex;
+        flex-wrap: wrap;
+        gap: 12px;
+        margin-top: 26px;
+      }}
+
+      .hero-panel {{
+        align-self: stretch;
+        display: grid;
+        gap: 14px;
+        padding: 18px;
+        border-radius: 22px;
+        border: 1px solid rgba(79, 209, 197, 0.16);
+        background: rgba(7, 19, 27, 0.46);
+        backdrop-filter: blur(14px);
+      }}
+
+      .panel-title {{
+        margin: 0;
+        font-size: 0.88rem;
+        color: var(--muted);
+        letter-spacing: 0.14em;
+        text-transform: uppercase;
+      }}
+
+      .signal-card {{
+        padding: 16px;
+        border-radius: 18px;
+        border: 1px solid var(--line);
+        background: rgba(255, 255, 255, 0.035);
+      }}
+
+      .signal-card strong {{
+        display: block;
+        margin-bottom: 6px;
+        font-size: 1rem;
+      }}
+
+      .signal-card span {{
+        color: var(--muted);
+        font-size: 0.92rem;
+        line-height: 1.55;
+      }}
+
+      .stats-grid,
+      .feature-grid,
+      .task-grid,
+      .shortcut-grid {{
+        display: grid;
+        gap: 16px;
+        margin-top: 20px;
+      }}
+
+      .stats-grid {{
+        grid-template-columns: repeat(4, minmax(0, 1fr));
+      }}
+
+      .feature-grid {{
+        grid-template-columns: repeat(3, minmax(0, 1fr));
+      }}
+
+      .task-grid {{
+        grid-template-columns: repeat(3, minmax(0, 1fr));
+      }}
+
+      .shortcut-grid {{
+        grid-template-columns: repeat(2, minmax(0, 1fr));
+      }}
+
+      .stat-card,
+      .feature-card,
+      .shortcut-card,
+      .task-card {{
+        border: 1px solid var(--line);
+        border-radius: var(--radius-lg);
+        background: var(--panel);
+        backdrop-filter: blur(16px);
+        box-shadow: var(--shadow);
+      }}
+
+      .stat-card {{
+        padding: 20px;
+      }}
+
+      .stat-card .value {{
+        display: block;
+        margin-bottom: 8px;
+        font-family: "Bahnschrift", "Aptos Display", "Trebuchet MS", sans-serif;
+        font-size: 2rem;
+        letter-spacing: -0.04em;
+      }}
+
+      .stat-card .label,
+      .stat-card .hint,
+      .feature-card p,
+      .shortcut-card p,
+      .task-card p {{
+        color: var(--muted);
+      }}
+
+      .stat-card .label {{
+        display: block;
+        margin-bottom: 6px;
+        font-size: 0.92rem;
+      }}
+
+      .stat-card .hint {{
+        font-size: 0.86rem;
+        line-height: 1.5;
+      }}
+
+      .section {{
+        margin-top: 24px;
+        padding: 28px;
+        border: 1px solid var(--line);
+        border-radius: var(--radius-xl);
+        background: linear-gradient(180deg, rgba(11, 26, 37, 0.84), rgba(9, 21, 30, 0.88));
+      }}
+
+      .section-head {{
+        display: flex;
+        align-items: end;
+        justify-content: space-between;
+        gap: 18px;
+        margin-bottom: 18px;
+      }}
+
+      .section-head h3 {{
+        margin: 0 0 8px;
+        font-family: "Bahnschrift", "Aptos Display", "Trebuchet MS", sans-serif;
+        font-size: 1.75rem;
+        letter-spacing: -0.03em;
+      }}
+
+      .section-head p {{
+        margin: 0;
+        max-width: 64ch;
+        color: var(--muted);
+        line-height: 1.65;
+      }}
+
+      .feature-card,
+      .shortcut-card {{
+        padding: 20px;
+      }}
+
+      .feature-card h4,
+      .shortcut-card h4,
+      .task-card h3 {{
+        margin: 0 0 10px;
+        font-size: 1.04rem;
+      }}
+
+      .task-card {{
+        padding: 20px;
+        position: relative;
+        overflow: hidden;
+      }}
+
+      .task-card::before {{
+        content: "";
+        position: absolute;
+        inset: 0 auto auto 0;
+        width: 100%;
+        height: 4px;
+        background: linear-gradient(90deg, rgba(79, 209, 197, 0.95), rgba(255, 180, 84, 0.72));
+      }}
+
+      .task-card.difficulty-easy::before {{
+        background: linear-gradient(90deg, rgba(127, 223, 159, 0.95), rgba(79, 209, 197, 0.7));
+      }}
+
+      .task-card.difficulty-medium::before {{
+        background: linear-gradient(90deg, rgba(79, 209, 197, 0.95), rgba(120, 196, 230, 0.72));
+      }}
+
+      .task-card.difficulty-hard::before {{
+        background: linear-gradient(90deg, rgba(255, 180, 84, 0.95), rgba(255, 122, 72, 0.78));
+      }}
+
+      .task-head {{
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        gap: 12px;
+        margin-bottom: 16px;
+      }}
+
+      .task-id {{
+        color: var(--muted);
+        font-size: 0.84rem;
+        letter-spacing: 0.12em;
+        text-transform: uppercase;
+      }}
+
+      .difficulty-pill {{
+        padding: 7px 10px;
+        border-radius: 999px;
+        border: 1px solid var(--line);
+        font-size: 0.74rem;
+        letter-spacing: 0.14em;
+        text-transform: uppercase;
+        color: #f6fafb;
+        background: rgba(255, 255, 255, 0.05);
+      }}
+
+      .field-row,
+      .chip-row {{
+        display: flex;
+        flex-wrap: wrap;
+        gap: 8px;
+        margin-top: 16px;
+      }}
+
+      .field-chip,
+      .mini-chip {{
+        padding: 8px 11px;
+        border-radius: 999px;
+        border: 1px solid var(--line);
+        background: rgba(255, 255, 255, 0.04);
+        color: #d9e7eb;
+        font-size: 0.82rem;
+      }}
+
+      .feature-card ul {{
+        margin: 12px 0 0;
+        padding-left: 18px;
+        color: var(--muted);
+        line-height: 1.65;
+      }}
+
+      .shortcut-card code {{
+        display: block;
+        margin: 12px 0 14px;
+        padding: 12px 14px;
+        border-radius: 14px;
+        background: rgba(0, 0, 0, 0.2);
+        border: 1px solid rgba(255, 255, 255, 0.05);
+        color: #d9fcf7;
+        font-family: "Cascadia Code", "Consolas", monospace;
+        font-size: 0.88rem;
+        white-space: nowrap;
+        overflow-x: auto;
+      }}
+
+      .footer {{
+        margin-top: 20px;
+        padding: 18px 6px 8px;
+        color: var(--muted);
+        font-size: 0.92rem;
+      }}
+
+      @keyframes rise {{
+        from {{
+          opacity: 0;
+          transform: translateY(12px);
+        }}
+        to {{
+          opacity: 1;
+          transform: translateY(0);
+        }}
+      }}
+
+      .hero,
+      .section,
+      .stat-card,
+      .task-card,
+      .feature-card,
+      .shortcut-card {{
+        animation: rise 420ms ease both;
+      }}
+
+      @media (max-width: 980px) {{
+        .hero,
+        .stats-grid,
+        .feature-grid,
+        .task-grid,
+        .shortcut-grid {{
+          grid-template-columns: 1fr;
+        }}
+
+        .topbar,
+        .section-head {{
+          border-radius: 24px;
+          flex-direction: column;
+          align-items: flex-start;
+        }}
+      }}
+
+      @media (max-width: 640px) {{
+        .shell {{
+          width: min(100vw - 18px, 1180px);
+          padding-top: 14px;
+        }}
+
+        .hero,
+        .section {{
+          padding: 22px;
+        }}
+
+        .hero-copy h2 {{
+          max-width: none;
+          font-size: clamp(2.4rem, 14vw, 3.5rem);
+        }}
+
+        .nav-links,
+        .hero-actions {{
+          width: 100%;
+        }}
+
+        .nav-links a,
+        .button {{
+          flex: 1 1 180px;
+        }}
+      }}
+    </style>
+  </head>
+  <body>
+    <main class="shell">
+      <header class="topbar">
+        <div class="brand">
+          <div class="brand-mark" aria-hidden="true"></div>
+          <div>
+            <p class="eyebrow">OpenEnv Environment</p>
+            <h1>{escape(PROJECT_TITLE)}</h1>
+          </div>
+        </div>
+        <nav class="nav-links">
+          <a href="/health">Health</a>
+          <a href="/tasks">Tasks JSON</a>
+          <a href="/docs">API Docs</a>
+        </nav>
+      </header>
+
+      <section class="hero">
+        <div class="hero-copy">
+          <p class="eyebrow">{escape(APP_ENV_NAME)}</p>
+          <h2>Queue decisions that actually carry forward.</h2>
+          <p>
+            A sleek benchmark surface for sequential helpdesk routing: hidden context,
+            cluster-aware follow-ons, incident handling, deferrals, and a terminal rubric
+            that rewards queue strategy instead of isolated classification alone.
+          </p>
+          <div class="hero-kickers">
+            <span class="kicker">Task family: easy to hard</span>
+            <span class="kicker">Closed-form grader</span>
+            <span class="kicker">Queue-level terminal objective</span>
+          </div>
+          <div class="hero-actions">
+            <a class="button primary" href="/docs">Explore the API</a>
+            <a class="button secondary" href="/baseline?task_id=3&amp;seed=42">Run Hard Baseline</a>
+            <a class="button" href="/tasks">Inspect Task Definitions</a>
+          </div>
+        </div>
+
+        <aside class="hero-panel">
+          <p class="panel-title">Why This Stands Out</p>
+          <div class="signal-card">
+            <strong>Not just ticket labels</strong>
+            <span>Medium and hard episodes now carry cluster state, follow-up debt, queue pressure, and operational actions across the whole episode.</span>
+          </div>
+          <div class="signal-card">
+            <strong>Judge-friendly surface</strong>
+            <span>Clear API entry points, deterministic grading, and a landing page that explains the benchmark without making anyone read code first.</span>
+          </div>
+          <div class="signal-card">
+            <strong>Built by {escape(TEAM_NAME)}</strong>
+            <span>Designed for OpenEnv evaluation, local policy comparison, and fast demoability during judging.</span>
+          </div>
+        </aside>
+      </section>
+
+      <section class="stats-grid" aria-label="Benchmark stats">
+        <article class="stat-card">
+          <span class="value">{dataset_size}</span>
+          <span class="label">Tickets in the grounded dataset</span>
+          <span class="hint">Curated records plus queue mutation mechanics create repeatable but non-trivial episodes.</span>
+        </article>
+        <article class="stat-card">
+          <span class="value">{alternate_route_count}</span>
+          <span class="label">Capacity-aware alternate routes</span>
+          <span class="hint">The grader can reward declared fallback routes instead of collapsing to all-or-nothing exact match.</span>
+        </article>
+        <article class="stat-card">
+          <span class="value">{clustered_case_count}</span>
+          <span class="label">Cluster-linked or coordinated cases</span>
+          <span class="hint">Handling one ticket can stabilize or destabilize the downstream tickets in the same workstream.</span>
+        </article>
+        <article class="stat-card">
+          <span class="value">{hidden_context_case_count}</span>
+          <span class="label">Hidden-context routing cases</span>
+          <span class="hint">Investigation tools matter because key evidence does not appear in the initial observation by default.</span>
+        </article>
+      </section>
+
+      <section class="section">
+        <div class="section-head">
+          <div>
+            <p class="eyebrow">Task Ladder</p>
+            <h3>One benchmark family, not three disconnected demos</h3>
+          </div>
+          <p>
+            The difficulty ladder keeps the same full-routing output while progressively changing
+            observability, queue dependencies, and operational pressure.
+          </p>
+        </div>
+        <div class="task-grid">
+          {task_cards}
+        </div>
+      </section>
+
+      <section class="section">
+        <div class="section-head">
+          <div>
+            <p class="eyebrow">Environment Signals</p>
+            <h3>What the agent is balancing</h3>
+          </div>
+          <p>
+            The benchmark is designed so strong policy choices change later tickets, incident
+            coverage, and terminal queue quality instead of just nudging shaped reward.
+          </p>
+        </div>
+        <div class="feature-grid">
+          <article class="feature-card">
+            <h4>Hidden context retrieval</h4>
+            <p>Related-ticket previews, requester history, internal routing notes, queue cluster summaries, and capacity forecasts are revealed through explicit tool use.</p>
+            <div class="chip-row">
+              <span class="mini-chip">investigate</span>
+              <span class="mini-chip">request_info</span>
+              <span class="mini-chip">cluster summary</span>
+            </div>
+          </article>
+          <article class="feature-card">
+            <h4>Operational actions with consequences</h4>
+            <p>Deferrals can raise later urgency, incident handling can reduce downstream debt, and weak handling can spawn or worsen follow-up work.</p>
+            <div class="chip-row">
+              <span class="mini-chip">defer</span>
+              <span class="mini-chip">open_incident</span>
+              <span class="mini-chip">follow-up spawning</span>
+            </div>
+          </article>
+          <article class="feature-card">
+            <h4>Queue-level terminal rubric</h4>
+            <p>Final scoring blends routing trajectory quality with queue management quality so agents are rewarded for coherent episode strategy, not just isolated ticket matches.</p>
+            <div class="chip-row">
+              <span class="mini-chip">terminal rubric</span>
+              <span class="mini-chip">queue quality</span>
+              <span class="mini-chip">planning-aware</span>
+            </div>
+          </article>
+        </div>
+      </section>
+
+      <section class="section">
+        <div class="section-head">
+          <div>
+            <p class="eyebrow">Quick Routes</p>
+            <h3>Fast ways to demo the environment</h3>
+          </div>
+          <p>
+            Useful entry points for judges, reviewers, or anyone trying to get signal from the project quickly.
+          </p>
+        </div>
+        <div class="shortcut-grid">
+          <article class="shortcut-card">
+            <h4>Interactive API docs</h4>
+            <p>Browse the full OpenEnv-compatible surface, request models, and built-in helper endpoints.</p>
+            <code>GET /docs</code>
+            <a class="button primary" href="/docs">Open Docs</a>
+          </article>
+          <article class="shortcut-card">
+            <h4>Task manifest</h4>
+            <p>Inspect the easy, medium, and hard task definitions exactly as exposed by the server.</p>
+            <code>GET /tasks</code>
+            <a class="button" href="/tasks">View Tasks</a>
+          </article>
+          <article class="shortcut-card">
+            <h4>Hard-task baseline rollout</h4>
+            <p>See a deterministic baseline episode over the hardest queue with the current environment logic.</p>
+            <code>GET /baseline?task_id=3&amp;seed=42</code>
+            <a class="button secondary" href="/baseline?task_id=3&amp;seed=42">Run Baseline</a>
+          </article>
+          <article class="shortcut-card">
+            <h4>Health and deployment status</h4>
+            <p>Quick check that the service is alive and ready for OpenEnv-style evaluation requests.</p>
+            <code>GET /health</code>
+            <a class="button" href="/health">Check Health</a>
+          </article>
+        </div>
+      </section>
+
+      <footer class="footer">
+        <span>{escape(PROJECT_TITLE)} • {escape(APP_ENV_NAME)} • {incident_sensitive_count} incident-sensitive records surfaced in the current dataset snapshot.</span>
+      </footer>
+    </main>
+  </body>
+</html>"""
     return HTMLResponse(content=html)
 
 

server/environment.py

@@ -35,7 +35,7 @@ BASE_AVAILABLE_TOOLS = (
 )
 TASK_AVAILABLE_ACTION_TYPES: dict[int, tuple[str, ...]] = {
     1: ("submit", "investigate"),
-    2: ("submit", "investigate", "request_info"),
+    2: ("submit", "investigate", "request_info", "defer"),
     3: ("submit", "investigate", "request_info", "defer", "open_incident"),
 }
 TASK_AVAILABLE_TOOLS: dict[int, tuple[str, ...]] = {
@@ -48,6 +48,7 @@ TASK_AVAILABLE_TOOLS: dict[int, tuple[str, ...]] = {
         "lookup_related_ticket",
         "lookup_requester_history",
         "lookup_internal_routing_note",
+        "lookup_queue_cluster_summary",
     ),
     3: BASE_AVAILABLE_TOOLS,
 }
@@ -79,6 +80,11 @@ CLUSTER_STABILIZE_SCORE_THRESHOLD = 0.84
 CLUSTER_DESTABILIZE_SCORE_THRESHOLD = 0.72
 CLUSTER_INCIDENT_RELIEF_MULTIPLIER = 0.94
 CLUSTER_OWNER_RELIEF_MULTIPLIER = 0.86
+TASK_QUEUE_MANAGEMENT_WEIGHT: dict[int, float] = {
+    1: 0.0,
+    2: 0.2,
+    3: 0.32,
+}
 
 TASK3_INVESTIGATION_TOOL_PLAN: dict[str, tuple[str, ...]] = {
     "ticket-021": ("lookup_related_ticket", "lookup_requester_history"),
@@ -228,6 +234,8 @@ class HelpdeskTicketRoutingEnvironment(
             incident_slots_remaining=incident_slots_initial,
             planning_penalty_total=0.0,
             capacity_pressure_tickets_resolved=0,
+            cluster_stabilizations_total=0,
+            cluster_destabilizations_total=0,
             ticket_request_info_usage={},
             ticket_defer_counts={},
             open_incident_ticket_ids=[],
@@ -238,6 +246,8 @@ class HelpdeskTicketRoutingEnvironment(
             spawned_follow_up_ticket_ids=[],
             spawned_follow_up_source_ids=[],
             dynamic_queue_events=[],
+            queue_management_score=0.0,
+            queue_management_breakdown={},
         )
 
         return self._build_observation(task)
@@ -292,6 +302,7 @@ class HelpdeskTicketRoutingEnvironment(
             trajectory_reward = None
             trajectory_components = None
             investigation_penalty = self._compute_episode_penalty() if is_done else 0.0
+            rubric_details: dict[str, Any] = {}
             if is_done:
                 trajectory_components = compute_trajectory_adjustments(
                     self._state.per_ticket_scores,
@@ -300,7 +311,9 @@ class HelpdeskTicketRoutingEnvironment(
                     completion_bonus=self._trajectory_consistency_bonus(),
                 )
                 trajectory_reward = trajectory_components["final_reward"]
-                final_reward = self._apply_episode_economics(trajectory_reward)
+                final_reward, rubric_details = self._finalize_terminal_rubric(
+                    trajectory_reward
+                )
                 self._state.total_reward = final_reward
             else:
                 final_reward = clamp_open_unit_interval(0.0)
@@ -329,6 +342,7 @@ class HelpdeskTicketRoutingEnvironment(
                         if trajectory_components is not None
                         else None
                     ),
+                    **rubric_details,
                 },
             )
             self._state.history_entries.append(
@@ -388,6 +402,7 @@ class HelpdeskTicketRoutingEnvironment(
         trajectory_components = None
         investigation_penalty = 0.0
         rubric_reward = None
+        rubric_details: dict[str, Any] = {}
 
         if is_done:
             self._state.per_ticket_scores.append(score)
@@ -403,8 +418,8 @@ class HelpdeskTicketRoutingEnvironment(
                 ),
             )
             trajectory_reward = trajectory_components["final_reward"]
-            rubric_reward = self._apply_episode_economics(
-                trajectory_reward - self._state.planning_penalty_total
+            rubric_reward, rubric_details = self._finalize_terminal_rubric(
+                trajectory_reward
             )
             final_reward = clamp_open_unit_interval(
                 rubric_reward - context_penalty - capacity_penalty - incident_gap_penalty
@@ -434,10 +449,13 @@ class HelpdeskTicketRoutingEnvironment(
                 trajectory_reward = None
                 trajectory_components = None
                 rubric_reward = None
+                rubric_details = {}
                 final_reward = clamp_open_unit_interval(
                     step_reward - context_penalty - capacity_penalty - incident_gap_penalty
                 )
                 self._state.total_reward = 0.0
+                self._state.queue_management_score = 0.0
+                self._state.queue_management_breakdown = {}
         if incident_gap_penalty > 0.0:
             self._state.incident_gap_total = round(
                 self._state.incident_gap_total + incident_gap_penalty,
@@ -503,6 +521,7 @@ class HelpdeskTicketRoutingEnvironment(
                     if trajectory_components is not None
                     else None
                 ),
+                **rubric_details,
             },
         )
         reward_components.update(capacity_details)
@@ -553,10 +572,6 @@ class HelpdeskTicketRoutingEnvironment(
 
     def _apply_episode_economics(self, base_reward: float) -> float:
         penalty = self._compute_episode_penalty()
-        penalty += min(
-            0.25,
-            self._state.sla_breach_count * SLA_BREACH_PENALTY + self._state.incident_gap_total,
-        )
         return clamp_open_unit_interval(base_reward - penalty)
 
     def _current_average_score(self) -> float:
@@ -564,6 +579,230 @@ class HelpdeskTicketRoutingEnvironment(
             return 0.0
         return sum(self._state.per_ticket_scores) / len(self._state.per_ticket_scores)
 
+    def _queue_management_blend_weight(self, task_id: int | None = None) -> float:
+        resolved_task_id = self._state.current_task_id if task_id is None else task_id
+        return TASK_QUEUE_MANAGEMENT_WEIGHT.get(int(resolved_task_id or 1), 0.0)
+
+    def _context_resolution_score(self) -> float:
+        hidden_context_tickets = [
+            ticket
+            for ticket in self._queue
+            if self._required_tools_for_ticket(ticket, self._state.current_task_id)
+        ]
+        if not hidden_context_tickets:
+            return 1.0
+        total_required = 0
+        total_resolved = 0
+        for ticket in hidden_context_tickets:
+            progress = self._tool_progress_for_ticket(ticket)
+            total_required += max(1, len(progress["required_tools"]))
+            total_resolved += max(
+                0,
+                len(progress["required_tools"]) - len(progress["remaining_tools"]),
+            )
+        return round(
+            max(0.0, min(1.0, total_resolved / max(1, total_required))),
+            4,
+        )
+
+    def _follow_up_containment_score(self) -> float:
+        follow_up_risk_tickets = [
+            ticket
+            for ticket in self._queue
+            if ticket.generated_from_ticket_id is None
+            and (
+                self._requires_incident(ticket)
+                or self._ticket_mentions_follow_up(ticket)
+                or ticket.related_ticket_id is not None
+                or ticket.priority in {"high", "critical"}
+            )
+        ]
+        if not follow_up_risk_tickets:
+            return 1.0
+        spawn_rate = len(self._state.spawned_follow_up_ticket_ids) / max(
+            1,
+            len(follow_up_risk_tickets),
+        )
+        generated_follow_up_scores = [
+            float(entry.get("score", 0.0))
+            for entry in self._state.history_entries
+            if entry.get("generated_from_ticket_id") is not None
+        ]
+        recovery_credit = (
+            sum(generated_follow_up_scores) / len(generated_follow_up_scores)
+            if generated_follow_up_scores
+            else 0.0
+        )
+        score = (1.0 - min(1.0, 0.7 * spawn_rate)) + (
+            min(1.0, spawn_rate) * 0.3 * recovery_credit
+        )
+        return round(max(0.0, min(1.0, score)), 4)
+
+    def _incident_management_score(self) -> float:
+        if (self._state.current_task_id or 1) < 3:
+            return 1.0
+        incident_sensitive_tickets = [
+            ticket
+            for ticket in self._queue
+            if ticket.generated_from_ticket_id is None and self._requires_incident(ticket)
+        ]
+        if not incident_sensitive_tickets:
+            return 1.0
+        coverage_ratio = sum(
+            1 for ticket in incident_sensitive_tickets if self._incident_open_for_ticket(ticket)
+        ) / max(1, len(incident_sensitive_tickets))
+        gap_ratio = min(
+            1.0,
+            self._state.incident_gap_total
+            / max(
+                INCIDENT_GAP_PENALTY,
+                len(incident_sensitive_tickets) * INCIDENT_GAP_PENALTY,
+            ),
+        )
+        score = (0.65 * (1.0 - gap_ratio)) + (0.35 * coverage_ratio)
+        return round(max(0.0, min(1.0, score)), 4)
+
+    def _sla_quality_score(self) -> float:
+        breach_denominator = max(1, self._state.deferred_ticket_count or len(self._queue))
+        breach_ratio = min(1.0, self._state.sla_breach_count / breach_denominator)
+        score = 1.0 - breach_ratio
+        return round(max(0.0, min(1.0, score)), 4)
+
+    def _planning_quality_score(self) -> float:
+        if (self._state.current_task_id or 1) < 3:
+            return 1.0
+        capacity_sensitive_count = sum(
+            1 for ticket in self._queue if self._ticket_has_alternate_route(ticket)
+        )
+        route_coverage = (
+            min(
+                1.0,
+                self._state.capacity_pressure_tickets_resolved / capacity_sensitive_count,
+            )
+            if capacity_sensitive_count
+            else 1.0
+        )
+        max_expected_penalty = max(
+            0.12,
+            len(self._queue)
+            * (
+                TEAM_CAPACITY_OVERFLOW_PENALTY
+                + HIGH_PRIORITY_SLOT_OVERFLOW_PENALTY
+                + ESCALATION_SLOT_OVERFLOW_PENALTY
+            ),
+        )
+        penalty_score = 1.0 - min(
+            1.0,
+            self._state.planning_penalty_total / max_expected_penalty,
+        )
+        score = (0.6 * penalty_score) + (0.4 * route_coverage)
+        return round(max(0.0, min(1.0, score)), 4)
+
+    def _cluster_coordination_score(self) -> float:
+        if (self._state.current_task_id or 1) < 2:
+            return 1.0
+        clustered_tickets = [
+            ticket
+            for ticket in self._queue
+            if ticket.service_cluster_id
+            or ticket.related_ticket_id is not None
+            or ticket.generated_from_ticket_id is not None
+            or self._ticket_repeated_requester_count(ticket) >= 2
+        ]
+        if not clustered_tickets:
+            return 1.0
+        cluster_count = max(1, len(clustered_tickets))
+        destabilization_ratio = min(
+            1.0,
+            self._state.cluster_destabilizations_total / cluster_count,
+        )
+        stabilization_ratio = min(
+            1.0,
+            self._state.cluster_stabilizations_total / cluster_count,
+        )
+        score = 1.0 - (0.75 * destabilization_ratio) + (0.25 * stabilization_ratio)
+        return round(max(0.0, min(1.0, score)), 4)
+
+    def _queue_management_breakdown(self, trajectory_reward: float) -> tuple[float, dict[str, Any]]:
+        task_id = int(self._state.current_task_id or 1)
+        if task_id < 2:
+            proxy_score = round(clamp_open_unit_interval(trajectory_reward), 4)
+            return proxy_score, {"routing_trajectory_proxy": proxy_score}
+
+        component_scores: dict[str, float] = {
+            "context_resolution": self._context_resolution_score(),
+            "cluster_coordination": self._cluster_coordination_score(),
+            "follow_up_containment": self._follow_up_containment_score(),
+            "sla_management": self._sla_quality_score(),
+        }
+        if task_id >= 3:
+            component_scores["planning_quality"] = self._planning_quality_score()
+            component_scores["incident_management"] = self._incident_management_score()
+            component_weights = {
+                "context_resolution": 0.2,
+                "planning_quality": 0.24,
+                "incident_management": 0.2,
+                "cluster_coordination": 0.16,
+                "follow_up_containment": 0.12,
+                "sla_management": 0.08,
+            }
+        else:
+            component_weights = {
+                "context_resolution": 0.38,
+                "cluster_coordination": 0.26,
+                "follow_up_containment": 0.2,
+                "sla_management": 0.16,
+            }
+
+        aggregate_score = round(
+            sum(
+                component_scores[name] * weight
+                for name, weight in component_weights.items()
+            ),
+            4,
+        )
+        breakdown: dict[str, Any] = {
+            name: round(score, 4) for name, score in component_scores.items()
+        }
+        breakdown["weights"] = {
+            name: round(weight, 4) for name, weight in component_weights.items()
+        }
+        breakdown["cluster_stabilizations_total"] = self._state.cluster_stabilizations_total
+        breakdown["cluster_destabilizations_total"] = self._state.cluster_destabilizations_total
+        breakdown["spawned_follow_up_count"] = len(self._state.spawned_follow_up_ticket_ids)
+        breakdown["sla_breach_count"] = self._state.sla_breach_count
+        breakdown["planning_penalty_total"] = round(self._state.planning_penalty_total, 4)
+        breakdown["incident_gap_total"] = round(self._state.incident_gap_total, 4)
+        breakdown["aggregate"] = aggregate_score
+        return aggregate_score, breakdown
+
+    def _finalize_terminal_rubric(
+        self,
+        trajectory_reward: float,
+    ) -> tuple[float, dict[str, Any]]:
+        task_id = int(self._state.current_task_id or 1)
+        queue_management_score, queue_management_breakdown = self._queue_management_breakdown(
+            trajectory_reward
+        )
+        route_weight = round(1.0 - self._queue_management_blend_weight(task_id), 4)
+        queue_weight = round(self._queue_management_blend_weight(task_id), 4)
+        blended_reward = clamp_open_unit_interval(
+            (route_weight * trajectory_reward) + (queue_weight * queue_management_score)
+        )
+        episode_economics_penalty = round(self._compute_episode_penalty(), 4)
+        rubric_reward = self._apply_episode_economics(blended_reward)
+        self._state.queue_management_score = queue_management_score
+        self._state.queue_management_breakdown = dict(queue_management_breakdown)
+        return rubric_reward, {
+            "trajectory_routing_reward": trajectory_reward,
+            "queue_management_score": queue_management_score,
+            "queue_management_breakdown": dict(queue_management_breakdown),
+            "route_objective_weight": route_weight,
+            "queue_management_weight": queue_weight,
+            "blended_objective_before_economics": blended_reward,
+            "episode_economics_penalty": episode_economics_penalty,
+        }
+
     def _available_action_types_for_task(self, task_id: int | None = None) -> list[str]:
         resolved_task_id = self._state.current_task_id if task_id is None else task_id
         return list(TASK_AVAILABLE_ACTION_TYPES.get(int(resolved_task_id or 1), ("submit",)))
@@ -595,7 +834,7 @@ class HelpdeskTicketRoutingEnvironment(
     def _sample_queue(self, task_id: int, queue_size: int) -> list[HelpdeskTicketRecord]:
         if queue_size <= 0:
             return []
-        if task_id != 3 or queue_size < 3:
+        if task_id not in {2, 3} or queue_size < 3:
             return self._rng.sample(self._dataset, queue_size)
 
         cluster_groups = self._cluster_sample_groups()
@@ -671,15 +910,27 @@ class HelpdeskTicketRoutingEnvironment(
                 indexes.append(index)
         return indexes
 
+    def _ticket_queue_index(self, ticket: HelpdeskTicketRecord) -> int | None:
+        for index, candidate in enumerate(self._queue):
+            if candidate.ticket_id == ticket.ticket_id:
+                return index
+        return None
+
     def _cluster_summary(
         self,
         ticket: HelpdeskTicketRecord,
         *,
         start_index: int | None = None,
     ) -> dict[str, Any]:
-        effective_start = (
-            self._state.current_ticket_index + 1 if start_index is None else start_index
-        )
+        if start_index is None:
+            ticket_index = self._ticket_queue_index(ticket)
+            effective_start = (
+                ticket_index + 1
+                if ticket_index is not None
+                else self._state.current_ticket_index + 1
+            )
+        else:
+            effective_start = start_index
         future_indexes = self._future_cluster_ticket_indexes(
             ticket,
             start_index=effective_start,
@@ -722,7 +973,7 @@ class HelpdeskTicketRoutingEnvironment(
         context_penalty: float,
         incident_gap_penalty: float,
     ) -> list[str]:
-        if self._state.current_task_id != 3:
+        if (self._state.current_task_id or 1) < 2:
             return []
         if score < CLUSTER_STABILIZE_SCORE_THRESHOLD:
             return []
@@ -791,6 +1042,7 @@ class HelpdeskTicketRoutingEnvironment(
             updated_ticket_ids.append(updated_ticket.ticket_id)
 
         if updated_ticket_ids:
+            self._state.cluster_stabilizations_total += len(updated_ticket_ids)
             self._record_dynamic_queue_event(
                 "stabilize_cluster",
                 source_ticket_id=current_ticket.ticket_id,
@@ -807,7 +1059,7 @@ class HelpdeskTicketRoutingEnvironment(
         context_penalty: float,
         incident_gap_penalty: float,
     ) -> list[str]:
-        if self._state.current_task_id != 3:
+        if (self._state.current_task_id or 1) < 2:
             return []
         if score >= CLUSTER_DESTABILIZE_SCORE_THRESHOLD:
             if context_penalty <= 0.0 and incident_gap_penalty <= 0.0:
@@ -850,6 +1102,7 @@ class HelpdeskTicketRoutingEnvironment(
             updated_ticket_ids.append(updated_ticket.ticket_id)
 
         if updated_ticket_ids:
+            self._state.cluster_destabilizations_total += len(updated_ticket_ids)
             self._record_dynamic_queue_event(
                 "destabilize_cluster",
                 source_ticket_id=current_ticket.ticket_id,
@@ -1431,17 +1684,27 @@ class HelpdeskTicketRoutingEnvironment(
         context_penalty: float,
         incident_gap_penalty: float,
     ) -> bool:
-        if self._state.current_task_id != 3:
+        task_id = int(self._state.current_task_id or 1)
+        if task_id < 2:
             return False
         if ticket.generated_from_ticket_id is not None:
             return False
         if ticket.ticket_id in self._state.spawned_follow_up_source_ids:
             return False
-        if not (
+        follow_up_risk = (
             self._requires_incident(ticket)
             or self._ticket_mentions_follow_up(ticket)
             or ticket.related_ticket_id is not None
             or ticket.priority in {"high", "critical"}
+            or self._cluster_summary(ticket)["future_cluster_ticket_count"] > 0
+        )
+        if not follow_up_risk:
+            return False
+        if task_id == 2 and not (
+            ticket.related_ticket_id is not None
+            or self._ticket_mentions_follow_up(ticket)
+            or self._cluster_summary(ticket)["future_cluster_ticket_count"] > 0
+            or self._ticket_repeated_requester_count(ticket) >= 2
         ):
             return False
         return (
@@ -1527,7 +1790,7 @@ class HelpdeskTicketRoutingEnvironment(
                 or self._future_queue_demand()["remaining_ticket_count"] > 0
             )
         if tool_name == "lookup_queue_cluster_summary":
-            if self._state.current_task_id != 3:
+            if (self._state.current_task_id or 1) < 2:
                 return False
             cluster_summary = self._cluster_summary(ticket)
             return (
@@ -1569,10 +1832,16 @@ class HelpdeskTicketRoutingEnvironment(
             and "lookup_queue_capacity_forecast" not in required_tools
         ):
             required_tools.append("lookup_queue_capacity_forecast")
+        ticket_index = self._ticket_queue_index(ticket)
+        cluster_start_index = (
+            ticket_index + 1
+            if ticket_index is not None
+            else self._state.current_ticket_index + 1
+        )
         if resolved_task_id == 3:
             cluster_summary = self._cluster_summary(
                 ticket,
-                start_index=self._state.current_ticket_index + 1,
+                start_index=cluster_start_index,
             )
             if (
                 cluster_summary["future_cluster_ticket_count"] > 0
@@ -1584,6 +1853,21 @@ class HelpdeskTicketRoutingEnvironment(
                 )
             ):
                 required_tools.append("lookup_queue_cluster_summary")
+        if resolved_task_id == 2:
+            cluster_summary = self._cluster_summary(
+                ticket,
+                start_index=cluster_start_index,
+            )
+            if (
+                cluster_summary["future_cluster_ticket_count"] > 0
+                and "lookup_queue_cluster_summary" not in required_tools
+                and (
+                    ticket.related_ticket_id is not None
+                    or cluster_summary["shared_requester_count"] > 1
+                    or self._ticket_mentions_follow_up(ticket)
+                )
+            ):
+                required_tools.append("lookup_queue_cluster_summary")
         filtered_required_tools: list[str] = []
         allowed_tool_set = set(self._available_tools_for_task(resolved_task_id))
         for tool_name in required_tools:
@@ -2316,6 +2600,10 @@ class HelpdeskTicketRoutingEnvironment(
         used_tools = set(self._used_tools_for_ticket(ticket.ticket_id))
         operational_actions = progress["recommended_operational_actions"]
         cluster_summary = self._cluster_summary(ticket)
+        cluster_hint = (
+            cluster_summary["future_cluster_ticket_count"] > 0
+            or cluster_summary["shared_requester_count"] > 1
+        )
         ticket_view: dict[str, Any] = {
             "ticket_id": ticket.ticket_id,
             "title": self._visible_title(ticket),
@@ -2341,12 +2629,19 @@ class HelpdeskTicketRoutingEnvironment(
             "incident_recommended": self._requires_incident(ticket),
             "incident_open": self._incident_open_for_ticket(ticket),
             "recommended_actions": operational_actions,
-            "service_cluster_id": ticket.service_cluster_id,
-            "future_cluster_ticket_count": cluster_summary["future_cluster_ticket_count"],
-            "future_cluster_ticket_ids": cluster_summary["future_cluster_ticket_ids"],
-            "shared_requester_count": cluster_summary["shared_requester_count"],
-            "active_incident_cover": cluster_summary["active_incident_cover"],
+            "cluster_coordination_hint": cluster_hint,
+            "shared_requester_pressure": cluster_summary["shared_requester_count"] > 1,
         }
+        if "lookup_queue_cluster_summary" in used_tools:
+            ticket_view["operational_context"].update(
+                {
+                    "service_cluster_id": ticket.service_cluster_id,
+                    "future_cluster_ticket_count": cluster_summary["future_cluster_ticket_count"],
+                    "future_cluster_ticket_ids": cluster_summary["future_cluster_ticket_ids"],
+                    "shared_requester_count": cluster_summary["shared_requester_count"],
+                    "active_incident_cover": cluster_summary["active_incident_cover"],
+                }
+            )
         if ticket.ambiguity_note is not None and "lookup_internal_routing_note" not in remaining_tools:
             ticket_view["ambiguity_note"] = ticket.ambiguity_note
         if (
@@ -2444,6 +2739,9 @@ class HelpdeskTicketRoutingEnvironment(
             incident_gap_penalty = reward_components.get("incident_gap_penalty")
             if incident_gap_penalty:
                 parts.append(f"incident_gap_penalty={incident_gap_penalty:.2f}")
+            queue_management_score = reward_components.get("queue_management_score")
+            if queue_management_score is not None:
+                parts.append(f"queue_management_score={queue_management_score:.2f}")
             spawned_follow_up_ticket_id = reward_components.get("spawned_follow_up_ticket_id")
             if spawned_follow_up_ticket_id:
                 parts.append(f"spawned_follow_up={spawned_follow_up_ticket_id}")
@@ -2493,11 +2791,21 @@ class HelpdeskTicketRoutingEnvironment(
                 "defer_count": self._defer_count(ticket.ticket_id),
                 "incident_open": self._incident_open_for_ticket(ticket),
                 "recommended_actions": progress["recommended_operational_actions"],
-                "service_cluster_id": ticket.service_cluster_id,
-                "future_cluster_ticket_count": cluster_summary["future_cluster_ticket_count"],
-                "active_incident_cover": cluster_summary["active_incident_cover"],
+                "cluster_coordination_hint": (
+                    cluster_summary["future_cluster_ticket_count"] > 0
+                    or cluster_summary["shared_requester_count"] > 1
+                ),
             },
         }
+        if "lookup_queue_cluster_summary" in self._used_tools_for_ticket(ticket.ticket_id):
+            history_entry["operational_context"].update(
+                {
+                    "service_cluster_id": ticket.service_cluster_id,
+                    "future_cluster_ticket_count": cluster_summary["future_cluster_ticket_count"],
+                    "active_incident_cover": cluster_summary["active_incident_cover"],
+                    "shared_requester_count": cluster_summary["shared_requester_count"],
+                }
+            )
         if self._state.current_task_id == 3:
             history_entry["capacity_state"] = self._capacity_state_snapshot()
         if reward is not None:
@@ -2610,12 +2918,13 @@ class HelpdeskTicketRoutingEnvironment(
             "planning_penalty_applied": self._state.planning_penalty_applied,
             "sla_breach_count": self._state.sla_breach_count,
             "incident_gap_total": self._state.incident_gap_total,
+            "queue_management_score": self._state.queue_management_score,
+            "queue_management_breakdown": dict(self._state.queue_management_breakdown),
             "dynamic_queue_events": list(self._state.dynamic_queue_events[-5:]),
             "clustered_follow_ons": self._future_queue_demand().get("clustered_follow_ons", 0),
         }
         if self._state.current_task_id == 3:
             metadata["capacity_state"] = self._capacity_state_snapshot()
-            metadata["future_queue_demand"] = self._future_queue_demand()
         if last_history_entry is not None:
             metadata["last_score"] = last_history_entry.get("score")
             metadata["last_reward"] = last_history_entry.get("reward")

server/tasks.py

@@ -29,9 +29,11 @@ TASKS = {
         "name": "Contextual Full Routing",
         "difficulty": "medium",
         "instructions": (
-            "Perform full helpdesk routing with partial observability. Some "
-            "tickets hide related-case, requester-history, or clarification "
-            "details until you investigate or request more information."
+            "Perform full helpdesk routing with partial observability and moderate "
+            "queue carry-over. Some tickets hide related-case, requester-history, "
+            "or cluster-coordination details until you investigate or request more "
+            "information, and medium episodes can also require deferral or coherent "
+            "handling across linked tickets in the same queue."
         ),
         "allowed_fields": [
             "issue_type",

tests/test_competitive_upgrade.py

@@ -729,6 +729,8 @@ class TestInvestigationActions(unittest.TestCase):
 
     def test_queue_cluster_summary_reveals_future_cluster_load(self) -> None:
         env, obs, root, follow_up = self._make_cluster_env()
+        self.assertNotIn("future_cluster_ticket_count", obs.current_ticket["operational_context"])
+        self.assertTrue(obs.current_ticket["operational_context"]["cluster_coordination_hint"])
 
         obs = env.step(
             HelpdeskTicketAction(
@@ -776,7 +778,7 @@ class TestInvestigationActions(unittest.TestCase):
 
         self.assertFalse(obs.done)
         self.assertEqual(obs.current_ticket["ticket_id"], follow_up.ticket_id)
-        self.assertTrue(obs.current_ticket["operational_context"]["active_incident_cover"])
+        self.assertTrue(obs.current_ticket["operational_context"]["incident_open"])
         self.assertIn(
             follow_up.ticket_id,
             obs.history[-1]["reward_components"]["cluster_stabilized_ticket_ids"],
@@ -839,6 +841,56 @@ class TestInvestigationActions(unittest.TestCase):
             0.0,
         )
 
+    def test_terminal_rubric_reports_queue_management_score(self) -> None:
+        from unittest.mock import patch
+
+        dataset = load_dataset()
+        ticket = next((t for t in dataset if t.ticket_id == "TKT-NONDEFAULT-003"), None)
+        self.assertIsNotNone(ticket)
+
+        env = _make_env()
+        with patch.object(env, "_dataset", [ticket]):
+            with patch.object(env, "_tickets_by_id", {ticket.ticket_id: ticket}):
+                obs = env.reset(seed=0, task_id=3, queue_size=1)
+
+        final_obs = env.step(
+            HelpdeskTicketAction(
+                issue_type=ticket.issue_type,
+                priority=ticket.priority,
+                assignment_group=ticket.assignment_group,
+                resolution_action=ticket.resolution_action,
+            )
+        )
+
+        self.assertTrue(final_obs.done)
+        self.assertIn("queue_management_score", final_obs.last_reward_components)
+        self.assertIn("queue_management_breakdown", final_obs.last_reward_components)
+        self.assertIn("context_resolution", final_obs.last_reward_components["queue_management_breakdown"])
+
+    def test_capacity_forecast_hides_future_demand_until_tool_use(self) -> None:
+        from unittest.mock import patch
+
+        dataset = load_dataset()
+        ticket = next(
+            (t for t in dataset if t.alternate_route_score_multiplier > 0.0),
+            None,
+        )
+        self.assertIsNotNone(ticket)
+
+        env = _make_env()
+        with patch.object(env, "_dataset", [ticket]):
+            with patch.object(env, "_tickets_by_id", {ticket.ticket_id: ticket}):
+                obs = env.reset(seed=0, task_id=3, queue_size=1)
+
+        self.assertNotIn("future_queue_demand", obs.metadata)
+        obs = env.step(
+            HelpdeskTicketAction(
+                action_type="investigate",
+                tool_name="lookup_queue_capacity_forecast",
+            )
+        )
+        self.assertIn("future_queue_demand", obs.last_tool_result)
+
 
 class TestQueueEconomics(unittest.TestCase):
     """Free investigations are allowed, but excessive investigation gets a queue-level penalty."""

tests/test_environment_smoke.py

@@ -124,6 +124,8 @@ class TestResetAllTaskIds(unittest.TestCase):
         env = _make_env()
         obs = env.reset(seed=42, task_id=2)
         self._assert_valid_reset_obs(obs, 2)
+        self.assertIn("defer", obs.available_action_types)
+        self.assertIn("lookup_queue_cluster_summary", obs.available_tools)
 
     def test_reset_task3(self) -> None:
         env = _make_env()
@@ -258,6 +260,22 @@ class TestSeededDeterminism(unittest.TestCase):
             f"Expected at least one repeated service_cluster_id in task 3 queue, got {cluster_ids}",
         )
 
+    def test_task2_queue_sampling_includes_clustered_follow_on(self) -> None:
+        env = _make_env()
+        env.reset(seed=42, task_id=2, queue_size=5)
+
+        cluster_ids = [
+            ticket.service_cluster_id for ticket in env._queue if ticket.service_cluster_id
+        ]
+        repeated_cluster_ids = {
+            cluster_id for cluster_id in cluster_ids if cluster_ids.count(cluster_id) >= 2
+        }
+
+        self.assertTrue(
+            repeated_cluster_ids,
+            f"Expected at least one repeated service_cluster_id in task 2 queue, got {cluster_ids}",
+        )
+
 
 class TestPerTicketScoreBounds(unittest.TestCase):
     """1.1.6 — all per-ticket scores stay in [0.0, 1.0] across a full episode."""

tests/test_policy_learning.py

@@ -209,6 +209,8 @@ class PolicyLearningTests(unittest.TestCase):
 
         self.assertEqual(report["best_policy"], "adaptive_cue_bandit")
         self.assertGreater(report["improvement_vs_baseline"]["avg_terminal_reward"], 0.0)
+        self.assertIn("avg_queue_management_score", report["improvement_vs_baseline"])
+        self.assertIn("avg_queue_management_score", report["policy_summaries"][0])
 
     def test_infer_ticket_cue_distinguishes_workflow_blocker(self) -> None:
         cue = infer_ticket_cue(