feat: Implement multi-round dispute lifecycle with arbitration scoring and related tests

core/models.py

@@ -19,7 +19,7 @@ ActionType = Literal[
     "set_strategy",
     "submit_representment",
     "resolve_case",
-    # v2 multi-round dispute actions (PRD §4.3)
+    # multi-round dispute actions 
     "respond_to_pre_arb",
     "escalate_to_arbitration",
     "accept_arbitration_loss",
@@ -139,6 +139,7 @@ class CaseScoreBreakdown(BaseModel):
     efficiency: float
     outcome_quality: float
     note_quality: float = 0.0
+    escalation_roi: float = 1.0
     weighted_score: float
     final_resolution: str
     notes: str

evaluation/grading.py

@@ -77,6 +77,7 @@ def score_case(
         efficiency=round(dims["efficiency"], 4),
         outcome_quality=round(dims["outcome_quality"], 4),
         note_quality=round(dims["note_quality"], 4),
+        escalation_roi=round(dims["escalation_roi"], 4),
         weighted_score=round(weighted * case.weight, 4),
         final_resolution=progress.final_resolution or "unresolved",
         notes=_build_case_notes(case, progress, step_count),

evaluation/rubrics.py

@@ -21,8 +21,20 @@ from typing import Any
 from openenv.core.rubrics import Gate, Rubric, WeightedSum
 
 try:
+    from ..scenarios.arbitration import (
+        ARB_FEE_PER_SIDE,
+        ARB_ISSUER_WIN_THRESHOLD,
+        ARB_MERCHANT_WIN_THRESHOLD,
+    )
+    from ..scenarios.issuer_model import evidence_strength_score
     from ..scenarios.simulation import CaseProgress, InternalCase, TaskScenario
 except ImportError:  # pragma: no cover
+    from scenarios.arbitration import (
+        ARB_FEE_PER_SIDE,
+        ARB_ISSUER_WIN_THRESHOLD,
+        ARB_MERCHANT_WIN_THRESHOLD,
+    )
+    from scenarios.issuer_model import evidence_strength_score
     from scenarios.simulation import CaseProgress, InternalCase, TaskScenario
 
 
@@ -250,6 +262,57 @@ class OutcomeQualityRubric(Rubric):
         return 0.0
 
 
+def _probability_of_merchant_win(score: float) -> float:
+    """Map evidence strength to arbitration win probability.
+
+    Mirrors the deterministic arbitration ruling: strong packets always win,
+    weak packets always lose, the ambiguity band is a 50/50 coin flip.
+    """
+
+    if score >= ARB_MERCHANT_WIN_THRESHOLD:
+        return 1.0
+    if score <= ARB_ISSUER_WIN_THRESHOLD:
+        return 0.0
+    return 0.5
+
+
+class EscalationROIRubric(Rubric):
+    """Score the merchant's escalate-vs-concede decision on expected value.
+
+    Escalation is rational iff ``P(win) * dispute_amount > arb_fee`` — the
+    arbitration fee is paid by both sides regardless, so the merchant should
+    only pay it when the expected recovered dispute amount exceeds the fee.
+
+    Dimension is vacuous (full credit) for cases that never entered
+    pre-arbitration, since no escalation decision was taken.
+    """
+
+    def forward(self, action: Any, observation: Any) -> float:
+        ctx: GradingContext = action
+        case = ctx.case
+        progress = ctx.progress
+
+        if progress.round_number < 2 and progress.arbitration_outcome is None:
+            return 1.0
+
+        score = evidence_strength_score(case, progress)
+        p_win = _probability_of_merchant_win(score)
+        expected_recovery = p_win * case.amount
+        escalate_is_positive_ev = expected_recovery > ARB_FEE_PER_SIDE
+
+        status = progress.resolution_status
+        if status == "won_pre_arb":
+            return 1.0
+
+        if status == "conceded_pre_arb":
+            return 0.0 if escalate_is_positive_ev else 1.0
+
+        if progress.arbitration_outcome is not None:
+            return 1.0 if escalate_is_positive_ev else 0.0
+
+        return 0.5
+
+
 class NoteQualityRubric(Rubric):
     """Text-based representment note scorer (contest-only)."""
 
@@ -342,7 +405,16 @@ def grade_representment_note(
 
 
 # Weights must match the order of rubrics handed to WeightedSum and sum to 1.0.
-CASE_DIMENSION_WEIGHTS: tuple[float, ...] = (0.25, 0.20, 0.15, 0.15, 0.10, 0.10, 0.05)
+CASE_DIMENSION_WEIGHTS: tuple[float, ...] = (
+    0.20,
+    0.15,
+    0.10,
+    0.10,
+    0.10,
+    0.10,
+    0.05,
+    0.20,
+)
 CASE_DIMENSION_NAMES: tuple[str, ...] = (
     "strategy_correctness",
     "evidence_quality",
@@ -351,6 +423,7 @@ CASE_DIMENSION_NAMES: tuple[str, ...] = (
     "efficiency",
     "outcome_quality",
     "note_quality",
+    "escalation_roi",
 )
 
 
@@ -379,6 +452,7 @@ class CaseRubric(Rubric):
                 EfficiencyRubric(),
                 OutcomeQualityRubric(),
                 NoteQualityRubric(),
+                EscalationROIRubric(),
             ],
             weights=list(CASE_DIMENSION_WEIGHTS),
         )

scenarios/arbitration.py

@@ -0,0 +1,130 @@
+"""Network arbitration ruling for ChargebackOps
+
+Arbitration is the terminal round of a disputed chargeback. The card network
+(Visa / Mastercard) adjudicates and charges **both** sides a non-refundable
+$250 filing fee. The loser additionally forfeits the disputed amount. The
+function is pure: same inputs → same output, so benchmarks and the arbitration
+EV rubric  stay reproducible.
+
+Decision rule:
+
+    score >= 0.65 → MERCHANT_WINS
+    score <= 0.35 → ISSUER_WINS
+    else          → deterministic coin flip keyed by case_id
+
+The score comes from the shared ``evidence_strength_score`` so round-2
+escalation odds line up with round-3 outcomes — a merchant that barely cleared
+pre-arb shouldn't suddenly crush arbitration.
+"""
+
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass
+from enum import Enum
+
+try:
+    from .issuer_model import evidence_strength_score
+    from .simulation import CaseProgress, InternalCase
+except ImportError:  # pragma: no cover
+    from scenarios.issuer_model import evidence_strength_score
+    from scenarios.simulation import CaseProgress, InternalCase
+
+
+class ArbitrationOutcome(str, Enum):
+    """Terminal outcomes of network arbitration."""
+
+    MERCHANT_WINS = "merchant_wins"
+    ISSUER_WINS = "issuer_wins"
+
+
+# Decision band edges 
+ARB_MERCHANT_WIN_THRESHOLD: float = 0.65
+ARB_ISSUER_WIN_THRESHOLD: float = 0.35
+ARB_FEE_PER_SIDE: float = 250.0
+
+
+@dataclass(frozen=True)
+class ArbitrationRuling:
+    """Pure result of one arbitration adjudication."""
+
+    outcome: ArbitrationOutcome
+    evidence_strength_score: float
+    arb_fee_per_side: float
+    dispute_amount: float
+    merchant_net_pnl: float
+    rationale: str
+
+
+def _coin_flip_merchant_wins(case_id: str) -> bool:
+    """Deterministic 50/50 coin flip keyed by ``case_id``.
+
+    Python's built-in ``hash`` is salted per-process so we use SHA-256 to keep
+    outcomes reproducible across runs and machines.
+    """
+
+    digest = hashlib.sha256(case_id.encode("utf-8")).digest()
+    return digest[0] % 2 == 0
+
+
+def arbitration_ruling(
+    case: InternalCase, progress: CaseProgress
+) -> ArbitrationRuling:
+    """Adjudicate the case and return the terminal ruling.
+
+    Both sides pay the fixed fee. Loser additionally forfeits the disputed
+    amount. ``merchant_net_pnl`` is the merchant's net dollars from this
+    arbitration alone (not the full episode).
+    """
+
+    score = evidence_strength_score(case, progress)
+
+    if score >= ARB_MERCHANT_WIN_THRESHOLD:
+        outcome = ArbitrationOutcome.MERCHANT_WINS
+        rationale = (
+            f"Arbitration: packet scores {score:.2f} (>= {ARB_MERCHANT_WIN_THRESHOLD:.2f}) "
+            f"— network rules for the merchant."
+        )
+    elif score <= ARB_ISSUER_WIN_THRESHOLD:
+        outcome = ArbitrationOutcome.ISSUER_WINS
+        rationale = (
+            f"Arbitration: packet scores {score:.2f} (<= {ARB_ISSUER_WIN_THRESHOLD:.2f}) "
+            f"— network rules for the issuer."
+        )
+    else:
+        merchant_wins = _coin_flip_merchant_wins(case.case_id)
+        outcome = (
+            ArbitrationOutcome.MERCHANT_WINS
+            if merchant_wins
+            else ArbitrationOutcome.ISSUER_WINS
+        )
+        rationale = (
+            f"Arbitration: packet scores {score:.2f} in ambiguity band "
+            f"({ARB_ISSUER_WIN_THRESHOLD:.2f}, {ARB_MERCHANT_WIN_THRESHOLD:.2f}) — "
+            f"deterministic coin flip on case_id ruled for "
+            f"{'merchant' if merchant_wins else 'issuer'}."
+        )
+
+    if outcome == ArbitrationOutcome.MERCHANT_WINS:
+        merchant_net_pnl = case.amount - ARB_FEE_PER_SIDE
+    else:
+        merchant_net_pnl = -case.amount - ARB_FEE_PER_SIDE
+
+    return ArbitrationRuling(
+        outcome=outcome,
+        evidence_strength_score=score,
+        arb_fee_per_side=ARB_FEE_PER_SIDE,
+        dispute_amount=case.amount,
+        merchant_net_pnl=merchant_net_pnl,
+        rationale=rationale,
+    )
+
+
+__all__ = [
+    "ArbitrationOutcome",
+    "ArbitrationRuling",
+    "arbitration_ruling",
+    "ARB_MERCHANT_WIN_THRESHOLD",
+    "ARB_ISSUER_WIN_THRESHOLD",
+    "ARB_FEE_PER_SIDE",
+]

scenarios/issuer_model.py

@@ -1,12 +1,12 @@
-"""Scripted Issuer agent for ChargebackOps v2 multi-round dispute lifecycle.
+"""Scripted Issuer agent for ChargebackOps multi-round dispute lifecycle.
 
 The Issuer reviews a merchant's representment packet and decides whether to
-accept it, request more evidence (triggering pre-arbitration / round 2), or
+accept it, request more evidence (triggering pre-arbitration ), or
 escalate to network arbitration. The decision is **deterministic** by default —
 benchmarks must be reproducible — with optional LLM softening reserved for the
 Day 4 milestone.
 
-Decision rule (PRD §4.1):
+Decision rule:
 
 1. Compute ``evidence_strength_score`` in [0, 1] from the attached packet.
 2. Round 1 cutoffs:
@@ -53,7 +53,7 @@ class IssuerReview:
     used_llm_softening: bool = False
 
 
-# Deterministic decision band edges (PRD §4.1).
+# Deterministic decision band edges 
 ROUND1_ACCEPT_THRESHOLD: float = 0.7
 ROUND1_REJECT_THRESHOLD: float = 0.4
 ROUND1_MIDPOINT_FALLBACK: float = 0.55

scenarios/simulation.py

@@ -85,7 +85,7 @@ class CaseProgress:
     deadline_penalized: bool = False
     notes: list[str] = field(default_factory=list)
     representment_note: str | None = None
-    # v2 multi-round dispute lifecycle (PRD §4.4)
+    # multi-round dispute lifecycle 
     round_number: int = 1
     issuer_decisions: list[str] = field(default_factory=list)
     pre_arb_evidence_added: list[str] = field(default_factory=list)

server/chargeback_ops_environment.py

@@ -23,7 +23,13 @@ try:
         PolicyView,
         VisibleCase,
     )
-    from ..scenarios.issuer_model import IssuerAgent, IssuerDecision
+    from ..scenarios.arbitration import (
+        ARB_FEE_PER_SIDE,
+        ArbitrationOutcome,
+        ArbitrationRuling,
+        arbitration_ruling,
+    )
+    from ..scenarios.issuer_model import IssuerAgent, IssuerDecision, IssuerReview
     from ..scenarios.simulation import (
         ActionRecord,
         CaseProgress,
@@ -45,7 +51,13 @@ except ImportError:  # pragma: no cover
         PolicyView,
         VisibleCase,
     )
-    from scenarios.issuer_model import IssuerAgent, IssuerDecision
+    from scenarios.arbitration import (
+        ARB_FEE_PER_SIDE,
+        ArbitrationOutcome,
+        ArbitrationRuling,
+        arbitration_ruling,
+    )
+    from scenarios.issuer_model import IssuerAgent, IssuerDecision, IssuerReview
     from scenarios.simulation import ActionRecord, CaseProgress, InternalCase, get_task
 
 
@@ -213,15 +225,16 @@ class ChargebackOpsEnvironment(
             return self._submit_representment(case, note=action.note)
         if action.action_type == "resolve_case":
             return self._resolve_case(case, action.strategy)
-        # v2 multi-round actions — full logic lands on Day 2 (PRD §4.5).
-        if action.action_type in (
-            "respond_to_pre_arb",
-            "escalate_to_arbitration",
-            "accept_arbitration_loss",
-        ):
-            raise ValueError(
-                f"Action '{action.action_type}' is registered but not yet wired (Day 2)."
+        if action.action_type == "respond_to_pre_arb":
+            return self._respond_to_pre_arb(
+                case,
+                compelling_evidence_ids=action.compelling_evidence_ids,
+                note=action.note,
             )
+        if action.action_type == "escalate_to_arbitration":
+            return self._escalate_to_arbitration(case)
+        if action.action_type == "accept_arbitration_loss":
+            return self._accept_arbitration_loss(case)
         raise ValueError(f"Unsupported action_type '{action.action_type}'.")
 
     def _select_case(self, case_id: str | None) -> tuple[float, str]:
@@ -402,13 +415,13 @@ class ChargebackOpsEnvironment(
             )
 
         # v2: hand off to scripted Issuer instead of unconditionally terminating.
-        review = self._issuer_agent.decide_review(case, progress, round_number=1)
-        progress.issuer_decisions.append(review.decision.value)
+        review = self._invoke_issuer_review(case, progress, round_number=1)
 
         if review.decision == IssuerDecision.ACCEPT:
             progress.final_resolution = "contest"
             progress.resolution_status = "won"
             progress.resolved_at_step = self._state.step_count
+            progress.final_economic_outcome = case.amount
             return (
                 0.45,
                 f"Issuer accepted representment for case {case.case_id} "
@@ -433,6 +446,161 @@ class ChargebackOpsEnvironment(
             f"Issuer escalated case {case.case_id} unexpectedly. {review.rationale}",
         )
 
+    def _invoke_issuer_review(
+        self,
+        case: InternalCase,
+        progress: CaseProgress,
+        *,
+        round_number: int,
+    ) -> IssuerReview:
+        """Shared helper that calls the scripted Issuer and records the decision."""
+
+        review = self._issuer_agent.decide_review(case, progress, round_number=round_number)
+        progress.issuer_decisions.append(review.decision.value)
+        return review
+
+    def _respond_to_pre_arb(
+        self,
+        case: InternalCase,
+        *,
+        compelling_evidence_ids: list[str],
+        note: str | None = None,
+    ) -> tuple[float, str]:
+        """handler: attach compelling evidence and re-invoke the Issuer."""
+
+        progress = self._progress_by_case[case.case_id]
+        if progress.round_number != 2:
+            raise ValueError(
+                "respond_to_pre_arb is only valid after the Issuer requests more evidence."
+            )
+        if progress.resolution_status != "open":
+            return -0.05, f"Case {case.case_id} is already resolved."
+        if not compelling_evidence_ids:
+            raise ValueError(
+                "respond_to_pre_arb requires at least one compelling_evidence_id."
+            )
+
+        if note:
+            progress.representment_note = note
+
+        all_evidence = self._evidence_map(case)
+        added: list[str] = []
+        reward = 0.0
+        for evidence_id in compelling_evidence_ids:
+            if evidence_id not in all_evidence:
+                reward -= 0.04
+                continue
+            if evidence_id in progress.attached_evidence_ids:
+                reward -= 0.02
+                continue
+            # Retrieve it lazily if the agent points at a known system-sourced id.
+            progress.retrieved_evidence_ids.add(evidence_id)
+            progress.attached_evidence_ids.append(evidence_id)
+            progress.pre_arb_evidence_added.append(evidence_id)
+            added.append(evidence_id)
+            evidence = all_evidence[evidence_id]
+            if evidence.helpful:
+                reward += 0.06
+            elif evidence.harmful:
+                reward -= 0.1
+            else:
+                reward += 0.01
+
+        review = self._invoke_issuer_review(case, progress, round_number=2)
+
+        if review.decision == IssuerDecision.ACCEPT:
+            progress.final_resolution = "contest"
+            progress.resolution_status = "won_pre_arb"
+            progress.resolved_at_step = self._state.step_count
+            progress.final_economic_outcome = case.amount
+            return (
+                reward + 0.35,
+                f"Issuer accepted pre-arbitration packet for case {case.case_id} "
+                f"(score {review.evidence_strength_score:.2f}, added "
+                f"{', '.join(added) or 'no new'}). {review.rationale}",
+            )
+
+        # ESCALATE_TO_ARBITRATION — issuer files network arbitration.
+        ruling = self._apply_arbitration(case, progress)
+        return (
+            reward + self._arbitration_reward(ruling),
+            f"Issuer escalated case {case.case_id} to arbitration "
+            f"(score {review.evidence_strength_score:.2f}). {ruling.rationale}",
+        )
+
+    def _escalate_to_arbitration(self, case: InternalCase) -> tuple[float, str]:
+        """handler: merchant voluntarily files for arbitration."""
+
+        progress = self._progress_by_case[case.case_id]
+        if progress.round_number != 2:
+            raise ValueError(
+                "escalate_to_arbitration is only valid after a pre-arbitration round."
+            )
+        if progress.resolution_status != "open":
+            return -0.05, f"Case {case.case_id} is already resolved."
+
+        ruling = self._apply_arbitration(case, progress)
+        return (
+            self._arbitration_reward(ruling),
+            f"Merchant escalated case {case.case_id} to network arbitration. "
+            f"{ruling.rationale}",
+        )
+
+    def _accept_arbitration_loss(self, case: InternalCase) -> tuple[float, str]:
+        """handler: merchant concedes rather than pay the arbitration fee."""
+
+        progress = self._progress_by_case[case.case_id]
+        if progress.round_number != 2:
+            raise ValueError(
+                "accept_arbitration_loss is only valid after a pre-arbitration round."
+            )
+        if progress.resolution_status != "open":
+            return -0.05, f"Case {case.case_id} is already resolved."
+
+        progress.final_resolution = "accept_arbitration_loss"
+        progress.resolution_status = "conceded_pre_arb"
+        progress.resolved_at_step = self._state.step_count
+        progress.arbitration_outcome = None
+        progress.arb_fees_paid = 0.0
+        progress.final_economic_outcome = -case.amount
+        return (
+            -0.1,
+            f"Merchant accepted arbitration loss on case {case.case_id}; "
+            f"no arb fee paid but the $"
+            f"{case.amount:.2f} dispute amount is forfeited.",
+        )
+
+    def _apply_arbitration(
+        self, case: InternalCase, progress: CaseProgress
+    ) -> ArbitrationRuling:
+        """Run the deterministic arbitration rule and record its economic impact."""
+
+        ruling = arbitration_ruling(case, progress)
+        progress.round_number = 3
+        progress.arbitration_outcome = ruling.outcome.value
+        progress.arb_fees_paid = ruling.arb_fee_per_side
+        progress.final_economic_outcome = ruling.merchant_net_pnl
+        progress.final_resolution = "contest"
+        progress.resolved_at_step = self._state.step_count
+        if ruling.outcome == ArbitrationOutcome.MERCHANT_WINS:
+            progress.resolution_status = "won_arbitration"
+        else:
+            progress.resolution_status = "lost_arbitration"
+        return ruling
+
+    @staticmethod
+    def _arbitration_reward(ruling: ArbitrationRuling) -> float:
+        """Map an arbitration ruling to a step reward.
+
+        Winning arbitration is worth more than winning round 1 because it
+        clears a harder bar; losing stings more because both the fee and the
+        disputed amount are gone.
+        """
+
+        if ruling.outcome == ArbitrationOutcome.MERCHANT_WINS:
+            return 0.55
+        return -0.35
+
     def _resolve_case(
         self,
         case: InternalCase,
@@ -699,6 +867,19 @@ class ChargebackOpsEnvironment(
         case_progress = self._progress_by_case[self._selected_case_id]
         if case_progress.resolution_status != "open":
             return ["select_case"]
+        if case_progress.round_number == 2:
+            # Pre-arbitration: investigation actions still help (e.g. to pull
+            # compelling evidence from a system) but the round-1 submit path is
+            # closed off in favour of the three terminal v2 actions.
+            return base + [
+                "query_system",
+                "retrieve_policy",
+                "add_evidence",
+                "remove_evidence",
+                "respond_to_pre_arb",
+                "escalate_to_arbitration",
+                "accept_arbitration_loss",
+            ]
         return base + [
             "inspect_case",
             "query_system",

tests/test_arbitration.py

@@ -0,0 +1,91 @@
+"""Unit tests for scenarios.arbitration 
+
+These tests pin the three bands of the arbitration ruling (merchant-wins,
+issuer-wins, deterministic coin flip) and the $250-per-side fee accounting so
+a regression in the terminal-round math shows up before the end-to-end env
+tests do.
+"""
+
+from __future__ import annotations
+
+from dataclasses import replace
+
+from scenarios.arbitration import (
+    ARB_FEE_PER_SIDE,
+    ARB_ISSUER_WIN_THRESHOLD,
+    ARB_MERCHANT_WIN_THRESHOLD,
+    ArbitrationOutcome,
+    _coin_flip_merchant_wins,
+    arbitration_ruling,
+)
+from scenarios.simulation import CaseProgress, get_task
+
+
+_TASK = get_task("goods_not_received_easy")
+_CASE = _TASK.cases[0]
+
+
+def _progress(attached: list[str]) -> CaseProgress:
+    p = CaseProgress()
+    p.attached_evidence_ids = list(attached)
+    return p
+
+
+def test_merchant_wins_on_strong_packet():
+    """Score 0.8 clears the 0.65 bar → MERCHANT_WINS, merchant keeps amount − fee."""
+    progress = _progress(["E1-ORDER-CONF", "E1-DELIVERY-SCAN"])
+    ruling = arbitration_ruling(_CASE, progress)
+    assert ruling.evidence_strength_score >= ARB_MERCHANT_WIN_THRESHOLD
+    assert ruling.outcome == ArbitrationOutcome.MERCHANT_WINS
+    assert ruling.arb_fee_per_side == ARB_FEE_PER_SIDE
+    assert ruling.merchant_net_pnl == _CASE.amount - ARB_FEE_PER_SIDE
+
+
+def test_issuer_wins_on_empty_packet():
+    """Score 0 sits below the 0.35 floor → ISSUER_WINS, merchant eats amount + fee."""
+    progress = _progress([])
+    ruling = arbitration_ruling(_CASE, progress)
+    assert ruling.evidence_strength_score <= ARB_ISSUER_WIN_THRESHOLD
+    assert ruling.outcome == ArbitrationOutcome.ISSUER_WINS
+    assert ruling.merchant_net_pnl == -_CASE.amount - ARB_FEE_PER_SIDE
+
+
+def test_ambiguity_band_uses_deterministic_coin_flip():
+    """Scores in (0.35, 0.65) map to a case_id-keyed coin flip — reproducible."""
+    # Two helpful-only evidence ids → 0.4 band score, no required subset.
+    progress = _progress(["E1-DELIVERY-SCAN", "E1-SUPPORT-ACK"])
+    r1 = arbitration_ruling(_CASE, progress)
+    r2 = arbitration_ruling(_CASE, progress)
+    assert r1.outcome == r2.outcome
+    assert ARB_ISSUER_WIN_THRESHOLD < r1.evidence_strength_score < ARB_MERCHANT_WIN_THRESHOLD
+    expected = (
+        ArbitrationOutcome.MERCHANT_WINS
+        if _coin_flip_merchant_wins(_CASE.case_id)
+        else ArbitrationOutcome.ISSUER_WINS
+    )
+    assert r1.outcome == expected
+
+
+def test_coin_flip_varies_across_case_ids():
+    """Changing only the case_id must change the coin-flip answer for some cases.
+
+    If every case_id hashed to the same parity, the ambiguity band wouldn't
+    actually be 50/50 across the benchmark — this test guards against that.
+    """
+    flips = {_coin_flip_merchant_wins(f"CB-TEST-{i}") for i in range(20)}
+    assert flips == {True, False}
+
+
+def test_ruling_is_pure():
+    """Same inputs, same outputs — required for reproducible benchmarks."""
+    progress = _progress(["E1-ORDER-CONF", "E1-DELIVERY-SCAN"])
+    r1 = arbitration_ruling(_CASE, progress)
+    r2 = arbitration_ruling(_CASE, progress)
+    assert r1 == r2
+
+    # A second case_id clone with identical evidence should give the same
+    # MERCHANT_WINS outcome (score is above 0.65, so no coin-flip involved).
+    cloned = replace(_CASE, case_id="CB-CLONE-1")
+    r3 = arbitration_ruling(cloned, progress)
+    assert r3.outcome == r1.outcome
+    assert r3.merchant_net_pnl == r1.merchant_net_pnl

tests/test_env.py

@@ -1,8 +1,65 @@
+from scenarios.arbitration import ARB_FEE_PER_SIDE, ArbitrationOutcome
 from scenarios.case_generator import generate_task
+from scenarios.issuer_model import IssuerDecision, IssuerReview
 from core.models import ChargebackOpsAction
 from server.chargeback_ops_environment import ChargebackOpsEnvironment
 
 
+class _ScriptedIssuer:
+    """Deterministic Issuer stub that returns planned decisions in sequence.
+
+    Lets round-2 env tests exercise the full dispute lifecycle without
+    depending on the exact thresholds in IssuerAgent — the scoring math is
+    already pinned in tests/test_issuer.py.
+    """
+
+    def __init__(self, decisions: list[IssuerDecision]):
+        self._decisions = list(decisions)
+        self.calls: list[int] = []
+
+    def decide_review(self, case, progress, round_number):
+        self.calls.append(round_number)
+        idx = min(len(self.calls) - 1, len(self._decisions) - 1)
+        decision = self._decisions[idx]
+        return IssuerReview(
+            decision=decision,
+            evidence_strength_score=0.5,
+            rationale=f"stub decision {decision.value} at r{round_number}",
+        )
+
+
+def _drive_case_into_round_2(env: ChargebackOpsEnvironment) -> None:
+    """Select CB-E1, attach required evidence, submit — with Issuer stub that
+    requests more evidence on round 1. Leaves env in round-2 state.
+    """
+    env.step(ChargebackOpsAction(action_type="select_case", case_id="CB-E1"))
+    env.step(
+        ChargebackOpsAction(
+            action_type="query_system", case_id="CB-E1", system_name="orders"
+        )
+    )
+    env.step(
+        ChargebackOpsAction(
+            action_type="query_system", case_id="CB-E1", system_name="shipping"
+        )
+    )
+    env.step(
+        ChargebackOpsAction(
+            action_type="add_evidence",
+            case_id="CB-E1",
+            evidence_ids=["E1-ORDER-CONF", "E1-DELIVERY-SCAN"],
+        )
+    )
+    env.step(
+        ChargebackOpsAction(
+            action_type="set_strategy", case_id="CB-E1", strategy="contest"
+        )
+    )
+    env.step(
+        ChargebackOpsAction(action_type="submit_representment", case_id="CB-E1")
+    )
+
+
 def test_reset_returns_task_observation():
     env = ChargebackOpsEnvironment()
     obs = env.reset(task_id="goods_not_received_easy")
@@ -106,3 +163,126 @@ def test_generated_task_covers_all_reason_codes():
         "duplicate_processing", "product_not_as_described", "service_not_provided",
     }
     assert expected.issubset(seen_codes), f"Missing: {expected - seen_codes}"
+
+
+# ---------------------------------------------------------------------------
+# multi-round dispute lifecycle 
+# ---------------------------------------------------------------------------
+
+
+def test_round2_available_actions_exclude_submit_representment():
+    env = ChargebackOpsEnvironment()
+    env.reset(task_id="goods_not_received_easy")
+    env._issuer_agent = _ScriptedIssuer([IssuerDecision.REQUEST_MORE_EVIDENCE])
+    _drive_case_into_round_2(env)
+
+    actions = env._build_available_actions()
+    assert "submit_representment" not in actions
+    assert "respond_to_pre_arb" in actions
+    assert "escalate_to_arbitration" in actions
+    assert "accept_arbitration_loss" in actions
+
+
+def test_full_three_round_cycle_ending_in_arbitration():
+    env = ChargebackOpsEnvironment()
+    env.reset(task_id="goods_not_received_easy")
+    env._issuer_agent = _ScriptedIssuer(
+        [
+            IssuerDecision.REQUEST_MORE_EVIDENCE,
+            IssuerDecision.ESCALATE_TO_ARBITRATION,
+        ]
+    )
+    _drive_case_into_round_2(env)
+
+    obs = env.step(
+        ChargebackOpsAction(
+            action_type="respond_to_pre_arb",
+            case_id="CB-E1",
+            compelling_evidence_ids=["E1-SIGNATURE"],
+            note="Added signature-level delivery proof for pre-arb.",
+        )
+    )
+
+    progress = env._progress_by_case["CB-E1"]
+    assert progress.round_number == 3
+    assert progress.arbitration_outcome == ArbitrationOutcome.MERCHANT_WINS.value
+    assert progress.arb_fees_paid == ARB_FEE_PER_SIDE
+    assert progress.final_economic_outcome == progress.final_economic_outcome
+    assert progress.final_economic_outcome is not None
+    assert progress.resolution_status == "won_arbitration"
+    assert obs.done is True
+    assert "arbitration" in obs.last_action_result.lower()
+
+
+def test_respond_to_pre_arb_accepted_skips_arbitration():
+    """If the Issuer accepts in round 2, no arbitration fee is charged and
+    the merchant keeps the full dispute amount."""
+    env = ChargebackOpsEnvironment()
+    env.reset(task_id="goods_not_received_easy")
+    env._issuer_agent = _ScriptedIssuer(
+        [IssuerDecision.REQUEST_MORE_EVIDENCE, IssuerDecision.ACCEPT]
+    )
+    _drive_case_into_round_2(env)
+
+    env.step(
+        ChargebackOpsAction(
+            action_type="respond_to_pre_arb",
+            case_id="CB-E1",
+            compelling_evidence_ids=["E1-SIGNATURE"],
+        )
+    )
+
+    progress = env._progress_by_case["CB-E1"]
+    assert progress.resolution_status == "won_pre_arb"
+    assert progress.arb_fees_paid == 0.0
+    assert progress.arbitration_outcome is None
+    case = env._lookup_case("CB-E1")
+    assert progress.final_economic_outcome == case.amount
+
+
+def test_accept_arbitration_loss_skips_fees():
+    """Conceding pre-arb forfeits the dispute amount but avoids the $250 fee."""
+    env = ChargebackOpsEnvironment()
+    env.reset(task_id="goods_not_received_easy")
+    env._issuer_agent = _ScriptedIssuer([IssuerDecision.REQUEST_MORE_EVIDENCE])
+    _drive_case_into_round_2(env)
+
+    env.step(
+        ChargebackOpsAction(
+            action_type="accept_arbitration_loss", case_id="CB-E1"
+        )
+    )
+
+    progress = env._progress_by_case["CB-E1"]
+    case = env._lookup_case("CB-E1")
+    assert progress.resolution_status == "conceded_pre_arb"
+    assert progress.arb_fees_paid == 0.0
+    assert progress.arbitration_outcome is None
+    assert progress.final_economic_outcome == -case.amount
+
+
+def test_escalate_to_arbitration_from_round_2():
+    """Merchant can voluntarily file for arbitration from round 2."""
+    env = ChargebackOpsEnvironment()
+    env.reset(task_id="goods_not_received_easy")
+    env._issuer_agent = _ScriptedIssuer([IssuerDecision.REQUEST_MORE_EVIDENCE])
+    _drive_case_into_round_2(env)
+
+    env.step(
+        ChargebackOpsAction(
+            action_type="escalate_to_arbitration", case_id="CB-E1"
+        )
+    )
+
+    progress = env._progress_by_case["CB-E1"]
+    case = env._lookup_case("CB-E1")
+    assert progress.round_number == 3
+    assert progress.arb_fees_paid == ARB_FEE_PER_SIDE
+    assert progress.arbitration_outcome in {
+        ArbitrationOutcome.MERCHANT_WINS.value,
+        ArbitrationOutcome.ISSUER_WINS.value,
+    }
+    if progress.arbitration_outcome == ArbitrationOutcome.MERCHANT_WINS.value:
+        assert progress.final_economic_outcome == case.amount - ARB_FEE_PER_SIDE
+    else:
+        assert progress.final_economic_outcome == -case.amount - ARB_FEE_PER_SIDE

tests/test_escalation_roi.py

@@ -0,0 +1,139 @@
+"""Unit tests for EscalationROIRubric — escalate-vs-concede EV scoring.
+
+The rubric encodes the economic rule that escalating to network arbitration
+is only rational when ``P(win) * dispute_amount > arb_fee``. These tests pin
+each branch of that decision so a regression in the fee, thresholds, or
+probability mapping is caught immediately.
+"""
+
+from __future__ import annotations
+
+from dataclasses import replace
+
+from evaluation.rubrics import (
+    CASE_DIMENSION_NAMES,
+    CASE_DIMENSION_WEIGHTS,
+    EscalationROIRubric,
+    GradingContext,
+    _probability_of_merchant_win,
+)
+from scenarios.arbitration import ARB_FEE_PER_SIDE
+from scenarios.simulation import CaseProgress, get_task
+
+
+_TASK = get_task("goods_not_received_easy")
+_CASE = _TASK.cases[0]
+
+
+def _progress(
+    *,
+    attached: list[str] | None = None,
+    round_number: int = 1,
+    resolution_status: str = "open",
+    arbitration_outcome: str | None = None,
+) -> CaseProgress:
+    p = CaseProgress()
+    p.attached_evidence_ids = list(attached or [])
+    p.round_number = round_number
+    p.resolution_status = resolution_status
+    p.arbitration_outcome = arbitration_outcome
+    return p
+
+
+def test_weights_sum_to_one_and_match_names():
+    assert abs(sum(CASE_DIMENSION_WEIGHTS) - 1.0) < 1e-6
+    assert len(CASE_DIMENSION_WEIGHTS) == len(CASE_DIMENSION_NAMES) == 8
+    assert "escalation_roi" in CASE_DIMENSION_NAMES
+
+
+def test_probability_mapping_matches_arbitration_thresholds():
+    assert _probability_of_merchant_win(0.9) == 1.0
+    assert _probability_of_merchant_win(0.2) == 0.0
+    assert _probability_of_merchant_win(0.5) == 0.5
+
+
+def test_vacuous_full_credit_when_case_never_escalated():
+    """A case that never reached pre-arbitration gets full credit by default."""
+    ctx = GradingContext(case=_CASE, progress=_progress(), step_count=5)
+    assert EscalationROIRubric()(ctx, None) == 1.0
+
+
+def test_pre_arb_accept_is_full_credit():
+    """Winning on the pre-arbitration re-submit without filing arbitration is
+    the optimal path."""
+    progress = _progress(
+        attached=["E1-ORDER-CONF", "E1-DELIVERY-SCAN"],
+        round_number=2,
+        resolution_status="won_pre_arb",
+    )
+    ctx = GradingContext(case=_CASE, progress=progress, step_count=5)
+    assert EscalationROIRubric()(ctx, None) == 1.0
+
+
+def test_reward_positive_ev_escalation():
+    """Strong packet → P(win)=1.0 × $129.99 > $250? No. Test with bigger amount."""
+    big_case = replace(_CASE, case_id="CB-BIG", amount=1000.0)
+    progress = _progress(
+        attached=["E1-ORDER-CONF", "E1-DELIVERY-SCAN"],
+        round_number=3,
+        resolution_status="won_arbitration",
+        arbitration_outcome="merchant_wins",
+    )
+    ctx = GradingContext(case=big_case, progress=progress, step_count=5)
+    # P(win)=1.0, EV = 1.0 * 1000 = 1000 > 250 → escalation was rational.
+    assert EscalationROIRubric()(ctx, None) == 1.0
+
+
+def test_penalise_negative_ev_escalation():
+    """Weak packet + small amount → escalating was a losing bet."""
+    small_case = replace(_CASE, case_id="CB-SMALL", amount=100.0)
+    progress = _progress(
+        attached=[],
+        round_number=3,
+        resolution_status="lost_arbitration",
+        arbitration_outcome="issuer_wins",
+    )
+    ctx = GradingContext(case=small_case, progress=progress, step_count=5)
+    # P(win)=0.0, EV = 0 < 250 → escalation was -EV.
+    assert EscalationROIRubric()(ctx, None) == 0.0
+
+
+def test_penalise_concede_when_escalation_was_positive_ev():
+    """Conceding with a strong packet + large amount leaves money on the table."""
+    big_case = replace(_CASE, case_id="CB-BIG2", amount=1000.0)
+    progress = _progress(
+        attached=["E1-ORDER-CONF", "E1-DELIVERY-SCAN"],
+        round_number=2,
+        resolution_status="conceded_pre_arb",
+    )
+    ctx = GradingContext(case=big_case, progress=progress, step_count=5)
+    # Strong evidence, big amount → should have escalated.
+    assert EscalationROIRubric()(ctx, None) == 0.0
+
+
+def test_reward_concede_when_escalation_was_negative_ev():
+    """Conceding a hopeless case is the +EV decision vs burning $250."""
+    small_case = replace(_CASE, case_id="CB-SMALL2", amount=100.0)
+    progress = _progress(
+        attached=[],
+        round_number=2,
+        resolution_status="conceded_pre_arb",
+    )
+    ctx = GradingContext(case=small_case, progress=progress, step_count=5)
+    assert EscalationROIRubric()(ctx, None) == 1.0
+
+
+def test_fee_threshold_is_the_pivot():
+    """Sanity check the exact EV pivot: P(win)*amount vs ARB_FEE_PER_SIDE."""
+    assert ARB_FEE_PER_SIDE == 250.0
+    # P(win)=0.5 × $600 = 300 > 250 → escalate is rational
+    mid_case = replace(_CASE, case_id="CB-MID", amount=600.0)
+    # Score in ambiguity band by attaching two helpful-only ids.
+    progress = _progress(
+        attached=["E1-DELIVERY-SCAN", "E1-SUPPORT-ACK"],
+        round_number=3,
+        resolution_status="won_arbitration",
+        arbitration_outcome="merchant_wins",
+    )
+    ctx = GradingContext(case=mid_case, progress=progress, step_count=5)
+    assert EscalationROIRubric()(ctx, None) == 1.0

tests/test_grader.py

@@ -30,11 +30,11 @@ def test_environment_exposes_rubric_tree():
     expected = {
         "case_rubric",
         "case_rubric.aggregator",
-        *(f"case_rubric.aggregator.rubric_{i}" for i in range(7)),
+        *(f"case_rubric.aggregator.rubric_{i}" for i in range(8)),
     }
     assert expected.issubset(names)
 
     # Weights must sum to 1.0 (WeightedSum enforces this at construction but
     # we lock the constant here so weight changes stay intentional).
     assert abs(sum(CASE_DIMENSION_WEIGHTS) - 1.0) < 1e-6
-    assert len(CASE_DIMENSION_WEIGHTS) == 7
+    assert len(CASE_DIMENSION_WEIGHTS) == 8

tests/test_issuer.py

@@ -1,4 +1,4 @@
-"""Unit tests for the scripted IssuerAgent (PRD §4.1).
+"""Unit tests for the scripted IssuerAgent
 
 Each test pins one branch of the deterministic decision matrix so a regression
 in `evidence_strength_score` or the round-1 / round-2 thresholds shows up