claude-dev-env 8.43.5 → 8.43.6

package/scripts/test_claude_chain_runner.py

@@ -1,1839 +0,0 @@
-"""Behavioral tests for the claude fallback-chain runner."""
-
-import json
-import os
-import subprocess
-import sys
-from pathlib import Path
-from unittest.mock import patch
-
-import pytest
-
-_SCRIPTS_DIR = Path(__file__).resolve().parent
-if str(_SCRIPTS_DIR) not in sys.path:
-    sys.path.insert(0, str(_SCRIPTS_DIR))
-
-import claude_chain_runner as runner  # noqa: E402
-import claude_chain_usage as chain_usage  # noqa: E402
-from claude_chain_runner import (  # noqa: E402
-    ChainEntry,
-    chain_subprocess_runner_lock,
-    override_chain_subprocess_runner,
-    default_affinity_state_path,
-    extract_resume_session_id,
-    load_affinity_store,
-    lookup_affinity_command,
-    order_entries_for_resume,
-    record_affinity_binding,
-    save_affinity_store_atomic,
-)
-from dev_env_scripts_constants.claude_chain_constants import (  # noqa: E402
-    AFFINITY_KEY_ALL_BINDINGS,
-    AFFINITY_KEY_COMMAND,
-    AFFINITY_KEY_SCHEMA_VERSION,
-    AFFINITY_KEY_SESSION_ID,
-    AFFINITY_MAXIMUM_ENTRIES,
-    AFFINITY_STATE_FILENAME,
-    AFFINITY_STATE_SCHEMA_VERSION,
-    RESUME_SESSION_FLAG,
-    ALL_USAGE_LIMIT_SIGNATURES,
-    ATTEMPT_STATUS_EXECUTABLE_NOT_FOUND,
-    ATTEMPT_STATUS_NONZERO_EXIT,
-    ATTEMPT_STATUS_SERVED,
-    ATTEMPT_STATUS_TIMEOUT,
-    ATTEMPT_STATUS_USAGE_LIMITED,
-    ATTEMPT_SUMMARY_ENTRY_TEMPLATE,
-    ATTEMPT_SUMMARY_JOIN_SEPARATOR,
-    CHAIN_ADVISOR_BLOCKED_EXIT_CODE,
-    CHAIN_CONFIG_ERROR_EXIT_CODE,
-    CHAIN_EXHAUSTED_EXIT_CODE,
-    CHAIN_EXHAUSTED_MESSAGE_TEMPLATE,
-    CLAUDE_HOME_SUBDIRECTORY,
-    CLI_ARGUMENTS_SEPARATOR,
-    CLI_ROUTING_MODE_FLAG,
-    CLI_TIMEOUT_FLAG,
-    CODEC_ERROR_STRATEGY,
-    CONFIG_CHAIN_EMPTY_REASON,
-    CONFIG_CHAIN_KEY,
-    CONFIG_CHAIN_NOT_LIST_REASON,
-    CONFIG_COMMAND_KEY,
-    CONFIG_ENTRY_COMMAND_MISSING_REASON,
-    CONFIG_ENTRY_EXTRA_ARGS_INVALID_REASON,
-    CONFIG_ENTRY_NOT_OBJECT_REASON,
-    CONFIG_EXTRA_ARGS_KEY,
-    CONFIG_FILENAME,
-    CONFIG_INVALID_SHAPE_MESSAGE_TEMPLATE,
-    CONFIG_MALFORMED_MESSAGE_TEMPLATE,
-    CONFIG_MISSING_MESSAGE_TEMPLATE,
-    CONFIG_NOT_OBJECT_REASON,
-    CONFIG_UNREADABLE_MESSAGE_TEMPLATE,
-    DEFAULT_TIMEOUT_SECONDS,
-    EXAMPLE_CONFIG_FILENAME,
-    NO_COMPLETED_PROCESS_RETURN_CODE,
-    ROUTING_MODE_ORDERED_ACCOUNT,
-    SESSION_ID_JSON_KEY,
-    TERMINAL_STATUS_ADVISOR_BLOCKED,
-    TERMINAL_STATUS_SERVED,
-    TERMINAL_STATUS_TIMEOUT,
-    UTF8_ENCODING,
-)
-
-_LARGE_CAPTURE_BYTE_COUNT = 400_000
-_LARGE_CAPTURE_MARKER = "X"
-
-
-def test_chain_subprocess_runner_lock_is_shared() -> None:
-    first_lock = chain_subprocess_runner_lock()
-    second_lock = chain_subprocess_runner_lock()
-
-    assert first_lock is second_lock
-
-
-def test_override_chain_subprocess_runner_restores_previous_runner() -> None:
-    previous_runner = runner.chain_subprocess_runner
-
-    def replacement_runner(
-        all_invocation_tokens: list[str],
-        **all_keywords: object,
-    ) -> subprocess.CompletedProcess[str]:
-        del all_invocation_tokens, all_keywords
-        return subprocess.CompletedProcess([], 0, "", "")
-
-    with override_chain_subprocess_runner(replacement_runner) as active_runner:
-        assert active_runner is previous_runner
-        assert runner.chain_subprocess_runner is replacement_runner
-
-    assert runner.chain_subprocess_runner is previous_runner
-
-
-_STDIN_ECHO_PAYLOAD = "charter body for spool path"
-_UNDECODABLE_STDOUT_BYTES = b"ok \x90 end"
-_DECODED_UNDECODABLE_STDOUT = "ok \ufffd end"
-_CRLF_CHILD_STDOUT_BYTES = b"a\r\nb\rc\n"
-_CRLF_CHILD_STDOUT_NORMALIZED = "a\nb\nc\n"
-
-_A_SIGNATURE = ALL_USAGE_LIMIT_SIGNATURES[0]
-_PROMPT_ARGUMENTS = ["-p", "hello"]
-_EQUAL_WEEKLY_REMAINING_PERCENT = 50.0
-_HIGH_WEEKLY_REMAINING_PERCENT = 90.0
-_MID_WEEKLY_REMAINING_PERCENT = 50.0
-_LOW_WEEKLY_REMAINING_PERCENT = 10.0
-_PRIMARY_LAUNCHER = "primary-launcher"
-_SECONDARY_LAUNCHER = "secondary-launcher"
-_BOUND_SESSION_ID = "session-bound-abc-123"
-_AUTHENTICATION_ERROR_STDERR = "authentication_error: invalid API key"
-_GENERIC_PROCESS_ERROR_STDERR = "unknown flag: --not-a-real-flag"
-_JSON_BIND_STDOUT_WITH_SESSION = (
-    f'{{"type":"result","{SESSION_ID_JSON_KEY}":"{_BOUND_SESSION_ID}",'
-    f'"result":"ENDORSE"}}\n'
-)
-
-
-def _completed(command, returncode, stdout="", stderr=""):
-    return subprocess.CompletedProcess(
-        args=[command], returncode=returncode, stdout=stdout, stderr=stderr
-    )
-
-
-def _entry(command, extra_args=None):
-    return {
-        CONFIG_COMMAND_KEY: command,
-        CONFIG_EXTRA_ARGS_KEY: extra_args if extra_args is not None else [],
-    }
-
-
-def _write_chain_config(tmp_path, chain_entries):
-    config_file = tmp_path / CONFIG_FILENAME
-    config_file.write_text(
-        json.dumps({CONFIG_CHAIN_KEY: chain_entries}), encoding=UTF8_ENCODING
-    )
-    return config_file
-
-
-def _config_order_usage_reporter(
-    *, config_path: Path
-) -> list[chain_usage.AccountUsageReport]:
-    all_entries = runner.load_chain(config_path)
-    return [
-        chain_usage.AccountUsageReport(
-            command=each_entry.command,
-            weekly_remaining_percent=_EQUAL_WEEKLY_REMAINING_PERCENT,
-        )
-        for each_entry in all_entries
-    ]
-
-
-def _usage_reporter_from_remaining(
-    remaining_percent_by_command: dict[str, float | None],
-):
-    call_count = {"count": 0}
-
-    def active_reporter(
-        *, config_path: Path
-    ) -> list[chain_usage.AccountUsageReport]:
-        call_count["count"] += 1
-        all_entries = runner.load_chain(config_path)
-        return [
-            chain_usage.AccountUsageReport(
-                command=each_entry.command,
-                weekly_remaining_percent=remaining_percent_by_command[
-                    each_entry.command
-                ],
-            )
-            for each_entry in all_entries
-        ]
-
-    active_reporter.call_count = call_count
-    return active_reporter
-
-
-class _Recorder:
-    def __init__(self, behavior_by_command):
-        self.behavior_by_command = behavior_by_command
-        self.invocations = []
-        self.timeouts = []
-        self.all_keyword_arguments = []
-
-    def __call__(self, invocation, **keyword_arguments):
-        self.invocations.append(invocation)
-        self.timeouts.append(keyword_arguments.get("timeout"))
-        self.all_keyword_arguments.append(keyword_arguments)
-        behavior = self.behavior_by_command[invocation[0]]
-        if isinstance(behavior, BaseException):
-            raise behavior
-        return behavior
-
-
-class _TtyStdin:
-    def isatty(self) -> bool:
-        return True
-
-
-def _install_tty_stdin(monkeypatch):
-    monkeypatch.setattr(runner.sys, "stdin", _TtyStdin())
-
-
-def _install(
-    monkeypatch,
-    config_file,
-    behavior_by_command,
-    *,
-    weekly_usage_reporter=None,
-):
-    recorder = _Recorder(behavior_by_command)
-    monkeypatch.setattr(runner, "chain_config_path", lambda: config_file)
-    monkeypatch.setattr(runner, "chain_subprocess_runner", recorder)
-    active_reporter = (
-        weekly_usage_reporter
-        if weekly_usage_reporter is not None
-        else _config_order_usage_reporter
-    )
-    monkeypatch.setattr(runner, "chain_weekly_usage_reporter", active_reporter)
-    affinity_path = Path(config_file).parent / AFFINITY_STATE_FILENAME
-    monkeypatch.setattr(
-        runner,
-        "default_affinity_state_path",
-        lambda _home, _affinity_path=affinity_path: _affinity_path,
-    )
-    _install_tty_stdin(monkeypatch)
-    return recorder
-
-
-def test_highest_weekly_remaining_is_tried_first(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(tmp_path, [_entry("claude"), _entry("claude-profile-c")])
-    usage_reporter = _usage_reporter_from_remaining(
-        {
-            "claude": _LOW_WEEKLY_REMAINING_PERCENT,
-            "claude-profile-c": _HIGH_WEEKLY_REMAINING_PERCENT,
-        }
-    )
-    recorder = _install(
-        monkeypatch,
-        config_file,
-        {
-            "claude": _completed("claude", 0, stdout="from-claude"),
-            "claude-profile-c": _completed("claude-profile-c", 0, stdout="from-profile-c"),
-        },
-        weekly_usage_reporter=usage_reporter,
-    )
-    chain_result = runner.run_claude(_PROMPT_ARGUMENTS, timeout_seconds=5)
-    assert chain_result.served_command == "claude-profile-c"
-    assert chain_result.returncode == 0
-    assert chain_result.stdout == "from-profile-c"
-    assert recorder.invocations[0][0] == "claude-profile-c"
-    assert [each_attempt.command for each_attempt in chain_result.attempts] == [
-        "claude-profile-c"
-    ]
-    assert chain_result.attempts[0].status == ATTEMPT_STATUS_SERVED
-
-
-def test_usage_limit_failsover_remaining_ranked_accounts(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(
-        tmp_path, [_entry("claude"), _entry("claude-profile-c"), _entry("claude-profile-a")]
-    )
-    usage_reporter = _usage_reporter_from_remaining(
-        {
-            "claude": _MID_WEEKLY_REMAINING_PERCENT,
-            "claude-profile-c": _HIGH_WEEKLY_REMAINING_PERCENT,
-            "claude-profile-a": _LOW_WEEKLY_REMAINING_PERCENT,
-        }
-    )
-    _install(
-        monkeypatch,
-        config_file,
-        {
-            "claude-profile-c": _completed("claude-profile-c", 1, stderr=_A_SIGNATURE),
-            "claude": _completed("claude", 0, stdout="ok"),
-            "claude-profile-a": _completed("claude-profile-a", 0, stdout="should not run"),
-        },
-        weekly_usage_reporter=usage_reporter,
-    )
-    chain_result = runner.run_claude(_PROMPT_ARGUMENTS, timeout_seconds=5)
-    assert chain_result.served_command == "claude"
-    assert chain_result.returncode == 0
-    assert [each_attempt.command for each_attempt in chain_result.attempts] == [
-        "claude-profile-c",
-        "claude",
-    ]
-    assert chain_result.attempts[0].status == ATTEMPT_STATUS_USAGE_LIMITED
-    assert chain_result.attempts[1].status == ATTEMPT_STATUS_SERVED
-
-
-def test_non_usage_error_on_highest_ranked_stops_without_rest(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(tmp_path, [_entry("claude"), _entry("claude-profile-c")])
-    usage_reporter = _usage_reporter_from_remaining(
-        {
-            "claude": _LOW_WEEKLY_REMAINING_PERCENT,
-            "claude-profile-c": _HIGH_WEEKLY_REMAINING_PERCENT,
-        }
-    )
-    _install(
-        monkeypatch,
-        config_file,
-        {
-            "claude-profile-c": _completed("claude-profile-c", 2, stderr="unknown flag"),
-            "claude": _completed("claude", 0, stdout="should not run"),
-        },
-        weekly_usage_reporter=usage_reporter,
-    )
-    chain_result = runner.run_claude(_PROMPT_ARGUMENTS, timeout_seconds=5)
-    assert chain_result.served_command == "claude-profile-c"
-    assert chain_result.returncode == 2
-    assert len(chain_result.attempts) == 1
-    assert chain_result.attempts[0].status == ATTEMPT_STATUS_NONZERO_EXIT
-
-
-def test_weekly_usage_probe_runs_once_per_run_claude(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(tmp_path, [_entry("claude"), _entry("claude-profile-c")])
-    usage_reporter = _usage_reporter_from_remaining(
-        {
-            "claude": _HIGH_WEEKLY_REMAINING_PERCENT,
-            "claude-profile-c": _LOW_WEEKLY_REMAINING_PERCENT,
-        }
-    )
-    _install(
-        monkeypatch,
-        config_file,
-        {
-            "claude": _completed("claude", 1, stderr=_A_SIGNATURE),
-            "claude-profile-c": _completed("claude-profile-c", 0, stdout="ok"),
-        },
-        weekly_usage_reporter=usage_reporter,
-    )
-    runner.run_claude(_PROMPT_ARGUMENTS, timeout_seconds=5)
-    assert usage_reporter.call_count["count"] == 1
-
-
-def test_usage_reporter_import_failure_falls_back_to_config_order(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(tmp_path, [_entry("claude"), _entry("claude-profile-c")])
-
-    def broken_usage_reporter(
-        *, config_path: Path
-    ) -> list[chain_usage.AccountUsageReport]:
-        raise ImportError("claude_chain_usage unavailable")
-
-    recorder = _install(
-        monkeypatch,
-        config_file,
-        {
-            "claude": _completed("claude", 0, stdout="from-claude"),
-            "claude-profile-c": _completed("claude-profile-c", 0, stdout="from-profile-c"),
-        },
-        weekly_usage_reporter=broken_usage_reporter,
-    )
-    chain_result = runner.run_claude(_PROMPT_ARGUMENTS, timeout_seconds=5)
-    assert chain_result.served_command == "claude"
-    assert chain_result.returncode == 0
-    assert chain_result.stdout == "from-claude"
-    assert recorder.invocations[0][0] == "claude"
-    assert [each_attempt.command for each_attempt in chain_result.attempts] == [
-        "claude"
-    ]
-
-
-def test_missing_high_remaining_binary_falls_through_to_lower_remaining(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(tmp_path, [_entry("claude"), _entry("claude-profile-c")])
-    usage_reporter = _usage_reporter_from_remaining(
-        {
-            "claude": _LOW_WEEKLY_REMAINING_PERCENT,
-            "claude-profile-c": _HIGH_WEEKLY_REMAINING_PERCENT,
-        }
-    )
-    _install(
-        monkeypatch,
-        config_file,
-        {
-            "claude-profile-c": FileNotFoundError(),
-            "claude": _completed("claude", 0, stdout="from-claude"),
-        },
-        weekly_usage_reporter=usage_reporter,
-    )
-    chain_result = runner.run_claude(_PROMPT_ARGUMENTS, timeout_seconds=5)
-    assert chain_result.served_command == "claude"
-    assert chain_result.returncode == 0
-    assert chain_result.stdout == "from-claude"
-    assert [each_attempt.command for each_attempt in chain_result.attempts] == [
-        "claude-profile-c",
-        "claude",
-    ]
-    assert [each_attempt.status for each_attempt in chain_result.attempts] == [
-        ATTEMPT_STATUS_EXECUTABLE_NOT_FOUND,
-        ATTEMPT_STATUS_SERVED,
-    ]
-
-
-def test_all_missing_binaries_exhausts_chain(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(tmp_path, [_entry("claude"), _entry("claude-profile-c")])
-    usage_reporter = _usage_reporter_from_remaining(
-        {
-            "claude": _LOW_WEEKLY_REMAINING_PERCENT,
-            "claude-profile-c": _HIGH_WEEKLY_REMAINING_PERCENT,
-        }
-    )
-    _install(
-        monkeypatch,
-        config_file,
-        {
-            "claude-profile-c": FileNotFoundError(),
-            "claude": FileNotFoundError(),
-        },
-        weekly_usage_reporter=usage_reporter,
-    )
-    chain_result = runner.run_claude(_PROMPT_ARGUMENTS, timeout_seconds=5)
-    assert chain_result.served_command is None
-    assert chain_result.returncode == NO_COMPLETED_PROCESS_RETURN_CODE
-    assert [each_attempt.command for each_attempt in chain_result.attempts] == [
-        "claude-profile-c",
-        "claude",
-    ]
-    assert [each_attempt.status for each_attempt in chain_result.attempts] == [
-        ATTEMPT_STATUS_EXECUTABLE_NOT_FOUND,
-        ATTEMPT_STATUS_EXECUTABLE_NOT_FOUND,
-    ]
-
-
-def test_missing_later_ranked_binary_is_skipped(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(
-        tmp_path, [_entry("claude"), _entry("claude-profile-c"), _entry("claude-profile-a")]
-    )
-    usage_reporter = _usage_reporter_from_remaining(
-        {
-            "claude": _MID_WEEKLY_REMAINING_PERCENT,
-            "claude-profile-c": _HIGH_WEEKLY_REMAINING_PERCENT,
-            "claude-profile-a": _LOW_WEEKLY_REMAINING_PERCENT,
-        }
-    )
-    _install(
-        monkeypatch,
-        config_file,
-        {
-            "claude-profile-c": _completed("claude-profile-c", 1, stderr=_A_SIGNATURE),
-            "claude": FileNotFoundError(),
-            "claude-profile-a": _completed("claude-profile-a", 0, stdout="done"),
-        },
-        weekly_usage_reporter=usage_reporter,
-    )
-    chain_result = runner.run_claude(_PROMPT_ARGUMENTS, timeout_seconds=5)
-    assert chain_result.served_command == "claude-profile-a"
-    assert [each_attempt.command for each_attempt in chain_result.attempts] == [
-        "claude-profile-c",
-        "claude",
-        "claude-profile-a",
-    ]
-    assert [each_attempt.status for each_attempt in chain_result.attempts] == [
-        ATTEMPT_STATUS_USAGE_LIMITED,
-        ATTEMPT_STATUS_EXECUTABLE_NOT_FOUND,
-        ATTEMPT_STATUS_SERVED,
-    ]
-
-
-def test_ranked_walk_preserves_extra_args_for_mapped_entry(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(
-        tmp_path,
-        [
-            _entry("claude", extra_args=["--account", "primary"]),
-            _entry("claude-profile-c", extra_args=["--account", "profile-c"]),
-        ],
-    )
-    usage_reporter = _usage_reporter_from_remaining(
-        {
-            "claude": _LOW_WEEKLY_REMAINING_PERCENT,
-            "claude-profile-c": _HIGH_WEEKLY_REMAINING_PERCENT,
-        }
-    )
-    recorder = _install(
-        monkeypatch,
-        config_file,
-        {"claude-profile-c": _completed("claude-profile-c", 0)},
-        weekly_usage_reporter=usage_reporter,
-    )
-    runner.run_claude(_PROMPT_ARGUMENTS, timeout_seconds=5)
-    assert recorder.invocations[0] == [
-        "claude-profile-c",
-        "-p",
-        "hello",
-        "--account",
-        "profile-c",
-    ]
-
-
-def test_duplicate_command_entries_are_both_walked(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(
-        tmp_path,
-        [
-            _entry("claude", extra_args=["--account", "primary"]),
-            _entry("claude", extra_args=["--account", "secondary"]),
-        ],
-    )
-    usage_reporter = _usage_reporter_from_remaining(
-        {"claude": _HIGH_WEEKLY_REMAINING_PERCENT}
-    )
-    recorder = _install(
-        monkeypatch,
-        config_file,
-        {"claude": _completed("claude", 1, stderr=_A_SIGNATURE)},
-        weekly_usage_reporter=usage_reporter,
-    )
-    chain_result = runner.run_claude(_PROMPT_ARGUMENTS, timeout_seconds=5)
-    assert [each_invocation[-1] for each_invocation in recorder.invocations] == [
-        "primary",
-        "secondary",
-    ]
-    assert [each_attempt.status for each_attempt in chain_result.attempts] == [
-        ATTEMPT_STATUS_USAGE_LIMITED,
-        ATTEMPT_STATUS_USAGE_LIMITED,
-    ]
-
-
-def test_entry_absent_from_usage_report_is_still_walked(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(tmp_path, [_entry("claude"), _entry("claude-profile-c")])
-
-    def partial_usage_reporter(
-        *, config_path: Path
-    ) -> list[chain_usage.AccountUsageReport]:
-        return [
-            chain_usage.AccountUsageReport(
-                command="claude-profile-c",
-                weekly_remaining_percent=_HIGH_WEEKLY_REMAINING_PERCENT,
-            )
-        ]
-
-    _install(
-        monkeypatch,
-        config_file,
-        {
-            "claude-profile-c": _completed("claude-profile-c", 1, stderr=_A_SIGNATURE),
-            "claude": _completed("claude", 0, stdout="ok"),
-        },
-        weekly_usage_reporter=partial_usage_reporter,
-    )
-    chain_result = runner.run_claude(_PROMPT_ARGUMENTS, timeout_seconds=5)
-    assert chain_result.served_command == "claude"
-    assert [each_attempt.command for each_attempt in chain_result.attempts] == [
-        "claude-profile-c",
-        "claude",
-    ]
-
-
-def test_usage_limited_primary_falls_over_to_second(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(tmp_path, [_entry("claude"), _entry("claude-profile-c")])
-    _install(
-        monkeypatch,
-        config_file,
-        {
-            "claude": _completed("claude", 1, stderr=_A_SIGNATURE),
-            "claude-profile-c": _completed("claude-profile-c", 0, stdout="ok"),
-        },
-    )
-    chain_result = runner.run_claude(_PROMPT_ARGUMENTS, timeout_seconds=5)
-    assert chain_result.served_command == "claude-profile-c"
-    assert chain_result.returncode == 0
-    assert chain_result.stdout == "ok"
-    assert [each_attempt.command for each_attempt in chain_result.attempts] == [
-        "claude",
-        "claude-profile-c",
-    ]
-    assert chain_result.attempts[0].status == ATTEMPT_STATUS_USAGE_LIMITED
-    assert chain_result.attempts[1].status == ATTEMPT_STATUS_SERVED
-
-
-def test_nonzero_exit_without_signature_does_not_fall_over(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(tmp_path, [_entry("claude"), _entry("claude-profile-c")])
-    _install(
-        monkeypatch,
-        config_file,
-        {
-            "claude": _completed("claude", 2, stderr="unknown flag"),
-            "claude-profile-c": _completed("claude-profile-c", 0, stdout="should not run"),
-        },
-    )
-    chain_result = runner.run_claude(_PROMPT_ARGUMENTS, timeout_seconds=5)
-    assert chain_result.served_command == "claude"
-    assert chain_result.returncode == 2
-    assert len(chain_result.attempts) == 1
-    assert chain_result.attempts[0].status == ATTEMPT_STATUS_NONZERO_EXIT
-
-
-def test_timeout_on_primary_does_not_fall_over(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(tmp_path, [_entry("claude"), _entry("claude-profile-c")])
-    _install(
-        monkeypatch,
-        config_file,
-        {
-            "claude": subprocess.TimeoutExpired(cmd=["claude"], timeout=5),
-            "claude-profile-c": _completed("claude-profile-c", 0),
-        },
-    )
-    chain_result = runner.run_claude(_PROMPT_ARGUMENTS, timeout_seconds=5)
-    assert chain_result.served_command is None
-    assert chain_result.returncode == NO_COMPLETED_PROCESS_RETURN_CODE
-    assert chain_result.terminal_status == TERMINAL_STATUS_TIMEOUT
-    assert len(chain_result.attempts) == 1
-    assert chain_result.attempts[0].status == ATTEMPT_STATUS_TIMEOUT
-
-
-def test_missing_primary_binary_falls_through_to_next(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(tmp_path, [_entry("claude"), _entry("claude-profile-c")])
-    _install(
-        monkeypatch,
-        config_file,
-        {
-            "claude": FileNotFoundError(),
-            "claude-profile-c": _completed("claude-profile-c", 0, stdout="from-profile-c"),
-        },
-    )
-    chain_result = runner.run_claude(_PROMPT_ARGUMENTS, timeout_seconds=5)
-    assert chain_result.served_command == "claude-profile-c"
-    assert chain_result.returncode == 0
-    assert chain_result.stdout == "from-profile-c"
-    assert [each_attempt.command for each_attempt in chain_result.attempts] == [
-        "claude",
-        "claude-profile-c",
-    ]
-    assert [each_attempt.status for each_attempt in chain_result.attempts] == [
-        ATTEMPT_STATUS_EXECUTABLE_NOT_FOUND,
-        ATTEMPT_STATUS_SERVED,
-    ]
-
-
-def test_missing_fallback_binary_is_skipped_and_walk_continues(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(
-        tmp_path, [_entry("claude"), _entry("claude-profile-c"), _entry("claude-profile-a")]
-    )
-    _install(
-        monkeypatch,
-        config_file,
-        {
-            "claude": _completed("claude", 1, stderr=_A_SIGNATURE),
-            "claude-profile-c": FileNotFoundError(),
-            "claude-profile-a": _completed("claude-profile-a", 0, stdout="done"),
-        },
-    )
-    chain_result = runner.run_claude(_PROMPT_ARGUMENTS, timeout_seconds=5)
-    assert chain_result.served_command == "claude-profile-a"
-    assert [each_attempt.status for each_attempt in chain_result.attempts] == [
-        ATTEMPT_STATUS_USAGE_LIMITED,
-        ATTEMPT_STATUS_EXECUTABLE_NOT_FOUND,
-        ATTEMPT_STATUS_SERVED,
-    ]
-
-
-def test_zero_exit_mentioning_usage_limit_is_success(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(tmp_path, [_entry("claude"), _entry("claude-profile-c")])
-    _install(
-        monkeypatch,
-        config_file,
-        {
-            "claude": _completed("claude", 0, stdout=f"note: {_A_SIGNATURE} earlier"),
-            "claude-profile-c": _completed("claude-profile-c", 0),
-        },
-    )
-    chain_result = runner.run_claude(_PROMPT_ARGUMENTS, timeout_seconds=5)
-    assert chain_result.served_command == "claude"
-    assert chain_result.returncode == 0
-    assert len(chain_result.attempts) == 1
-    assert chain_result.attempts[0].status == ATTEMPT_STATUS_SERVED
-
-
-def test_exhausted_chain_records_every_attempt(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(tmp_path, [_entry("claude"), _entry("claude-profile-c")])
-    _install(
-        monkeypatch,
-        config_file,
-        {
-            "claude": _completed("claude", 1, stderr=_A_SIGNATURE),
-            "claude-profile-c": _completed("claude-profile-c", 1, stderr=_A_SIGNATURE),
-        },
-    )
-    chain_result = runner.run_claude(_PROMPT_ARGUMENTS, timeout_seconds=5)
-    assert chain_result.served_command is None
-    assert chain_result.returncode == 1
-    assert [each_attempt.status for each_attempt in chain_result.attempts] == [
-        ATTEMPT_STATUS_USAGE_LIMITED,
-        ATTEMPT_STATUS_USAGE_LIMITED,
-    ]
-
-
-def test_reordering_config_changes_walk_order(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    behavior_by_command = {
-        "claude": _completed("claude", 0, stdout="from-claude"),
-        "claude-profile-c": _completed("claude-profile-c", 0, stdout="from-profile-c"),
-    }
-    first_config = tmp_path / "first"
-    first_config.mkdir()
-    config_a = _write_chain_config(
-        first_config, [_entry("claude"), _entry("claude-profile-c")]
-    )
-    _install(monkeypatch, config_a, behavior_by_command)
-    result_a = runner.run_claude(_PROMPT_ARGUMENTS, timeout_seconds=5)
-    assert result_a.served_command == "claude"
-
-    second_config = tmp_path / "second"
-    second_config.mkdir()
-    config_b = _write_chain_config(
-        second_config, [_entry("claude-profile-c"), _entry("claude")]
-    )
-    _install(monkeypatch, config_b, behavior_by_command)
-    result_b = runner.run_claude(_PROMPT_ARGUMENTS, timeout_seconds=5)
-    assert result_b.served_command == "claude-profile-c"
-
-
-def test_extra_args_are_appended_to_invocation(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(
-        tmp_path, [_entry("claude", extra_args=["--account", "profile-c"])]
-    )
-    recorder = _install(monkeypatch, config_file, {"claude": _completed("claude", 0)})
-    runner.run_claude(_PROMPT_ARGUMENTS, timeout_seconds=5)
-    assert recorder.invocations[0] == ["claude", "-p", "hello", "--account", "profile-c"]
-
-
-def test_run_claude_forwards_stdin_text_to_subprocess(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(tmp_path, [_entry("claude")])
-    recorder = _install(monkeypatch, config_file, {"claude": _completed("claude", 0)})
-    runner.run_claude(
-        _PROMPT_ARGUMENTS, timeout_seconds=5, stdin_text="charter body"
-    )
-    assert recorder.all_keyword_arguments[0]["input"] == "charter body"
-
-
-def test_run_claude_passes_none_input_when_stdin_text_omitted(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(tmp_path, [_entry("claude")])
-    recorder = _install(monkeypatch, config_file, {"claude": _completed("claude", 0)})
-    runner.run_claude(_PROMPT_ARGUMENTS, timeout_seconds=5)
-    assert recorder.all_keyword_arguments[0].get("input") is None
-
-
-def test_cli_forwards_piped_stdin_to_invocation(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(tmp_path, [_entry("claude")])
-    recorder = _install(monkeypatch, config_file, {"claude": _completed("claude", 0)})
-
-    class _PipedStdin:
-        def isatty(self) -> bool:
-            return False
-
-        def read(self) -> str:
-            return "charter body"
-
-    monkeypatch.setattr(runner.sys, "stdin", _PipedStdin())
-    exit_code = runner.main([CLI_ARGUMENTS_SEPARATOR, "-p", "hi"])
-    assert exit_code == 0
-    assert recorder.all_keyword_arguments[0]["input"] == "charter body"
-
-
-def test_signature_matching_is_case_insensitive(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(tmp_path, [_entry("claude"), _entry("claude-profile-c")])
-    _install(
-        monkeypatch,
-        config_file,
-        {
-            "claude": _completed("claude", 1, stderr=_A_SIGNATURE.upper()),
-            "claude-profile-c": _completed("claude-profile-c", 0),
-        },
-    )
-    chain_result = runner.run_claude(_PROMPT_ARGUMENTS, timeout_seconds=5)
-    assert chain_result.served_command == "claude-profile-c"
-
-
-def test_cli_passthrough_builds_argument_list_and_timeout(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(tmp_path, [_entry("claude")])
-    recorder = _install(monkeypatch, config_file, {"claude": _completed("claude", 0)})
-    exit_code = runner.main(
-        [CLI_TIMEOUT_FLAG, "9", CLI_ARGUMENTS_SEPARATOR, "-p", "hi"]
-    )
-    assert exit_code == 0
-    assert recorder.invocations[0] == ["claude", "-p", "hi"]
-    assert recorder.timeouts[0] == 9
-
-
-def test_cli_uses_default_timeout_when_flag_omitted(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(tmp_path, [_entry("claude")])
-    recorder = _install(monkeypatch, config_file, {"claude": _completed("claude", 0)})
-    runner.main([CLI_ARGUMENTS_SEPARATOR, "-p", "hi"])
-    assert recorder.timeouts[0] == DEFAULT_TIMEOUT_SECONDS
-
-
-def test_cli_served_nonzero_exit_is_passed_through(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path, capsys: pytest.CaptureFixture[str]
-) -> None:
-    config_file = _write_chain_config(tmp_path, [_entry("claude")])
-    _install(
-        monkeypatch,
-        config_file,
-        {"claude": _completed("claude", 7, stdout="out", stderr="err")},
-    )
-    exit_code = runner.main([CLI_ARGUMENTS_SEPARATOR, "-p", "hi"])
-    captured = capsys.readouterr()
-    assert exit_code == 7
-    assert captured.out == "out"
-    assert "err" in captured.err
-
-
-def test_cli_exhausted_chain_exits_nonzero_with_attempt_summary(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path, capsys: pytest.CaptureFixture[str]
-) -> None:
-    config_file = _write_chain_config(tmp_path, [_entry("claude"), _entry("claude-profile-c")])
-    _install(
-        monkeypatch,
-        config_file,
-        {
-            "claude": _completed("claude", 1, stderr=_A_SIGNATURE),
-            "claude-profile-c": _completed("claude-profile-c", 1, stderr=_A_SIGNATURE),
-        },
-    )
-    exit_code = runner.main([CLI_ARGUMENTS_SEPARATOR, "-p", "hi"])
-    captured = capsys.readouterr()
-    assert exit_code == CHAIN_EXHAUSTED_EXIT_CODE
-    expected_summary = ATTEMPT_SUMMARY_JOIN_SEPARATOR.join(
-        ATTEMPT_SUMMARY_ENTRY_TEMPLATE.format(
-            command=each_command, status=ATTEMPT_STATUS_USAGE_LIMITED
-        )
-        for each_command in ("claude", "claude-profile-c")
-    )
-    assert (
-        CHAIN_EXHAUSTED_MESSAGE_TEMPLATE.format(attempt_summary=expected_summary)
-        in captured.err
-    )
-
-
-def test_cli_missing_config_exits_config_error(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path, capsys: pytest.CaptureFixture[str]
-) -> None:
-    missing_config = tmp_path / CONFIG_FILENAME
-    monkeypatch.setattr(runner, "chain_config_path", lambda: missing_config)
-    _install_tty_stdin(monkeypatch)
-    exit_code = runner.main([CLI_ARGUMENTS_SEPARATOR, "-p", "hi"])
-    captured = capsys.readouterr()
-    assert exit_code == CHAIN_CONFIG_ERROR_EXIT_CODE
-    assert EXAMPLE_CONFIG_FILENAME in captured.err
-
-
-def test_missing_config_raises_naming_path_and_example(tmp_path: Path) -> None:
-    missing_config = tmp_path / CONFIG_FILENAME
-    with pytest.raises(runner.ChainConfigurationError) as raised:
-        runner.load_chain(missing_config)
-    assert str(raised.value) == CONFIG_MISSING_MESSAGE_TEMPLATE.format(
-        config_path=missing_config, example_filename=EXAMPLE_CONFIG_FILENAME
-    )
-
-
-def test_malformed_json_raises_configuration_error(tmp_path: Path) -> None:
-    config_file = tmp_path / CONFIG_FILENAME
-    config_file.write_text("{ not valid json", encoding=UTF8_ENCODING)
-    with pytest.raises(runner.ChainConfigurationError) as raised:
-        runner.load_chain(config_file)
-    malformed_prefix = CONFIG_MALFORMED_MESSAGE_TEMPLATE.split("{config_path}")[0]
-    assert malformed_prefix in str(raised.value)
-    assert EXAMPLE_CONFIG_FILENAME in str(raised.value)
-
-
-def test_unreadable_config_raises_configuration_error(tmp_path: Path) -> None:
-    config_file = tmp_path / CONFIG_FILENAME
-    config_file.write_text("{}", encoding=UTF8_ENCODING)
-    with patch.object(Path, "read_text", side_effect=OSError("locked")):
-        with pytest.raises(runner.ChainConfigurationError) as raised:
-            runner.load_chain(config_file)
-    unreadable_prefix = CONFIG_UNREADABLE_MESSAGE_TEMPLATE.split("{config_path}")[0]
-    assert unreadable_prefix in str(raised.value)
-
-
-def test_top_level_not_object_raises_invalid_shape(tmp_path: Path) -> None:
-    config_file = tmp_path / CONFIG_FILENAME
-    config_file.write_text(json.dumps(["claude"]), encoding=UTF8_ENCODING)
-    with pytest.raises(runner.ChainConfigurationError) as raised:
-        runner.load_chain(config_file)
-    assert str(raised.value) == CONFIG_INVALID_SHAPE_MESSAGE_TEMPLATE.format(
-        config_path=config_file,
-        reason=CONFIG_NOT_OBJECT_REASON,
-        example_filename=EXAMPLE_CONFIG_FILENAME,
-    )
-
-
-def test_chain_key_not_list_raises_invalid_shape(tmp_path: Path) -> None:
-    config_file = tmp_path / CONFIG_FILENAME
-    config_file.write_text(
-        json.dumps({CONFIG_CHAIN_KEY: "claude"}), encoding=UTF8_ENCODING
-    )
-    with pytest.raises(runner.ChainConfigurationError) as raised:
-        runner.load_chain(config_file)
-    assert CONFIG_CHAIN_NOT_LIST_REASON in str(raised.value)
-
-
-def test_empty_chain_raises_invalid_shape(tmp_path: Path) -> None:
-    config_file = _write_chain_config(tmp_path, [])
-    with pytest.raises(runner.ChainConfigurationError) as raised:
-        runner.load_chain(config_file)
-    assert CONFIG_CHAIN_EMPTY_REASON in str(raised.value)
-
-
-def test_entry_not_object_raises_invalid_shape(tmp_path: Path) -> None:
-    config_file = _write_chain_config(tmp_path, ["claude"])
-    with pytest.raises(runner.ChainConfigurationError) as raised:
-        runner.load_chain(config_file)
-    assert CONFIG_ENTRY_NOT_OBJECT_REASON in str(raised.value)
-
-
-def test_entry_without_command_raises_invalid_shape(tmp_path: Path) -> None:
-    config_file = _write_chain_config(tmp_path, [{CONFIG_EXTRA_ARGS_KEY: []}])
-    with pytest.raises(runner.ChainConfigurationError) as raised:
-        runner.load_chain(config_file)
-    assert CONFIG_ENTRY_COMMAND_MISSING_REASON in str(raised.value)
-
-
-def test_entry_with_non_list_extra_args_raises_invalid_shape(tmp_path: Path) -> None:
-    config_file = _write_chain_config(
-        tmp_path, [{CONFIG_COMMAND_KEY: "claude", CONFIG_EXTRA_ARGS_KEY: "nope"}]
-    )
-    with pytest.raises(runner.ChainConfigurationError) as raised:
-        runner.load_chain(config_file)
-    assert CONFIG_ENTRY_EXTRA_ARGS_INVALID_REASON in str(raised.value)
-
-
-def test_extra_args_default_to_empty_when_omitted(tmp_path: Path) -> None:
-    config_file = _write_chain_config(tmp_path, [{CONFIG_COMMAND_KEY: "claude"}])
-    all_entries = runner.load_chain(config_file)
-    assert all_entries[0].command == "claude"
-    assert all_entries[0].extra_args == ()
-
-
-def test_load_chain_parses_command_and_extra_args(tmp_path: Path) -> None:
-    config_file = _write_chain_config(
-        tmp_path, [_entry("claude", extra_args=["--account", "profile-c"])]
-    )
-    all_entries = runner.load_chain(config_file)
-    assert all_entries == [
-        runner.ChainEntry(command="claude", extra_args=("--account", "profile-c"))
-    ]
-
-
-def test_chain_config_path_points_at_home_config() -> None:
-    config_path = runner.chain_config_path()
-    assert config_path.name == CONFIG_FILENAME
-    assert CLAUDE_HOME_SUBDIRECTORY in config_path.parts
-
-
-def test_real_subprocess_capture_replaces_undecodable_bytes(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(tmp_path, [_entry(sys.executable)])
-    monkeypatch.setattr(runner, "chain_config_path", lambda: config_file)
-    monkeypatch.setattr(
-        runner, "chain_weekly_usage_reporter", _config_order_usage_reporter
-    )
-    child_code = 'import sys; sys.stdout.buffer.write(b"ok \\x90 end")'
-    chain_result = runner.run_claude(["-c", child_code], timeout_seconds=60)
-    assert chain_result.served_command == sys.executable
-    assert chain_result.returncode == 0
-    assert chain_result.stdout == "ok � end"
-
-
-def test_real_subprocess_capture_preserves_utf8_text(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(tmp_path, [_entry(sys.executable)])
-    monkeypatch.setattr(runner, "chain_config_path", lambda: config_file)
-    monkeypatch.setattr(
-        runner, "chain_weekly_usage_reporter", _config_order_usage_reporter
-    )
-    child_code = 'import sys; sys.stdout.buffer.write("report ✅ done".encode("utf-8"))'
-    chain_result = runner.run_claude(["-c", child_code], timeout_seconds=60)
-    assert chain_result.served_command == sys.executable
-    assert chain_result.returncode == 0
-    assert chain_result.stdout == "report ✅ done"
-
-
-def test_run_captured_subprocess_spools_large_stdout_and_stderr() -> None:
-    child_code = (
-        "import sys;"
-        f"sys.stdout.write({_LARGE_CAPTURE_MARKER!r} * {_LARGE_CAPTURE_BYTE_COUNT});"
-        "sys.stderr.write('err-marker');"
-        "sys.exit(3)"
-    )
-    completion = runner._run_captured_subprocess(
-        [sys.executable, "-c", child_code],
-        encoding=UTF8_ENCODING,
-        errors=CODEC_ERROR_STRATEGY,
-        timeout=60,
-        check=False,
-        input=None,
-    )
-    assert completion.returncode == 3
-    assert len(completion.stdout) == _LARGE_CAPTURE_BYTE_COUNT
-    assert completion.stdout == _LARGE_CAPTURE_MARKER * _LARGE_CAPTURE_BYTE_COUNT
-    assert completion.stderr == "err-marker"
-
-
-def test_run_captured_subprocess_forwards_stdin_input() -> None:
-    child_code = "import sys; sys.stdout.write(sys.stdin.read())"
-    completion = runner._run_captured_subprocess(
-        [sys.executable, "-c", child_code],
-        encoding=UTF8_ENCODING,
-        errors=CODEC_ERROR_STRATEGY,
-        timeout=60,
-        check=False,
-        input=_STDIN_ECHO_PAYLOAD,
-    )
-    assert completion.returncode == 0
-    assert completion.stdout == _STDIN_ECHO_PAYLOAD
-    assert completion.stderr == ""
-
-
-def test_run_captured_subprocess_replaces_undecodable_stdout_bytes() -> None:
-    child_code = (
-        "import sys;"
-        f"sys.stdout.buffer.write({_UNDECODABLE_STDOUT_BYTES!r})"
-    )
-    completion = runner._run_captured_subprocess(
-        [sys.executable, "-c", child_code],
-        encoding=UTF8_ENCODING,
-        errors=CODEC_ERROR_STRATEGY,
-        timeout=60,
-        check=False,
-        input=None,
-    )
-    assert completion.returncode == 0
-    assert completion.stdout == _DECODED_UNDECODABLE_STDOUT
-
-
-def test_run_captured_subprocess_normalizes_crlf_to_lf() -> None:
-    """Spool decode matches subprocess text=True universal-newline translation."""
-    child_code = (
-        "import sys;"
-        f"sys.stdout.buffer.write({_CRLF_CHILD_STDOUT_BYTES!r})"
-    )
-    completion = runner._run_captured_subprocess(
-        [sys.executable, "-c", child_code],
-        encoding=UTF8_ENCODING,
-        errors=CODEC_ERROR_STRATEGY,
-        timeout=60,
-        check=False,
-        input=None,
-    )
-    assert completion.returncode == 0
-    assert completion.stdout == _CRLF_CHILD_STDOUT_NORMALIZED
-
-
-def test_run_captured_subprocess_honors_cwd(tmp_path: Path) -> None:
-    child_code = "import os, sys; sys.stdout.write(os.getcwd())"
-    completion = runner._run_captured_subprocess(
-        [sys.executable, "-c", child_code],
-        encoding=UTF8_ENCODING,
-        errors=CODEC_ERROR_STRATEGY,
-        timeout=60,
-        check=False,
-        cwd=str(tmp_path),
-    )
-    assert completion.returncode == 0
-    assert Path(completion.stdout).resolve() == tmp_path.resolve()
-
-
-def test_run_captured_subprocess_timeout_keeps_partial_stdout() -> None:
-    child_code = (
-        "import sys, time;"
-        "sys.stdout.write('partial-before-timeout');"
-        "sys.stdout.flush();"
-        "time.sleep(30)"
-    )
-    with pytest.raises(subprocess.TimeoutExpired) as raised:
-        runner._run_captured_subprocess(
-            [sys.executable, "-c", child_code],
-            encoding=UTF8_ENCODING,
-            errors=CODEC_ERROR_STRATEGY,
-            timeout=1,
-            check=False,
-            input=None,
-        )
-    assert raised.value.stdout == "partial-before-timeout"
-    assert isinstance(raised.value.stdout, str)
-
-
-def test_run_captured_subprocess_reads_stdin_stream(tmp_path: Path) -> None:
-    prompt_path = tmp_path / "prompt_body.txt"
-    prompt_path.write_text(_STDIN_ECHO_PAYLOAD, encoding=UTF8_ENCODING)
-    child_code = "import sys; sys.stdout.write(sys.stdin.read())"
-    with prompt_path.open(encoding=UTF8_ENCODING) as prompt_stream:
-        completion = runner._run_captured_subprocess(
-            [sys.executable, "-c", child_code],
-            encoding=UTF8_ENCODING,
-            errors=CODEC_ERROR_STRATEGY,
-            timeout=60,
-            check=False,
-            stdin=prompt_stream,
-        )
-    assert completion.returncode == 0
-    assert completion.stdout == _STDIN_ECHO_PAYLOAD
-
-
-def test_cli_emits_utf8_when_console_encoding_is_legacy(tmp_path: Path) -> None:
-    tmp_home = tmp_path / "home"
-    claude_directory = tmp_home / CLAUDE_HOME_SUBDIRECTORY
-    claude_directory.mkdir(parents=True)
-    config_file = claude_directory / CONFIG_FILENAME
-    config_file.write_text(
-        json.dumps({CONFIG_CHAIN_KEY: [_entry(sys.executable)]}),
-        encoding=UTF8_ENCODING,
-    )
-    runner_script = _SCRIPTS_DIR / "claude_chain_runner.py"
-    child_code = 'import sys; sys.stdout.buffer.write("report ✅".encode("utf-8"))'
-    legacy_console_encoding = "cp1252"
-    child_environment = dict(os.environ)
-    child_environment["USERPROFILE"] = str(tmp_home)
-    child_environment["HOME"] = str(tmp_home)
-    child_environment["PYTHONIOENCODING"] = legacy_console_encoding
-    child_environment.pop("PYTHONUTF8", None)
-    runner_command = [
-        sys.executable,
-        str(runner_script),
-        CLI_ARGUMENTS_SEPARATOR,
-        "-c",
-        child_code,
-    ]
-    completed = subprocess.run(
-        runner_command,
-        capture_output=True,
-        env=child_environment,
-        timeout=60,
-    )
-    assert completed.returncode == 0
-    assert b"Traceback" not in completed.stderr
-    assert "report ✅" in completed.stdout.decode(UTF8_ENCODING)
-
-
-def test_usage_limit_classifier_keys_on_exact_signature_constants() -> None:
-    assert ALL_USAGE_LIMIT_SIGNATURES == (
-        "hit your session limit",
-        "usage limit reached",
-        "out of usage",
-        "usage quota exceeded",
-    )
-    assert _A_SIGNATURE in ALL_USAGE_LIMIT_SIGNATURES
-    assert runner._is_usage_limit_failure(
-        _completed("primary-launcher", 1, stderr=_A_SIGNATURE)
-    )
-    assert not runner._is_usage_limit_failure(
-        _completed("primary-launcher", 1, stderr=_GENERIC_PROCESS_ERROR_STDERR)
-    )
-
-
-def test_extract_session_id_from_stdout_reads_json_object_and_ndjson() -> None:
-    single_object = (
-        f'{{"type":"result","{SESSION_ID_JSON_KEY}":"{_BOUND_SESSION_ID}",'
-        f'"result":"ENDORSE"}}'
-    )
-    assert runner.extract_session_id_from_stdout(single_object) == _BOUND_SESSION_ID
-    ndjson_stream = (
-        f'{{"type":"system","{SESSION_ID_JSON_KEY}":"{_BOUND_SESSION_ID}"}}\n'
-        f'{{"type":"result","{SESSION_ID_JSON_KEY}":"{_BOUND_SESSION_ID}",'
-        f'"result":"ok"}}\n'
-    )
-    assert runner.extract_session_id_from_stdout(ndjson_stream) == _BOUND_SESSION_ID
-    assert runner.extract_session_id_from_stdout("not json at all") is None
-    assert runner.extract_session_id_from_stdout("") is None
-
-
-def test_ordered_account_mode_tries_primary_launcher_first(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(
-        tmp_path, [_entry(_PRIMARY_LAUNCHER), _entry(_SECONDARY_LAUNCHER)]
-    )
-    usage_reporter = _usage_reporter_from_remaining(
-        {
-            _PRIMARY_LAUNCHER: _LOW_WEEKLY_REMAINING_PERCENT,
-            _SECONDARY_LAUNCHER: _HIGH_WEEKLY_REMAINING_PERCENT,
-        }
-    )
-    recorder = _install(
-        monkeypatch,
-        config_file,
-        {
-            _PRIMARY_LAUNCHER: _completed(
-                _PRIMARY_LAUNCHER, 0, stdout=_JSON_BIND_STDOUT_WITH_SESSION
-            ),
-            _SECONDARY_LAUNCHER: _completed(
-                _SECONDARY_LAUNCHER, 0, stdout="should-not-run"
-            ),
-        },
-        weekly_usage_reporter=usage_reporter,
-    )
-    chain_result = runner.run_claude(
-        _PROMPT_ARGUMENTS,
-        timeout_seconds=5,
-        routing_mode=ROUTING_MODE_ORDERED_ACCOUNT,
-    )
-    assert chain_result.served_command == _PRIMARY_LAUNCHER
-    assert chain_result.terminal_status == TERMINAL_STATUS_SERVED
-    assert recorder.invocations[0][0] == _PRIMARY_LAUNCHER
-    assert usage_reporter.call_count["count"] == 0
-    assert [each_attempt.command for each_attempt in chain_result.attempts] == [
-        _PRIMARY_LAUNCHER
-    ]
-
-
-def test_ordered_account_mode_usage_limit_falls_over_to_secondary(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(
-        tmp_path, [_entry(_PRIMARY_LAUNCHER), _entry(_SECONDARY_LAUNCHER)]
-    )
-    _install(
-        monkeypatch,
-        config_file,
-        {
-            _PRIMARY_LAUNCHER: _completed(
-                _PRIMARY_LAUNCHER, 1, stderr=_A_SIGNATURE
-            ),
-            _SECONDARY_LAUNCHER: _completed(
-                _SECONDARY_LAUNCHER, 0, stdout=_JSON_BIND_STDOUT_WITH_SESSION
-            ),
-        },
-    )
-    chain_result = runner.run_claude(
-        _PROMPT_ARGUMENTS,
-        timeout_seconds=5,
-        routing_mode=ROUTING_MODE_ORDERED_ACCOUNT,
-    )
-    assert chain_result.served_command == _SECONDARY_LAUNCHER
-    assert chain_result.returncode == 0
-    assert chain_result.terminal_status == TERMINAL_STATUS_SERVED
-    assert [each_attempt.command for each_attempt in chain_result.attempts] == [
-        _PRIMARY_LAUNCHER,
-        _SECONDARY_LAUNCHER,
-    ]
-    assert chain_result.attempts[0].status == ATTEMPT_STATUS_USAGE_LIMITED
-    assert chain_result.attempts[1].status == ATTEMPT_STATUS_SERVED
-
-
-def test_ordered_account_mode_authentication_error_is_advisor_blocked(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(
-        tmp_path, [_entry(_PRIMARY_LAUNCHER), _entry(_SECONDARY_LAUNCHER)]
-    )
-    recorder = _install(
-        monkeypatch,
-        config_file,
-        {
-            _PRIMARY_LAUNCHER: _completed(
-                _PRIMARY_LAUNCHER, 1, stderr=_AUTHENTICATION_ERROR_STDERR
-            ),
-            _SECONDARY_LAUNCHER: _completed(
-                _SECONDARY_LAUNCHER, 0, stdout="should-not-run"
-            ),
-        },
-    )
-    chain_result = runner.run_claude(
-        _PROMPT_ARGUMENTS,
-        timeout_seconds=5,
-        routing_mode=ROUTING_MODE_ORDERED_ACCOUNT,
-    )
-    assert chain_result.terminal_status == TERMINAL_STATUS_ADVISOR_BLOCKED
-    assert chain_result.served_command is None
-    assert chain_result.returncode == 1
-    assert _AUTHENTICATION_ERROR_STDERR in chain_result.stderr
-    assert len(recorder.invocations) == 1
-    assert chain_result.attempts[0].status == ATTEMPT_STATUS_NONZERO_EXIT
-
-
-def test_ordered_account_mode_timeout_is_advisor_blocked(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(
-        tmp_path, [_entry(_PRIMARY_LAUNCHER), _entry(_SECONDARY_LAUNCHER)]
-    )
-    recorder = _install(
-        monkeypatch,
-        config_file,
-        {
-            _PRIMARY_LAUNCHER: subprocess.TimeoutExpired(
-                cmd=[_PRIMARY_LAUNCHER], timeout=5
-            ),
-            _SECONDARY_LAUNCHER: _completed(_SECONDARY_LAUNCHER, 0),
-        },
-    )
-    chain_result = runner.run_claude(
-        _PROMPT_ARGUMENTS,
-        timeout_seconds=5,
-        routing_mode=ROUTING_MODE_ORDERED_ACCOUNT,
-    )
-    assert chain_result.terminal_status == TERMINAL_STATUS_ADVISOR_BLOCKED
-    assert chain_result.served_command is None
-    assert chain_result.returncode == NO_COMPLETED_PROCESS_RETURN_CODE
-    assert len(recorder.invocations) == 1
-    assert chain_result.attempts[0].status == ATTEMPT_STATUS_TIMEOUT
-
-
-def test_ordered_account_mode_generic_process_error_is_advisor_blocked(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(
-        tmp_path, [_entry(_PRIMARY_LAUNCHER), _entry(_SECONDARY_LAUNCHER)]
-    )
-    recorder = _install(
-        monkeypatch,
-        config_file,
-        {
-            _PRIMARY_LAUNCHER: _completed(
-                _PRIMARY_LAUNCHER, 2, stderr=_GENERIC_PROCESS_ERROR_STDERR
-            ),
-            _SECONDARY_LAUNCHER: _completed(
-                _SECONDARY_LAUNCHER, 0, stdout="should-not-run"
-            ),
-        },
-    )
-    chain_result = runner.run_claude(
-        _PROMPT_ARGUMENTS,
-        timeout_seconds=5,
-        routing_mode=ROUTING_MODE_ORDERED_ACCOUNT,
-    )
-    assert chain_result.terminal_status == TERMINAL_STATUS_ADVISOR_BLOCKED
-    assert chain_result.served_command is None
-    assert chain_result.returncode == 2
-    assert len(recorder.invocations) == 1
-    assert chain_result.attempts[0].status == ATTEMPT_STATUS_NONZERO_EXIT
-
-
-def test_ordered_account_mode_configuration_error_does_not_fall_over(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path, capsys: pytest.CaptureFixture[str]
-) -> None:
-    missing_config = tmp_path / CONFIG_FILENAME
-    monkeypatch.setattr(runner, "chain_config_path", lambda: missing_config)
-    _install_tty_stdin(monkeypatch)
-    exit_code = runner.main(
-        [
-            CLI_ROUTING_MODE_FLAG,
-            ROUTING_MODE_ORDERED_ACCOUNT,
-            CLI_ARGUMENTS_SEPARATOR,
-            "-p",
-            "hi",
-        ]
-    )
-    captured = capsys.readouterr()
-    assert exit_code == CHAIN_CONFIG_ERROR_EXIT_CODE
-    assert EXAMPLE_CONFIG_FILENAME in captured.err
-
-
-def test_ordered_account_mode_preserves_session_id_on_success(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(
-        tmp_path, [_entry(_PRIMARY_LAUNCHER), _entry(_SECONDARY_LAUNCHER)]
-    )
-    _install(
-        monkeypatch,
-        config_file,
-        {
-            _PRIMARY_LAUNCHER: _completed(
-                _PRIMARY_LAUNCHER, 0, stdout=_JSON_BIND_STDOUT_WITH_SESSION
-            ),
-            _SECONDARY_LAUNCHER: _completed(_SECONDARY_LAUNCHER, 0),
-        },
-    )
-    chain_result = runner.run_claude(
-        _PROMPT_ARGUMENTS,
-        timeout_seconds=5,
-        routing_mode=ROUTING_MODE_ORDERED_ACCOUNT,
-    )
-    assert chain_result.terminal_status == TERMINAL_STATUS_SERVED
-    assert chain_result.session_id == _BOUND_SESSION_ID
-    assert chain_result.served_command == _PRIMARY_LAUNCHER
-
-
-def test_default_routing_mode_remains_usage_ranked(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(
-        tmp_path, [_entry(_PRIMARY_LAUNCHER), _entry(_SECONDARY_LAUNCHER)]
-    )
-    usage_reporter = _usage_reporter_from_remaining(
-        {
-            _PRIMARY_LAUNCHER: _LOW_WEEKLY_REMAINING_PERCENT,
-            _SECONDARY_LAUNCHER: _HIGH_WEEKLY_REMAINING_PERCENT,
-        }
-    )
-    recorder = _install(
-        monkeypatch,
-        config_file,
-        {
-            _PRIMARY_LAUNCHER: _completed(
-                _PRIMARY_LAUNCHER, 0, stdout="from-primary"
-            ),
-            _SECONDARY_LAUNCHER: _completed(
-                _SECONDARY_LAUNCHER, 0, stdout="from-secondary"
-            ),
-        },
-        weekly_usage_reporter=usage_reporter,
-    )
-    chain_result = runner.run_claude(_PROMPT_ARGUMENTS, timeout_seconds=5)
-    assert chain_result.served_command == _SECONDARY_LAUNCHER
-    assert chain_result.terminal_status == TERMINAL_STATUS_SERVED
-    assert recorder.invocations[0][0] == _SECONDARY_LAUNCHER
-    assert usage_reporter.call_count["count"] == 1
-
-
-def test_cli_ordered_account_routing_mode_flag(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(
-        tmp_path, [_entry(_PRIMARY_LAUNCHER), _entry(_SECONDARY_LAUNCHER)]
-    )
-    usage_reporter = _usage_reporter_from_remaining(
-        {
-            _PRIMARY_LAUNCHER: _LOW_WEEKLY_REMAINING_PERCENT,
-            _SECONDARY_LAUNCHER: _HIGH_WEEKLY_REMAINING_PERCENT,
-        }
-    )
-    recorder = _install(
-        monkeypatch,
-        config_file,
-        {
-            _PRIMARY_LAUNCHER: _completed(
-                _PRIMARY_LAUNCHER, 0, stdout=_JSON_BIND_STDOUT_WITH_SESSION
-            ),
-            _SECONDARY_LAUNCHER: _completed(
-                _SECONDARY_LAUNCHER, 0, stdout="should-not-run"
-            ),
-        },
-        weekly_usage_reporter=usage_reporter,
-    )
-    exit_code = runner.main(
-        [
-            CLI_ROUTING_MODE_FLAG,
-            ROUTING_MODE_ORDERED_ACCOUNT,
-            CLI_ARGUMENTS_SEPARATOR,
-            "-p",
-            "hi",
-        ]
-    )
-    assert exit_code == 0
-    assert recorder.invocations[0][0] == _PRIMARY_LAUNCHER
-    assert usage_reporter.call_count["count"] == 0
-
-
-def test_cli_ordered_account_advisor_blocked_exit_code(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(
-        tmp_path, [_entry(_PRIMARY_LAUNCHER), _entry(_SECONDARY_LAUNCHER)]
-    )
-    _install(
-        monkeypatch,
-        config_file,
-        {
-            _PRIMARY_LAUNCHER: _completed(
-                _PRIMARY_LAUNCHER, 2, stderr=_GENERIC_PROCESS_ERROR_STDERR
-            ),
-            _SECONDARY_LAUNCHER: _completed(_SECONDARY_LAUNCHER, 0),
-        },
-    )
-    exit_code = runner.main(
-        [
-            CLI_ROUTING_MODE_FLAG,
-            ROUTING_MODE_ORDERED_ACCOUNT,
-            CLI_ARGUMENTS_SEPARATOR,
-            "-p",
-            "hi",
-        ]
-    )
-    assert exit_code == CHAIN_ADVISOR_BLOCKED_EXIT_CODE
-
-
-def test_default_affinity_state_path_joins_filename() -> None:
-    claude_home = Path("/tmp/claude-home")
-    resolved = default_affinity_state_path(claude_home)
-    assert resolved == claude_home / AFFINITY_STATE_FILENAME
-
-
-def test_affinity_store_round_trip_is_versioned_and_atomic(tmp_path: Path) -> None:
-    state_path = tmp_path / AFFINITY_STATE_FILENAME
-    empty_store = load_affinity_store(state_path)
-    assert empty_store.schema_version == AFFINITY_STATE_SCHEMA_VERSION
-    assert empty_store.all_bindings == []
-
-    updated = record_affinity_binding(
-        empty_store,
-        session_id=_BOUND_SESSION_ID,
-        command=_PRIMARY_LAUNCHER,
-    )
-    save_affinity_store_atomic(state_path, updated)
-
-    reloaded = load_affinity_store(state_path)
-    assert reloaded.schema_version == AFFINITY_STATE_SCHEMA_VERSION
-    assert len(reloaded.all_bindings) == 1
-    assert reloaded.all_bindings[0].session_id == _BOUND_SESSION_ID
-    assert reloaded.all_bindings[0].command == _PRIMARY_LAUNCHER
-    on_disk = json.loads(state_path.read_text(encoding=UTF8_ENCODING))
-    assert on_disk[AFFINITY_KEY_SCHEMA_VERSION] == AFFINITY_STATE_SCHEMA_VERSION
-    assert on_disk[AFFINITY_KEY_ALL_BINDINGS][0][AFFINITY_KEY_SESSION_ID] == (
-        _BOUND_SESSION_ID
-    )
-    assert on_disk[AFFINITY_KEY_ALL_BINDINGS][0][AFFINITY_KEY_COMMAND] == (
-        _PRIMARY_LAUNCHER
-    )
-
-
-def test_affinity_store_is_bounded_and_drops_oldest() -> None:
-    store = runner.AffinityStore()
-    for each_index in range(AFFINITY_MAXIMUM_ENTRIES + 3):
-        store = record_affinity_binding(
-            store,
-            session_id=f"session-{each_index}",
-            command=_PRIMARY_LAUNCHER,
-            maximum_entries=AFFINITY_MAXIMUM_ENTRIES,
-        )
-    assert len(store.all_bindings) == AFFINITY_MAXIMUM_ENTRIES
-    all_session_ids = [each.session_id for each in store.all_bindings]
-    assert "session-0" not in all_session_ids
-    assert "session-1" not in all_session_ids
-    assert "session-2" not in all_session_ids
-    assert f"session-{AFFINITY_MAXIMUM_ENTRIES + 2}" in all_session_ids
-
-
-def test_affinity_rebind_moves_session_to_newest_end() -> None:
-    store = runner.AffinityStore()
-    store = record_affinity_binding(
-        store, session_id="a", command=_PRIMARY_LAUNCHER
-    )
-    store = record_affinity_binding(
-        store, session_id="b", command=_SECONDARY_LAUNCHER
-    )
-    store = record_affinity_binding(
-        store, session_id="a", command=_SECONDARY_LAUNCHER
-    )
-    assert [each.session_id for each in store.all_bindings] == ["b", "a"]
-    assert store.all_bindings[-1].command == _SECONDARY_LAUNCHER
-
-
-def test_affinity_corrupt_state_raises_actionable_diagnostic(tmp_path: Path) -> None:
-    state_path = tmp_path / AFFINITY_STATE_FILENAME
-    state_path.write_text("{not-json", encoding=UTF8_ENCODING)
-    with pytest.raises(ValueError, match="corrupt or unreadable") as raised:
-        load_affinity_store(state_path)
-    assert str(state_path) in str(raised.value)
-
-
-def test_affinity_unsupported_schema_version_raises_actionable_diagnostic(
-    tmp_path: Path,
-) -> None:
-    state_path = tmp_path / AFFINITY_STATE_FILENAME
-    state_path.write_text(
-        json.dumps(
-            {
-                AFFINITY_KEY_SCHEMA_VERSION: AFFINITY_STATE_SCHEMA_VERSION + 1,
-                AFFINITY_KEY_ALL_BINDINGS: [],
-            }
-        ),
-        encoding=UTF8_ENCODING,
-    )
-    with pytest.raises(ValueError, match="unsupported schema_version") as raised:
-        load_affinity_store(state_path)
-    assert str(state_path) in str(raised.value)
-
-
-def test_affinity_binding_not_object_raises_actionable_diagnostic(
-    tmp_path: Path,
-) -> None:
-    state_path = tmp_path / AFFINITY_STATE_FILENAME
-    state_path.write_text(
-        json.dumps(
-            {
-                AFFINITY_KEY_SCHEMA_VERSION: AFFINITY_STATE_SCHEMA_VERSION,
-                AFFINITY_KEY_ALL_BINDINGS: ["not-an-object"],
-            }
-        ),
-        encoding=UTF8_ENCODING,
-    )
-    with pytest.raises(ValueError, match="not an object") as raised:
-        load_affinity_store(state_path)
-    assert str(state_path) in str(raised.value)
-
-
-def test_record_affinity_binding_rejects_empty_session_or_command() -> None:
-    store = runner.AffinityStore()
-    with pytest.raises(ValueError, match="session_id and command"):
-        record_affinity_binding(store, session_id="", command=_PRIMARY_LAUNCHER)
-    with pytest.raises(ValueError, match="session_id and command"):
-        record_affinity_binding(store, session_id=_BOUND_SESSION_ID, command="")
-
-
-def test_record_affinity_binding_rejects_non_positive_maximum_entries() -> None:
-    store = runner.AffinityStore()
-    with pytest.raises(ValueError, match="maximum_entries must be at least 1"):
-        record_affinity_binding(
-            store,
-            session_id=_BOUND_SESSION_ID,
-            command=_PRIMARY_LAUNCHER,
-            maximum_entries=0,
-        )
-
-
-def test_affinity_write_failure_raises_actionable_diagnostic(
-    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    state_path = tmp_path / AFFINITY_STATE_FILENAME
-    store = record_affinity_binding(
-        runner.AffinityStore(),
-        session_id=_BOUND_SESSION_ID,
-        command=_PRIMARY_LAUNCHER,
-    )
-
-    def _raise_replace(_source: object, _destination: object) -> None:
-        raise OSError("disk full")
-
-    monkeypatch.setattr(runner.os, "replace", _raise_replace)
-    with pytest.raises(OSError, match="Failed to write affinity state") as raised:
-        save_affinity_store_atomic(state_path, store)
-    assert str(state_path) in str(raised.value)
-
-
-def test_extract_resume_session_id_reads_flag() -> None:
-    assert extract_resume_session_id(
-        [RESUME_SESSION_FLAG, _BOUND_SESSION_ID, "-p", "hi"]
-    ) == _BOUND_SESSION_ID
-    assert extract_resume_session_id(["-p", "hi"]) is None
-    assert extract_resume_session_id([RESUME_SESSION_FLAG]) is None
-
-
-def test_order_entries_for_resume_puts_originating_binary_first() -> None:
-    all_entries = [
-        ChainEntry(command=_PRIMARY_LAUNCHER, extra_args=()),
-        ChainEntry(command=_SECONDARY_LAUNCHER, extra_args=()),
-    ]
-    ordered = order_entries_for_resume(
-        all_entries, preferred_command=_SECONDARY_LAUNCHER
-    )
-    assert [each.command for each in ordered] == [
-        _SECONDARY_LAUNCHER,
-        _PRIMARY_LAUNCHER,
-    ]
-
-
-def test_order_entries_for_resume_falls_back_when_command_missing() -> None:
-    all_entries = [
-        ChainEntry(command=_PRIMARY_LAUNCHER, extra_args=()),
-        ChainEntry(command=_SECONDARY_LAUNCHER, extra_args=()),
-    ]
-    ordered = order_entries_for_resume(
-        all_entries, preferred_command="missing-binary"
-    )
-    assert [each.command for each in ordered] == [
-        _PRIMARY_LAUNCHER,
-        _SECONDARY_LAUNCHER,
-    ]
-    ordered_none = order_entries_for_resume(all_entries, preferred_command=None)
-    assert [each.command for each in ordered_none] == [
-        _PRIMARY_LAUNCHER,
-        _SECONDARY_LAUNCHER,
-    ]
-
-
-def test_lookup_affinity_command_returns_bound_binary() -> None:
-    store = record_affinity_binding(
-        runner.AffinityStore(),
-        session_id=_BOUND_SESSION_ID,
-        command=_SECONDARY_LAUNCHER,
-    )
-    assert lookup_affinity_command(store, _BOUND_SESSION_ID) == _SECONDARY_LAUNCHER
-    assert lookup_affinity_command(store, "unknown") is None
-
-
-def test_run_claude_resume_routes_through_originating_binary(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(
-        tmp_path, [_entry(_PRIMARY_LAUNCHER), _entry(_SECONDARY_LAUNCHER)]
-    )
-    affinity_path = tmp_path / "claude-chain-affinity.json"
-    store = record_affinity_binding(
-        runner.AffinityStore(),
-        session_id=_BOUND_SESSION_ID,
-        command=_SECONDARY_LAUNCHER,
-    )
-    save_affinity_store_atomic(affinity_path, store)
-
-    monkeypatch.setattr(runner, "chain_config_path", lambda: config_file)
-    monkeypatch.setattr(
-        runner,
-        "default_affinity_state_path",
-        lambda _home: affinity_path,
-    )
-    monkeypatch.setattr(
-        runner,
-        "chain_weekly_usage_reporter",
-        _usage_reporter_from_remaining(
-            {
-                _PRIMARY_LAUNCHER: _HIGH_WEEKLY_REMAINING_PERCENT,
-                _SECONDARY_LAUNCHER: _LOW_WEEKLY_REMAINING_PERCENT,
-            }
-        ),
-    )
-    all_called: list[str] = []
-
-    def _runner(command, **_kwargs):
-        all_called.append(command[0])
-        return _completed(command[0], 0, stdout=_JSON_BIND_STDOUT_WITH_SESSION)
-
-    monkeypatch.setattr(runner, "chain_subprocess_runner", _runner)
-    outcome = runner.run_claude(
-        [RESUME_SESSION_FLAG, _BOUND_SESSION_ID, "-p", "hi"],
-        timeout_seconds=DEFAULT_TIMEOUT_SECONDS,
-    )
-    assert outcome.served_command == _SECONDARY_LAUNCHER
-    assert all_called[0] == _SECONDARY_LAUNCHER
-
-
-def test_run_claude_success_persists_session_affinity(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(
-        tmp_path, [_entry(_PRIMARY_LAUNCHER), _entry(_SECONDARY_LAUNCHER)]
-    )
-    _install(
-        monkeypatch,
-        config_file,
-        {
-            _PRIMARY_LAUNCHER: _completed(
-                _PRIMARY_LAUNCHER, 0, stdout=_JSON_BIND_STDOUT_WITH_SESSION
-            ),
-            _SECONDARY_LAUNCHER: _completed(_SECONDARY_LAUNCHER, 0),
-        },
-    )
-    chain_result = runner.run_claude(
-        _PROMPT_ARGUMENTS,
-        timeout_seconds=DEFAULT_TIMEOUT_SECONDS,
-        routing_mode=ROUTING_MODE_ORDERED_ACCOUNT,
-    )
-    assert chain_result.served_command == _PRIMARY_LAUNCHER
-    assert chain_result.session_id == _BOUND_SESSION_ID
-    affinity_path = Path(config_file).parent / AFFINITY_STATE_FILENAME
-    reloaded = load_affinity_store(affinity_path)
-    assert len(reloaded.all_bindings) == 1
-    assert reloaded.all_bindings[0].session_id == _BOUND_SESSION_ID
-    assert reloaded.all_bindings[0].command == _PRIMARY_LAUNCHER
-
-
-def test_run_claude_resume_falls_back_when_affinity_corrupt(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    config_file = _write_chain_config(
-        tmp_path, [_entry(_PRIMARY_LAUNCHER), _entry(_SECONDARY_LAUNCHER)]
-    )
-    affinity_path = Path(config_file).parent / AFFINITY_STATE_FILENAME
-    affinity_path.write_text("{not-json", encoding=UTF8_ENCODING)
-    usage_reporter = _usage_reporter_from_remaining(
-        {
-            _PRIMARY_LAUNCHER: _HIGH_WEEKLY_REMAINING_PERCENT,
-            _SECONDARY_LAUNCHER: _LOW_WEEKLY_REMAINING_PERCENT,
-        }
-    )
-    all_called: list[str] = []
-
-    def _runner(command, **_kwargs):
-        all_called.append(command[0])
-        return _completed(command[0], 0, stdout=_JSON_BIND_STDOUT_WITH_SESSION)
-
-    monkeypatch.setattr(runner, "chain_config_path", lambda: config_file)
-    monkeypatch.setattr(
-        runner,
-        "default_affinity_state_path",
-        lambda _home, _affinity_path=affinity_path: _affinity_path,
-    )
-    monkeypatch.setattr(runner, "chain_weekly_usage_reporter", usage_reporter)
-    monkeypatch.setattr(runner, "chain_subprocess_runner", _runner)
-    outcome = runner.run_claude(
-        [RESUME_SESSION_FLAG, _BOUND_SESSION_ID, "-p", "hi"],
-        timeout_seconds=DEFAULT_TIMEOUT_SECONDS,
-    )
-    assert outcome.served_command == _PRIMARY_LAUNCHER
-    assert all_called[0] == _PRIMARY_LAUNCHER