AI ARB

    graph.add_edge(START, "scan")
    graph.add_edge("scan", "draft_plan")
    graph.add_conditional_edges("draft_plan", routing.after_draft)
    graph.add_edge("clarify", "draft_plan")
    graph.add_edge("critique", "triage")
    graph.add_conditional_edges("triage", routing.after_triage)
    graph.add_edge("respond", "rule")
    graph.add_conditional_edges("rule", routing.after_rule)
    graph.add_conditional_edges("verify", routing.after_round)
    graph.add_conditional_edges("judge", routing.after_judge)
    graph.add_edge("decide", "rescore")
    graph.add_edge("rescore", "explain")
    graph.add_edge("explain", "finalise")
    graph.add_edge("finalise", END)

    return graph.compile(checkpointer=checkpointer, name="aiarb")  # pyright: ignore[reportUnknownMemberType]

    def transition(
        self,
        to: Status,
        *,
        actor: Actor,
        round: int,
        note: str,
        refs: Iterable[Ref] = (),
        resolution: Resolution | None = None,
    ) -> Objection:
        """Move to another status, if the rules allow it."""
        rule = TRANSITIONS.get((self.status, to))
        if rule is None:
            raise TransitionError(f"{self.id}: cannot move from {self.status} to {to}")
        if actor not in rule.actors:
            raise TransitionError(f"{self.id}: {actor} cannot move from {self.status} to {to}")
        if rule.types is not None and self.type not in rule.types:
            raise TransitionError(
                f"{self.id}: a {self.type} objection cannot move from {self.status} to {to}"
            )
        if to is Status.RESOLVED and resolution is None:
            raise TransitionError(
                f"{self.id}: an objection is resolved only by a plan change or cited evidence"
            )
        if to is not Status.RESOLVED and resolution is not None:
            raise TransitionError(f"{self.id}: only a move to {Status.RESOLVED} has a resolution")
        if to is Status.NOTED and not self.severity.skips_debate:
            raise TransitionError(
                f"{self.id}: a {self.severity} objection must be debated, not noted"
            )
        return self._record(
            round=round,
            actor=actor,
            status=to,
            severity=self.severity,
            note=note,
            refs=tuple(refs),
            resolution=resolution,
        )

def after_round(state: RunState, runtime: Runtime[RunContext]) -> AfterRound:
    """Go another round, hand the leftovers to the judge, or finish the debate.

    Trade-offs can be waiting for the user once the debate ends without the
    judge: after the user reopened other items instead of deciding them.
    """
    if not _any_open(state):
        return "decide" if decisions_needed(state) else "rescore"
    if judge_needed(state, round_limit(state, runtime.context.charter)):
        return "judge"
    return "respond"


def after_judge(state: RunState) -> AfterJudge:
    """Ask the user about trade-offs left for them, or move on to rescoring."""
    return "decide" if decisions_needed(state) else "rescore"


def judge_needed(state: RunState, max_rounds: int) -> bool:
    """The debate has items left but must stop: out of rounds, or going in circles."""
    return round_limit_reached(state, max_rounds) or stalled(state)


def round_limit(state: RunState, charter: Charter) -> int:
    """The run's round limit: the one it was given, or the charter's."""
    return state["max_rounds"] or charter.debate.max_rounds


def round_limit_reached(state: RunState, max_rounds: int) -> bool:
    """The current debate has had its rounds. A debate the user reopened gets a
    full set of its own."""
    return state["round"] - state["debate_start"] >= max_rounds


def stalled(state: RunState) -> bool:
    """No objection has left the debate for `STALL_ROUNDS` rounds.

    Leaving means being resolved, deferred, sent for a decision, or anything else
    that ends the argument over it. A rejected answer does not count, even if the
    plan changed, since the critic was not persuaded. The user reopening items
    restarts the clock.
    """
    return state["round"] - max(last_progress(state), state["debate_start"]) >= STALL_ROUNDS

def refusal(root: Path, tool: str, tool_input: dict[str, Any]) -> str | None:
    """Why this tool call may not run, or None if it may."""
    if tool == ANSWER_TOOL:
        return None
    if tool not in READ_ONLY_TOOLS:
        return f"{tool} is not available: this review may only read and search the repository."
    for key in ("file_path", "path"):
        value = tool_input.get(key)
        if value is None:
            continue
        if not isinstance(value, str) or not _inside(root, value):
            return f"{value!r} is outside the repository; only files inside {root} can be read."
    pattern = tool_input.get("pattern")
    if tool == "Glob" and isinstance(pattern, str) and _escapes(pattern):
        return f"the pattern {pattern!r} reaches outside the repository."
    return None

class Models(_Section):
    """The model each role runs on. Any model ID Claude Code accepts."""

    planner: ModelId = "claude-opus-5-5"
    critic: ModelId = "claude-sonnet-5-5"
    judge: ModelId = "claude-opus-5-5"
    verifier: ModelId = "claude-sonnet-5-5"
    explainer: ModelId = "claude-sonnet-5-5"
    scorer: ModelId = "claude-sonnet-5-5"
    """Used by the language-model scorer, whether chosen or as Jev's fallback, and
    to confirm blocker calls."""

    @model_validator(mode="after")
    def _critic_differs_from_planner(self) -> "Models":
        if self.critic == self.planner:
            raise ValueError(
                f"the critic must be a different model from the planner (both are "
                f"{self.planner!r}): a model reviewing its own plan shares its blind spots"
            )
        return self