claude-dev-env 8.43.1 → 8.43.3

package/package.json

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

package/scripts/account_broker.py

@@ -244,7 +244,7 @@ def _attempt_once(context: _RunContext, decision: Decision) -> JobOutcome | None
     except (OSError, subprocess.TimeoutExpired) as error:
         status = "timeout" if isinstance(error, subprocess.TimeoutExpired) else "start_failed"
         _record_spent_attempt(context, account, status, COMMAND_MISSING_EXIT_CODE)
-        if not context.all_readings:
+        if isinstance(error, subprocess.TimeoutExpired) or not context.all_readings:
             context.report.final_decision = decision
             return JobOutcome(COMMAND_MISSING_EXIT_CODE, "", str(error), account.name, tuple(context.all_attempts), "advisor_blocked", None, None)
         return None

package/scripts/dev_env_scripts_constants/account_broker_constants.py

@@ -224,9 +224,13 @@ def _account_reset(reading: Reading, is_spent: bool = False) -> datetime | None:
         return None
     if is_spent:
         return min((reset for reset in (meters.session_resets_at, meters.weekly_resets_at) if reset is not None), default=None)
-    if reading.account.product is Product.CLAUDE:
-        if reading.account.is_main:
-            return meters.weekly_resets_at
+    is_claude_main = reading.account.product is Product.CLAUDE and reading.account.is_main
+    if is_claude_main:
+        blocking = (
+            (meters.session_percent_left, FULL_PERCENT - ALL_CLAUDE_FLOORS["main_session_used_ceiling"], meters.session_resets_at),
+            (meters.weekly_percent_left, FULL_PERCENT - ALL_CLAUDE_FLOORS["main_weekly_used_ceiling"], meters.weekly_resets_at),
+        )
+    elif reading.account.product is Product.CLAUDE:
         blocking = (
             (meters.session_percent_left, FULL_PERCENT - ALL_CLAUDE_FLOORS["extra_session_used_ceiling"], meters.session_resets_at),
             (meters.weekly_percent_left, FULL_PERCENT - ALL_CLAUDE_FLOORS["extra_weekly_used_ceiling"], meters.weekly_resets_at),
@@ -236,7 +240,10 @@ def _account_reset(reading: Reading, is_spent: bool = False) -> datetime | None:
             (meters.session_percent_left, ALL_CODEX_FLOORS["luna_short_minimum_left"], meters.session_resets_at),
             (meters.weekly_percent_left, ALL_CODEX_FLOORS["luna_stop_left"], meters.weekly_resets_at),
         )
-    return max((reset for room, floor, reset in blocking if room is not None and room <= floor and reset is not None), default=None)
+    all_blocking_resets = [reset for room, floor, reset in blocking if room is not None and room <= floor and reset is not None]
+    if is_claude_main and meters.weekly_resets_at is not None:
+        all_blocking_resets.append(meters.weekly_resets_at - ALL_CLAUDE_FLOORS["main_spend_window"])
+    return max(all_blocking_resets, default=None)
 
 
 def _rank_key(reading: Reading) -> float:

package/scripts/test_account_broker.py

@@ -127,6 +127,28 @@ def test_should_prioritize_main_when_its_guard_passes() -> None:
     assert decision.account == main.account
 
 
+@pytest.mark.parametrize(
+    ("short_left", "weekly_left", "weekly_reset", "expected_reset"),
+    (
+        (40, 20, NOW + timedelta(hours=4), NOW + timedelta(hours=2)),
+        (80, 5, NOW + timedelta(hours=4), NOW + timedelta(hours=4)),
+        (80, 50, NOW + timedelta(days=3), NOW + timedelta(days=2)),
+    ),
+)
+def test_should_wait_for_the_meter_or_window_that_blocks_main(
+    short_left: float, weekly_left: float, weekly_reset: datetime, expected_reset: datetime
+) -> None:
+    main = Reading(
+        _account("main", Product.CLAUDE, main=True),
+        _meters(short_left, weekly_left, short_reset=NOW + timedelta(hours=2), weekly_reset=weekly_reset),
+    )
+
+    decision = choose_from_readings(Product.CLAUDE, (main,), now=NOW)
+
+    assert decision.action == "wait"
+    assert decision.resets_at == expected_reset
+
+
 def test_should_try_next_account_after_usage_limit(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
     accounts = (_account("first"), _account("second"))
     adapter = _adapter(accounts, {"first": _meters(80, 80), "second": _meters(70, 70)})
@@ -361,12 +383,8 @@ def test_should_keep_spent_mark_until_reset(
     assert json.loads(capsys.readouterr().out)["decision"]["account"] == "second"
 
 
-@pytest.mark.parametrize(
-    ("start_error", "expected_status"),
-    ((OSError("missing command"), "start_failed"), (subprocess.TimeoutExpired("job", 1), "timeout")),
-)
 def test_should_leave_later_choices_open_after_start_failure(
-    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], start_error: Exception, expected_status: str
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
 ) -> None:
     accounts = (_account("first"), _account("second"))
     monkeypatch.setitem(account_broker.all_product_adapters, Product.CODEX, _adapter(accounts, {
@@ -374,12 +392,37 @@ def test_should_leave_later_choices_open_after_start_failure(
     }))
 
     def runner(argv: object, **options: object) -> subprocess.CompletedProcess[str]:
-        raise start_error
+        raise OSError("missing command")
 
     with account_broker.override_subprocess_runner(runner):
         outcome, _ = account_broker._execute(Product.CODEX, ("job",), now=datetime.now(timezone.utc))
 
-    assert outcome.attempts == (("first", expected_status), ("second", expected_status))
+    assert outcome.attempts == (("first", "start_failed"), ("second", "start_failed"))
+    assert account_broker.main(("choose", "--product", "codex")) == 0
+    assert json.loads(capsys.readouterr().out)["decision"]["account"] == "first"
+
+
+def test_should_stop_after_timeout_without_running_job_again(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> 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)
+    }))
+    invoked_homes: list[str] = []
+
+    def runner(argv: object, **options: object) -> subprocess.CompletedProcess[str]:
+        invoked_homes.append(Path(options["env"]["CODEX_HOME"]).name)
+        raise subprocess.TimeoutExpired("job", 1)
+
+    with account_broker.override_subprocess_runner(runner):
+        outcome, report = account_broker._execute(Product.CODEX, ("job",), now=datetime.now(timezone.utc))
+
+    assert invoked_homes == ["first"]
+    assert outcome.attempts == (("first", "timeout"),)
+    assert outcome.status == "advisor_blocked"
+    assert outcome.account_name == "first"
+    assert report.final_decision.account.name == "first"
     assert account_broker.main(("choose", "--product", "codex")) == 0
     assert json.loads(capsys.readouterr().out)["decision"]["account"] == "first"