Refine rejection heuristics and trap orders

src/delivery_dispatch/policies.py

@@ -4,7 +4,7 @@ from dataclasses import dataclass
 from typing import Any
 
 
-ActionDict = dict[str, list[dict[str, str]]]
+ActionDict = dict[str, list[Any]]
 Point = tuple[int, int]
 
 
@@ -21,6 +21,16 @@ class CandidateAssignment:
     feasible_now: bool
 
 
+@dataclass(frozen=True)
+class CandidateRejection:
+    order_id: str
+    score: float
+    estimated_best_cost: int
+    slack_to_cutoff: int
+    reward_value: float
+    has_idle_agents: bool
+
+
 def _as_point(value: Any) -> Point:
     x, y = value
     return int(x), int(y)
@@ -107,6 +117,13 @@ def _idle_agents(state: dict[str, Any]) -> list[dict[str, Any]]:
     return [agent for agent in state.get("agents", []) if agent.get("status") == "idle"]
 
 
+def _service_cutoff(order: dict[str, Any]) -> int:
+    cutoff = order.get("service_cutoff_time")
+    if cutoff is not None:
+        return int(cutoff)
+    return int(order["deadline"])
+
+
 def _baseline_candidate(
     agent: dict[str, Any],
     order: dict[str, Any],
@@ -175,12 +192,67 @@ def _score_candidate(
     )
 
 
-def build_action(assignments: list[tuple[str, str]]) -> ActionDict:
+def _score_rejection_candidate(
+    order: dict[str, Any],
+    idle_agents: list[dict[str, Any]],
+    congested_zones: set[Point],
+    current_time: int,
+) -> CandidateRejection:
+    reward_value = float(order["reward_value"])
+    cutoff = _service_cutoff(order)
+    estimated_costs = [
+        estimate_job_cost(
+            _as_point(agent["location"]),
+            _as_point(order["pickup_location"]),
+            _as_point(order["drop_location"]),
+            congested_zones,
+        )
+        for agent in idle_agents
+    ]
+    estimated_best_cost = min(estimated_costs) if estimated_costs else 999
+    best_finish = current_time + estimated_best_cost
+    slack_to_cutoff = cutoff - best_finish
+    reject_pressure = 0.0
+
+    if not idle_agents:
+        reject_pressure += 4.0
+    if slack_to_cutoff < 0:
+        reject_pressure += 9.0 + (2.2 * abs(slack_to_cutoff))
+    elif slack_to_cutoff <= 1:
+        reject_pressure += 4.5
+
+    if reward_value <= 8:
+        reject_pressure += 2.4
+    elif reward_value <= 10:
+        reject_pressure += 1.6
+    elif reward_value >= 16:
+        reject_pressure -= 2.2
+
+    reward_density = reward_value / max(estimated_best_cost, 1)
+    if reward_density < 1.0:
+        reject_pressure += 3.6
+    elif reward_density < 1.35:
+        reject_pressure += 2.4
+    elif reward_density > 2.5:
+        reject_pressure -= 1.0
+
+    return CandidateRejection(
+        order_id=str(order["order_id"]),
+        score=reject_pressure,
+        estimated_best_cost=estimated_best_cost,
+        slack_to_cutoff=slack_to_cutoff,
+        reward_value=reward_value,
+        has_idle_agents=bool(idle_agents),
+    )
+
+
+def build_action(assignments: list[tuple[str, str]], rejections: list[str] | None = None) -> ActionDict:
     return {
         "assignments": [
             {"agent_id": agent_id, "order_id": order_id}
             for agent_id, order_id in assignments
-        ]
+        ],
+        "rejections": list(rejections or []),
     }
 
 
@@ -243,12 +315,41 @@ def target_policy(state: dict[str, Any]) -> ActionDict:
         chosen_orders.add(candidate.order_id)
         assignments.append((candidate.agent_id, candidate.order_id))
 
