task 4

baseline.py

@@ -12,7 +12,7 @@ Usage
 
 Optional env vars
 -----------------
-  TASK          = easy_headline | medium_pacing | hard_assembly | all  (default: all)
+  TASK          = easy_headline | medium_pacing | hard_assembly | hard_sequencing | all  (default: all)
   USE_LLM_SIMULATOR = 1   to enable Llama-3 User Simulator (requires GPU + model)
 """
 
@@ -29,7 +29,7 @@ from models import Action
 
 client = OpenAI(
     base_url="https://openrouter.ai/api/v1",
-    api_key="KEY",
+    api_key="key",
 )
 
 # ---------------------------------------------------------------------------
@@ -110,10 +110,25 @@ Also choose headline_id and creative_id that reinforce the caption theme.
 Bid competitively ($0.60–$1.50) since revenue matters too.
 """.strip()
 
+SYSTEM_HARD_SEQ = """
+You are focused on CROSS-CONTEXT CAMPAIGN SEQUENCING.
+
+Rules:
+- Plan ad placements across 24 hours to maximise conversions.
+- Winning an auction boosts CTR for the next 3 hours (carry-over effect):
+    +15% at t+1, +10% at t+2, +5% at t+3.
+- Cover at least 3 of 4 contexts (Fitness, Tech, Fashion, Gaming) for a 20% bonus.
+- Skip expensive hours; bid aggressively in cheap hours to trigger carry-over.
+- Use carryover_boost from observation to time high-value bids.
+- Keep ≥15% budget for hours 18–22 (peak engagement).
+- Your score is compared against a DP oracle that finds the hindsight-optimal plan.
+""".strip()
+
 SYSTEM_PROMPTS = {
-    "easy_headline":  SYSTEM_EASY,
-    "medium_pacing":  SYSTEM_MEDIUM,
-    "hard_assembly":  SYSTEM_HARD,
+    "easy_headline":   SYSTEM_EASY,
+    "medium_pacing":   SYSTEM_MEDIUM,
+    "hard_assembly":   SYSTEM_HARD,
+    "hard_sequencing": SYSTEM_HARD_SEQ,
 }
 
 
@@ -128,9 +143,11 @@ def build_user_prompt(task_id: str, obs, catalog: str) -> str:
         f"Viral Trend: '{obs.viral_trend}'\n"
         f"Budget remaining: ${obs.remaining_budget} | "
         f"Market pressure: {obs.market_pressure:.2f} | "
-        f"Fatigue level: {obs.fatigue_level:.2f}\n\n"
-        f"{catalog}\n\n"
+        f"Fatigue level: {obs.fatigue_level:.2f}"
     )
