claude-dev-env 8.46.18 → 8.46.20

package/hooks/blocking/code_rules_shared.py

@@ -431,6 +431,26 @@ def _existing_scratchpad_root(
     return None
 
 
+def _is_at_or_under_payload_working_directory(file_path: str, hook_payload: dict) -> bool:
+    """Return True when file_path's real path sits at or under the payload ``cwd``.
+
+    Args:
+        file_path: The path the write targets.
+        hook_payload: The PreToolUse payload that may carry ``cwd``.
+
+    Returns:
+        True when the payload names a working directory and file_path resolves
+        at or under its real path.
+    """
+    working_directory = str(hook_payload.get("cwd") or "")
+    if not working_directory:
+        return False
+    return _is_at_or_under_root(
+        _normalized_absolute_comparison_path(os.path.realpath(file_path)),
+        _normalized_absolute_comparison_path(os.path.realpath(working_directory)),
+    )
+
+
 def is_under_session_scratchpad(file_path: str, hook_payload: dict) -> bool:
     """Return True when file_path resolves under the harness session scratchpad.
 
@@ -460,13 +480,9 @@ def is_under_session_scratchpad(file_path: str, hook_payload: dict) -> bool:
     session_id = _session_id_for_scratchpad(hook_payload)
     if not session_id:
         return False
-    real_target = os.path.realpath(file_path)
-    working_directory = str(hook_payload.get("cwd") or "")
-    if working_directory and _is_at_or_under_root(
-        _normalized_absolute_comparison_path(real_target),
-        _normalized_absolute_comparison_path(os.path.realpath(working_directory)),
-    ):
+    if _is_at_or_under_payload_working_directory(file_path, hook_payload):
         return False
+    real_target = os.path.realpath(file_path)
     real_temp_root = os.path.realpath(tempfile.gettempdir())
     all_relative_parts = _relative_parts_under_temp_root(real_target, real_temp_root)
     return (
@@ -482,10 +498,10 @@ def is_ephemeral_path(file_path: str, hook_payload: dict | None = None) -> bool:
     scratch directories (``/tmp`` and ``$CLAUDE_JOB_DIR/tmp``), the harness
     session scratchpad, and a coding agent's own home-directory tooling such as
     ``~/.grok/runs/``. A path inside the payload's own working directory
-    (``cwd``) is never treated as scratch, so a repository checked out under
-    ``/tmp`` still receives full enforcement. The scratchpad match reads the
-    session id from the payload when supplied, else the harness environment
-    variable. The code-rules and TDD gates call the underlying predicates
+    (``cwd``) is never treated as scratch or agent tooling, so a repository
+    checked out under ``/tmp`` or ``~/.grok/runs/`` still receives full
+    enforcement. The scratchpad match reads the session id from the payload
+    when supplied, else the harness environment variable. The code-rules and TDD gates call the underlying predicates
     ``is_ephemeral_script_path``, ``is_agent_home_tooling``, and
     ``is_under_session_scratchpad`` directly.
 
@@ -501,7 +517,9 @@ def is_ephemeral_path(file_path: str, hook_payload: dict | None = None) -> bool:
     repository_root = str((hook_payload or {}).get("cwd") or "")
     if is_ephemeral_script_path(file_path, repository_root):
         return True
-    if is_agent_home_tooling(file_path):
+    if is_agent_home_tooling(file_path) and not _is_at_or_under_payload_working_directory(
+        file_path, hook_payload or {}
+    ):
         return True
     return is_under_session_scratchpad(file_path, hook_payload or {})
 

package/hooks/blocking/test_code_rules_shared.py

@@ -357,3 +357,20 @@ def test_ephemeral_path_stays_true_for_scratchpad_file_outside_payload_cwd(
     assert (
         _SHARED_MODULE.is_ephemeral_path(str(throwaway_script), payload_with_worktree_cwd) is True
     )
+
+
+def test_ephemeral_path_is_false_for_file_under_payload_cwd_inside_agent_home() -> None:
+    checkout_directory = os.path.join("/home/example", ".grok", "runs", "checkout")
+    repository_module = os.path.join(checkout_directory, "src", "service.py")
+
+    assert (
+        _SHARED_MODULE.is_ephemeral_path(repository_module, {"cwd": checkout_directory})
+        is False
+    )
+
+
+def test_ephemeral_path_stays_true_for_agent_home_file_outside_payload_cwd() -> None:
+    checkout_directory = os.path.join("/home/example", ".grok", "runs", "checkout")
+    helper_script = os.path.join("/home/example", ".grok", "runs", "worktree-health", "health.py")
+
+    assert _SHARED_MODULE.is_ephemeral_path(helper_script, {"cwd": checkout_directory}) is True

package/package.json

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

package/scripts/account_broker.py

@@ -128,13 +128,22 @@ def readings_payload(all_readings: Sequence[Reading]) -> list[dict[str, object]]
     ]
 
 
+def _stored_reset(raw: object, now: datetime) -> datetime | None:
+    if not isinstance(raw, (int, float)) or raw <= now.timestamp():
+        return None
+    try:
+        return datetime.fromtimestamp(raw, timezone.utc)
+    except (ValueError, OSError, OverflowError):
+        return None
+
+
 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 = {}
     for each_reading in all_readings:
-        raw = marks.get(_state_key(each_reading.account))
-        if isinstance(raw, (int, float)) and raw > now.timestamp():
-            spent[each_reading.account] = datetime.fromtimestamp(raw, timezone.utc)
+        reset = _stored_reset(marks.get(_state_key(each_reading.account)), now)
+        if reset is not None:
+            spent[each_reading.account] = reset
     return frozenset(spent), spent
 
 
@@ -147,21 +156,31 @@ 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, ...]:
+def _outside_roster_resets(product: Product, all_readings: Sequence[Reading], all_state: Mapping[str, object], now: datetime) -> dict[str, 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:
+    all_resets_by_name = {}
+    for each_key, each_raw in marks.items():
+        if not (isinstance(each_key, str) and each_key.startswith(prefix) and each_key.endswith(placeholder_suffix)):
+            continue
+        name = each_key[len(prefix):-len(placeholder_suffix)]
+        reset = _stored_reset(each_raw, now)
+        if name not in all_roster_names and reset is not None:
+            all_resets_by_name[name] = reset
+    return all_resets_by_name
+
+
+def _with_outside_spent_marks(decision: Decision, all_outside_resets_by_name: Mapping[str, datetime]) -> Decision:
+    if not all_outside_resets_by_name:
         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:
+    outside_name, outside_reset = min(all_outside_resets_by_name.items(), key=lambda each_item: each_item[1])
+    if decision.action != "wait":
+        return Decision("wait", None, outside_reset, f"account {outside_name} outside the roster is spent; next reset at {_time_text(outside_reset)}", "wait")
+    if decision.resets_at is not None and decision.resets_at <= outside_reset:
         return decision
-    return Decision("wait", None, soonest, f"no account has room; next reset at {_time_text(soonest)}", "wait")
+    return Decision("wait", None, outside_reset, f"no account has room; next reset at {_time_text(outside_reset)}", "wait")
 
 
 def _write_report(path: Path, report: Report) -> None:
@@ -328,12 +347,17 @@ def _parser() -> argparse.ArgumentParser:
 
 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 not name:
+        raise BrokerConfigurationError(f"spent mark {mark!r} needs an account name")
     try:
         reset = datetime.fromtimestamp(float(reset_text), timezone.utc) if separator else None
     except (ValueError, OSError, OverflowError) as error:
         raise BrokerConfigurationError(f"invalid reset for account {name}") from error
     reading = all_accounts_by_name.get(name)
-    return reading if reading is not None else Reading(Account(product, name, Path(), False), None), reset
+    if reading is None:
+        print(f"warning: spent mark names {name}, an account outside the roster; choose waits until its reset", file=sys.stderr)
+        return Reading(Account(product, name, Path(), False), None), reset
+    return reading, reset
 
 
 def _save_spent_arguments(all_marks: Sequence[str], all_readings: Sequence[Reading], all_state: dict[str, object], now: datetime, product: Product) -> None:

package/scripts/test_account_broker.py

@@ -696,6 +696,81 @@ def test_should_run_job_through_override(
     assert calls == [b"input"]
 
 
+@pytest.mark.parametrize("marked_name", ["retired", "first"])
+def test_should_run_past_a_stored_spent_mark_beyond_the_platform_range(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], marked_name: str
+) -> None:
+    account = _account("first")
+    second = _account("second")
+    monkeypatch.setitem(account_broker.all_product_adapters, Product.CODEX, _adapter((account, second), {"first": _meters(80, 80), "second": _meters(80, 80)}))
+    _freeze_clock(monkeypatch, NOW)
+    marked_account = account if marked_name == "first" else Account(Product.CODEX, marked_name, Path(), False)
+    account_broker._save_state(
+        account_broker.broker_state_path(),
+        {"meters": {}, "spent": {account_broker._state_key(marked_account): 1e20}, "affinity": {}},
+    )
+
+    code = account_broker.main(("choose", "--product", "codex"))
+
+    decision = json.loads(capsys.readouterr().out)["decision"]
+    assert code == 0
+    assert decision["action"] == "run"
+
+
+def test_should_name_the_outside_spent_mark_when_it_forces_a_wait(
+    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)
+    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 decision["reason"] == f"account visitor outside the roster is spent; next reset at {account_broker._time_text(reset)}"
+
+
+def test_should_warn_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)
+
+    account_broker.main(("choose", "--product", "codex", "--spent", "frist", "--spent", "first"))
+
+    all_warning_lines = capsys.readouterr().err.splitlines()
+    assert len(all_warning_lines) == 1
+    assert "frist" in all_warning_lines[0]
+    assert "outside the roster" in all_warning_lines[0]
+
+
+@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
+) -> 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", mark))
+
+    assert code == 2
+    assert "account name" in capsys.readouterr().err
+    assert account_broker._load_state(account_broker.broker_state_path())["spent"] == {}
+
+
+def test_should_serialize_a_run_and_a_wait_decision() -> None:
+    account = _account("first")
+    reset = NOW + timedelta(hours=2)
+
+    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()}
+
 
 def test_should_print_the_whole_rate_limit_result_for_one_home(
     monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path