claude-dev-env 8.45.0 → 8.46.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "8.45.0",
+    "version": "8.46.0",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {

package/scripts/account_broker.py

@@ -14,6 +14,7 @@ from pathlib import Path
 from typing import Mapping, Sequence
 
 import account_broker_support as support
+import codex_account_meters
 from account_broker_support import (
     all_product_adapters,
     Account,
@@ -310,11 +311,14 @@ def run_job(
 def _parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(description=__doc__)
     commands = parser.add_subparsers(dest="action", required=True)
-    for each_action in ("choose", "check", "accounts", "run"):
+    for each_action in ("choose", "check", "accounts", "limits", "run"):
         command = commands.add_parser(each_action)
         command.add_argument("--product", choices=[each_product.value for each_product in Product], required=True)
         if each_action == "choose":
             command.add_argument("--spent", action="append", default=[])
+        if each_action == "limits":
+            command.add_argument("--home", type=Path, required=True)
+            command.add_argument("--codex", type=Path)
         if each_action == "run":
             command.add_argument("--report", type=Path, required=True)
             command.add_argument("command", nargs=argparse.REMAINDER)
@@ -344,6 +348,19 @@ def _accounts_cli(product: Product) -> int:
     return 0
 
 
+def _limits_cli(product: Product, parsed: argparse.Namespace) -> int:
+    if product is not Product.CODEX:
+        raise BrokerConfigurationError("limits reads Codex accounts only")
+    try:
+        rate_limit_records = codex_account_meters.read_rate_limit_records(
+            codex_account_meters.resolve_codex_path(parsed.codex), parsed.home
+        )
+    except (codex_account_meters.CodexMeterUnreadError, OSError) as error:
+        raise BrokerConfigurationError(str(error)) from error
+    print(json.dumps({"home": str(parsed.home), "rate_limits": rate_limit_records}))
+    return 0
+
+
 def _run_cli(product: Product, parsed: argparse.Namespace, parser: argparse.ArgumentParser) -> int:
     command = list(parsed.command)
     if command and command[0] == "--":
@@ -387,6 +404,8 @@ def main(all_arguments: Sequence[str]) -> int:
     try:
         if parsed.action == "accounts":
             return _accounts_cli(product)
+        if parsed.action == "limits":
+            return _limits_cli(product, parsed)
         if parsed.action == "run":
             return _run_cli(product, parsed, parser)
         return _choose_cli(product, parsed)

package/scripts/claude_account_worker_process.py

@@ -1,4 +1,4 @@
-"""Run a headless Claude worker through the account broker."""
+"""Time one broker job for the headless Claude worker."""
 
 from __future__ import annotations
 

package/scripts/claude_account_worker_report.py

@@ -57,6 +57,7 @@ def wait_report(account: str, reason: str, wait_reset_at: datetime | None) -> Wo
     Args:
         account: The chosen account slot.
         reason: Why the broker returned a wait decision.
+        wait_reset_at: The soonest account reset, or None when unknown.
 
     Returns:
         A report carrying the wait exit code and no payload.
@@ -111,7 +112,7 @@ def pre_launch_failure_report(
 
     Args:
         account: The chosen account slot.
-        reason: Why the picker chose that account.
+        reason: Why the worker stopped before launch.
         exit_code: The failure's exit code.
 
     Returns:

package/scripts/codex_account_meters.py

@@ -161,7 +161,7 @@ def _parse_window(raw_window: object) -> UsageWindow | None:
     )
 
 
-def _rate_limits_mapping(reply_text: str) -> Mapping[str, object]:
+def _reply_body(reply_text: str) -> Mapping[str, object]:
     try:
         reply = json.loads(reply_text)
     except json.JSONDecodeError as error:
@@ -171,7 +171,13 @@ def _rate_limits_mapping(reply_text: str) -> Mapping[str, object]:
     if reply.get("error") is not None:
         raise CodexMeterUnreadError(f"rate-limit read failed: {reply['error']}")
     body = reply.get("result")
-    rate_limits = body.get("rateLimits") if isinstance(body, dict) else None
+    if not isinstance(body, dict):
+        raise CodexMeterUnreadError("rate-limit reply has no result")
+    return body
+
+
+def _rate_limits_mapping(reply_text: str) -> Mapping[str, object]:
+    rate_limits = _reply_body(reply_text).get("rateLimits")
     if not isinstance(rate_limits, dict):
         raise CodexMeterUnreadError("rate-limit reply names no rateLimits")
     return rate_limits
@@ -338,13 +344,45 @@ def read_codex_meters(
     Raises:
         CodexMeterUnreadError: The server failed, timed out, or sent no usable reply.
     """
+    return parse_rate_limits_reply(_rate_limits_reply_line(codex_path, codex_home, exchange))
+
+
+def read_rate_limit_records(
+    codex_path: Path,
+    codex_home: Path,
+    exchange: ServerExchange = exchange_with_app_server,
+) -> Mapping[str, object]:
+    """Read one account's whole rate-limit reply through the app server.
+
+    ::
+
+        {"id": 2, "result": {"rateLimits": {...}, "rateLimitsByLimitId": {...}}}
+        -> {"rateLimits": {...}, "rateLimitsByLimitId": {...}}
+
+    Args:
+        codex_path: The Codex executable.
+        codex_home: The account's Codex home.
+        exchange: Sends messages and returns output lines; tests pass a fake.
+
+    Returns:
+        The reply's ``result`` object, with every limit record it carries.
+
+    Raises:
+        CodexMeterUnreadError: The server failed, timed out, or sent no usable reply.
+    """
+    return _reply_body(_rate_limits_reply_line(codex_path, codex_home, exchange))
+
+
+def _rate_limits_reply_line(
+    codex_path: Path, codex_home: Path, exchange: ServerExchange
+) -> str:
     try:
         all_lines = exchange(codex_path, codex_home, request_messages())
     except (OSError, subprocess.SubprocessError, UnicodeDecodeError) as error:
         raise CodexMeterUnreadError(f"codex app-server failed: {error}") from error
     for each_line in all_lines:
         if _is_rate_limits_reply(each_line):
-            return parse_rate_limits_reply(each_line)
+            return each_line
     raise CodexMeterUnreadError("codex app-server sent no rate-limit reply")
 
 

package/scripts/dev_env_scripts_constants/claude_account_worker_constants.py

@@ -11,10 +11,6 @@ DEFAULT_TIMEOUT_MINUTES: int = 60
 
 MINIMUM_TIMEOUT_MINUTES: int = 1
 
-TIMEOUT_EXIT_CODE: int = 124
-
-MISSING_BINARY_EXIT_CODE: int = 127
-
 LAUNCH_FAILURE_EXIT_CODE: int = 1
 
 CONFIGURATION_FAILURE_EXIT_CODE: int = 2
@@ -23,18 +19,12 @@ WAIT_DURATION_SECONDS: float = 0.0
 
 STDOUT_TAIL_CHARACTER_LIMIT: int = 4000
 
-DRAIN_GRACE_TIMEOUT_SECONDS: int = 10
-
-DRAIN_ATTEMPT_LIMIT: int = 2
-
 DURATION_DECIMAL_PLACES: int = 3
 
 REPORT_INDENT: int = 2
 
 UTF8_ENCODING: str = "utf-8"
 
-UTF8_DECODE_ERRORS: str = "replace"
-
 CLI_DESCRIPTION: str = "Run one Claude worker through the account broker."
 
 PROMPT_FILE_FLAG: str = "--prompt-file"
@@ -85,8 +75,6 @@ __all__ = [
     "CWD_FLAG",
     "DEFAULT_PERMISSION_MODE",
     "DEFAULT_TIMEOUT_MINUTES",
-    "DRAIN_ATTEMPT_LIMIT",
-    "DRAIN_GRACE_TIMEOUT_SECONDS",
     "DURATION_DECIMAL_PLACES",
     "INVALID_TIMEOUT_MESSAGE",
     "JSON_ACCOUNT_KEY",
@@ -94,7 +82,6 @@ __all__ = [
     "JSON_REASON_KEY",
     "JSON_RESULT_KEY",
     "LAUNCH_FAILURE_EXIT_CODE",
-    "MISSING_BINARY_EXIT_CODE",
     "MINIMUM_TIMEOUT_MINUTES",
     "MODEL_FLAG",
     "OUTPUT_FORMAT_FLAG",
@@ -113,9 +100,7 @@ __all__ = [
     "SINGLE_PROMPT_FLAG",
     "STDOUT_TAIL_CHARACTER_LIMIT",
     "SUMMARY_LINE_TEMPLATE",
-    "TIMEOUT_EXIT_CODE",
     "TIMEOUT_MINUTES_FLAG",
-    "UTF8_DECODE_ERRORS",
     "UTF8_ENCODING",
     "WAIT_DURATION_SECONDS",
     "WAIT_EXIT_CODE",

package/scripts/dev_env_scripts_constants/claude_chain_constants.py

@@ -1,93 +1,7 @@
-"""Named constants for the claude fallback-chain runner, and the helper that
-picks which text-codec kwargs a chain subprocess wrapper forwards.
-
-Per the project's configuration conventions, every scalar and structural
-constant the runner needs lives here rather than inline in the module.
-"""
+"""Named constants the account broker and the code review CLI share for Claude runs."""
 
 from __future__ import annotations
 
-from collections.abc import Mapping
-
-UTF8_ENCODING: str = "utf-8"
-"""Encoding used to read the chain configuration file."""
-
-CODEC_ERROR_STRATEGY: str = "replace"
-"""Codec error handler that maps any unencodable or undecodable value to a marker."""
-
-CRLF_NEWLINE: str = "\r\n"
-"""Windows-style newline sequence normalized away when decoding spool captures."""
-
-CARRIAGE_RETURN: str = "\r"
-"""Bare carriage return normalized to LF when decoding spool captures."""
-
-LINE_FEED: str = "\n"
-"""Unix-style newline retained after universal-newline normalization."""
-
-SUBPROCESS_ENCODING_KEYWORD: str = "encoding"
-"""Keyword name for text encoding when forwarding chain subprocess runner kwargs."""
-
-SUBPROCESS_ERRORS_KEYWORD: str = "errors"
-"""Keyword name for text decode error policy when forwarding chain subprocess runner kwargs."""
-
-ALL_SUBPROCESS_TEXT_CODEC_KEYWORDS: tuple[str, ...] = (
-    SUBPROCESS_ENCODING_KEYWORD,
-    SUBPROCESS_ERRORS_KEYWORD,
-)
-"""Keyword names to forward from the chain runner for text-mode subprocess capture."""
-
-
-def collect_forwarded_text_codec(
-    all_keywords: Mapping[str, object],
-) -> dict[str, object]:
-    """Return only the text-codec kwargs present in ``all_keywords``.
-
-    ::
-
-        collect_forwarded_text_codec({"encoding": "utf-8", "timeout": 30})
-        # -> {"encoding": "utf-8"}
-
-        collect_forwarded_text_codec({"timeout": 30})
-        # -> {}
-
-    Args:
-        all_keywords: Keyword arguments received by a chain subprocess wrapper.
-
-    Returns:
-        Mapping of codec keyword names to their values, limited to keys listed
-        in ``ALL_SUBPROCESS_TEXT_CODEC_KEYWORDS`` that are present in the input.
-    """
-    return {
-        each_key: all_keywords[each_key]
-        for each_key in ALL_SUBPROCESS_TEXT_CODEC_KEYWORDS
-        if each_key in all_keywords
-    }
-
-
-CLAUDE_HOME_SUBDIRECTORY: str = ".claude"
-"""Per-user directory under the home directory that holds the chain config."""
-
-CONFIG_FILENAME: str = "claude-chain.json"
-"""Real chain-configuration filename read from the user's home directory."""
-
-CHAIN_USAGE_MODULE_NAME: str = "claude_chain_usage"
-"""Import name of the weekly-usage report module loaded lazily by the runner."""
-
-EXAMPLE_CONFIG_FILENAME: str = "claude-chain.example.json"
-"""Committed template filename referenced in the config-error guidance."""
-
-CONFIG_CHAIN_KEY: str = "chain"
-"""Top-level key whose value is the ordered list of chain entries."""
-
-CONFIG_COMMAND_KEY: str = "command"
-"""Chain-entry key naming the binary to spawn."""
-
-CONFIG_EXTRA_ARGS_KEY: str = "extra_args"
-"""Chain-entry key holding per-account arguments appended to each invocation."""
-
-CONFIG_CREDENTIALS_PATH_KEY: str = "credentials_path"
-"""Optional chain-entry key naming that account's OAuth credentials file path."""
-
 ALL_USAGE_LIMIT_SIGNATURES: tuple[str, ...] = (
     "hit your session limit",
     "usage limit reached",
@@ -96,208 +10,5 @@ ALL_USAGE_LIMIT_SIGNATURES: tuple[str, ...] = (
 )
 """Case-insensitive substrings that mark a non-zero exit as a usage-limit refusal."""
 
-ATTEMPT_STATUS_SERVED: str = "served"
-"""Status recorded when a binary exits zero and serves the call."""
-
-ATTEMPT_STATUS_USAGE_LIMITED: str = "usage_limited"
-"""Status recorded when a binary fails with a usage-limit signature."""
-
-ATTEMPT_STATUS_EXECUTABLE_NOT_FOUND: str = "executable_not_found"
-"""Status recorded when a binary is not installed."""
-
-ATTEMPT_STATUS_NONZERO_EXIT: str = "nonzero_exit"
-"""Status recorded when a binary fails without a usage-limit signature."""
-
-ATTEMPT_STATUS_TIMEOUT: str = "timeout"
-"""Status recorded when a binary exceeds the invocation timeout."""
-
-DEFAULT_TIMEOUT_SECONDS: int = 300
-"""Timeout applied to each binary invocation when the caller names none."""
-
-NO_COMPLETED_PROCESS_RETURN_CODE: int = 1
-"""Return code carried on the result when no binary produced a completed process."""
-
-CHAIN_EXHAUSTED_EXIT_CODE: int = 2
-"""CLI exit code when no binary in the chain served the call."""
-
 CHAIN_CONFIG_ERROR_EXIT_CODE: int = 3
 """CLI exit code when the chain configuration is missing or invalid."""
-
-CLI_TIMEOUT_FLAG: str = "--timeout-seconds"
-"""CLI flag that overrides the per-invocation timeout in seconds."""
-
-CLI_ROUTING_MODE_FLAG: str = "--routing-mode"
-"""CLI flag that selects usage-ranked or ordered-account chain routing."""
-
-CLI_ARGUMENTS_SEPARATOR: str = "--"
-"""CLI token separating runner flags from the passthrough claude arguments."""
-
-ROUTING_MODE_USAGE_RANKED: str = "usage_ranked"
-"""Default routing: probe weekly remaining and try highest remaining first."""
-
-ROUTING_MODE_ORDERED_ACCOUNT: str = "ordered_account"
-"""Explicit routing: walk chain entries in config order; usage-limit-only fallover."""
-
-DEFAULT_ROUTING_MODE: str = ROUTING_MODE_USAGE_RANKED
-"""Routing mode applied when the caller does not name one."""
-
-ALL_ROUTING_MODES: frozenset[str] = frozenset(
-    {
-        ROUTING_MODE_USAGE_RANKED,
-        ROUTING_MODE_ORDERED_ACCOUNT,
-    }
-)
-"""Accepted values for the routing-mode parameter and CLI flag."""
-
-TERMINAL_STATUS_SERVED: str = "served"
-"""Outcome status when a binary served the call (zero or non-usage nonzero)."""
-
-TERMINAL_STATUS_ADVISOR_BLOCKED: str = "advisor_blocked"
-"""Outcome status when ordered-account mode stops on a non-usage failure."""
-
-TERMINAL_STATUS_CHAIN_EXHAUSTED: str = "chain_exhausted"
-"""Outcome status when every chain entry was usage-limited or missing."""
-
-TERMINAL_STATUS_TIMEOUT: str = "timeout"
-"""Outcome status when a usage-ranked walk stops on TimeoutExpired mid-walk."""
-
-SESSION_ID_JSON_KEY: str = "session_id"
-"""JSON key read from Claude ``--output-format json`` events for resume."""
-
-CHAIN_ADVISOR_BLOCKED_EXIT_CODE: int = 4
-"""CLI exit code when ordered-account mode stops with advisor_blocked."""
-
-CONFIG_NOT_OBJECT_REASON: str = "the top-level value is not a JSON object"
-"""Reason detail when the config root is not an object."""
-
-CONFIG_CHAIN_NOT_LIST_REASON: str = "the 'chain' key is missing or not a list"
-"""Reason detail when the chain key is absent or the wrong type."""
-
-CONFIG_CHAIN_EMPTY_REASON: str = "the 'chain' list is empty"
-"""Reason detail when the chain contains no entries."""
-
-CONFIG_ENTRY_NOT_OBJECT_REASON: str = "a chain entry is not a JSON object"
-"""Reason detail when a chain entry is not an object."""
-
-CONFIG_ENTRY_COMMAND_MISSING_REASON: str = "a chain entry has no string 'command'"
-"""Reason detail when a chain entry lacks a usable command."""
-
-CONFIG_ENTRY_EXTRA_ARGS_INVALID_REASON: str = (
-    "a chain entry's 'extra_args' is not a list of strings"
-)
-"""Reason detail when a chain entry's extra_args value is the wrong shape."""
-
-CONFIG_ENTRY_CREDENTIALS_PATH_INVALID_REASON: str = (
-    "a chain entry's 'credentials_path' is not a non-empty string"
-)
-"""Reason detail when a chain entry's credentials_path value is the wrong shape."""
-
-CONFIG_MISSING_MESSAGE_TEMPLATE: str = (
-    "Claude chain config not found at {config_path}. Copy {example_filename} to "
-    "{config_path} and list your account binaries. Try order comes from weekly "
-    "remaining; config order is the tiebreak."
-)
-"""Guidance shown when the config file is absent."""
-
-CONFIG_UNREADABLE_MESSAGE_TEMPLATE: str = (
-    "Cannot read claude chain config at {config_path}: {error}. "
-    "See {example_filename} for the expected shape."
-)
-"""Guidance shown when the config file cannot be read."""
-
-CONFIG_MALFORMED_MESSAGE_TEMPLATE: str = (
-    "Malformed JSON in claude chain config at {config_path}: {error}. "
-    "See {example_filename} for the expected shape."
-)
-"""Guidance shown when the config file is not valid JSON."""
-
-CONFIG_INVALID_SHAPE_MESSAGE_TEMPLATE: str = (
-    "Invalid claude chain config at {config_path}: {reason}. "
-    "See {example_filename} for the expected shape."
-)
-"""Guidance shown when the config JSON does not match the expected shape."""
-
-CHAIN_EXHAUSTED_MESSAGE_TEMPLATE: str = (
-    "No claude binary in the chain served the call. Attempts: {attempt_summary}"
-)
-"""CLI stderr message when the walk ends without a serving binary."""
-
-ATTEMPT_SUMMARY_ENTRY_TEMPLATE: str = "{command}={status}"
-"""Per-attempt fragment used to build the exhausted-chain summary."""
-
-ATTEMPT_SUMMARY_JOIN_SEPARATOR: str = ", "
-"""Separator joining per-attempt fragments in the exhausted-chain summary."""
-
-AFFINITY_STATE_SCHEMA_VERSION: int = 1
-"""Version field written into the session-to-binary affinity state document."""
-
-AFFINITY_STATE_FILENAME: str = "claude-chain-affinity.json"
-"""Default affinity state file name under the Claude home directory."""
-
-AFFINITY_MAXIMUM_ENTRIES: int = 64
-"""Hard cap on retained session-to-binary affinity rows (oldest drop first)."""
-
-AFFINITY_KEY_SCHEMA_VERSION: str = "schema_version"
-"""JSON key for the affinity document schema version."""
-
-AFFINITY_KEY_ALL_BINDINGS: str = "all_bindings"
-"""JSON key for the ordered list of session-to-command bindings."""
-
-AFFINITY_KEY_SESSION_ID: str = "session_id"
-"""JSON key for a bound Claude session id."""
-
-AFFINITY_KEY_COMMAND: str = "command"
-"""JSON key for the chain binary command bound to a session id."""
-
-AFFINITY_TEMP_SUFFIX: str = ".tmp"
-"""Suffix for the temporary file used during atomic affinity replacement."""
-
-AFFINITY_BINDING_NOT_OBJECT_REASON: str = "a binding entry is not an object"
-"""Reason when an affinity binding entry is not a JSON object."""
-
-AFFINITY_BINDING_SESSION_ID_MISSING_REASON: str = (
-    "binding missing non-empty session_id"
-)
-"""Reason when an affinity binding lacks a usable session_id."""
-
-AFFINITY_BINDING_COMMAND_MISSING_REASON: str = "binding missing non-empty command"
-"""Reason when an affinity binding lacks a usable command."""
-
-AFFINITY_UNSUPPORTED_SCHEMA_VERSION_REASON_TEMPLATE: str = (
-    "unsupported schema_version {schema_version!r}"
-)
-"""Reason when the affinity document schema version is not supported."""
-
-AFFINITY_BINDINGS_MISSING_OR_NOT_LIST_REASON: str = (
-    "all_bindings is missing or not a list"
-)
-"""Reason when all_bindings is absent or the wrong type."""
-
-AFFINITY_TOP_LEVEL_NOT_OBJECT_REASON: str = "top-level value is not a JSON object"
-"""Reason when the affinity document root is not an object."""
-
-AFFINITY_SESSION_ID_AND_COMMAND_REQUIRED_MESSAGE: str = (
-    "session_id and command must be non-empty"
-)
-"""ValueError message when record_affinity_binding receives empty ids."""
-
-AFFINITY_MAXIMUM_ENTRIES_MINIMUM_MESSAGE: str = "maximum_entries must be at least 1"
-"""ValueError message when maximum_entries is below one."""
-
-AFFINITY_CORRUPT_MESSAGE_TEMPLATE: str = (
-    "Affinity state at {state_path} is corrupt or unreadable: {error}. "
-    "Delete or repair the file before retrying."
-)
-"""Actionable diagnostic when affinity state cannot be loaded."""
-
-AFFINITY_WRITE_FAILED_MESSAGE_TEMPLATE: str = (
-    "Failed to write affinity state at {state_path}: {error}. "
-    "Check directory permissions and free space."
-)
-"""Actionable diagnostic when atomic affinity replacement fails."""
-
-AFFINITY_JSON_INDENT_SPACES: int = 2
-"""Indent width for the written affinity state JSON document."""
-
-RESUME_SESSION_FLAG: str = "--resume"
-"""Claude CLI flag that continues a prior session by id."""

package/scripts/test_account_broker.py

@@ -663,3 +663,41 @@ def test_should_run_job_through_override(
     assert outcome.status == "served"
     assert outcome.attempts == (("only", "served"),)
     assert calls == [b"input"]
+
+
+
+def test_should_print_the_whole_rate_limit_result_for_one_home(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
+) -> None:
+    rate_limit_records = {"rateLimitsByLimitId": {"codex": {"primary": {"usedPercent": 20}}}}
+    observed: list[tuple[Path, Path]] = []
+
+    def read_result(codex_path: Path, codex_home: Path) -> dict[str, object]:
+        observed.append((codex_path, codex_home))
+        return rate_limit_records
+
+    monkeypatch.setattr(account_broker.codex_account_meters, "read_rate_limit_records", read_result)
+    home = tmp_path / "codex-2"
+
+    assert account_broker.main(("limits", "--product", "codex", "--home", str(home), "--codex", "codex-bin")) == 0
+    assert json.loads(capsys.readouterr().out) == {"home": str(home), "rate_limits": rate_limit_records}
+    assert observed == [(Path("codex-bin"), home)]
+
+
+def test_should_exit_two_when_the_limits_read_fails(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
+) -> None:
+    def read_result(_codex_path: Path, _codex_home: Path) -> dict[str, object]:
+        raise account_broker.codex_account_meters.CodexMeterUnreadError("codex app-server sent no rate-limit reply")
+
+    monkeypatch.setattr(account_broker.codex_account_meters, "read_rate_limit_records", read_result)
+
+    assert account_broker.main(("limits", "--product", "codex", "--home", str(tmp_path), "--codex", "codex-bin")) == 2
+    captured = capsys.readouterr()
+    assert captured.out == ""
+    assert "no rate-limit reply" in captured.err
+
+
+def test_should_refuse_limits_for_claude(tmp_path: Path, capsys: pytest.CaptureFixture[str]) -> None:
+    assert account_broker.main(("limits", "--product", "claude", "--home", str(tmp_path))) == 2
+    assert "Codex accounts only" in capsys.readouterr().err

package/scripts/test_codex_account_meters.py

@@ -15,6 +15,7 @@ from codex_account_meters import (
     exchange_with_app_server,
     parse_rate_limits_reply,
     read_codex_meters,
+    read_rate_limit_records,
     request_messages,
     resolve_codex_path,
 )
@@ -163,6 +164,38 @@ class TestReadCodexMeters:
             read_codex_meters(Path("codex"), Path("/h"), broken_exchange)
 
 
+
+class TestReadRateLimitRecords:
+    def should_return_every_limit_record_the_reply_carries(self) -> None:
+        rate_limit_records = {
+            "rateLimits": {"limitId": "codex", "primary": {"usedPercent": 20}},
+            "rateLimitsByLimitId": {
+                "codex": {"limitId": "codex", "planType": "pro"},
+                "codex_other": {"limitId": "codex_other"},
+            },
+        }
+
+        assert (
+            read_rate_limit_records(
+                Path("codex"),
+                Path("/h"),
+                lambda *_: [json.dumps({"id": 1}), json.dumps({"id": 2, "result": rate_limit_records})],
+            )
+            == rate_limit_records
+        )
+
+    def should_raise_unread_on_an_error_reply(self) -> None:
+        with pytest.raises(CodexMeterUnreadError, match="read failed"):
+            read_rate_limit_records(
+                Path("codex"),
+                Path("/h"),
+                lambda *_: [json.dumps({"id": 2, "error": {"code": 1}})],
+            )
+
+    def should_raise_unread_when_the_server_never_answers(self) -> None:
+        with pytest.raises(CodexMeterUnreadError, match="no rate-limit reply"):
+            read_rate_limit_records(Path("codex"), Path("/h"), lambda *_: [])
+
 FAKE_APP_SERVER = """#!/usr/bin/env python3
 import json, os, sys
 for line in sys.stdin: