claude-dev-env 8.78.3 → 8.80.0

package/scripts/test_account_broker_support.py

@@ -8,6 +8,7 @@ import subprocess
 import sys
 import time
 from datetime import datetime, timezone
+from collections.abc import Callable
 from pathlib import Path
 from types import SimpleNamespace
 
@@ -15,6 +16,7 @@ import pytest
 
 import account_broker_support as support
 from account_broker_support import Account, Meters, Product, ProductAdapter
+from codex_account_meters import CodexAccountMeters, UsageWindow
 
 
 def test_should_load_claude_roster_from_both_lists(
@@ -45,6 +47,61 @@ def _claude_home_with_extras(monkeypatch: pytest.MonkeyPatch, tmp_path: Path, ex
     return main_home
 
 
+def test_should_name_a_chain_account_profile_from_its_home(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    monkeypatch.setattr(Path, "home", lambda: tmp_path)
+    monkeypatch.delenv("LLM_SETTINGS_PROFILES_ROOT", raising=False)
+    main_home = tmp_path / ".claude"
+    main_home.mkdir()
+    profiles_root = tmp_path / ".claude-profiles"
+    launcher = "C:\\bin\\claude-editor.cmd"
+    (main_home / "claude-chain.json").write_text(
+        json.dumps(
+            {
+                "chain": [
+                    {"command": launcher, "credentials_path": str(profiles_root / "editor" / ".credentials.json")},
+                    {"command": "C:\\bin\\other.cmd", "credentials_path": str(tmp_path / "elsewhere" / ".credentials.json")},
+                    {"command": "C:\\bin\\reserved.cmd", "credentials_path": str(profiles_root / "main" / ".credentials.json")},
+                ]
+            }
+        ),
+        encoding="utf-8",
+    )
+    (main_home / "extra-profiles.json").write_text('["extra"]', encoding="utf-8")
+
+    accounts = support.load_claude_accounts()
+
+    assert [(each_account.name, each_account.profile) for each_account in accounts] == [
+        ("main", None),
+        (launcher, "editor"),
+        ("C:\\bin\\other.cmd", None),
+        ("C:\\bin\\reserved.cmd", None),
+        ("extra", "extra"),
+    ]
+
+
+@pytest.mark.parametrize(
+    ("target_parts", "expected_profile"),
+    [(("claude-profiles-link-target", "target"), None), ((".claude-profiles", "target"), "target")],
+)
+def test_should_name_an_extra_account_profile_from_its_resolved_home(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path, create_directory_link: Callable[..., None], target_parts: tuple[str, str], expected_profile: str | None
+) -> None:
+    monkeypatch.setattr(Path, "home", lambda: tmp_path)
+    monkeypatch.delenv("LLM_SETTINGS_PROFILES_ROOT", raising=False)
+    main_home = tmp_path / ".claude"
+    main_home.mkdir()
+    profiles_root = tmp_path / ".claude-profiles"
+    profiles_root.mkdir()
+    target = tmp_path.joinpath(*target_parts)
+    target.mkdir(parents=True)
+    create_directory_link(from_link=profiles_root / "alias", to_target=target)
+    (main_home / "extra-profiles.json").write_text('["alias"]', encoding="utf-8")
+
+    accounts = support.load_claude_accounts()
+
+    assert [(each_account.name, each_account.profile) for each_account in accounts[1:]] == [("target", expected_profile)]
+
+
 def test_should_leave_claude_priorities_unset_without_an_order_file(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:
@@ -128,16 +185,24 @@ def test_should_read_claude_meters_through_injected_probe(
 def test_should_read_codex_meters_through_injected_reader(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:
-    short = SimpleNamespace(duration_minutes=300, used_percent=20.0, resets_at=None)
-    weekly = SimpleNamespace(duration_minutes=10080, used_percent=30.0, resets_at=None)
-    usage = SimpleNamespace(all_windows=(short, weekly), short_window_percent_left=80.0)
+    short_reset = datetime(2026, 10, 3, 5, tzinfo=timezone.utc)
+    unknown_length_reset = datetime(2026, 10, 9, tzinfo=timezone.utc)
+    usage = CodexAccountMeters(
+        (
+            UsageWindow(300, 20.0, short_reset),
+            UsageWindow(10080, 30.0, None),
+            UsageWindow(None, 50.0, unknown_length_reset),
+        )
+    )
     monkeypatch.setattr(support.codex_account_meters, "resolve_codex_path", lambda _: tmp_path / "codex")
     monkeypatch.setattr(support.codex_account_meters, "read_codex_meters", lambda *_: usage)
 
     meters = support.read_codex_account_meters(Account(Product.CODEX, "one", tmp_path))
 
     assert meters.session_percent_left == 80.0
-    assert meters.weekly_percent_left == 70.0
+    assert meters.session_resets_at == short_reset
+    assert meters.weekly_percent_left == 50.0
+    assert meters.weekly_resets_at == unknown_length_reset
 
 
 def _codex_meter_reads(
@@ -205,8 +270,7 @@ def test_should_read_claude_meters_after_transient_failures_with_growing_delays(
 def test_should_read_codex_meters_after_transient_failures_with_growing_delays(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:
-    weekly = SimpleNamespace(duration_minutes=10080, used_percent=30.0, resets_at=None)
-    usage = SimpleNamespace(all_windows=(weekly,), short_window_percent_left=None)
+    usage = CodexAccountMeters((UsageWindow(10080, 30.0, None),))
     unread = support.codex_account_meters.CodexMeterUnreadError("codex app-server sent no rate-limit reply")
     all_homes_read = _codex_meter_reads(monkeypatch, tmp_path, [unread, unread, usage])
     all_delays = _recorded_sleeps(monkeypatch)
@@ -219,6 +283,24 @@ def test_should_read_codex_meters_after_transient_failures_with_growing_delays(
     assert all_delays == [1.0, 2.0]
 
 
+def test_should_stop_at_once_when_no_codex_executable_is_found(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    unpatched_resolve_codex_path = support.codex_account_meters.resolve_codex_path
+    all_homes_read = _codex_meter_reads(monkeypatch, tmp_path, [])
+    monkeypatch.setattr(support.codex_account_meters, "resolve_codex_path", unpatched_resolve_codex_path)
+    monkeypatch.setenv("PATH", "")
+    monkeypatch.setattr(Path, "home", lambda: tmp_path)
+    all_delays = _recorded_sleeps(monkeypatch)
+
+    reading = _first_reading(monkeypatch, tmp_path, Account(Product.CODEX, "one", tmp_path), support.read_codex_account_meters)[0]
+
+    assert reading.meters is None
+    assert reading.unread_reason == "no codex executable on PATH or at its install path"
+    assert all_homes_read == []
+    assert all_delays == []
+
+
 def test_should_keep_the_unread_reason_after_every_claude_read_fails(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:

package/scripts/test_claude_chain_usage.py

@@ -2,12 +2,11 @@
 
 from __future__ import annotations
 
-import importlib
-import os
 import subprocess
 import sys
 import urllib.error
 from datetime import datetime, timezone
+from collections.abc import Callable
 from pathlib import Path
 
 import pytest
@@ -105,18 +104,11 @@ def test_probe_rejects_missing_access_token_for_another_account(
         usage.probe_account_meters(Path("home") / ".claude-profiles" / "ev" / ".credentials.json")
 
 
-def _create_directory_link(*, from_link: Path, to_target: Path) -> None:
-    if sys.platform.startswith("win32"):
-        importlib.import_module("_winapi").CreateJunction(str(to_target), str(from_link))
-        return
-    os.symlink(to_target, from_link, target_is_directory=True)
-
-
-def test_scripts_directory_follows_the_installed_scripts_link(tmp_path: Path) -> None:
+def test_scripts_directory_follows_the_installed_scripts_link(tmp_path: Path, create_directory_link: Callable[..., None]) -> None:
     home = tmp_path.resolve()
     (home / ".agents" / "scripts").mkdir(parents=True)
     (home / ".claude").mkdir()
-    _create_directory_link(
+    create_directory_link(
         from_link=home / ".claude" / "scripts", to_target=home / ".agents" / "scripts"
     )
 

package/scripts/test_codex_account_meters.py

@@ -11,6 +11,7 @@ from pathlib import Path
 import pytest
 
 from codex_account_meters import (
+    CodexExecutableNotFoundError,
     CodexMeterUnreadError,
     exchange_with_app_server,
     parse_rate_limits_reply,
@@ -30,7 +31,7 @@ def reply_line(rate_limits: object) -> str:
 
 
 class TestParseRateLimitsReply:
-    def should_measure_room_by_the_tightest_window(self) -> None:
+    def should_read_every_window(self) -> None:
         meters = parse_rate_limits_reply(
             reply_line(
                 {
@@ -47,7 +48,7 @@ class TestParseRateLimitsReply:
                 }
             )
         )
-        assert meters.percent_left == 15.0
+        assert [each.used_percent for each in meters.all_windows] == [30.0, 85.0]
         assert [each.duration_minutes for each in meters.all_windows] == [300, 10080]
         assert meters.all_windows[0].resets_at == datetime.fromtimestamp(
             RESET_SECONDS, tz=timezone.utc
@@ -62,11 +63,11 @@ class TestParseRateLimitsReply:
                 }
             )
         )
-        assert meters.percent_left == 60.0
+        assert [each.used_percent for each in meters.all_windows] == [40.0]
 
     def should_clamp_used_percent_past_full(self) -> None:
         meters = parse_rate_limits_reply(reply_line({"primary": {"usedPercent": 130}}))
-        assert meters.percent_left == 0.0
+        assert [each.used_percent for each in meters.all_windows] == [100.0]
 
     @pytest.mark.parametrize(
         "line",
@@ -103,20 +104,31 @@ class TestShortWindowPercentLeft:
         )
         assert meters.short_window_percent_left is None
 
+    def should_count_a_window_without_a_length_as_weekly(self) -> None:
+        meters = parse_rate_limits_reply(reply_line({"primary": {"usedPercent": 90}}))
+        assert meters.short_window_percent_left is None
+        assert meters.weekly_window is not None
+        assert meters.weekly_window.used_percent == 90.0
+
 
-class TestBlockingReset:
-    def should_name_when_the_last_blocking_window_resets(self) -> None:
+class TestTightestWindows:
+    def should_pick_the_most_used_window_in_each_class(self) -> None:
         meters = parse_rate_limits_reply(
             reply_line(
                 {
-                    "primary": {"usedPercent": 95, "resetsAt": RESET_SECONDS},
-                    "secondary": {"usedPercent": 99, "resetsAt": RESET_SECONDS + 3600},
+                    "primary": {"usedPercent": 70, "windowDurationMins": 300, "resetsAt": RESET_SECONDS},
+                    "secondary": {"usedPercent": 20, "windowDurationMins": 10080, "resetsAt": RESET_SECONDS + 3600},
                 }
             )
         )
-        assert meters.resets_before_room(10.0) == datetime.fromtimestamp(
-            RESET_SECONDS + 3600, tz=timezone.utc
-        )
+        assert meters.short_window is not None
+        assert meters.short_window.resets_at == datetime.fromtimestamp(RESET_SECONDS, tz=timezone.utc)
+        assert meters.weekly_window is not None
+        assert meters.weekly_window.resets_at == datetime.fromtimestamp(RESET_SECONDS + 3600, tz=timezone.utc)
+
+    def should_name_no_weekly_window_for_a_short_only_account(self) -> None:
+        meters = parse_rate_limits_reply(reply_line({"primary": {"usedPercent": 70, "windowDurationMins": 300}}))
+        assert meters.weekly_window is None
 
 
 class TestReadCodexMeters:
@@ -141,7 +153,7 @@ class TestReadCodexMeters:
             ]
 
         meters = read_codex_meters(Path("codex"), Path("profiles") / "codex-1", fake_exchange)
-        assert meters.percent_left == 80.0
+        assert [each.used_percent for each in meters.all_windows] == [20.0]
         assert all_calls == [
             (
                 Path("codex"),
@@ -215,7 +227,7 @@ class TestExchangeWithAppServer:
 
         meters = read_codex_meters(fake_codex, tmp_path / "codex-2", exchange_with_app_server)
 
-        assert meters.percent_left == 88.0
+        assert [each.used_percent for each in meters.all_windows] == [12.0]
 
 
 class TestRequestMessages:
@@ -234,5 +246,5 @@ class TestResolveCodexPath:
     ) -> None:
         monkeypatch.setenv("PATH", "")
         monkeypatch.setattr(Path, "home", lambda: tmp_path)
-        with pytest.raises(FileNotFoundError):
+        with pytest.raises(CodexExecutableNotFoundError):
             resolve_codex_path(None)

package/scripts/test_merge_review_receipt.py

@@ -11,6 +11,7 @@ import pytest
 import merge_review_receipt
 
 HEAD = "abc1234def5678abc1234def5678abc1234def56"
+RULINGS_LINK = "https://github.com/acme/tools/pull/12#issuecomment-1"
 
 
 @pytest.fixture(autouse=True)
@@ -36,3 +37,88 @@ def test_record_review_replaces_the_previous_pass(receipt_folder: Path) -> None:
     path = merge_review_receipt.record_review("Acme/Tools", 12, HEAD, 0)
     assert path == receipt_folder / "acme__tools__12.json"
     assert json.loads(path.read_text(encoding="utf-8")) == {"head": HEAD, "findings": 0}
+
+
+def test_should_print_clean_when_every_finding_is_ruled_out_with_a_link() -> None:
+    verdict_stream = StringIO()
+    exit_code = merge_review_receipt.main(
+        ["acme/tools", "12", HEAD, "2", "--ruled-out", "2", "--rulings", RULINGS_LINK],
+        verdict_stream,
+    )
+    assert exit_code == 0
+    assert verdict_stream.getvalue() == (
+        f"CLEAN acme/tools#12 {HEAD} (2 findings ruled out: {RULINGS_LINK})\n"
+    )
+
+
+def test_should_record_the_rulings_link_without_surrounding_whitespace(
+    receipt_folder: Path,
+) -> None:
+    verdict_stream = StringIO()
+    exit_code = merge_review_receipt.main(
+        ["acme/tools", "12", HEAD, "2", "--ruled-out", "2", "--rulings", f" {RULINGS_LINK}\n"],
+        verdict_stream,
+    )
+    assert exit_code == 0
+    assert verdict_stream.getvalue() == (
+        f"CLEAN acme/tools#12 {HEAD} (2 findings ruled out: {RULINGS_LINK})\n"
+    )
+    (receipt_file,) = receipt_folder.rglob("*.json")
+    assert json.loads(receipt_file.read_text(encoding="utf-8"))["rulings"] == RULINGS_LINK
+
+
+def test_should_keep_the_raw_finding_count_beside_the_ruled_out_count(
+    receipt_folder: Path,
+) -> None:
+    path = merge_review_receipt.record_review("acme/tools", 12, HEAD, 2, 2, RULINGS_LINK)
+    assert json.loads(path.read_text(encoding="utf-8")) == {
+        "head": HEAD,
+        "findings": 2,
+        "ruled_out": 2,
+        "rulings": RULINGS_LINK,
+    }
+
+
+def test_should_report_reviewed_when_some_findings_stay_open() -> None:
+    verdict_stream = StringIO()
+    exit_code = merge_review_receipt.main(
+        ["acme/tools", "12", HEAD, "3", "--ruled-out", "2", "--rulings", RULINGS_LINK],
+        verdict_stream,
+    )
+    assert exit_code == 1
+    assert verdict_stream.getvalue() == f"REVIEWED acme/tools#12 {HEAD} 3 findings\n"
+
+
+@pytest.mark.parametrize(
+    "extra_arguments",
+    [["--ruled-out", "2"], ["--ruled-out", "4", "--rulings", RULINGS_LINK], ["--ruled-out", "-1"]],
+)
+def test_should_refuse_a_ruled_out_count_it_cannot_back(extra_arguments: list[str]) -> None:
+    with pytest.raises(SystemExit):
+        merge_review_receipt.main(["acme/tools", "12", HEAD, "3", *extra_arguments], StringIO())
+
+
+@pytest.mark.parametrize(
+    "all_arguments",
+    [
+        ["acme/tools", "12", HEAD, "-1"],
+        ["acme/tools", "12", HEAD, "2", "--rulings", RULINGS_LINK],
+    ],
+)
+def test_should_refuse_counts_and_links_it_cannot_record(
+    all_arguments: list[str], receipt_folder: Path
+) -> None:
+    with pytest.raises(SystemExit):
+        merge_review_receipt.main(all_arguments, StringIO())
+    assert list(receipt_folder.iterdir()) == []
+
+
+def test_should_report_reviewed_when_the_rulings_link_points_at_another_pull_request() -> None:
+    verdict_stream = StringIO()
+    other_link = "https://github.com/acme/tools/pull/13#issuecomment-1"
+    exit_code = merge_review_receipt.main(
+        ["acme/tools", "12", HEAD, "2", "--ruled-out", "2", "--rulings", other_link],
+        verdict_stream,
+    )
+    assert exit_code == 1
+    assert verdict_stream.getvalue() == f"REVIEWED acme/tools#12 {HEAD} 2 findings\n"

package/scripts/test_shared_tree_paths.py

@@ -2,13 +2,13 @@
 
 from __future__ import annotations
 
-import importlib
-import os
-import sys
+import subprocess
+from collections.abc import Callable
 from pathlib import Path
 
 import pytest
 
+import claude_account_profile
 import shared_tree_paths
 from dev_env_scripts_constants.grok_worker_constants import (
     CLAUDE_CONFIG_DIR_ENV_VAR,
@@ -23,27 +23,17 @@ from dev_env_scripts_constants.shared_tree_constants import (
 )
 
 
-def _create_directory_link(*, from_link: Path, to_target: Path) -> None:
-    if sys.platform.startswith("win32"):
-        importlib.import_module("_winapi").CreateJunction(
-            str(to_target), str(from_link)
-        )
-        return
-    try:
-        os.symlink(to_target, from_link, target_is_directory=True)
-    except OSError:
-        pytest.skip("directory symlink creation is not available")
-
-
-def _build_junction_scripts_layout(tmp_path: Path) -> Path:
-    real_scripts_directory = tmp_path / "real" / SCRIPTS_DIRECTORY_NAME
-    real_scripts_directory.mkdir(parents=True)
-    (real_scripts_directory / "runner.py").write_text("", encoding="utf-8")
+def _build_junction_scripts_layout(
+    tmp_path: Path, create_directory_link: Callable[..., None]
+) -> Path:
+    linked_scripts_directory = tmp_path / "target" / SCRIPTS_DIRECTORY_NAME
+    linked_scripts_directory.mkdir(parents=True)
+    (linked_scripts_directory / "runner.py").write_text("", encoding="utf-8")
     managed_root = tmp_path / "root"
     managed_root.mkdir()
-    _create_directory_link(
+    create_directory_link(
         from_link=managed_root / SCRIPTS_DIRECTORY_NAME,
-        to_target=real_scripts_directory,
+        to_target=linked_scripts_directory,
     )
     return managed_root / SCRIPTS_DIRECTORY_NAME / "runner.py"
 
@@ -63,9 +53,9 @@ def _write_process_tree_kill_stub(from_root: Path) -> Path:
 
 
 def test_junction_scripts_dir_finds_shared_tree_on_unresolved_parent(
-    tmp_path: Path,
+    tmp_path: Path, create_directory_link: Callable[..., None],
 ) -> None:
-    module_file = _build_junction_scripts_layout(tmp_path)
+    module_file = _build_junction_scripts_layout(tmp_path, create_directory_link)
     expected_scripts_directory = _write_process_tree_kill_stub(tmp_path / "root")
     resolved_scripts_directory = (
         shared_tree_paths.resolve_shared_process_tree_scripts_directory(
@@ -76,10 +66,10 @@ def test_junction_scripts_dir_finds_shared_tree_on_unresolved_parent(
 
 
 def test_resolved_parent_is_used_when_link_side_has_no_shared_tree(
-    tmp_path: Path,
+    tmp_path: Path, create_directory_link: Callable[..., None],
 ) -> None:
-    module_file = _build_junction_scripts_layout(tmp_path)
-    expected_scripts_directory = _write_process_tree_kill_stub(tmp_path / "real")
+    module_file = _build_junction_scripts_layout(tmp_path, create_directory_link)
+    expected_scripts_directory = _write_process_tree_kill_stub(tmp_path / "target")
     resolved_scripts_directory = (
         shared_tree_paths.resolve_shared_process_tree_scripts_directory(
             module_file, all_environment={}
@@ -89,9 +79,9 @@ def test_resolved_parent_is_used_when_link_side_has_no_shared_tree(
 
 
 def test_configured_root_is_used_when_neither_parent_holds_the_module(
-    tmp_path: Path,
+    tmp_path: Path, create_directory_link: Callable[..., None],
 ) -> None:
-    module_file = _build_junction_scripts_layout(tmp_path)
+    module_file = _build_junction_scripts_layout(tmp_path, create_directory_link)
     configured_root = tmp_path / "configured"
     expected_scripts_directory = _write_process_tree_kill_stub(configured_root)
     resolved_scripts_directory = (
@@ -106,9 +96,9 @@ def test_configured_root_is_used_when_neither_parent_holds_the_module(
 
 
 def test_unresolved_parent_wins_when_configured_root_also_holds_the_module(
-    tmp_path: Path,
+    tmp_path: Path, create_directory_link: Callable[..., None],
 ) -> None:
-    module_file = _build_junction_scripts_layout(tmp_path)
+    module_file = _build_junction_scripts_layout(tmp_path, create_directory_link)
     expected_scripts_directory = _write_process_tree_kill_stub(tmp_path / "root")
     configured_root = tmp_path / "configured"
     _write_process_tree_kill_stub(configured_root)
@@ -123,8 +113,8 @@ def test_unresolved_parent_wins_when_configured_root_also_holds_the_module(
     assert resolved_scripts_directory == expected_scripts_directory
 
 
-def test_missing_module_returns_unresolved_candidate(tmp_path: Path) -> None:
-    module_file = _build_junction_scripts_layout(tmp_path)
+def test_missing_module_returns_unresolved_candidate(tmp_path: Path, create_directory_link: Callable[..., None]) -> None:
+    module_file = _build_junction_scripts_layout(tmp_path, create_directory_link)
     expected_scripts_directory = (
         tmp_path
         / "root"
@@ -144,9 +134,9 @@ def test_missing_module_returns_unresolved_candidate(tmp_path: Path) -> None:
 
 
 def test_junction_scripts_dir_finds_advisor_scripts_on_unresolved_parent(
-    tmp_path: Path,
+    tmp_path: Path, create_directory_link: Callable[..., None],
 ) -> None:
-    module_file = _build_junction_scripts_layout(tmp_path)
+    module_file = _build_junction_scripts_layout(tmp_path, create_directory_link)
     expected_scripts_directory = (
         tmp_path
         / "root"
@@ -198,7 +188,7 @@ def test_generalized_resolver_serves_a_deeper_anchor(tmp_path: Path) -> None:
 
 @pytest.mark.parametrize("managed_name", (".claude", "profile-a"))
 def test_resolved_agents_scripts_find_the_verified_managed_root(
-    tmp_path: Path, managed_name: str,
+    tmp_path: Path, create_directory_link: Callable[..., None], managed_name: str,
 ) -> None:
     agents_name = ".agents" if managed_name == ".claude" else f"{managed_name}.agents"
     agents_root = tmp_path / agents_name
@@ -208,7 +198,7 @@ def test_resolved_agents_scripts_find_the_verified_managed_root(
     module_file.write_text("", encoding="utf-8")
     managed_root = tmp_path / managed_name
     managed_root.mkdir()
-    _create_directory_link(from_link=managed_root / "scripts", to_target=scripts_directory)
+    create_directory_link(from_link=managed_root / "scripts", to_target=scripts_directory)
     expected = _write_process_tree_kill_stub(managed_root)
     resolved_directory = shared_tree_paths.resolve_shared_process_tree_scripts_directory(module_file, {})
     assert resolved_directory == expected
@@ -227,3 +217,35 @@ def test_neighboring_managed_root_cannot_supply_a_foreign_shared_tree(tmp_path:
     resolved_directory = shared_tree_paths.resolve_shared_process_tree_scripts_directory(module_file, {})
     expected = agents_root / "_shared" / "process-tree" / "scripts"
     assert resolved_directory == expected
+
+
+def test_should_fail_with_the_link_command_output_when_a_link_cannot_be_made(
+    tmp_path: Path,
+    create_directory_link: Callable[..., None],
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    def refuse_link(source_path: Path, link_path: Path) -> None:
+        raise subprocess.CalledProcessError(1, ["mklink"], b"", b"Access is denied.")
+
+    monkeypatch.setattr(claude_account_profile, "_link_directory", refuse_link)
+
+    with pytest.raises(pytest.fail.Exception) as failure:
+        create_directory_link(from_link=tmp_path / "link", to_target=tmp_path)
+
+    assert "Access is denied." in str(failure.value)
+
+
+def test_should_fail_with_the_os_error_when_a_symlink_cannot_be_made(
+    tmp_path: Path,
+    create_directory_link: Callable[..., None],
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    def refuse_link(source_path: Path, link_path: Path) -> None:
+        raise PermissionError("Operation not permitted")
+
+    monkeypatch.setattr(claude_account_profile, "_link_directory", refuse_link)
+
+    with pytest.raises(pytest.fail.Exception) as failure:
+        create_directory_link(from_link=tmp_path / "link", to_target=tmp_path)
+
+    assert "Operation not permitted" in str(failure.value)

package/scripts/tests/test_adapter_configuration.py

@@ -58,6 +58,14 @@ def test_pull_request_lifecycle_gate_registration_is_clean(tmp_path: Path) -> No
     assert adapters.hook_configuration_diagnostics(current_document, tmp_path) == ()
 
 
+def test_new_merge_offer_gate_registration_is_clean(tmp_path: Path) -> None:
+    current_document = _hook_document(
+        ["hooks/blocking/merge_over_review_offer_gate.py"],
+        '{"hooks": {}}',
+    )
+    assert adapters.hook_configuration_diagnostics(current_document, tmp_path) == ()
+
+
 def test_new_step_note_gate_registration_is_clean(tmp_path: Path) -> None:
     current_document = _hook_document(
         ["hooks/blocking/step_note_gate.py"],

package/settings.json

@@ -22,5 +22,8 @@
       "Updating or installing the claude-dev-env package is allowed: running `npx claude-dev-env@latest --update` or `npx --yes claude-dev-env@latest --update --target <claude config dir>` is the user's own daily environment sync from the user's own public package, and its writes to the Claude config directory are the intended result. This covers only that package and command.",
       "Developing the claude-dev-env repository is allowed: editing, testing, committing and pushing its settings, hooks, scripts and tests is the user's requested work on the user's own public package. It changes the package source in the repository; it does not change the running session's own configuration."
     ]
+  },
+  "env": {
+    "CLAUDE_CODE_IDLE_COMPACT_MIN_TOKENS": "100000"
   }
 }