claude-dev-env 8.78.3 → 8.80.0

package/scripts/dev_env_scripts_constants/codex_account_constants.py

@@ -174,26 +174,8 @@ EXIT_CODE_ROOM: int = 0
 EXIT_CODE_NO_ROOM: int = 3
 """Check answer: the account is at or below the floor, or its meter is unread."""
 
-REASON_NORMAL_TEMPLATE: str = "{account} has {percent_left:.0f}% left"
-"""Reason when an account takes the job at its normal model."""
-
-REASON_LUNA_TEMPLATE: str = (
-    "every account is at or under {bar:.0f}% left; {account} has"
-    " {percent_left:.0f}% and runs Luna until {stop:.0f}%"
-)
-"""Reason when the job falls back to Luna."""
-
-REASON_WAIT_TEMPLATE: str = "no account has room; {account} resets first, at {reset}"
-"""Reason when every account is out of room."""
-
-REASON_WAIT_UNREAD: str = "no account meter could be read"
-"""Reason when no account's meter reads at all."""
-
 UNREAD_NOT_SIGNED_IN: str = "not signed in"
 """Unread reason when the account's Codex home holds no sign-in."""
 
-UNKNOWN_RESET_TEXT: str = "an unknown time"
-"""Reset text when no blocking window carries a reset time."""
-
 TEXT_ENCODING: str = "utf-8"
 """Encoding for the server pipes and the JSON reports."""

package/scripts/dev_env_scripts_constants/test_account_broker_constants.py

@@ -5,11 +5,11 @@ from __future__ import annotations
 import dataclasses
 import importlib
 import importlib.util
-import os
 import shutil
 import sys
 import types
 from datetime import datetime, timedelta, timezone
+from collections.abc import Callable
 from pathlib import Path
 
 import pytest