+    if task_id == "hard_sequencing":
+        base += f" | Carryover boost: {obs.carryover_boost:.2f}"
+    base += f"\n\n{catalog}\n\n"
 
     schema = (
         'Respond ONLY with a JSON object:\n'
@@ -209,6 +226,10 @@ def run_task(task_id: str) -> float:
     elif task_id == "hard_assembly":
         print(f"  CLIP Similarity Score    : {final_info.clip_similarity_score:.4f}")
         print(f"  Revenue Factor           : ${final_info.total_revenue:.2f}")
+    elif task_id == "hard_sequencing":
+        print(f"  Sequencing Score         : {final_info.sequencing_score:.4f}")
+        print(f"  Contexts Covered         : {final_info.contexts_covered}/4")
+        print(f"  Diversity Multiplier     : {final_info.diversity_multiplier:.2f}")
     print(f"{'─'*52}\n")
 
     return final_info.task_score
@@ -222,11 +243,11 @@ if __name__ == "__main__":
     task_arg = os.environ.get("TASK", "all").lower()
 
     if task_arg == "all":
-        tasks = ["easy_headline", "medium_pacing", "hard_assembly"]
-    elif task_arg in ("easy_headline", "medium_pacing", "hard_assembly"):
+        tasks = ["easy_headline", "medium_pacing", "hard_assembly", "hard_sequencing"]
+    elif task_arg in ("easy_headline", "medium_pacing", "hard_assembly", "hard_sequencing"):
         tasks = [task_arg]
     else:
-        print(f"Unknown TASK='{task_arg}'. Choose: easy_headline | medium_pacing | hard_assembly | all")
+        print(f"Unknown TASK='{task_arg}'. Choose: easy_headline | medium_pacing | hard_assembly | hard_sequencing | all")
         sys.exit(1)
 
     scores = {}
@@ -243,4 +264,3 @@ if __name__ == "__main__":
         print(f"╠{'═'*50}╣")
         print(f"║  {'AVERAGE':<20} {'█'*int(avg*20) + '░'*(20-int(avg*20))}  {avg:.4f} ║")
     print("╚══════════════════════════════════════════════════╝")
-

environment.py

@@ -78,7 +78,7 @@ DATA_DIR = pathlib.Path(__file__).parent.resolve() / "Datasets"
 IPINYOU_PATH = DATA_DIR
 
 # MIND (Microsoft News Dataset) — replaces Criteo + Pitt
-MIND_PATH        = DATA_DIR / "MINDlarge_train" / "MINDlarge_train"
+MIND_PATH        = DATA_DIR / "MINDlarge_train"
 MIND_BEHAVIOURS  = MIND_PATH / "behaviors.tsv"   # impression click log
 MIND_NEWS        = MIND_PATH / "news.tsv"          # news article metadata
 
@@ -913,6 +913,129 @@ class HardAssemblyGrader:
         self._scores.clear()
 
 
+# ---------------------------------------------------------------------------
+
+class HardSequencingGrader:
+    """
+    Level 4: Cross-Context Campaign Sequencing
+
+    Tracks per-step data (clearing prices, CTRs, contexts, costs) and at
+    episode end runs a DP oracle to find the optimal bid/skip sequence.
+
+    Score = min(1.0, (agent_conversions / oracle_conversions) x diversity_mult)
+    """
+
+    CARRYOVER_BOOSTS = [0.15, 0.10, 0.05]   # t+1, t+2, t+3
+    DIVERSITY_THRESHOLD = 3
+    DIVERSITY_BONUS = 1.20
+
+    def __init__(self) -> None:
+        self._step_log: List[dict] = []
+        self._contexts_won: set = set()
+
+    def record_step(self, step: int, context: str, clearing_price: float,
+                    base_ctr: float, auction_won: bool, cost: float,
+                    conversion_value: float) -> None:
+        self._step_log.append({
+            "step": step, "context": context,
+            "clearing_price": clearing_price,
+            "base_ctr": base_ctr,
+            "auction_won": auction_won,
+            "cost": cost,
+            "conversion_value": conversion_value,
+        })
+        if auction_won:
+            self._contexts_won.add(context)
+
+    # ------------------------------------------------------------------
+    def _diversity_multiplier(self) -> float:
+        return (self.DIVERSITY_BONUS
+                if len(self._contexts_won) >= self.DIVERSITY_THRESHOLD
+                else 1.0)
+
+    # ------------------------------------------------------------------
+    def _agent_conversions(self) -> float:
+        """Total weighted conversions the agent actually achieved."""
+        total = 0.0
+        for idx, s in enumerate(self._step_log):
+            if not s["auction_won"]:
+                continue
+            boost = 0.0
+            for j, bv in enumerate(self.CARRYOVER_BOOSTS):
+                prev = idx - 1 - j
+                if prev >= 0 and self._step_log[prev]["auction_won"]:
+                    boost += bv
+            eff_ctr = s["base_ctr"] * (1.0 + boost)
+            total += eff_ctr * s["conversion_value"]
+        return total
+
+    # ------------------------------------------------------------------
+    def _oracle_conversions(self, budget: float) -> float:
+        """
+        DP over N steps.
+        State = (step_index, budget_units, carry_state).
+        carry_state is a 3-bit int encoding wins at t-1, t-2, t-3.
+        """
+        steps = self._step_log
+        n = len(steps)
+        if n == 0:
+            return 0.0
+
+        RES = 0.10
+        budget_units = int(budget / RES) + 1
+
+        # cur maps (budget_units, carry_state_3bit) -> best cumulative value
+        cur: Dict[tuple, float] = {(budget_units, 0): 0.0}
+
+        for i in range(n):
+            s = steps[i]
+            cp = s["clearing_price"]
+            base = s["base_ctr"]
+            cv = s["conversion_value"]
+            cost_u = max(1, int(round(cp / RES)))
+
+            nxt: Dict[tuple, float] = {}
+
+            for (bu, cs), val in cur.items():
+                w1 = (cs >> 2) & 1
+                w2 = (cs >> 1) & 1
+                w3 = cs & 1
+                boost = 0.15 * w1 + 0.10 * w2 + 0.05 * w3
+
+                # Option A: skip
+                ns_skip = ((w1 << 1) | w2) & 0b111
+                key_s = (bu, ns_skip)
+                if key_s not in nxt or val > nxt[key_s]:
+                    nxt[key_s] = val
+
+                # Option B: bid (if affordable)
+                if bu >= cost_u:
+                    eff = base * (1.0 + boost)
+                    nv = val + eff * cv
+                    nb = bu - cost_u
+                    ns_bid = ((1 << 2) | (w1 << 1) | w2) & 0b111
+                    key_b = (nb, ns_bid)
+                    if key_b not in nxt or nv > nxt[key_b]:
+                        nxt[key_b] = nv
+
+            cur = nxt
+
+        return max(cur.values()) if cur else 0.0
+
+    # ------------------------------------------------------------------
+    def episode_score(self, initial_budget: float) -> float:
+        oracle = self._oracle_conversions(initial_budget)
+        if oracle <= 0:
+            return 0.0
+        agent = self._agent_conversions()
+        div = self._diversity_multiplier()
+        return min(1.0, round((agent / oracle) * div, 4))
+
+    def reset(self) -> None:
+        self._step_log.clear()
+        self._contexts_won.clear()
+
+
 # ===========================================================================
 # Main Environment
 # ===========================================================================
@@ -939,9 +1062,10 @@ class OpenEnvAuctioneer:
 
     # Per-task initial budgets
     _BUDGETS = {
-        "easy_headline":  100.0,
+        "easy_headline":   100.0,
         "medium_pacing":   50.0,
-        "hard_assembly":  100.0,
+        "hard_assembly":   100.0,
+        "hard_sequencing": 100.0,
     }
 
     def __init__(self, task_id: str = "easy_headline") -> None:
@@ -964,6 +1088,7 @@ class OpenEnvAuctioneer:
         self._easy_grader   = EasyHeadlineGrader(self._user_sim, self._pool)
         self._medium_grader = MediumPacingGrader()
         self._hard_grader   = HardAssemblyGrader(self._user_sim._smodel)
+        self._seq_grader    = HardSequencingGrader()
 
         # ── Episode state (populated by reset) ────────────────────────────
         self._step            = 0
@@ -976,6 +1101,8 @@ class OpenEnvAuctioneer:
         self._context         = ""
         self._trend           = ""
         self._prev_remaining  = 0.0
+        self._carryover_boost = 0.0
+        self._carryover_schedule: Dict[int, float] = {}
 
         self._contexts = ["Fitness", "Tech", "Fashion", "Gaming"]
         self._trends   = ["Quiet Luxury", "Eco-Friendly", "Cyberpunk", "Minimalism"]
@@ -994,6 +1121,9 @@ class OpenEnvAuctioneer:
         self._easy_grader.reset()
         self._medium_grader.reset()
         self._hard_grader.reset()
+        self._seq_grader.reset()
+        self._carryover_boost = 0.0
+        self._carryover_schedule = {}
 
         self._update_context()
         return self._make_obs()
@@ -1004,6 +1134,10 @@ class OpenEnvAuctioneer:
         if self._remaining <= 0:
             return self._make_obs(), Reward(value=0.0), True, self._make_info(0.0, 0.0, False, 0.0, 0.0, 0.0)
 
+        # ── Read carry-over boost for hard_sequencing ─────────────────
+        if self.task_id == "hard_sequencing":
+            self._carryover_boost = self._carryover_schedule.get(self._step, 0.0)
+
         clearing_price = self._market.sample_clearing_price(self._step)
         step_reward    = 0.0
         auction_won    = False
@@ -1022,9 +1156,22 @@ class OpenEnvAuctioneer:
 
             raw_ctr, adjusted_ctr = self._user_sim.compute_ctr(
                 action, self._context, self._trend, self._fatigue)
-            self._last_ctr = adjusted_ctr
 
-            revenue       = adjusted_ctr * self.CONVERSION_VALUE
+            # Apply carry-over boost for hard_sequencing
+            if self.task_id == "hard_sequencing":
+                effective_ctr = round(adjusted_ctr * (1.0 + self._carryover_boost), 4)
+                self._last_ctr = effective_ctr
+                revenue = effective_ctr * self.CONVERSION_VALUE
+                # Schedule carry-over boosts for future steps
+                for ci, bv in enumerate(HardSequencingGrader.CARRYOVER_BOOSTS):
+                    fs = self._step + 1 + ci
+                    if fs < 24:
+                        self._carryover_schedule[fs] = (
+                            self._carryover_schedule.get(fs, 0.0) + bv)
+            else:
+                self._last_ctr = adjusted_ctr
+                revenue = adjusted_ctr * self.CONVERSION_VALUE
+
             self._total_revenue += revenue
             step_reward   = revenue - clearing_price
             self._fatigue = min(1.0, self._fatigue + self.FATIGUE_STEP)
@@ -1056,6 +1203,13 @@ class OpenEnvAuctioneer:
         else:
             clip_score = 0.0
 
+        if self.task_id == "hard_sequencing":
+            self._seq_grader.record_step(
+                step=self._step, context=self._context,
+                clearing_price=clearing_price, base_ctr=adjusted_ctr,
+                auction_won=auction_won, cost=spent,
+                conversion_value=self.CONVERSION_VALUE)
+
         # ── Advance time ─────────────────────────────────────────────────
         self._prev_remaining  = self._remaining
         self._step           += 1
@@ -1093,6 +1247,7 @@ class OpenEnvAuctioneer:
                                         min(self._step, 23)),
             ads_shown_this_session= self._ads_shown,
             fatigue_level         = round(self._fatigue, 3),
+            carryover_boost       = round(min(self._carryover_boost, 0.30), 4),
             last_ctr              = self._last_ctr,
             cumulative_revenue    = round(self._total_revenue, 2),
         )
@@ -1113,7 +1268,7 @@ class OpenEnvAuctioneer:
             pacing_score       = task_score
             clip_sim_score     = 0.0
 
-        else:  # hard_assembly
+        elif self.task_id == "hard_assembly":
             clip_sim_score     = self._hard_grader.episode_score()
             revenue_factor     = float(np.clip(self._total_revenue / 45.0, 0.0, 1.0))
             # Blend: 60% viral alignment + 40% revenue
@@ -1121,6 +1276,23 @@ class OpenEnvAuctioneer:
             headline_score     = 0.0
             pacing_score       = 0.0
 
+        else:  # hard_sequencing
+            seq_sc             = self._seq_grader.episode_score(self._budget_init)
+            task_score         = seq_sc
+            headline_score     = 0.0
+            pacing_score       = 0.0
+            clip_sim_score     = 0.0
+
+        # Sequencing sub-scores (non-zero only for hard_sequencing)
+        if self.task_id == "hard_sequencing":
+            _seq_score = task_score
+            _ctx_cov   = len(self._seq_grader._contexts_won)
+            _div_mult  = self._seq_grader._diversity_multiplier()
+        else:
+            _seq_score = 0.0
+            _ctx_cov   = 0
+            _div_mult  = 1.0
+
         return Info(
             task_id                 = self.task_id,
             current_step            = self._step,
@@ -1133,4 +1305,7 @@ class OpenEnvAuctioneer:
             headline_alignment_score= headline_score,
             pacing_score            = pacing_score,
             clip_similarity_score   = clip_sim_score,
+            sequencing_score        = _seq_score,
+            contexts_covered        = _ctx_cov,
+            diversity_multiplier    = _div_mult,
         )

models.py

@@ -172,6 +172,8 @@ class Observation(BaseModel):
         description="Accumulated user-fatigue penalty (0 = fresh, 1 = fully fatigued).")
 
     # ── Performance Feedback (delayed by 1 step) ───────────────────────────
+    carryover_boost: float = Field(default=0.0, ge=0.0, le=0.30,
+        description="CTR boost from brand-recall carry-over (decaying from prior ad wins).")
     last_ctr: float = Field(default=0.0, ge=0.0, le=1.0,
         description="CTR returned by the User Simulator on the previous step.")
     cumulative_revenue: float = Field(default=0.0,
@@ -193,10 +195,9 @@ class Action(BaseModel):
     creative_id: int = Field(..., ge=0, le=5,
         description="Index into the Creatives Catalog (0–5).")
 
-    # Optional free-text caption (used in hard_assembly grading via CLIP/semantic sim)
+    # Optional free-text caption (retained for backwards compatibility). No effect in hard_sequencing.
     generated_caption: Optional[str] = Field(default=None,
-        description="Free-form caption generated by the agent for hard_assembly. "
-                    "Leave None for easy/medium tasks.")
+        description="Free-form caption generated by the agent in old hard_assembly mode.")
 
 
 # ---------------------------------------------------------------------------
@@ -226,4 +227,10 @@ class Info(BaseModel):
     pacing_score: float = Field(default=0.0, ge=0.0, le=1.0,
         description="[medium_pacing] Budget-smoothness and peak-hour survival bonus.")
     clip_similarity_score: float = Field(default=0.0, ge=0.0, le=1.0,
-        description="[hard_assembly] Cosine similarity between caption and viral token.")
+        description="[hard_assembly] Cosine similarity between caption and viral token.")
+    sequencing_score: float = Field(default=0.0, ge=0.0, le=1.0,
+        description="[hard_sequencing] Agent conversions / Oracle conversions × diversity bonus.")
+    contexts_covered: int = Field(default=0, ge=0, le=4,
+        description="[hard_sequencing] Number of distinct contexts that received ≥1 ad.")
+    diversity_multiplier: float = Field(default=1.0,
+        description="[hard_sequencing] 1.2 if ≥3 contexts covered, else 1.0.")

