claude-dev-env 8.79.0 → 8.80.0

package/scripts/merge_review_receipt.py

@@ -7,8 +7,14 @@ The agent loops a code review on its pull request. Each pass is recorded::
     fix, push, review the new head
     python3 merge_review_receipt.py owner/name 12 def5678 0   -> CLEAN owner/name#12 def5678
 
+A pass whose every finding is ruled out with file:line evidence counts as
+clean once the rulings are posted and linked::
+
+    python3 merge_review_receipt.py owner/name 12 def5678 2 --ruled-out 2 --rulings <url>
+        -> CLEAN owner/name#12 def5678 (2 findings ruled out: <url>)
+
 ``hooks/blocking/merge_review_gate.py`` allows a merge pinned to the head of
-the newest pass only when that pass counted zero findings.
+the newest pass only when that pass is clean.
 """
 
 from __future__ import annotations
@@ -24,14 +30,23 @@ hooks_directory = str(Path(__file__).resolve().parent.parent / "hooks")
 if hooks_directory not in sys.path:
     sys.path.insert(0, hooks_directory)
 
-from blocking.merge_review_gate import receipt_path
+from blocking.merge_review_gate import is_clean_receipt, receipt_path
 from hooks_constants.merge_review_gate_constants import (
     RECEIPT_FINDINGS_KEY,
     RECEIPT_HEAD_KEY,
+    RECEIPT_RULED_OUT_KEY,
+    RECEIPT_RULINGS_KEY,
 )
 
 
-def record_review(slug: str, number: int, head: str, finding_count: int) -> Path:
+def record_review(
+    slug: str,
+    number: int,
+    head: str,
+    finding_count: int,
+    ruled_out_count: int = 0,
+    rulings: str = "",
+) -> Path:
     """Write the receipt for one review pass, replacing the previous pass.
 
     Args:
@@ -39,21 +54,34 @@ def record_review(slug: str, number: int, head: str, finding_count: int) -> Path
         number: Pull request number.
         head: The commit the pass reviewed.
         finding_count: How many findings the pass reported.
+        ruled_out_count: How many of those findings were ruled out.
+        rulings: Link to the posted rulings, empty when none were ruled out.
 
     Returns:
         The receipt path written.
     """
+    receipt = _receipt_fields(head, finding_count, ruled_out_count, rulings)
+    return _write_receipt(slug, number, receipt)
+
+
+def _write_receipt(slug: str, number: int, all_receipt_fields: dict[str, object]) -> Path:
     owner, repo = slug.split("/", 1)
     path = receipt_path(owner, repo, number)
     path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(
-        json.dumps({RECEIPT_HEAD_KEY: head, RECEIPT_FINDINGS_KEY: finding_count})
-        + "\n",
-        encoding="utf-8",
-    )
+    path.write_text(json.dumps(all_receipt_fields) + "\n", encoding="utf-8")
     return path
 
 
+def _receipt_fields(
+    head: str, finding_count: int, ruled_out_count: int, rulings: str
+) -> dict[str, object]:
+    receipt: dict[str, object] = {RECEIPT_HEAD_KEY: head, RECEIPT_FINDINGS_KEY: finding_count}
+    if ruled_out_count:
+        receipt[RECEIPT_RULED_OUT_KEY] = ruled_out_count
+        receipt[RECEIPT_RULINGS_KEY] = rulings
+    return receipt
+
+
 def main(all_arguments: Sequence[str], stdout: TextIO = sys.stdout) -> int:
     """Record one pass and print its verdict line.
 
@@ -62,17 +90,33 @@ def main(all_arguments: Sequence[str], stdout: TextIO = sys.stdout) -> int:
         stdout: Stream that receives the verdict.
 
     Returns:
-        0 for a clean pass, and 1 for a pass with findings.
+        0 for a clean pass, and 1 for a pass with findings still open.
     """
     parser = argparse.ArgumentParser(prog="merge_review_receipt")
     parser.add_argument("slug", help="Repository as owner/name.")
     parser.add_argument("number", type=int, help="Pull request number.")
     parser.add_argument("head", help="The head commit the pass reviewed.")
     parser.add_argument("findings", type=int, help="Findings the pass reported.")
+    parser.add_argument(
+        "--ruled-out", type=int, default=0, help="Findings ruled out with file:line evidence."
+    )
+    parser.add_argument("--rulings", default="", help="Link to the posted rulings.")
     parsed = parser.parse_args(all_arguments)
-    record_review(parsed.slug, parsed.number, parsed.head, parsed.findings)
-    if parsed.findings == 0:
-        stdout.write(f"CLEAN {parsed.slug}#{parsed.number} {parsed.head}\n")
+    rulings = parsed.rulings.strip()
+    if parsed.ruled_out < 0 or parsed.ruled_out > parsed.findings:
+        parser.error("--ruled-out must be between 0 and the finding count")
+    if parsed.ruled_out and not rulings:
+        parser.error("--ruled-out needs --rulings, a link to the posted rulings")
+    if rulings and not parsed.ruled_out:
+        parser.error("--rulings needs --ruled-out, the count of findings it rules out")
+    receipt = _receipt_fields(parsed.head, parsed.findings, parsed.ruled_out, rulings)
+    _write_receipt(parsed.slug, parsed.number, receipt)
+    owner, repo = parsed.slug.split("/", 1)
+    if is_clean_receipt(receipt, owner, repo, parsed.number):
+        ruled_out_note = (
+            f" ({parsed.ruled_out} findings ruled out: {rulings})" if parsed.ruled_out else ""
+        )
+        stdout.write(f"CLEAN {parsed.slug}#{parsed.number} {parsed.head}{ruled_out_note}\n")
         return 0
     stdout.write(
         f"REVIEWED {parsed.slug}#{parsed.number} {parsed.head} {parsed.findings} findings\n"

package/scripts/test_account_broker.py

@@ -226,6 +226,18 @@ def test_should_wait_for_main_5_hour_reset_while_its_week_resets_days_away() ->
     assert decision.resets_at == short_reset
 
 
+def test_should_check_main_again_in_an_hour_when_a_blocking_window_has_no_reset() -> None:
+    main = Reading(
+        _account("main", Product.CLAUDE, main=True),
+        Meters(5, None, 1, NOW + timedelta(hours=4)),
+    )
+
+    decision = choose_from_readings(Product.CLAUDE, (main,), now=NOW)
+
+    assert decision.action == "wait"
+    assert decision.resets_at == NOW + timedelta(hours=1)
+
+
 @pytest.mark.parametrize(
     ("short_left", "weekly_left", "weekly_reset", "expected_reset"),
     (

package/scripts/test_account_broker_support.py

@@ -16,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(
@@ -184,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(
@@ -261,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)
@@ -275,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_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/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"
   }
 }