claude-dev-env 8.38.0 → 8.38.1

package/docs/account-broker.md

@@ -18,7 +18,7 @@ python scripts/account_broker.py run --product claude --report report.json -- cl
 
 `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.
 
-The broker stores cached meters, spent marks, and Claude session bindings in one JSON file under `~/.claude/account-broker`. State writes use a sibling temporary file and `os.replace`.
+The broker stores cached meters, spent marks, and Claude session bindings in one JSON file under `~/.claude/account-broker`. Every broker process for the same user reads that file, so a spent mark pauses that account for every job. A write holds an exclusive lock on the sibling `state.json.lock`, re-reads the file, merges, and swaps in a sibling temporary file with `os.replace`. The merge keeps the latest reset for each spent mark and the newest meter read for each account.
 
 ## Exit codes and report
 

package/package.json

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

package/scripts/account_broker_support.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 import os
 import subprocess
+import sys
 import tempfile
 import threading
 from contextlib import contextmanager
@@ -12,6 +13,11 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Iterator, Sequence
 
+if sys.platform == "win32":
+    import msvcrt
+else:
+    import fcntl
+
 import codex_account_choice
 import codex_account_meters
 from claude_account_profile import default_profile_home, validate_profile_name
@@ -19,6 +25,7 @@ from claude_chain_usage import WeeklyUtilizationProbeError, probe_account_meters
 from dev_env_scripts_constants.account_broker_constants import (
     BROKER_STATE_DIRECTORY_NAME,
     BROKER_STATE_FILE_NAME,
+    BROKER_STATE_LOCK_SUFFIX,
     BROKER_STATE_TEMP_SUFFIX,
     Account,
     BrokerConfigurationError,
@@ -222,18 +229,79 @@ def _load_state(path: Path) -> dict[str, object]:
     return {key: parsed_state.get(key) if isinstance(parsed_state.get(key), dict) else {} for key in ("meters", "spent", "affinity")}
 
 
-def _save_state(path: Path, all_state: dict[str, object]) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    temporary_name: str | None = None
+if sys.platform == "win32":
+
+    def _acquire_state_lock(lock_descriptor: int) -> None:
+        os.lseek(lock_descriptor, 0, os.SEEK_SET)
+        msvcrt.locking(lock_descriptor, msvcrt.LK_LOCK, 1)
+
+    def _release_state_lock(lock_descriptor: int) -> None:
+        os.lseek(lock_descriptor, 0, os.SEEK_SET)
+        msvcrt.locking(lock_descriptor, msvcrt.LK_UNLCK, 1)
+
+else:
+
+    def _acquire_state_lock(lock_descriptor: int) -> None:
+        fcntl.flock(lock_descriptor, fcntl.LOCK_EX)
+
+    def _release_state_lock(lock_descriptor: int) -> None:
+        fcntl.flock(lock_descriptor, fcntl.LOCK_UN)
+
+
+@contextmanager
+def _state_lock(path: Path) -> Iterator[None]:
+    """Hold an exclusive operating-system lock on the state file's sibling lock file."""
+    lock_descriptor = os.open(path.with_name(path.name + BROKER_STATE_LOCK_SUFFIX), os.O_CREAT | os.O_RDWR)
     try:
-        with tempfile.NamedTemporaryFile(mode="w", encoding="utf-8", dir=path.parent, prefix="state-", suffix=BROKER_STATE_TEMP_SUFFIX, delete=False, newline="\n") as stream:
-            temporary_name = stream.name
-            json.dump(all_state, stream, indent=REPORT_INDENT_SPACES, sort_keys=True)
-            stream.write("\n")
-        os.replace(temporary_name, path)
+        _acquire_state_lock(lock_descriptor)
+        try:
+            yield
+        finally:
+            _release_state_lock(lock_descriptor)
     finally:
-        if temporary_name is not None and os.path.exists(temporary_name):
-            os.unlink(temporary_name)
+        os.close(lock_descriptor)
+
+
+def _read_at(entry: object) -> float:
+    if not isinstance(entry, dict):
+        return float("-inf")
+    read_at = entry.get("read_at")
+    return float(read_at) if isinstance(read_at, (int, float)) else float("-inf")
+
+
+def _merged_state(all_saved_state: dict[str, object], all_unsaved_state: dict[str, object]) -> dict[str, object]:
+    """Combine two state documents so each writer keeps the other writer's entries.
+
+    A spent mark keeps its latest reset, a meter entry keeps its newest read,
+    and the unsaved session bindings take their keys.
+    """
+    all_meters = dict(all_saved_state["meters"])
+    for each_key, each_entry in all_unsaved_state["meters"].items():
+        if _read_at(each_entry) >= _read_at(all_meters.get(each_key)):
+            all_meters[each_key] = each_entry
+    all_spent = dict(all_saved_state["spent"])
+    for each_key, each_reset in all_unsaved_state["spent"].items():
+        saved_reset = all_spent.get(each_key)
+        if not isinstance(saved_reset, (int, float)) or (isinstance(each_reset, (int, float)) and each_reset > saved_reset):
+            all_spent[each_key] = each_reset
+    return {"meters": all_meters, "spent": all_spent, "affinity": {**all_saved_state["affinity"], **all_unsaved_state["affinity"]}}
+
+
+def _save_state(path: Path, all_state: dict[str, object]) -> None:
+    """Merge the caller's state into the saved file under a lock, then refresh the caller's copy."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with _state_lock(path):
+        all_state.update(_merged_state(_load_state(path), all_state))
+        temporary_name: str | None = None
+        try:
+            with tempfile.NamedTemporaryFile(mode="w", encoding="utf-8", dir=path.parent, prefix="state-", suffix=BROKER_STATE_TEMP_SUFFIX, delete=False, newline="\n") as stream:
+                temporary_name = stream.name
+                json.dump(all_state, stream, indent=REPORT_INDENT_SPACES, sort_keys=True)
+                stream.write("\n")
+            os.replace(temporary_name, path)
+        finally:
+            if temporary_name is not None and os.path.exists(temporary_name):
+                os.unlink(temporary_name)
 
 
 def _state_key(account: Account) -> str:

package/scripts/dev_env_scripts_constants/account_broker_constants.py

@@ -49,6 +49,7 @@ REPORT_INDENT_SPACES = 2
 BROKER_STATE_DIRECTORY_NAME = "account-broker"
 BROKER_STATE_FILE_NAME = "state.json"
 BROKER_STATE_TEMP_SUFFIX = ".json"
+BROKER_STATE_LOCK_SUFFIX = ".lock"
 SECONDS_PER_HOUR = 3600
 
 

package/scripts/test_account_broker_support.py

@@ -105,3 +105,23 @@ def test_should_extract_session_id_and_restore_runner() -> None:
         assert support.subprocess_runner is runner
     assert support.subprocess_runner is original
     assert support.extract_session_id_from_stdout('{"session_id":"one"}') == "one"
+
+
+def test_should_keep_every_concurrent_spent_mark_and_newest_meter_reading(tmp_path: Path) -> None:
+    state_path = tmp_path / "broker" / "state.json"
+    first_worker = support._load_state(state_path)
+    second_worker = support._load_state(state_path)
+    first_worker["spent"]["codex:one"] = 2000.0
+    first_worker["meters"]["codex:one"] = {"read_at": 500.0, "meters": None}
+    support._save_state(state_path, first_worker)
+    second_worker["spent"]["codex:two"] = 3000.0
+    second_worker["meters"]["codex:one"] = {"read_at": 100.0, "meters": None}
+    support._save_state(state_path, second_worker)
+    stale_worker = {"meters": {}, "spent": {"codex:one": 1000.0}, "affinity": {"session": "one"}}
+    support._save_state(state_path, stale_worker)
+
+    saved = support._load_state(state_path)
+
+    assert saved["spent"] == {"codex:one": 2000.0, "codex:two": 3000.0}
+    assert saved["meters"]["codex:one"]["read_at"] == 500.0
+    assert saved["affinity"] == {"session": "one"}