-    return build_action(assignments)
+    remaining_orders = [
+        order
+        for order in available_orders
+        if str(order["order_id"]) not in chosen_orders
+    ]
+    rejection_candidates = [
+        _score_rejection_candidate(order, idle_agents, congested_zones, current_time)
+        for order in remaining_orders
+    ]
+    rejection_candidates.sort(
+        key=lambda item: (
+            -item.score,
+            item.slack_to_cutoff,
+            item.estimated_best_cost,
+            item.order_id,
+        )
+    )
+
+    rejections: list[str] = []
+    for candidate in rejection_candidates:
+        if candidate.score < 6.5:
+            continue
+        if candidate.reward_value >= 16 and candidate.slack_to_cutoff >= -2:
+            continue
+        if candidate.reward_value >= 12 and candidate.slack_to_cutoff >= 0 and candidate.estimated_best_cost <= 8:
+            continue
+        rejections.append(candidate.order_id)
+
+    return build_action(assignments, rejections)
 
 
 __all__ = [
     "ActionDict",
     "CandidateAssignment",
+    "CandidateRejection",
     "baseline_policy",
     "build_action",
     "estimate_job_cost",

src/delivery_dispatch/scenarios.py

@@ -61,11 +61,12 @@ def build_high_demand_scenario() -> Scenario:
             OrderState(order_id="o14", created_at=28, pickup_location=(7, 7), drop_location=(9, 7), reward_value=12, deadline=37),
             OrderState(order_id="o15", created_at=34, pickup_location=(4, 1), drop_location=(5, 3), reward_value=8, deadline=42),
             OrderState(order_id="o16", created_at=36, pickup_location=(8, 7), drop_location=(9, 5), reward_value=14, deadline=43),
+            OrderState(order_id="o17", created_at=19, pickup_location=(1, 1), drop_location=(9, 9), reward_value=5, deadline=25),
         ),
         episode_horizon=60,
-        briefing="Demand arrives faster than the fleet can comfortably absorb, including short hotspot bursts that tempt overcommitment.",
-        dispatch_objective="Balance urgency, value density, and capacity; skipping the wrong job should hurt later throughput.",
-        known_future_signal="Expect bursty arrivals around the upper-right hotspot near t=17-22 and again late in the episode.",
+        briefing="Demand arrives faster than the fleet can comfortably absorb, including short hotspot bursts, premium clusters, and occasional low-value long-haul distractions.",
+        dispatch_objective="Balance urgency, value density, and capacity; skipping the wrong job should hurt later throughput, but some requests are not worth tying up the fleet for.",
+        known_future_signal="Expect bursty arrivals around the upper-right hotspot near t=17-22 and again late in the episode, with one low-yield cross-city distraction in the middle.",
     )
 
 
@@ -109,11 +110,12 @@ def build_hotspot_congestion_scenario() -> Scenario:
             OrderState(order_id="o16", created_at=47, pickup_location=(12, 11), drop_location=(14, 14), reward_value=21, deadline=56),
             OrderState(order_id="o17", created_at=56, pickup_location=(13, 11), drop_location=(14, 13), reward_value=21, deadline=66),
             OrderState(order_id="o18", created_at=63, pickup_location=(10, 3), drop_location=(6, 1), reward_value=10, deadline=74),
+            OrderState(order_id="o19", created_at=32, pickup_location=(1, 2), drop_location=(14, 14), reward_value=6, deadline=40),
         ),
         episode_horizon=80,
-        briefing="Large city with hotspot bursts, tight premium orders, and fixed congestion pockets. Positioning and selective commitments matter.",
-        dispatch_objective="Trade off local urgent jobs against future hotspot bursts while avoiding long congested detours that block the fleet.",
-        known_future_signal="Expect premium hotspot spikes near t=18-20 and t=47, plus occasional cross-city long-haul requests later.",
+        briefing="Large city with hotspot bursts, tight premium orders, fixed congestion pockets, and a few low-yield long-haul traps. Positioning and selective commitments matter.",
+        dispatch_objective="Trade off local urgent jobs against future hotspot bursts while avoiding long congested detours and low-value commitments that block the fleet.",
+        known_future_signal="Expect premium hotspot spikes near t=18-20 and t=47, plus an unattractive cross-city request around t=32 and other long-haul work later.",
     )