@@ -21,7 +21,9 @@ from dev_env_scripts_constants.account_broker_constants import (
     ALL_CODEX_FLOORS,
     ALL_PARENT_CLAUDE_SESSION_VARIABLES,
     CMD_SHELL_METACHARACTERS,
+    Account,
     JobOutcome,
+    Product,
 )
 from dev_env_scripts_constants.claude_account_constants import (
     MAIN_SESSION_USED_CEILING_PERCENT,
@@ -113,16 +115,9 @@ def test_parse_utc_time_converts_an_offset_timestamp() -> None:
     assert parsed.isoformat() == "2026-10-03T11:30:00+00:00"
 
 
-def _create_directory_link(*, from_link: Path, to_target: Path) -> None:
-    if sys.platform.startswith("win32"):
-        importlib.import_module("_winapi").CreateJunction(
-            str(to_target), str(from_link)
-        )
-        return
-    os.symlink(to_target, from_link, target_is_directory=True)
-
-
-def _build_install_layout(home: Path) -> tuple[Path, Path]:
+def _build_install_layout(
+    home: Path, create_directory_link: Callable[..., None]
+) -> tuple[Path, Path]:
     agents_constants_directory = (
         home / ".agents" / "scripts" / "dev_env_scripts_constants"
     )
@@ -143,7 +138,7 @@ def _build_install_layout(home: Path) -> tuple[Path, Path]:
     (classifier_directory / "classifier_constants.py").write_text(
         f"ALL_USAGE_LIMIT_MARKERS = ({TEMP_TREE_MARKER!r},)\n", encoding="utf-8"
     )
-    _create_directory_link(
+    create_directory_link(
         from_link=home / ".claude" / "scripts", to_target=home / ".agents" / "scripts"
     )
     linked_module = (
@@ -170,10 +165,10 @@ def _load_module_from(
 
 @pytest.mark.parametrize("entry_point", ("through_scripts_link", "through_agents_path"))
 def test_codex_usage_limit_signatures_finds_shared_tree_beside_the_scripts_link(
-    entry_point: str, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    entry_point: str, tmp_path: Path, create_directory_link: Callable[..., None], monkeypatch: pytest.MonkeyPatch
 ) -> None:
     monkeypatch.delenv("CLAUDE_CONFIG_DIR", raising=False)
-    linked_module, agents_module = _build_install_layout(tmp_path / "home")
+    linked_module, agents_module = _build_install_layout(tmp_path / "home", create_directory_link)
     module_file = (
         linked_module if entry_point == "through_scripts_link" else agents_module
     )
@@ -188,3 +183,51 @@ def test_parent_session_variables_name_the_session_link_and_leave_the_account_ho
     assert "CLAUDE_CODE_SESSION_ID" in ALL_PARENT_CLAUDE_SESSION_VARIABLES
     assert "CLAUDECODE" in ALL_PARENT_CLAUDE_SESSION_VARIABLES
     assert "CLAUDE_CONFIG_DIR" not in ALL_PARENT_CLAUDE_SESSION_VARIABLES
+
+
+def test_should_treat_accounts_that_differ_only_in_profile_as_one_account() -> None:
+    home = Path("/profiles/first")
+
+    assert Account(Product.CLAUDE, "first", home, profile="first") == Account(Product.CLAUDE, "first", home)
+
+
+def _codex_reading(meters: broker_constants.Meters) -> broker_constants.Reading:
+    return broker_constants.Reading(Account(Product.CODEX, "codex-1", Path("/profiles/codex-1")), meters)
+
+
+def test_should_let_a_codex_account_at_the_short_window_floor_take_luna() -> None:
+    weekly_reset = datetime(2026, 10, 4, tzinfo=timezone.utc)
+    session_reset = weekly_reset + timedelta(hours=4)
+    meters = broker_constants.Meters(
+        LUNA_TIER_SHORT_WINDOW_MINIMUM_PERCENT_LEFT, session_reset, LUNA_TIER_STOP_PERCENT_LEFT / 2, weekly_reset
+    )
+
+    assert broker_constants._codex_tier(
+        dataclasses.replace(meters, weekly_percent_left=NORMAL_TIER_MINIMUM_PERCENT_LEFT)
+    ) == "luna"
+    assert broker_constants._account_reset(_codex_reading(meters)) == weekly_reset
+
+
+def test_should_name_no_codex_reset_when_a_blocking_window_has_none() -> None:
+    session_reset = datetime(2026, 10, 3, 2, tzinfo=timezone.utc)
+    meters = broker_constants.Meters(
+        LUNA_TIER_SHORT_WINDOW_MINIMUM_PERCENT_LEFT / 2, session_reset, LUNA_TIER_STOP_PERCENT_LEFT / 2, None
+    )
+
+    assert broker_constants._account_reset(_codex_reading(meters)) is None
+
+
+def test_should_name_the_latest_codex_reset_when_every_blocking_window_has_one() -> None:
+    session_reset = datetime(2026, 10, 3, 2, tzinfo=timezone.utc)
+    weekly_reset = datetime(2026, 10, 4, tzinfo=timezone.utc)
+    meters = broker_constants.Meters(
+        LUNA_TIER_SHORT_WINDOW_MINIMUM_PERCENT_LEFT / 2, session_reset, LUNA_TIER_STOP_PERCENT_LEFT / 2, weekly_reset
+    )
+
+    assert broker_constants._account_reset(_codex_reading(meters)) == weekly_reset
+
+
+def test_should_double_the_meter_read_delay_up_to_its_cap() -> None:
+    all_delays = [broker_constants.meter_read_delay_seconds(each_attempt) for each_attempt in range(1, 6)]
+
+    assert all_delays == [1.0, 2.0, 4.0, 8.0, 8.0]

package/scripts/dev_env_scripts_constants/test_codex_account_constants.py

@@ -0,0 +1,119 @@
+"""The Codex account constants match what docs/codex-accounts.md tells the reader."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from dev_env_scripts_constants import codex_account_constants as constants
+from dev_env_scripts_constants.account_broker_constants import METER_READ_ATTEMPTS, meter_read_delay_seconds
+from dev_env_scripts_constants.claude_account_constants import ALL_LAUNCHER_DIRECTORY_RELATIVE_PARTS
+
+CODEX_ACCOUNTS_DOC_PATH = Path(__file__).resolve().parents[2] / "docs" / "codex-accounts.md"
+SECTION_HEADING_PREFIX = "## "
+CHOOSE_COMMAND_SUFFIX = "choose --product codex"
+CODE_FENCE = "```"
+
+
+def documented_section_lines(heading: str) -> list[str]:
+    all_doc_lines = CODEX_ACCOUNTS_DOC_PATH.read_text(encoding="utf-8").splitlines()
+    heading_index = all_doc_lines.index(SECTION_HEADING_PREFIX + heading)
+    all_section_lines: list[str] = []
+    for each_line in all_doc_lines[heading_index + 1 :]:
+        if each_line.startswith(SECTION_HEADING_PREFIX):
+            break
+        all_section_lines.append(each_line)
+    return all_section_lines
+
+
+def documented_section(heading: str) -> str:
+    return " ".join(" ".join(documented_section_lines(heading)).split())
+
+
+def documented_choose_sample() -> dict[str, Any]:
+    all_section_lines = documented_section_lines("Which account a job uses")
+    command_index = next(
+        index for index, each_line in enumerate(all_section_lines) if each_line.endswith(CHOOSE_COMMAND_SUFFIX)
+    )
+    fence_index = all_section_lines.index(CODE_FENCE, command_index)
+    return json.loads("\n".join(all_section_lines[command_index + 1 : fence_index]))
+
+
+def documented_list(all_names: list[str]) -> str:
+    *all_leading_names, last_name = [f"`{each_name}`" for each_name in all_names]
+    if not all_leading_names:
+        return last_name
+    return ", ".join(all_leading_names) + f" and {last_name}"
+
+
+def documented_percent(percent: float) -> str:
+    return f"{percent:g}%"
+
+
+def test_fallback_roster_matches_the_documented_accounts() -> None:
+    expected_sentence = (
+        "When neither exists, the accounts are "
+        + documented_list(list(constants.ALL_CODEX_ACCOUNT_NAMES))
+        + "."
+    )
+    assert expected_sentence in documented_section("Names and order")
+
+
+def test_shared_home_entries_match_the_documented_list() -> None:
+    expected_sentence = "They are " + documented_list(sorted(constants.ALL_SHARED_CODEX_HOME_NAMES)) + "."
+    assert expected_sentence in documented_section("Sign in once")
+
+
+def test_sign_in_file_stays_per_account() -> None:
+    expected_sentence = f"The sign-in lives in that folder's `{constants.CODEX_AUTH_FILE_NAME}`."
+    assert expected_sentence in documented_section("Sign in once")
+    assert constants.CODEX_AUTH_FILE_NAME not in constants.ALL_SHARED_CODEX_HOME_NAMES
+
+
+def test_launcher_matches_the_documented_name_directory_and_variable() -> None:
+    launcher_file_name = constants.CODEX_LAUNCHER_PROGRAM.file_name_template.format(profile_name="<name>")
+    launcher_directory = "/".join(["~", *ALL_LAUNCHER_DIRECTORY_RELATIVE_PARTS])
+    expected_sentence = (
+        f"Each roster account gets a launcher, `{launcher_file_name}`, in `{launcher_directory}`. "
+        f"It sets `{constants.CODEX_LAUNCHER_PROGRAM.environment_variable}` to that account's home "
+        f"and runs Codex with every argument"
+    )
+    assert expected_sentence in documented_section("Named launchers")
+
+
+def test_tier_bars_match_the_documented_table() -> None:
+    normal_bar = documented_percent(constants.NORMAL_TIER_MINIMUM_PERCENT_LEFT)
+    luna_stop = documented_percent(constants.LUNA_TIER_STOP_PERCENT_LEFT)
+    luna_short_window_floor = documented_percent(constants.LUNA_TIER_SHORT_WINDOW_MINIMUM_PERCENT_LEFT)
+    all_expected_rows = [
+        f"| One or more accounts with more than {normal_bar} left | `{constants.TIER_NORMAL}` on the account with the most room |",
+        f"| No account over {normal_bar}, one or more over {luna_stop} | `{constants.TIER_LUNA}` on the account with the most room |",
+        f"| An account that reports a window shorter than a week, such as the 5-hour window, with under {luna_short_window_floor} of that window left | never takes `{constants.TIER_LUNA}` |",
+        f"| No account over {luna_stop} | `{constants.TIER_WAIT}`, naming the next reset when known |",
+    ]
+    section_text = documented_section("Which account a job uses")
+    for each_row in all_expected_rows:
+        assert each_row in section_text
+
+
+def test_meter_retries_match_the_documented_table() -> None:
+    all_delays = [meter_read_delay_seconds(each_attempt) for each_attempt in range(1, METER_READ_ATTEMPTS)]
+    all_delay_texts = [f"{each_delay:g} second" + ("" if each_delay == 1 else "s") for each_delay in all_delays]
+    expected_row = (
+        f"| A meter read fails | The broker reads it again, up to {METER_READ_ATTEMPTS} reads, "
+        f"waiting {' and then '.join(all_delay_texts)} |"
+    )
+    assert expected_row in documented_section("Which account a job uses")
+
+
+def test_documented_choose_sample_runs_normal_on_the_tightest_window() -> None:
+    sample = documented_choose_sample()
+    decision = sample["decision"]
+    chosen_meters = next(
+        each_account["meters"] for each_account in sample["accounts"] if each_account["name"] == decision["account"]
+    )
+    room = min(chosen_meters["session_percent_left"], chosen_meters["weekly_percent_left"])
+    assert decision["tier"] == constants.TIER_NORMAL
+    assert room > constants.NORMAL_TIER_MINIMUM_PERCENT_LEFT
+    assert decision["reason"] == f"{decision['account']} has {room:g}% left"

package/scripts/merge_review_receipt.py

@@ -7,8 +7,14 @@ The agent loops a code review on its pull request. Each pass is recorded::
     fix, push, review the new head
     python3 merge_review_receipt.py owner/name 12 def5678 0   -> CLEAN owner/name#12 def5678
 
+A pass whose every finding is ruled out with file:line evidence counts as
+clean once the rulings are posted and linked::
+
+    python3 merge_review_receipt.py owner/name 12 def5678 2 --ruled-out 2 --rulings <url>
+        -> CLEAN owner/name#12 def5678 (2 findings ruled out: <url>)
+
 ``hooks/blocking/merge_review_gate.py`` allows a merge pinned to the head of
-the newest pass only when that pass counted zero findings.
+the newest pass only when that pass is clean.
 """
 
 from __future__ import annotations
@@ -24,14 +30,23 @@ hooks_directory = str(Path(__file__).resolve().parent.parent / "hooks")
 if hooks_directory not in sys.path:
     sys.path.insert(0, hooks_directory)
 
-from blocking.merge_review_gate import receipt_path
+from blocking.merge_review_gate import is_clean_receipt, receipt_path
 from hooks_constants.merge_review_gate_constants import (
     RECEIPT_FINDINGS_KEY,
     RECEIPT_HEAD_KEY,
+    RECEIPT_RULED_OUT_KEY,
+    RECEIPT_RULINGS_KEY,
 )
 
 
-def record_review(slug: str, number: int, head: str, finding_count: int) -> Path:
+def record_review(
+    slug: str,
+    number: int,
+    head: str,
+    finding_count: int,
+    ruled_out_count: int = 0,
+    rulings: str = "",
+) -> Path:
     """Write the receipt for one review pass, replacing the previous pass.
 
     Args:
@@ -39,21 +54,34 @@ def record_review(slug: str, number: int, head: str, finding_count: int) -> Path
         number: Pull request number.
         head: The commit the pass reviewed.
         finding_count: How many findings the pass reported.
+        ruled_out_count: How many of those findings were ruled out.
+        rulings: Link to the posted rulings, empty when none were ruled out.
 
     Returns:
         The receipt path written.
     """
+    receipt = _receipt_fields(head, finding_count, ruled_out_count, rulings)
+    return _write_receipt(slug, number, receipt)
+
+
+def _write_receipt(slug: str, number: int, all_receipt_fields: dict[str, object]) -> Path:
     owner, repo = slug.split("/", 1)
     path = receipt_path(owner, repo, number)
     path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(
-        json.dumps({RECEIPT_HEAD_KEY: head, RECEIPT_FINDINGS_KEY: finding_count})
-        + "\n",
-        encoding="utf-8",
-    )
+    path.write_text(json.dumps(all_receipt_fields) + "\n", encoding="utf-8")
     return path
 
 
+def _receipt_fields(
+    head: str, finding_count: int, ruled_out_count: int, rulings: str
+) -> dict[str, object]:
+    receipt: dict[str, object] = {RECEIPT_HEAD_KEY: head, RECEIPT_FINDINGS_KEY: finding_count}
+    if ruled_out_count:
+        receipt[RECEIPT_RULED_OUT_KEY] = ruled_out_count
+        receipt[RECEIPT_RULINGS_KEY] = rulings
+    return receipt
+
+
 def main(all_arguments: Sequence[str], stdout: TextIO = sys.stdout) -> int:
     """Record one pass and print its verdict line.
 
@@ -62,17 +90,33 @@ def main(all_arguments: Sequence[str], stdout: TextIO = sys.stdout) -> int:
         stdout: Stream that receives the verdict.
 
     Returns:
-        0 for a clean pass, and 1 for a pass with findings.
+        0 for a clean pass, and 1 for a pass with findings still open.
     """
     parser = argparse.ArgumentParser(prog="merge_review_receipt")
     parser.add_argument("slug", help="Repository as owner/name.")
     parser.add_argument("number", type=int, help="Pull request number.")
     parser.add_argument("head", help="The head commit the pass reviewed.")
     parser.add_argument("findings", type=int, help="Findings the pass reported.")
+    parser.add_argument(
+        "--ruled-out", type=int, default=0, help="Findings ruled out with file:line evidence."
+    )
+    parser.add_argument("--rulings", default="", help="Link to the posted rulings.")
     parsed = parser.parse_args(all_arguments)
-    record_review(parsed.slug, parsed.number, parsed.head, parsed.findings)
-    if parsed.findings == 0:
-        stdout.write(f"CLEAN {parsed.slug}#{parsed.number} {parsed.head}\n")
+    rulings = parsed.rulings.strip()
+    if parsed.ruled_out < 0 or parsed.ruled_out > parsed.findings:
+        parser.error("--ruled-out must be between 0 and the finding count")
+    if parsed.ruled_out and not rulings:
+        parser.error("--ruled-out needs --rulings, a link to the posted rulings")
+    if rulings and not parsed.ruled_out:
+        parser.error("--rulings needs --ruled-out, the count of findings it rules out")
+    receipt = _receipt_fields(parsed.head, parsed.findings, parsed.ruled_out, rulings)
+    _write_receipt(parsed.slug, parsed.number, receipt)
+    owner, repo = parsed.slug.split("/", 1)
+    if is_clean_receipt(receipt, owner, repo, parsed.number):
+        ruled_out_note = (
+            f" ({parsed.ruled_out} findings ruled out: {rulings})" if parsed.ruled_out else ""
+        )
+        stdout.write(f"CLEAN {parsed.slug}#{parsed.number} {parsed.head}{ruled_out_note}\n")
         return 0
     stdout.write(
         f"REVIEWED {parsed.slug}#{parsed.number} {parsed.head} {parsed.findings} findings\n"

package/scripts/policy_lint/adapter_configuration.py

@@ -135,6 +135,7 @@ def _names_exempt_registration_path(registered_string: str) -> bool:
         hooks/blocking/verify_before_acting.py           -> exempt
         hooks/blocking/session_title_format_gate.py      -> exempt
         hooks/blocking/artifact_dark_mode_gate.py        -> exempt
+        hooks/blocking/merge_over_review_offer_gate.py   -> exempt
         hooks/blocking/some_new_blocker.py               -> flagged
 
     The Bash PreToolUse dispatcher sits under ``blocking/`` for layout reasons
@@ -166,6 +167,10 @@ def _names_exempt_registration_path(registered_string: str) -> bool:
     The artifact page gate denies a page publish whose text is unreadable in
     dark mode. It decides how a page renders and no code or safety policy.
 
+    The merge offer gate denies a decision card whose text offers a merge and
+    names open review findings. It reads only the wording of a chat card and
+    decides no code or safety policy; the merge review gate holds the merge.
+
     Args:
         registered_string: One command, path, script, or entrypoint string.
     """

package/scripts/policy_lint/config/constants.py

@@ -74,6 +74,7 @@ ALL_ACTION_BOUNDARY_EXEMPT_REGISTRATION_PATHS = (
     "blocking/image_read_size_gate.py",
     "blocking/artifact_dark_mode_gate.py",
     "blocking/haiku_spawn_slim_gate.py",
+    "blocking/merge_over_review_offer_gate.py",
 )
 ALL_TEST_DIRECTORY_NAMES = frozenset({"tests"})
 ALL_TEST_FILE_PREFIXES = ("test_",)

package/scripts/test_account_broker.py

@@ -226,6 +226,18 @@ def test_should_wait_for_main_5_hour_reset_while_its_week_resets_days_away() ->
     assert decision.resets_at == short_reset
 
 
+def test_should_check_main_again_in_an_hour_when_a_blocking_window_has_no_reset() -> None:
+    main = Reading(
+        _account("main", Product.CLAUDE, main=True),
+        Meters(5, None, 1, NOW + timedelta(hours=4)),
+    )
+
+    decision = choose_from_readings(Product.CLAUDE, (main,), now=NOW)
+
+    assert decision.action == "wait"
+    assert decision.resets_at == NOW + timedelta(hours=1)
+
+
 @pytest.mark.parametrize(
     ("short_left", "weekly_left", "weekly_reset", "expected_reset"),
     (
@@ -441,6 +453,7 @@ def test_should_print_decision_and_meters_for_choose(
     assert account_broker.main(("choose", "--product", "codex")) == 0
     payload = json.loads(capsys.readouterr().out)
     assert payload["decision"]["account"] == "roomy"
+    assert payload["decision"]["profile"] is None
     assert payload["accounts"][0]["meters"]["session_percent_left"] == 80
     assert payload["state_path"].endswith("state.json")
 
@@ -781,7 +794,7 @@ def test_should_list_accounts_without_reading_meters(
 
     assert account_broker.main(("accounts", "--product", "codex")) == 0
     assert json.loads(capsys.readouterr().out) == {
-        "accounts": [{"name": "listed", "home": str(account.home), "is_main": False}]
+        "accounts": [{"name": "listed", "profile": None, "home": str(account.home), "is_main": False}]
     }
 
 
@@ -931,6 +944,59 @@ def test_should_mark_a_windows_launcher_path_account_spent(
     assert decision["account"] == "second"
 
 
+def test_should_mark_an_account_spent_by_its_profile(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    launcher_name = "C:\\Users\\someone\\.local\\bin\\claude-first.cmd"
+    first = Account(Product.CLAUDE, launcher_name, Path("/profiles/first"), command=launcher_name, profile="first")
+    second = _account("second", Product.CLAUDE)
+    monkeypatch.setitem(
+        account_broker.all_product_adapters,
+        Product.CLAUDE,
+        _adapter((first, second), {launcher_name: _meters(80, 80), "second": _meters(80, 80)}),
+    )
+    _freeze_clock(monkeypatch, NOW)
+
+    code = account_broker.main(("choose", "--product", "claude", "--spent", f"first:{(NOW + timedelta(hours=2)).timestamp()}"))
+
+    decision = json.loads(capsys.readouterr().out)["decision"]
+    assert code == 0
+    assert decision["account"] == "second"
+
+
+def test_should_mark_the_account_named_by_a_mark_that_is_also_another_profile(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    launcher_name = "C:\\Users\\someone\\.local\\bin\\claude-editor.cmd"
+    profiled = Account(Product.CLAUDE, launcher_name, Path("/profiles/second"), command=launcher_name, profile="second")
+    second = _account("second", Product.CLAUDE)
+    monkeypatch.setitem(
+        account_broker.all_product_adapters,
+        Product.CLAUDE,
+        _adapter((second, profiled), {launcher_name: _meters(80, 80), "second": _meters(90, 90)}),
+    )
+    _freeze_clock(monkeypatch, NOW)
+
+    code = account_broker.main(("choose", "--product", "claude", "--spent", f"second:{(NOW + timedelta(hours=2)).timestamp()}"))
+
+    decision = json.loads(capsys.readouterr().out)["decision"]
+    assert code == 0
+    assert decision["account"] == launcher_name
+
+
+def test_should_save_no_spent_mark_when_a_later_mark_is_unreadable(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    account = _account("first")
+    monkeypatch.setitem(account_broker.all_product_adapters, Product.CODEX, _adapter((account,), {"first": _meters(80, 80)}))
+
+    code = account_broker.main(("choose", "--product", "codex", "--spent", "first", "--spent", "guest:tomorrow"))
+
+    assert code == 2
+    assert "invalid reset" in capsys.readouterr().err
+    assert account_broker._load_state(account_broker.broker_state_path()).get("spent", {}) == {}
+
+
 def test_should_reject_an_invalid_spent_reset(
     monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
 ) -> None:
@@ -1044,6 +1110,22 @@ def test_should_run_past_a_stored_spent_mark_beyond_the_platform_range(
     assert decision["action"] == "run"
 
 
+def test_should_wait_on_an_outside_spent_mark_under_another_state_key_layout(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    account = _account("first")
+    monkeypatch.setitem(account_broker.all_product_adapters, Product.CODEX, _adapter((account,), {"first": _meters(80, 80)}))
+    monkeypatch.setattr(account_broker, "_state_key", lambda marked: f"{marked.product.value}|{marked.name}|{marked.home}")
+    _freeze_clock(monkeypatch, NOW)
+    reset = NOW + timedelta(hours=2)
+
+    account_broker.main(("choose", "--product", "codex", "--spent", f"visitor:{int(reset.timestamp())}"))
+
+    decision = json.loads(capsys.readouterr().out)["decision"]
+    assert decision["action"] == "wait"
+    assert "account visitor outside the roster is spent" in decision["reason"]
+
+
 def test_should_name_the_outside_spent_mark_when_it_forces_a_wait(
     monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
 ) -> None:
@@ -1106,6 +1188,37 @@ def test_should_warn_when_a_spent_mark_names_an_account_the_roster_lacks(
     assert "outside the roster" in all_warning_lines[0]
 
 
+def test_should_print_no_outside_roster_warning_when_a_later_mark_is_unreadable(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    account = _account("first")
+    monkeypatch.setitem(account_broker.all_product_adapters, Product.CODEX, _adapter((account,), {"first": _meters(80, 80)}))
+
+    code = account_broker.main(("choose", "--product", "codex", "--spent", "visitor", "--spent", "first:notanumber"))
+
+    all_error_lines = capsys.readouterr().err.splitlines()
+    assert code == 2
+    assert len(all_error_lines) == 1
+    assert "invalid reset in spent mark 'first:notanumber'" in all_error_lines[0]
+    assert account_broker._load_state(account_broker.broker_state_path())["spent"] == {}
+
+
+def test_should_save_an_outside_launcher_path_given_with_an_explicit_reset(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    account = _account("first")
+    monkeypatch.setitem(account_broker.all_product_adapters, Product.CODEX, _adapter((account,), {"first": _meters(80, 80)}))
+    reset = int((datetime.now(timezone.utc) + timedelta(hours=2)).timestamp())
+
+    code = account_broker.main(("choose", "--product", "codex", "--spent", f"C:\\bin\\old.cmd:{reset}"))
+
+    all_warning_lines = capsys.readouterr().err.splitlines()
+    all_saved_marks = account_broker._load_state(account_broker.broker_state_path())["spent"]
+    assert code == WAIT_EXIT_CODE
+    assert "C:\\bin\\old.cmd" in all_warning_lines[0]
+    assert all_saved_marks == {f"codex:C:\\bin\\old.cmd:{Path()}": float(reset)}
+
+
 @pytest.mark.parametrize("mark", ["", ":1800000000"])
 def test_should_reject_a_spent_mark_without_an_account_name(
     monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], mark: str
@@ -1127,8 +1240,8 @@ def test_should_serialize_a_run_and_a_wait_decision() -> None:
     run_payload = account_broker.decision_payload(account_broker.Decision("run", account, None, "first has 80% left", "normal"))
     wait_payload = account_broker.decision_payload(account_broker.Decision("wait", None, reset, "no account has room", "wait"))
 
-    assert run_payload == {"action": "run", "account": "first", "home": str(Path("/profiles/first")), "reason": "first has 80% left", "tier": "normal", "resets_at": None}
-    assert wait_payload == {"action": "wait", "account": None, "home": None, "reason": "no account has room", "tier": "wait", "resets_at": reset.isoformat()}
+    assert run_payload == {"action": "run", "account": "first", "profile": None, "home": str(Path("/profiles/first")), "reason": "first has 80% left", "tier": "normal", "resets_at": None}
+    assert wait_payload == {"action": "wait", "account": None, "profile": None, "home": None, "reason": "no account has room", "tier": "wait", "resets_at": reset.isoformat()}
 
 
 def test_should_print_the_whole_rate_limit_result_for_one_home(
@@ -1236,6 +1349,12 @@ def test_should_hand_the_live_log_to_the_subprocess_runner(tmp_path: Path, monke
     assert captured_options["live_log"] == live_log
 
 
+def test_decision_payload_should_carry_the_profile_of_a_claude_account() -> None:
+    account = Account(Product.CLAUDE, "C:\\bin\\claude-editor.cmd", Path("/profiles/editor"), command="C:\\bin\\claude-editor.cmd", profile="editor")
+
+    assert account_broker.decision_payload(account_broker.Decision("run", account, None, "most room", "normal"))["profile"] == "editor"
+
+
 def test_decision_payload_should_name_the_chosen_account_and_its_home() -> None:
     account = _account("codex-2")
     decision = account_broker.Decision("run", account, None, "most room", "normal")
@@ -1243,6 +1362,7 @@ def test_decision_payload_should_name_the_chosen_account_and_its_home() -> None:
     assert account_broker.decision_payload(decision) == {
         "action": "run",
         "account": "codex-2",
+        "profile": None,
         "home": str(Path("/profiles") / "codex-2"),
         "reason": "most room",
         "tier": "normal",
@@ -1259,3 +1379,25 @@ def test_decision_payload_should_leave_the_account_empty_and_give_the_reset_for_
     assert payload["account"] is None
     assert payload["home"] is None
     assert payload["resets_at"] == "2026-10-03T08:00:00+00:00"
+
+
+def test_should_save_every_spent_mark_in_one_write(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    accounts = (_account("first"), _account("second"))
+    monkeypatch.setitem(account_broker.all_product_adapters, Product.CODEX, _adapter(accounts, {
+        "first": _meters(80, 80), "second": _meters(70, 70)
+    }))
+    all_saved_marks: list[dict[str, object]] = []
+
+    def save_or_fail(path: Path, all_state: dict[str, object]) -> None:
+        all_saved_marks.append(dict(all_state["spent"]))
+        raise OSError("disk full")
+
+    monkeypatch.setattr(account_broker, "_save_state", save_or_fail)
+
+    with pytest.raises(OSError):
+        account_broker.main(("choose", "--product", "codex", "--spent", "first", "--spent", "second"))
+
+    assert len(all_saved_marks) == 1
+    assert len(all_saved_marks[0]) == 2