claude-dev-env 8.83.0 → 8.83.2

package/scripts/test_account_broker_support.py

@@ -7,7 +7,7 @@ import shutil
 import subprocess
 import sys
 import time
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
 from collections.abc import Callable
 from pathlib import Path
 from types import SimpleNamespace
@@ -341,10 +341,11 @@ def test_should_cap_the_meter_read_delay(monkeypatch: pytest.MonkeyPatch, tmp_pa
     all_failures = [support.WeeklyUtilizationProbeError("down") for _ in range(6)]
     _claude_meter_reads(monkeypatch, all_failures)
 
-    meters, unread_reason = support.read_meters_with_backoff(support.read_claude_meters, Account(Product.CLAUDE, "one", tmp_path))
+    meters, unread_reason, is_rate_limited = support.read_meters_with_backoff(support.read_claude_meters, Account(Product.CLAUDE, "one", tmp_path))
 
     assert meters is None
     assert unread_reason == "down"
+    assert not is_rate_limited
     assert all_delays == [1.0, 2.0, 4.0, 8.0, 8.0]
 
 
@@ -356,10 +357,11 @@ def test_should_read_a_signed_out_claude_account_once(monkeypatch: pytest.Monkey
         all_reads.append(account)
         raise support.ClaudeSignedOutError("no usable bearer token")
 
-    meters, unread_reason = support.read_meters_with_backoff(signed_out_reader, Account(Product.CLAUDE, "main", tmp_path))
+    meters, unread_reason, is_rate_limited = support.read_meters_with_backoff(signed_out_reader, Account(Product.CLAUDE, "main", tmp_path))
 
     assert meters is None
     assert unread_reason == "no usable bearer token"
+    assert not is_rate_limited
     assert len(all_reads) == 1
     assert all_delays == []
 
@@ -385,6 +387,162 @@ def test_should_cache_account_reading_under_injected_state_path(
     assert support.broker_state_path().is_file()
 
 
+def _read_twice(monkeypatch: pytest.MonkeyPatch, tmp_path: Path, all_results: list[object], gap: timedelta) -> object:
+    monkeypatch.setattr(support, "broker_state_path", lambda: tmp_path / "broker" / "state.json")
+    _recorded_sleeps(monkeypatch)
+    account = Account(Product.CLAUDE, "second", tmp_path)
+    pending = list(all_results)
+
+    def reader(_selected: Account) -> Meters:
+        next_outcome = pending.pop(0)
+        if isinstance(next_outcome, Exception):
+            raise next_outcome
+        return next_outcome
+
+    adapter = ProductAdapter(lambda: (account,), reader, "CLAUDE_CONFIG_DIR", ())
+    state = support._load_state(support.broker_state_path())
+    first_read_at = datetime(2026, 10, 11, 19, 20, tzinfo=timezone.utc)
+    support.read_accounts(Product.CLAUDE, adapter, all_state=state, now=first_read_at)
+    return support.read_accounts(Product.CLAUDE, adapter, all_state=state, now=first_read_at + gap)[0]
+
+
+def test_should_keep_the_last_good_meters_when_the_usage_endpoint_rate_limits(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    rate_limited = support.WeeklyUtilizationProbeError("usage probe failed: HTTP Error 429: Too Many Requests")
+    reading = _read_twice(monkeypatch, tmp_path, [Meters(74.0, None, 81.0, None), rate_limited], timedelta(minutes=5))
+
+    assert reading.meters == Meters(74.0, None, 81.0, None)
+    assert reading.unread_reason == str(rate_limited)
+    assert reading.measured_at == datetime(2026, 10, 11, 19, 20, tzinfo=timezone.utc)
+
+
+def test_should_drop_last_good_meters_older_than_the_fallback_window(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    rate_limited = support.WeeklyUtilizationProbeError("usage probe failed: HTTP Error 429: Too Many Requests")
+    reading = _read_twice(monkeypatch, tmp_path, [Meters(74.0, None, 81.0, None), rate_limited], timedelta(hours=2))
+
+    assert reading.meters is None
+    assert reading.unread_reason == "usage probe failed: HTTP Error 429: Too Many Requests"
+
+
+def test_should_keep_last_good_meters_at_the_fallback_boundary(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    rate_limited = support.WeeklyUtilizationProbeError("usage probe failed: HTTP Error 429")
+    reading = _read_twice(
+        monkeypatch, tmp_path,
+        [Meters(74.0, None, 81.0, None), rate_limited], timedelta(minutes=30),
+    )
+
+    assert reading.meters == Meters(74.0, None, 81.0, None)
+
+
+def test_should_drop_last_good_meters_after_a_window_reset(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    first_read = datetime(2026, 10, 11, 19, 20, tzinfo=timezone.utc)
+    rate_limited = support.WeeklyUtilizationProbeError("usage probe failed: HTTP Error 429")
+    reading = _read_twice(
+        monkeypatch, tmp_path,
+        [Meters(3.0, first_read + timedelta(minutes=10), 81.0, None), rate_limited],
+        timedelta(minutes=25),
+    )
+
+    assert reading.meters is None
+    assert reading.unread_reason == str(rate_limited)
+
+
+def test_should_drop_held_meters_when_a_window_resets(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    monkeypatch.setattr(support, "broker_state_path", lambda: tmp_path / "broker" / "state.json")
+    account = Account(Product.CLAUDE, "second", tmp_path)
+    start = datetime(2026, 10, 11, 19, 20, tzinfo=timezone.utc)
+    state = support._load_state(support.broker_state_path())
+    state["meters"][support._state_key(account)] = {
+        "read_at": start.timestamp(),
+        "measured_at": (start - timedelta(minutes=5)).timestamp(),
+        "meters": support._meter_payload(Meters(3.0, start + timedelta(minutes=1), 81.0, None)),
+        "unread_reason": "usage probe failed: HTTP Error 429",
+        "retry_at": (start + timedelta(minutes=5)).timestamp(),
+    }
+    adapter = ProductAdapter(lambda: (account,), lambda _: pytest.fail("probe during cooldown"), "CLAUDE_CONFIG_DIR", ())
+
+    reading = support.read_accounts(Product.CLAUDE, adapter, all_state=state, now=start + timedelta(minutes=2))[0]
+
+    assert reading.meters is None
+    assert reading.retry_at == start + timedelta(minutes=5)
+
+
+def test_should_reject_a_last_good_entry_with_an_unrelated_failure() -> None:
+    now = datetime(2026, 10, 11, 19, 20, tzinfo=timezone.utc)
+    entry = {
+        "measured_at": now.timestamp(),
+        "meters": support._meter_payload(Meters(74.0, None, 81.0, None)),
+        "unread_reason": "credentials file missing",
+    }
+
+    assert support._last_good_meters(entry, now) is None
+
+
+def test_should_not_use_last_good_meters_after_a_file_failure(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    reading = _read_twice(
+        monkeypatch, tmp_path,
+        [Meters(74.0, None, 81.0, None), *[OSError("credentials file missing") for _ in range(3)]],
+        timedelta(minutes=5),
+    )
+
+    assert reading.meters is None
+    assert reading.unread_reason == "credentials file missing"
+
+
+def test_should_keep_first_measurement_time_across_rate_limit_fallbacks(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    monkeypatch.setattr(support, "broker_state_path", lambda: tmp_path / "broker" / "state.json")
+    _recorded_sleeps(monkeypatch)
+    account = Account(Product.CLAUDE, "second", tmp_path)
+    rate_limited = support.WeeklyUtilizationProbeError("usage probe failed: HTTP Error 429")
+    pending = [Meters(74.0, None, 81.0, None), rate_limited, rate_limited]
+    calls = []
+
+    def reader(_selected: Account) -> Meters:
+        calls.append(1)
+        outcome = pending.pop(0)
+        if isinstance(outcome, Exception):
+            raise outcome
+        return outcome
+
+    adapter = ProductAdapter(lambda: (account,), reader, "CLAUDE_CONFIG_DIR", ())
+    state = support._load_state(support.broker_state_path())
+    first = datetime(2026, 10, 11, 19, 20, tzinfo=timezone.utc)
+    support.read_accounts(Product.CLAUDE, adapter, all_state=state, now=first)
+    second = support.read_accounts(Product.CLAUDE, adapter, all_state=state, now=first + timedelta(minutes=5))[0]
+    held = support.read_accounts(Product.CLAUDE, adapter, all_state=state, now=first + timedelta(minutes=6))[0]
+    third = support.read_accounts(Product.CLAUDE, adapter, all_state=state, now=first + timedelta(minutes=10))[0]
+
+    assert second.measured_at == first
+    assert held.measured_at == first
+    assert third.measured_at == first
+    assert len(calls) == 3
+
+
+def test_should_keep_newer_measurement_when_stale_fallback_saves_last(tmp_path: Path) -> None:
+    state_path = tmp_path / "broker" / "state.json"
+    account = Account(Product.CLAUDE, "second", tmp_path)
+    key = support._state_key(account)
+    old = {"meters": {key: {"read_at": 40.0, "measured_at": 10.0, "meters": support._meter_payload(Meters(74.0, None, 81.0, None)), "unread_reason": "HTTP Error 429"}}, "spent": {}, "affinity": {}}
+    newer = {"meters": {key: {"read_at": 30.0, "measured_at": 30.0, "meters": support._meter_payload(Meters(5.0, None, 81.0, None)), "unread_reason": None}}, "spent": {}, "affinity": {}}
+    support._save_state(state_path, newer)
+    support._save_state(state_path, old)
+
+    assert support._load_state(state_path)["meters"][key]["meters"]["session_percent_left"] == 5.0
+
+
 def test_should_extract_session_id_and_restore_runner() -> None:
     original = support.subprocess_runner
 

package/scripts/tests/Sync-RepoMain.Tests.ps1

@@ -105,4 +105,29 @@ Describe 'Sync-RepoMain' {
         [System.IO.File]::ReadAllText((Join-Path $fixture.MirrorPath 'added.txt')) | Should -Be "local only`n"
         [System.IO.File]::ReadAllText((Join-Path $fixture.MirrorPath 'tracked.txt')) | Should -Be "new`n"
     }
+
+    It 'skips without fetching while another sync of the same repo holds the run lock' {
+        $fixture = New-MirrorBehindRemote -Name 'lock-held'
+        $lockPath = [System.IO.Path]::TrimEndingDirectorySeparator([System.IO.Path]::GetFullPath($fixture.MirrorPath))
+        $pathBytes = [System.Text.Encoding]::UTF8.GetBytes($lockPath.ToLowerInvariant())
+        $lockName = 'Global\SyncRepoMain-' + [System.Convert]::ToHexString([System.Security.Cryptography.SHA256]::HashData($pathBytes))
+        $readyPath = Join-Path $TestDrive 'lock-ready'
+        $holderCommand = "`$lock = [System.Threading.Mutex]::new(`$true, '$lockName'); Set-Content -LiteralPath '$readyPath' -Value ready; Start-Sleep -Seconds 30"
+        $holder = Start-Process pwsh -ArgumentList '-NoProfile', '-Command', $holderCommand -PassThru
+        try {
+            $deadline = (Get-Date).AddSeconds(20)
+            while (-not (Test-Path -LiteralPath $readyPath) -and (Get-Date) -lt $deadline) {
+                Start-Sleep -Milliseconds 200
+            }
+
+            $exitCode = Invoke-SyncScript -Fixture $fixture
+        }
+        finally {
+            Stop-Process -Id $holder.Id -Force -ErrorAction SilentlyContinue
+        }
+
+        $exitCode | Should -Be 3
+        (Invoke-TestGit -RepoPath $fixture.MirrorPath -Arguments @('rev-parse', 'HEAD')) | Should -Be $fixture.OldTip
+        (Get-Content -LiteralPath $fixture.LogPath -Raw) | Should -Match 'still running'
+    }
 }

package/scripts/tests/test_adapter_configuration.py

@@ -130,6 +130,14 @@ def test_new_artifact_page_gate_registration_is_clean(tmp_path: Path) -> None:
     assert adapters.hook_configuration_diagnostics(current_document, tmp_path) == ()
 
 
+def test_new_eval_write_gate_registration_is_clean(tmp_path: Path) -> None:
+    current_document = _hook_document(
+        ["hooks/blocking/build_eval_before_eval_write_gate.py"],
+        '{"hooks": {}}',
+    )
+    assert adapters.hook_configuration_diagnostics(current_document, tmp_path) == ()
+
+
 def test_new_blocker_in_staged_change_is_rejected(tmp_path: Path) -> None:
     current_document = _hook_document(
         ["hooks/blocking/new.py"],

package/scripts/tests/test_rule_load_scopes.py

@@ -8,6 +8,7 @@ SKILLS_DIRECTORY = PACKAGE_ROOT / ".agents" / "skills"
 
 ALWAYS_ON_RULE_NAMES = frozenset(
     {
+        "agent-board.md",
         "correction-lens.md",
         "index.md",
         "question-presentation.md",

package/scripts/tests/test_sync_repo_main_run_lock.py

@@ -0,0 +1,168 @@
+"""Specifications for Sync-RepoMain skipping while another run of the same repo is live."""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import shutil
+import subprocess
+import time
+from pathlib import Path
+
+_SCRIPT_PATH = Path(__file__).resolve().parents[1] / "Sync-RepoMain.ps1"
+_PWSH = shutil.which("pwsh") or "pwsh"
+_SKIPPED_EXIT_CODE = 3
+_SUCCESS_EXIT_CODE = 0
+_LOCK_READY_TIMEOUT_SECONDS = 20
+
+
+def _git(repository_path: Path, *arguments: str) -> str:
+    completed = subprocess.run(
+        [
+            "git",
+            "-C",
+            str(repository_path),
+            "-c",
+            "user.name=tester",
+            "-c",
+            "user.email=tester@example.com",
+            *arguments,
+        ],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    return completed.stdout.strip()
+
+
+def _mirror_one_commit_behind(root_path: Path) -> Path:
+    remote_path = root_path / "remote.git"
+    author_path = root_path / "author"
+    mirror_path = root_path / "mirror"
+    remote_path.mkdir()
+    author_path.mkdir()
+    _git(remote_path, "init", "-q", "--bare", "-b", "main")
+    _git(author_path, "init", "-q", "-b", "main")
+    (author_path / "tracked.txt").write_text("old\n", encoding="utf-8")
+    _git(author_path, "add", "-A")
+    _git(author_path, "commit", "-q", "-m", "first")
+    _git(author_path, "remote", "add", "origin", str(remote_path))
+    _git(author_path, "push", "-q", "origin", "main")
+    subprocess.run(
+        ["git", "clone", "-q", str(remote_path), str(mirror_path)], check=True
+    )
+    (author_path / "tracked.txt").write_text("new\n", encoding="utf-8")
+    _git(author_path, "commit", "-q", "-am", "second")
+    _git(author_path, "push", "-q", "origin", "main")
+    return mirror_path
+
+
+def _run_lock_name(mirror_path: Path) -> str:
+    normalized_path = os.path.normpath(str(mirror_path)).lower()
+    path_digest = hashlib.sha256(normalized_path.encode("utf-8")).hexdigest().upper()
+    return f"Global\\SyncRepoMain-{path_digest}"
+
+
+def _run_sync(mirror_path: Path, log_path: Path, repo_path: str | None = None) -> int:
+    argument_path = str(mirror_path) if repo_path is None else repo_path
+    completed = subprocess.run(
+        [
+            _PWSH,
+            "-NoProfile",
+            "-File",
+            str(_SCRIPT_PATH),
+            "-RepoPath",
+            argument_path,
+            "-LogPath",
+            str(log_path),
+        ],
+        capture_output=True,
+        text=True,
+    )
+    return completed.returncode
+
+
+def test_should_skip_without_fetching_while_another_run_holds_the_lock(
+    tmp_path: Path,
+) -> None:
+    mirror_path = _mirror_one_commit_behind(tmp_path)
+    old_tip = _git(mirror_path, "rev-parse", "HEAD")
+    log_path = tmp_path / "sync.log"
+    ready_path = tmp_path / "lock-ready"
+    holder_command = (
+        f"$lock = [System.Threading.Mutex]::new($true, '{_run_lock_name(mirror_path)}'); "
+        f"Set-Content -LiteralPath '{ready_path}' -Value ready; Start-Sleep -Seconds 30"
+    )
+    holder = subprocess.Popen([_PWSH, "-NoProfile", "-Command", holder_command])
+    try:
+        deadline = time.monotonic() + _LOCK_READY_TIMEOUT_SECONDS
+        while not ready_path.exists() and time.monotonic() < deadline:
+            time.sleep(0.2)
+        held_exit_code = _run_sync(mirror_path, log_path)
+    finally:
+        holder.kill()
+        holder.wait()
+
+    assert held_exit_code == _SKIPPED_EXIT_CODE
+    assert _git(mirror_path, "rev-parse", "HEAD") == old_tip
+    assert "still running" in log_path.read_text(encoding="utf-8")
+
+    assert _run_sync(mirror_path, log_path) == _SUCCESS_EXIT_CODE
+    assert _git(mirror_path, "rev-parse", "HEAD") != old_tip
+
+
+def test_should_skip_a_second_spelling_of_the_same_repo(tmp_path: Path) -> None:
+    mirror_path = _mirror_one_commit_behind(tmp_path)
+    old_tip = _git(mirror_path, "rev-parse", "HEAD")
+    ready_path = tmp_path / "lock-ready"
+    holder_command = (
+        f"$lock = [System.Threading.Mutex]::new($true, '{_run_lock_name(mirror_path)}'); "
+        f"Set-Content -LiteralPath '{ready_path}' -Value ready; Start-Sleep -Seconds 30"
+    )
+    holder = subprocess.Popen([_PWSH, "-NoProfile", "-Command", holder_command])
+    try:
+        deadline = time.monotonic() + _LOCK_READY_TIMEOUT_SECONDS
+        while not ready_path.exists() and time.monotonic() < deadline:
+            time.sleep(0.2)
+        assert ready_path.exists()
+        spellings = (
+            f"{mirror_path}{os.sep}",
+            os.path.join(str(mirror_path), "."),
+        )
+        for spelling in spellings:
+            spelling_log = tmp_path / "spelling.log"
+            spelling_log.unlink(missing_ok=True)
+            exit_code = _run_sync(mirror_path, spelling_log, repo_path=spelling)
+            assert exit_code == _SKIPPED_EXIT_CODE
+            assert _git(mirror_path, "rev-parse", "HEAD") == old_tip
+            assert "still running" in spelling_log.read_text(encoding="utf-8")
+    finally:
+        holder.kill()
+        holder.wait()
+
+
+def test_should_skip_when_the_repo_path_is_a_symlink(tmp_path: Path) -> None:
+    mirror_path = _mirror_one_commit_behind(tmp_path)
+    old_tip = _git(mirror_path, "rev-parse", "HEAD")
+    link_path = tmp_path / "mirror-link"
+    os.symlink(mirror_path, link_path, target_is_directory=True)
+    log_path = tmp_path / "sync.log"
+    ready_path = tmp_path / "lock-ready"
+    holder_command = (
+        f"$lock = [System.Threading.Mutex]::new($true, '{_run_lock_name(mirror_path)}'); "
+        f"Set-Content -LiteralPath '{ready_path}' -Value ready; Start-Sleep -Seconds 30"
+    )
+    holder = subprocess.Popen([_PWSH, "-NoProfile", "-Command", holder_command])
+    try:
+        deadline = time.monotonic() + _LOCK_READY_TIMEOUT_SECONDS
+        while not ready_path.exists() and time.monotonic() < deadline:
+            time.sleep(0.2)
+        assert ready_path.exists()
+        exit_code = _run_sync(mirror_path, log_path, repo_path=str(link_path))
+    finally:
+        holder.kill()
+        holder.wait()
+
+    assert exit_code == _SKIPPED_EXIT_CODE
+    assert _git(mirror_path, "rev-parse", "HEAD") == old_tip
+    assert "still running" in log_path.read_text(encoding="utf-8")