openenv.yaml

@@ -53,6 +53,24 @@ tasks:
       score_range: [0.0, 1.0]
       target_score: 0.65
 
+  - id: "hard_sequencing"
+    difficulty: "hard"
+    initial_budget_usd: 100.0
+    description: >
+      Plan a 24-hour sequence of ad placements across Fitness, Tech, Fashion,
+      and Gaming contexts. Winning an auction triggers carry-over brand-recall
+      boosts (+15%/+10%/+5% CTR) for the next 3 hours. Cover >=3 contexts for
+      a 20% diversity bonus. Graded against DP oracle.
+    grader:
+      type: "HardSequencingGrader"
+      formula: "min(1.0, (agent_conversions / oracle_conversions) x diversity_multiplier)"
+      components:
+        agent_conversions:      "sum(adjusted_ctr x conversion_value) for won auctions"
+        oracle_conversions:     "DP-optimal bid/skip sequence with carry-over"
+        diversity_multiplier:   "1.2 if >=3 distinct contexts served, else 1.0"
+      score_range: [0.0, 1.0]
+      target_score: 0.60
+
 # ─────────────────────────────────────────────────────────────────────────────
 # Datasets
 # ─────────────────────────────────────────────────────────────────────────────

test_sequencing.py

@@ -0,0 +1,168 @@
+"""
+test_sequencing.py — Unit tests for the HardSequencingGrader and DP oracle.
+
+Run: python test_sequencing.py
+"""
+
+import sys
+sys.path.insert(0, ".")
+
+from environment import HardSequencingGrader
+
+
+def test_dp_oracle_simple():
+    """Fixed scenario: 4 steps, known optimal is to bid on steps 0 and 2."""
+    g = HardSequencingGrader()
+
+    # Step 0: cheap (clears at $1), good CTR 0.10
+    g.record_step(step=0, context="Fitness", clearing_price=1.0,
+                  base_ctr=0.10, auction_won=True, cost=1.0,
+                  conversion_value=15.0)
+    # Step 1: expensive (clears at $8), low CTR 0.02
+    g.record_step(step=1, context="Tech", clearing_price=8.0,
+                  base_ctr=0.02, auction_won=False, cost=0.0,
+                  conversion_value=15.0)
+    # Step 2: cheap (clears at $1), good CTR 0.10
+    g.record_step(step=2, context="Fashion", clearing_price=1.0,
+                  base_ctr=0.10, auction_won=True, cost=1.0,
+                  conversion_value=15.0)
+    # Step 3: cheap (clears at $1), good CTR 0.08
+    g.record_step(step=3, context="Gaming", clearing_price=1.0,
+                  base_ctr=0.08, auction_won=True, cost=1.0,
+                  conversion_value=15.0)
+
+    oracle_val = g._oracle_conversions(budget=10.0)
+    assert oracle_val > 0, f"Oracle should find positive conversions, got {oracle_val}"
+    print(f"  DP oracle conversions: {oracle_val:.4f} ✓")
+
+    score = g.episode_score(initial_budget=10.0)
+    assert 0.0 <= score <= 1.0, f"Score out of range: {score}"
+    print(f"  Episode score: {score:.4f} ✓")
+
+
+def test_never_bid_score_zero():
+    """Agent never bids → score should be 0.0."""
+    g = HardSequencingGrader()
+    for i in range(24):
+        ctx = ["Fitness", "Tech", "Fashion", "Gaming"][i % 4]
+        g.record_step(step=i, context=ctx, clearing_price=1.0,
+                      base_ctr=0.05, auction_won=False, cost=0.0,
+                      conversion_value=15.0)
+
+    score = g.episode_score(initial_budget=100.0)
+    assert score == 0.0, f"Expected 0.0 for never-bid agent, got {score}"
+    print(f"  Never-bid score: {score} ✓")
+
+
+def test_diversity_multiplier():
+    """Check 1.2× when ≥3 contexts, 1.0 otherwise."""
+    g = HardSequencingGrader()
+
+    # Only 2 contexts
+    g.record_step(step=0, context="Fitness", clearing_price=1.0,
+                  base_ctr=0.10, auction_won=True, cost=1.0,
+                  conversion_value=15.0)
+    g.record_step(step=1, context="Tech", clearing_price=1.0,
+                  base_ctr=0.10, auction_won=True, cost=1.0,
+                  conversion_value=15.0)
+    assert g._diversity_multiplier() == 1.0, "Should be 1.0 with only 2 contexts"
+
+    # Add 3rd context
+    g.record_step(step=2, context="Fashion", clearing_price=1.0,
+                  base_ctr=0.10, auction_won=True, cost=1.0,
+                  conversion_value=15.0)
+    assert g._diversity_multiplier() == 1.20, "Should be 1.2 with 3 contexts"
+    print(f"  Diversity multiplier: correct ✓")
+
+
+def test_carryover_schedule():
+    """Verify carry-over boosts decay correctly: +15%/+10%/+5%."""
+    g = HardSequencingGrader()
+
+    # Win at step 0, skip rest
+    g.record_step(step=0, context="Fitness", clearing_price=1.0,
+                  base_ctr=0.10, auction_won=True, cost=1.0,
+                  conversion_value=15.0)
+    for i in range(1, 5):
+        g.record_step(step=i, context="Tech", clearing_price=1.0,
+                      base_ctr=0.10, auction_won=False, cost=0.0,
+                      conversion_value=15.0)
+
+    agent_conv = g._agent_conversions()
+    # Only step 0 won, no prior wins → no boost, base conversion = 0.10 * 15 = 1.5
+    expected = 0.10 * 15.0
+    assert abs(agent_conv - expected) < 0.001, \
+        f"Expected {expected}, got {agent_conv}"
+    print(f"  Carry-over schedule: correct ✓")
+
+    # Now test with consecutive wins
+    g.reset()
+    g.record_step(step=0, context="Fitness", clearing_price=1.0,
+                  base_ctr=0.10, auction_won=True, cost=1.0,
+                  conversion_value=15.0)
+    g.record_step(step=1, context="Tech", clearing_price=1.0,
+                  base_ctr=0.10, auction_won=True, cost=1.0,
+                  conversion_value=15.0)
+
+    agent_conv = g._agent_conversions()
+    # step 0: no boost → 0.10 * 15 = 1.5
+    # step 1: boost from step 0 win = +15% → 0.10 * 1.15 * 15 = 1.725
+    expected = 1.5 + 0.10 * 1.15 * 15.0
+    assert abs(agent_conv - expected) < 0.001, \
+        f"Expected {expected}, got {agent_conv}"
+    print(f"  Consecutive carry-over: correct ✓")
+
+
+def test_episode_score_bounded():
+    """Score should always be in [0.0, 1.0]."""
+    g = HardSequencingGrader()
+
+    # Agent bids on everything (cheap auctions)
+    for i in range(24):
+        ctx = ["Fitness", "Tech", "Fashion", "Gaming"][i % 4]
+        g.record_step(step=i, context=ctx, clearing_price=0.50,
+                      base_ctr=0.08, auction_won=True, cost=0.50,
+                      conversion_value=15.0)
+
+    score = g.episode_score(initial_budget=100.0)
+    assert 0.0 <= score <= 1.0, f"Score out of bounds: {score}"
+    print(f"  All-bid score: {score:.4f} (bounded) ✓")
+
+
+def test_empty_episode():
+    """Empty episode → score 0.0."""
+    g = HardSequencingGrader()
+    score = g.episode_score(initial_budget=100.0)
+    assert score == 0.0, f"Expected 0.0 for empty episode, got {score}"
+    print(f"  Empty episode: {score} ✓")
+
+
+if __name__ == "__main__":
+    tests = [
+        ("DP Oracle (simple scenario)", test_dp_oracle_simple),
+        ("Never-bid agent → 0.0", test_never_bid_score_zero),
+        ("Diversity multiplier", test_diversity_multiplier),
+        ("Carry-over schedule", test_carryover_schedule),
+        ("Score bounded [0, 1]", test_episode_score_bounded),
+        ("Empty episode", test_empty_episode),
+    ]
+
+    print("=" * 52)
+    print("  HardSequencingGrader Unit Tests")
+    print("=" * 52)
+
+    passed = 0
+    for name, fn in tests:
+        try:
+            print(f"\n▸ {name}")
+            fn()
+            passed += 1
+        except Exception as e:
+            print(f"  ✗ FAILED: {e}")
+
+    print(f"\n{'─'*52}")
+    print(f"  {passed}/{len(tests)} tests passed")
+    print(f"{'─'*52}")
+
+    if passed < len(tests):
+        sys.exit(1)