claude-dev-env 8.44.5 → 8.45.0

package/docs/account-broker.md

@@ -14,7 +14,7 @@ python scripts/account_broker.py check --product codex
 python scripts/account_broker.py run --product claude --report report.json -- claude --output-format json -p "prompt"
 ```
 
-`accounts` prints the roster without reading meters. `choose` prints `decision`, `accounts`, and `state_path`. Each decision contains `action`, `account`, `home`, `reason`, `tier`, and `resets_at`. A wait decision has no account or home and includes the soonest reset in UTC. A failed meter read excludes the account for that choice. `--spent` saves an exclusion until the supplied Unix reset, the account's soonest known meter reset, or one hour when neither is available. Meter reads younger than 60 seconds are reused.
+`accounts` prints the roster without reading meters. `choose` prints `decision`, `accounts`, and `state_path`. Each decision contains `action`, `account`, `home`, `reason`, `tier`, and `resets_at`. A wait decision has no account or home and includes the soonest reset in UTC. A failed meter read excludes the account for that choice. `--spent` saves an exclusion until the supplied Unix reset, the account's soonest known meter reset, or one hour when neither is available. A `--spent` name absent from the roster is saved until the supplied Unix reset, or for one hour when no reset is given. While any such mark is still in the future, `choose` waits until the soonest mark and exits 3, and with no Codex roster `--spent default` waits until that mark passes. Meter reads younger than 60 seconds are reused.
 
 `check` prints nothing and exits 3 while every account is below its floor. `run` sets only `CLAUDE_CONFIG_DIR` or `CODEX_HOME` for each attempt. It replays the same stdin bytes when a usage limit or start failure leads to another account. It writes the command's stdout to stdout and diagnostics to stderr. A resumed Claude session uses the account bound to its session when that account has room.
 

package/hooks/hooks.json

@@ -14,6 +14,11 @@
             "type": "command",
             "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/routing/spawn_readiness_hook.py",
             "timeout": 10
+          },
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/routing/subagent_model_pin_hook.py",
+            "timeout": 10
           }
         ]
       },

package/hooks/hooks_constants/subagent_model_pin_hook_constants.py

@@ -0,0 +1,16 @@
+"""Constants for the subagent model pin PreToolUse hook.
+
+Groups: the model every subagent runs on, the model families the hook moves,
+and the hook input and output keys.
+"""
+
+from __future__ import annotations
+
+SUBAGENT_MODEL_ALIAS = "opus"
+ALL_MOVED_MODEL_FAMILIES = ("sonnet", "haiku")
+MODEL_INPUT_KEY = "model"
+TOOL_INPUT_KEY = "tool_input"
+CONTEXT_PREFIX = "Subagent model moved to opus (was "
+CONTEXT_OMITTED_MODEL_TEXT = "inherited from the parent"
+CONTEXT_SUFFIX = ")."
+ADDITIONAL_CONTEXT_KEY = "additionalContext"

package/hooks/hooks_constants/thread_spawn_pace_hook_constants.py

@@ -11,35 +11,18 @@ USAGE_PACE_SCRIPT_FILE_NAME = "usage_pace.py"
 USAGE_PACE_TIMEOUT_SECONDS = 15
 
 TOOL_INPUT_KEY = "tool_input"
-THREAD_MODEL_WHEN_OVER_PACE = "claude-sonnet-5-5"
-THREAD_EFFORT_WHEN_OVER_PACE = "medium"
+THREAD_MODEL_WHEN_OVER_PACE = "opus"
+THREAD_EFFORT_WHEN_OVER_PACE = "low"
 MODEL_INPUT_KEY = "model"
 EFFORT_INPUT_KEY = "effort"
-INSTRUCTIONS_INPUT_KEY = "instructions"
-INSTRUCTIONS_MAXIMUM_BYTES = 8192
-INSTRUCTIONS_SEPARATOR = "\n\n"
-INSTRUCTIONS_ENCODING = "utf-8"
-FABLE_ADVISOR_LINE = (
-    "Mandatory Fable advisor: usage is over pace, so this thread runs on "
-    "Sonnet 5.5 at medium effort. Invoke /team-advisor before substantive "
-    "work and bind a Fable advisor through it. Consult that advisor again "
-    "before you report done, and name its verdict in your report."
-)
 
 PERMISSION_DENY = "deny"
 PERMISSION_DECISION_REASON_KEY = "permissionDecisionReason"
 ADDITIONAL_CONTEXT_KEY = "additionalContext"
 NOT_AN_OBJECT_REASON = "start_thread_session input is not a JSON object"
-NO_INSTRUCTIONS_REASON = "start_thread_session input has no instructions text"
-OVER_BYTE_CAP_REASON_TEMPLATE = (
-    "usage is over pace and the brief plus the mandatory Fable advisor line is "
-    "{reshaped_byte_count} bytes, over the {maximum_bytes}-byte cap; "
-    "shorten the instructions by {excess_byte_count} bytes"
-)
 RESHAPE_CONTEXT_PREFIX = (
     "Usage over pace or unreadable: this thread spawn now runs on "
-    "claude-sonnet-5-5 at medium effort with a mandatory Fable advisor line. "
-    "Pace verdict: "
+    "opus at low effort. Pace verdict: "
 )
 PACE_VERDICT_CONTEXT_MAXIMUM_CHARACTERS = 600
 LAUNCH_FAILURE_ERROR_TEMPLATE = "usage pace did not finish: {failure_type}"

package/hooks/routing/subagent_model_pin_hook.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""PreToolUse hook: run every Agent and Task subagent on Opus.
+
+Registered on ``Agent|Task``. Nested spawns pass through the same hook, so the
+pin holds at every level.
+
+::
+
+    model omitted           -> allow with updatedInput model "opus"
+    model sonnet or haiku   -> allow with updatedInput model "opus"
+    model opus or fable     -> no output; the call runs unchanged
+
+A model id counts by its family: ``claude-sonnet-5-5`` is sonnet. A fork
+ignores the model field, so the rewrite leaves it unchanged.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+hooks_root_directory = str(Path(__file__).resolve().parent.parent)
+if hooks_root_directory not in sys.path:
+    sys.path.insert(0, hooks_root_directory)
+
+from hooks_constants.bash_pre_tool_use_dispatcher_constants import (
+    ALLOW_DECISION,
+    HOOK_EVENT_NAME,
+)
+from hooks_constants.pre_tool_use_allow_output import (
+    HOOK_EVENT_NAME_KEY,
+    HOOK_SPECIFIC_OUTPUT_KEY,
+    PERMISSION_DECISION_KEY,
+    UPDATED_INPUT_KEY,
+)
+from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
+from hooks_constants.subagent_model_pin_hook_constants import (
+    ADDITIONAL_CONTEXT_KEY,
+    ALL_MOVED_MODEL_FAMILIES,
+    CONTEXT_OMITTED_MODEL_TEXT,
+    CONTEXT_PREFIX,
+    CONTEXT_SUFFIX,
+    MODEL_INPUT_KEY,
+    SUBAGENT_MODEL_ALIAS,
+    TOOL_INPUT_KEY,
+)
+
+
+def is_moved_model(model: object) -> bool:
+    """Return True when the spawn names no model or a model family the pin moves.
+
+    ::
+
+        None -> True        "sonnet" -> True     "claude-haiku-4-5-20251001" -> True
+        "opus" -> False     "claude-fable-5-1" -> False
+
+    Args:
+        model: The ``model`` field of the spawn input.
+    """
+    if model is None or model == "":
+        return True
+    if not isinstance(model, str):
+        return False
+    lowered_model = model.lower()
+    return any(each_family in lowered_model for each_family in ALL_MOVED_MODEL_FAMILIES)
+
+
+def decide_hook_output(tool_input: object) -> dict[str, object] | None:
+    """Choose the hook's output for one subagent spawn.
+
+    Args:
+        tool_input: The ``tool_input`` of the PreToolUse payload.
+
+    Returns:
+        None to pass the call through unchanged, else the hook JSON output.
+    """
+    if not isinstance(tool_input, dict):
+        return None
+    requested_model = tool_input.get(MODEL_INPUT_KEY)
+    if not is_moved_model(requested_model):
+        return None
+    previous_model_text = requested_model or CONTEXT_OMITTED_MODEL_TEXT
+    return {
+        HOOK_SPECIFIC_OUTPUT_KEY: {
+            HOOK_EVENT_NAME_KEY: HOOK_EVENT_NAME,
+            PERMISSION_DECISION_KEY: ALLOW_DECISION,
+            UPDATED_INPUT_KEY: {**tool_input, MODEL_INPUT_KEY: SUBAGENT_MODEL_ALIAS},
+            ADDITIONAL_CONTEXT_KEY: f"{CONTEXT_PREFIX}{previous_model_text}{CONTEXT_SUFFIX}",
+        }
+    }
+
+
+def main() -> int:
+    """Read the PreToolUse payload and print the decision.
+
+    Returns:
+        0 in every case.
+    """
+    hook_payload = read_hook_input_dictionary_from_stdin()
+    tool_input = hook_payload.get(TOOL_INPUT_KEY) if hook_payload is not None else None
+    hook_output = decide_hook_output(tool_input)
+    if hook_output is not None:
+        sys.stdout.write(json.dumps(hook_output))
+        sys.stdout.flush()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/hooks/routing/test_subagent_model_pin_hook.py

@@ -0,0 +1,67 @@
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+HOOK_SCRIPT = Path(__file__).resolve().parent / "subagent_model_pin_hook.py"
+HOOKS_JSON = Path(__file__).resolve().parent.parent / "hooks.json"
+CONSTANTS_DIRECTORY = Path(__file__).resolve().parent.parent / "hooks_constants"
+SPAWN_INPUT = {"subagent_type": "pstack:poteto-agent", "prompt": "Do X.", "description": "d"}
+
+
+def _run_hook(tool_input: object) -> str:
+    completed = subprocess.run(
+        [sys.executable, str(HOOK_SCRIPT)],
+        input=json.dumps({"tool_name": "Agent", "tool_input": tool_input}),
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    return completed.stdout
+
+
+@pytest.mark.parametrize(
+    "requested_model",
+    [None, "", "sonnet", "haiku", "claude-sonnet-5-5", "claude-sonnet-5-5[1m]", "claude-haiku-4-5-20251001"],
+)
+def test_should_move_the_spawn_to_opus(requested_model: object) -> None:
+    tool_input = dict(SPAWN_INPUT)
+    if requested_model is not None:
+        tool_input["model"] = requested_model
+    decision = json.loads(_run_hook(tool_input))["hookSpecificOutput"]
+    assert decision["permissionDecision"] == "allow"
+    assert decision["updatedInput"] == {**SPAWN_INPUT, "model": "opus"}
+
+
+@pytest.mark.parametrize("requested_model", ["opus", "fable", "claude-opus-5-5", "claude-fable-5-1"])
+def test_should_leave_an_opus_or_fable_spawn_alone(requested_model: str) -> None:
+    assert _run_hook({**SPAWN_INPUT, "model": requested_model}) == ""
+
+
+def test_should_pass_a_tool_input_that_is_not_an_object() -> None:
+    assert _run_hook(["not", "an", "object"]) == ""
+
+
+def test_should_register_the_pin_on_the_agent_and_task_matcher() -> None:
+    all_agent_entries = [
+        each_entry
+        for each_entry in json.loads(HOOKS_JSON.read_text(encoding="utf-8"))["hooks"]["PreToolUse"]
+        if each_entry["matcher"] == "Agent|Task"
+    ]
+    all_commands = [
+        each_hook["command"] for each_entry in all_agent_entries for each_hook in each_entry["hooks"]
+    ]
+    assert any("subagent_model_pin_hook.py" in each_command for each_command in all_commands)
+
+
+def test_should_keep_every_constant_free_of_a_sonnet_model_id() -> None:
+    all_offending_files = [
+        each_file.name
+        for each_file in CONSTANTS_DIRECTORY.glob("*.py")
+        if not each_file.name.startswith("test_")
+        and each_file.name != "subagent_model_pin_hook_constants.py"
+        and "claude-sonnet" in each_file.read_text(encoding="utf-8")
+    ]
+    assert all_offending_files == []

package/hooks/routing/test_thread_spawn_pace_hook.py

@@ -5,7 +5,6 @@ import sys
 from pathlib import Path
 
 import pytest
-from hooks_constants.thread_spawn_pace_hook_constants import FABLE_ADVISOR_LINE
 
 HOOK_SCRIPT = Path(__file__).resolve().parent / "thread_spawn_pace_hook.py"
 SPAWN_INPUT = {
@@ -55,9 +54,8 @@ def _assert_reshaped(stdout: str) -> None:
     assert decision["permissionDecision"] == "allow"
     assert decision["updatedInput"] == {
         **SPAWN_INPUT,
-        "model": "claude-sonnet-5-5",
-        "effort": "medium",
-        "instructions": f"Do the example task.\n\n{FABLE_ADVISOR_LINE}",
+        "model": "opus",
+        "effort": "low",
     }
 
 
@@ -91,27 +89,15 @@ def test_should_reshape_the_spawn_when_the_pace_script_is_missing(
     _assert_reshaped(_run_hook(tmp_path / "absent.py", SPAWN_INPUT))
 
 
-def test_should_append_the_advisor_line_once(tmp_path: Path) -> None:
-    already_reshaped = {
-        **SPAWN_INPUT,
-        "instructions": f"Do the example task.\n\n{FABLE_ADVISOR_LINE}",
-    }
-    stdout = _run_hook(
-        _write_pace_stub(tmp_path, 0, {"over_pace": True}), already_reshaped
-    )
-    assert (
-        _hook_specific_output(stdout)["updatedInput"]["instructions"].count(
-            FABLE_ADVISOR_LINE
-        )
-        == 1
-    )
+def test_should_name_no_sonnet_model_in_the_reshaped_spawn(tmp_path: Path) -> None:
+    stdout = _run_hook(_write_pace_stub(tmp_path, 0, {"over_pace": True}), SPAWN_INPUT)
+    assert "sonnet" not in stdout.lower()
 
 
 @pytest.mark.parametrize(
     ("tool_input", "reason"),
     [
         (["not", "an", "object"], "start_thread_session input is not a JSON object"),
-        ({"title": "No brief"}, "start_thread_session input has no instructions text"),
     ],
 )
 def test_should_deny_a_spawn_it_cannot_reshape(
@@ -123,17 +109,3 @@ def test_should_deny_a_spawn_it_cannot_reshape(
     assert decision["permissionDecision"] == "deny"
     assert decision["permissionDecisionReason"] == reason
     assert "updatedInput" not in decision
-
-
-def test_should_deny_a_brief_the_advisor_line_would_push_past_the_byte_cap(
-    tmp_path: Path,
-) -> None:
-    full_brief = {**SPAWN_INPUT, "instructions": "x" * 8100}
-    decision = _hook_specific_output(
-        _run_hook(_write_pace_stub(tmp_path, 0, {"over_pace": True}), full_brief)
-    )
-    assert decision["permissionDecision"] == "deny"
-    over_by = 8100 + 2 + len(FABLE_ADVISOR_LINE.encode("utf-8")) - 8192
-    assert decision["permissionDecisionReason"].endswith(
-        f"shorten the instructions by {over_by} bytes"
-    )

package/hooks/routing/thread_spawn_pace_hook.py

@@ -8,8 +8,7 @@ beside it, or the script ``COORDINATOR_USAGE_PACE_SCRIPT`` names.
 
     usage under pace (exit 1)          -> no output; the call runs unchanged
     over pace (exit 0) or unreadable   -> allow with updatedInput:
-        model "claude-sonnet-5-5", effort "medium",
-        instructions + the mandatory Fable advisor line
+        model "opus", effort "low"
     input that cannot be reshaped      -> deny with a one-line reason
 
 ``updatedInput`` is the whole tool input the call runs with, so it carries
@@ -42,16 +41,9 @@ from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_s
 from hooks_constants.thread_spawn_pace_hook_constants import (
     ADDITIONAL_CONTEXT_KEY,
     EFFORT_INPUT_KEY,
-    FABLE_ADVISOR_LINE,
-    INSTRUCTIONS_ENCODING,
-    INSTRUCTIONS_INPUT_KEY,
-    INSTRUCTIONS_MAXIMUM_BYTES,
-    INSTRUCTIONS_SEPARATOR,
     LAUNCH_FAILURE_ERROR_TEMPLATE,
     MODEL_INPUT_KEY,
-    NO_INSTRUCTIONS_REASON,
     NOT_AN_OBJECT_REASON,
-    OVER_BYTE_CAP_REASON_TEMPLATE,
     PACE_VERDICT_CONTEXT_MAXIMUM_CHARACTERS,
     PERMISSION_DECISION_REASON_KEY,
     PERMISSION_DENY,
@@ -72,55 +64,30 @@ from hooks_constants.usage_pace_constants import (
 
 
 class SpawnNotReshapable(Exception):
-    """The spawn input cannot carry the over-pace model, effort, and advisor line."""
-
-
-def _instructions_with_advisor_line(instructions: str) -> str:
-    reshaped_instructions = (
-        instructions
-        if FABLE_ADVISOR_LINE in instructions
-        else f"{instructions}{INSTRUCTIONS_SEPARATOR}{FABLE_ADVISOR_LINE}"
-    )
-    reshaped_byte_count = len(reshaped_instructions.encode(INSTRUCTIONS_ENCODING))
-    if reshaped_byte_count > INSTRUCTIONS_MAXIMUM_BYTES:
-        raise SpawnNotReshapable(
-            OVER_BYTE_CAP_REASON_TEMPLATE.format(
-                reshaped_byte_count=reshaped_byte_count,
-                maximum_bytes=INSTRUCTIONS_MAXIMUM_BYTES,
-                excess_byte_count=reshaped_byte_count - INSTRUCTIONS_MAXIMUM_BYTES,
-            )
-        )
-    return reshaped_instructions
+    """The spawn input cannot carry the over-pace model and effort."""
 
 
 def reshape_thread_spawn(tool_input: object) -> dict[str, object]:
-    """Move a thread spawn to Sonnet at medium effort with a Fable advisor line.
+    """Move a thread spawn to the latest Opus at low effort.
 
     ::
 
         {"title": "t", "instructions": "Do X."}
-        -> {"title": "t", "instructions": "Do X.\\n\\nMandatory Fable advisor: ...",
-            "model": "claude-sonnet-5-5", "effort": "medium"}
-
-    An instructions text that already carries the advisor line keeps one copy.
+        -> {"title": "t", "instructions": "Do X.",
+            "model": "opus", "effort": "low"}
 
     Args:
         tool_input: The ``tool_input`` object of the start_thread_session call.
 
     Raises:
-        SpawnNotReshapable: The input is not an object, has no instructions
-            text, or would pass the server's instructions byte cap.
+        SpawnNotReshapable: The input is not an object.
     """
     if not isinstance(tool_input, dict):
         raise SpawnNotReshapable(NOT_AN_OBJECT_REASON)
-    instructions = tool_input.get(INSTRUCTIONS_INPUT_KEY)
-    if not isinstance(instructions, str):
-        raise SpawnNotReshapable(NO_INSTRUCTIONS_REASON)
     return {
         **tool_input,
         MODEL_INPUT_KEY: THREAD_MODEL_WHEN_OVER_PACE,
         EFFORT_INPUT_KEY: THREAD_EFFORT_WHEN_OVER_PACE,
-        INSTRUCTIONS_INPUT_KEY: _instructions_with_advisor_line(instructions),
     }
 
 

package/package.json

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

package/scripts/account_broker.py

@@ -127,7 +127,6 @@ def readings_payload(all_readings: Sequence[Reading]) -> list[dict[str, object]]
     ]
 
 
-
 def _spent_for_readings(all_readings: Sequence[Reading], all_state: dict[str, object], now: datetime) -> tuple[frozenset[Account], dict[Account, datetime]]:
     marks = all_state["spent"]
     spent = {}
@@ -147,6 +146,23 @@ def _mark_spent(all_state: dict[str, object], reading: Reading, now: datetime, r
     return until
 
 
+def _outside_roster_resets(product: Product, all_readings: Sequence[Reading], all_state: Mapping[str, object], now: datetime) -> tuple[datetime, ...]:
+    marks = all_state.get("spent") if isinstance(all_state.get("spent"), dict) else {}
+    all_roster_names = {each_reading.account.name for each_reading in all_readings}
+    prefix = f"{product.value}:"
+    placeholder_suffix = f":{Path()}"
+    return tuple(datetime.fromtimestamp(float(each_raw), timezone.utc) for each_key, each_raw in marks.items() if isinstance(each_key, str) and each_key.startswith(prefix) and each_key.endswith(placeholder_suffix) and each_key[len(prefix):-len(placeholder_suffix)] not in all_roster_names and isinstance(each_raw, (int, float)) and each_raw > now.timestamp())
+
+
+def _with_outside_spent_marks(decision: Decision, all_outside_resets: Sequence[datetime]) -> Decision:
+    if not all_outside_resets:
+        return decision
+    soonest = min(all_outside_resets) if decision.resets_at is None else min(decision.resets_at, *all_outside_resets)
+    if decision.action == "wait" and decision.resets_at == soonest:
+        return decision
+    return Decision("wait", None, soonest, f"no account has room; next reset at {_time_text(soonest)}", "wait")
+
+
 def _write_report(path: Path, report: Report) -> None:
     payload = {
         "product": report.product.value,
@@ -268,12 +284,8 @@ def _execute(
 ) -> tuple[JobOutcome, Report]:
     context = _prepare_run(product, all_argv, now, timeout_seconds, stdin_text, cwd, encoding, errors)
     while True:
-        decision = choose_from_readings(
-            product, context.all_readings, now=now,
-            all_spent_accounts=frozenset(context.all_spent_accounts),
-            preferred_command=context.preferred_command, adapter=context.active,
-            all_spent_resets=context.all_spent_resets
-        )
+        picked = choose_from_readings(product, context.all_readings, now=now, all_spent_accounts=frozenset(context.all_spent_accounts), preferred_command=context.preferred_command, adapter=context.active, all_spent_resets=context.all_spent_resets)
+        decision = _with_outside_spent_marks(picked, _outside_roster_resets(product, context.all_readings, context.all_state, now))
         context.report.events.append({"type": "pick", "decision": decision_payload(decision)})
         if decision.account is None:
             return _wait_outcome(context, decision), context.report
@@ -309,21 +321,20 @@ def _parser() -> argparse.ArgumentParser:
     return parser
 
 
-def _parse_spent_mark(all_accounts_by_name: Mapping[str, Reading], mark: str) -> tuple[Reading, datetime | None]:
+def _parse_spent_mark(all_accounts_by_name: Mapping[str, Reading], mark: str, product: Product) -> tuple[Reading, datetime | None]:
     name, separator, reset_text = mark.partition(":")
-    if name not in all_accounts_by_name:
-        raise BrokerConfigurationError(f"unknown account {name}")
     try:
         reset = datetime.fromtimestamp(float(reset_text), timezone.utc) if separator else None
-    except ValueError as error:
+    except (ValueError, OSError, OverflowError) as error:
         raise BrokerConfigurationError(f"invalid reset for account {name}") from error
-    return all_accounts_by_name[name], reset
+    reading = all_accounts_by_name.get(name)
+    return reading if reading is not None else Reading(Account(product, name, Path(), False), None), reset
 
 
-def _save_spent_arguments(all_marks: Sequence[str], all_readings: Sequence[Reading], all_state: dict[str, object], now: datetime) -> None:
+def _save_spent_arguments(all_marks: Sequence[str], all_readings: Sequence[Reading], all_state: dict[str, object], now: datetime, product: Product) -> None:
     all_accounts_by_name = {each_reading.account.name: each_reading for each_reading in all_readings}
     for each_mark in all_marks:
-        reading, reset = _parse_spent_mark(all_accounts_by_name, each_mark)
+        reading, reset = _parse_spent_mark(all_accounts_by_name, each_mark, product)
         _mark_spent(all_state, reading, now, reset)
 
 
@@ -352,9 +363,10 @@ def _choose_cli(product: Product, parsed: argparse.Namespace) -> int:
     all_state = _load_state(broker_state_path())
     all_readings = read_accounts(product, all_state=all_state, now=now)
     if parsed.action == "choose" and parsed.spent:
-        _save_spent_arguments(parsed.spent, all_readings, all_state, now)
+        _save_spent_arguments(parsed.spent, all_readings, all_state, now, product)
     spent, resets = _spent_for_readings(all_readings, all_state, now)
     decision = choose_from_readings(product, all_readings, now=now, all_spent_accounts=spent, all_spent_resets=resets)
+    decision = _with_outside_spent_marks(decision, _outside_roster_resets(product, all_readings, all_state, now))
     if parsed.action == "choose":
         print(json.dumps({"decision": decision_payload(decision), "accounts": readings_payload(all_readings), "state_path": str(broker_state_path())}))
     return WAIT_EXIT_CODE if decision.action == "wait" else 0

package/scripts/dev_env_scripts_constants/test_account_broker_constants.py

@@ -0,0 +1,49 @@
+"""Floors and outcome shape for the account broker."""
+
+from __future__ import annotations
+
+import dataclasses
+
+import pytest
+
+from dev_env_scripts_constants.account_broker_constants import (
+    ALL_CLAUDE_FLOORS,
+    ALL_CODEX_FLOORS,
+    JobOutcome,
+)
+from dev_env_scripts_constants.claude_account_constants import (
+    MAIN_SESSION_USED_CEILING_PERCENT,
+    MAIN_SPEND_WINDOW,
+    MAIN_WEEKLY_USED_CEILING_PERCENT,
+    SECOND_SESSION_USED_CEILING_PERCENT,
+    SECOND_WEEKLY_USED_CEILING_PERCENT,
+)
+from dev_env_scripts_constants.codex_account_constants import (
+    LUNA_TIER_SHORT_WINDOW_MINIMUM_PERCENT_LEFT,
+    LUNA_TIER_STOP_PERCENT_LEFT,
+    NORMAL_TIER_MINIMUM_PERCENT_LEFT,
+)
+
+
+def test_should_keep_claude_floors_tied_to_the_account_ceilings() -> None:
+    assert ALL_CLAUDE_FLOORS == {
+        "main_weekly_used_ceiling": MAIN_WEEKLY_USED_CEILING_PERCENT,
+        "main_session_used_ceiling": MAIN_SESSION_USED_CEILING_PERCENT,
+        "main_spend_window": MAIN_SPEND_WINDOW,
+        "extra_weekly_used_ceiling": SECOND_WEEKLY_USED_CEILING_PERCENT,
+        "extra_session_used_ceiling": SECOND_SESSION_USED_CEILING_PERCENT,
+    }
+
+
+def test_should_keep_codex_floors_tied_to_the_tier_limits() -> None:
+    assert ALL_CODEX_FLOORS == {
+        "normal_minimum_left": NORMAL_TIER_MINIMUM_PERCENT_LEFT,
+        "luna_stop_left": LUNA_TIER_STOP_PERCENT_LEFT,
+        "luna_short_minimum_left": LUNA_TIER_SHORT_WINDOW_MINIMUM_PERCENT_LEFT,
+    }
+
+
+def test_should_freeze_job_outcome() -> None:
+    outcome = JobOutcome(0, "", "", None, (), "served", None, None)
+    with pytest.raises(dataclasses.FrozenInstanceError):
+        outcome.status = "wait"

package/scripts/test_account_broker.py

@@ -24,6 +24,21 @@ from dev_env_scripts_constants.account_broker_constants import WAIT_EXIT_CODE
 NOW = datetime(2026, 10, 3, tzinfo=timezone.utc)
 
 
+class _FrozenClock(datetime):
+    instant = NOW
+
+    @classmethod
+    def now(cls, tz: timezone | None = None) -> datetime:
+        if tz is None:
+            return cls.instant.replace(tzinfo=None)
+        return cls.instant.astimezone(tz)
+
+
+def _freeze_clock(monkeypatch: pytest.MonkeyPatch, instant: datetime) -> None:
+    _FrozenClock.instant = instant
+    monkeypatch.setattr(account_broker, "datetime", _FrozenClock)
+
+
 @pytest.fixture(autouse=True)
 def isolated_state(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
     monkeypatch.setattr(account_broker, "broker_state_path", lambda: tmp_path / "broker" / "state.json")
@@ -525,6 +540,112 @@ def test_should_raise_configuration_error_for_broken_list(
         account_broker.load_claude_accounts()
 
 
+def test_should_wait_when_a_spent_mark_names_an_account_outside_the_roster(
+    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)}))
+    _freeze_clock(monkeypatch, NOW)
+    sooner = NOW + timedelta(hours=2)
+    later = NOW + timedelta(hours=5)
+
+    code = account_broker.main((
+        "choose", "--product", "codex",
+        "--spent", f"visitor:{int(sooner.timestamp())}",
+        "--spent", f"guest:{int(later.timestamp())}",
+    ))
+
+    decision = json.loads(capsys.readouterr().out)["decision"]
+    assert code == WAIT_EXIT_CODE
+    assert decision["action"] == "wait"
+    assert decision["account"] is None
+    assert decision["resets_at"] == sooner.isoformat()
+
+
+def test_should_wait_for_spent_default_home_until_the_mark_passes(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    home = tmp_path / "default-home"
+    monkeypatch.setitem(account_broker.all_product_adapters, Product.CODEX, _adapter((), {}))
+    monkeypatch.setenv("CODEX_HOME", str(home))
+    _freeze_clock(monkeypatch, NOW)
+    reset = NOW + timedelta(hours=2)
+
+    waiting = account_broker.main(("choose", "--product", "codex", "--spent", f"default:{int(reset.timestamp())}"))
+    waiting_decision = json.loads(capsys.readouterr().out)["decision"]
+    assert waiting == WAIT_EXIT_CODE
+    assert waiting_decision["action"] == "wait"
+    assert waiting_decision["resets_at"] == reset.isoformat()
+
+    _FrozenClock.instant = reset + timedelta(seconds=1)
+    running = account_broker.main(("choose", "--product", "codex"))
+    running_decision = json.loads(capsys.readouterr().out)["decision"]
+    assert running == 0
+    assert running_decision["action"] == "run"
+    assert running_decision["account"] == "default"
+    assert running_decision["home"] == str(home.resolve())
+
+
+def test_should_keep_a_spent_mark_without_a_reset_for_one_hour(
+    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)}))
+    _freeze_clock(monkeypatch, NOW)
+
+    code = account_broker.main(("choose", "--product", "codex", "--spent", "guest"))
+
+    decision = json.loads(capsys.readouterr().out)["decision"]
+    assert code == WAIT_EXIT_CODE
+    assert decision["action"] == "wait"
+    assert decision["resets_at"] == (NOW + timedelta(hours=1)).isoformat()
+
+
+def test_should_reject_an_invalid_spent_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)}))
+
+    code = account_broker.main(("choose", "--product", "codex", "--spent", "guest:tomorrow"))
+
+    assert code == 2
+    assert "invalid reset" in capsys.readouterr().err
+
+
+@pytest.mark.parametrize("reset_text", ["inf", "1e20", "-1e20"])
+def test_should_reject_a_spent_reset_outside_the_platform_range(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], reset_text: 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", f"guest:{reset_text}"))
+
+    assert code == 2
+    assert "invalid reset" in capsys.readouterr().err
+
+
+def test_should_run_past_a_spent_mark_left_by_an_account_removed_from_the_roster(
+    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)}))
+    _freeze_clock(monkeypatch, NOW)
+    retired_key = account_broker._state_key(_account("retired"))
+    account_broker._save_state(
+        account_broker.broker_state_path(),
+        {"meters": {}, "spent": {retired_key: (NOW + timedelta(days=6)).timestamp()}, "affinity": {}},
+    )
+
+    code = account_broker.main(("choose", "--product", "codex"))
+
+    decision = json.loads(capsys.readouterr().out)["decision"]
+    assert code == 0
+    assert decision["action"] == "run"
+    assert decision["account"] == "first"
+
+
 def test_should_run_job_through_override(
     monkeypatch: pytest.MonkeyPatch
 ) -> None: