claude-dev-env 8.52.1 → 8.53.1

package/docs/second-claude-account.md

@@ -43,8 +43,7 @@ room.
 
 | Account | Has room while |
 |---|---|
-| main | under 90% of its week and under 50% of its 5-hour window |
-| second and each extra profile | under 95% of its week and under 90% of its 5-hour window |
+| every account | under 99% of its week and under 95% of its 5-hour window |
 
 When no account has room, the job waits until the next account reset, or for one
 hour when no reset is known. An unreadable meter never picks its account, and

package/hooks/advisory/auto_mode_denial_quick_fix.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python3
+"""PermissionDenied advisor: a proposed quick fix for each auto mode denial.
+
+This hook never retries the denied call. It reads the denial, names the
+classifier rule from the bracketed label in ``denial_reason``, drafts one
+``autoMode.allow`` entry for the denied action, and adds a PowerShell 7 block
+that writes the entry to ``~/.claude/settings.json`` with ``"$defaults"``
+kept. The agent receives the proposal as ``additionalContext``; the user
+receives a one-line ``systemMessage``.
+
+A denial with no ``classifier_verdict`` gets a short note and no block,
+because an allow entry cannot clear it.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import sys
+from pathlib import Path
+
+_hooks_root_directory = str(Path(__file__).resolve().parent.parent)
+if _hooks_root_directory not in sys.path:
+    sys.path.insert(0, _hooks_root_directory)
+
+from hooks_constants.auto_mode_denial_quick_fix_constants import (
+    ALL_COMMAND_INPUT_KEYS,
+    ALLOW_ENTRY_TEMPLATE,
+    HOOK_EVENT_NAME,
+    MAXIMUM_ACTION_SUMMARY_CHARACTERS,
+    NO_VERDICT_CONTEXT_TEMPLATE,
+    POWERSHELL_BLOCK_TEMPLATE,
+    RULE_LABEL_PATTERN,
+    SUMMARY_WORD_SEPARATOR,
+    TRUNCATION_MARKER,
+    UNNAMED_RULE_LABEL,
+    USER_MESSAGE_TEMPLATE,
+    VERDICT_CONTEXT_TEMPLATE,
+)
+
+
+def rule_label_from(denial_reason: str) -> str:
+    """Return the classifier rule name from a denial reason.
+
+    Args:
+        denial_reason: The ``denial_reason`` text, such as
+            ``"[Security Weaken] lowers a guard"``.
+
+    Returns:
+        The first bracketed label, or the unnamed-rule label.
+    """
+    label_match = re.search(RULE_LABEL_PATTERN, denial_reason)
+    return label_match.group(1).strip() if label_match else UNNAMED_RULE_LABEL
+
+
+def _summary_source_text(tool_input: object) -> str:
+    if not isinstance(tool_input, dict):
+        return json.dumps(tool_input, sort_keys=True)
+    for each_key in ALL_COMMAND_INPUT_KEYS:
+        if isinstance(tool_input.get(each_key), str):
+            return tool_input[each_key]
+    return json.dumps(tool_input, sort_keys=True)
+
+
+def action_summary_from(tool_input: object) -> str:
+    """Return one short line that names the denied action.
+
+    Args:
+        tool_input: The denied call's ``tool_input``.
+
+    Returns:
+        The command, URL or path when the input has one, else the compact
+        JSON input, cut to the summary length limit.
+    """
+    single_line_text = SUMMARY_WORD_SEPARATOR.join(_summary_source_text(tool_input).split())
+    if len(single_line_text) <= MAXIMUM_ACTION_SUMMARY_CHARACTERS:
+        return single_line_text
+    kept_length = MAXIMUM_ACTION_SUMMARY_CHARACTERS - len(TRUNCATION_MARKER)
+    return single_line_text[:kept_length] + TRUNCATION_MARKER
+
+
+def powershell_block_for(allow_entry: str) -> str:
+    """Return the PowerShell 7 block that adds one allow entry.
+
+    Args:
+        allow_entry: The ``autoMode.allow`` entry text.
+
+    Returns:
+        The block, with the entry in a single-quoted PowerShell literal.
+    """
+    escaped_entry = allow_entry.replace("'", "''")
+    return POWERSHELL_BLOCK_TEMPLATE.replace("{escaped_entry}", escaped_entry)
+
+
+def _verdict_context_text(
+    tool_name: str, denial_reason: str, action_summary: str, rule_label: str
+) -> str:
+    allow_entry = ALLOW_ENTRY_TEMPLATE.format(
+        rule_label=rule_label,
+        tool_name=tool_name,
+        action_summary=action_summary,
+    )
+    return VERDICT_CONTEXT_TEMPLATE.format(
+        tool_name=tool_name,
+        rule_label=rule_label,
+        denial_reason=denial_reason,
+        action_summary=action_summary,
+        powershell_block=powershell_block_for(allow_entry),
+    )
+
+
+def build_hook_output(all_denial_fields: dict[str, object]) -> dict[str, object]:
+    """Return the PermissionDenied hook output for one denial payload.
+
+    Args:
+        all_denial_fields: The hook input JSON.
+
+    Returns:
+        A ``hookSpecificOutput`` with ``additionalContext`` for the agent and
+        a top-level ``systemMessage`` for the user.
+    """
+    tool_name = str(all_denial_fields.get("tool_name") or "tool")
+    denial_reason = str(all_denial_fields.get("denial_reason") or "")
+    action_summary = action_summary_from(all_denial_fields.get("tool_input"))
+    rule_label = rule_label_from(denial_reason)
+    if all_denial_fields.get("classifier_verdict"):
+        context_text = _verdict_context_text(tool_name, denial_reason, action_summary, rule_label)
+    else:
+        context_text = NO_VERDICT_CONTEXT_TEMPLATE.format(
+            tool_name=tool_name,
+            denial_reason=denial_reason,
+            action_summary=action_summary,
+        )
+    return {
+        "hookSpecificOutput": {
+            "hookEventName": HOOK_EVENT_NAME,
+            "additionalContext": context_text,
+        },
+        "systemMessage": USER_MESSAGE_TEMPLATE.format(tool_name=tool_name, rule_label=rule_label),
+    }
+
+
+def main() -> int:
+    try:
+        payload = json.load(sys.stdin)
+    except (json.JSONDecodeError, ValueError):
+        return 0
+    if not isinstance(payload, dict):
+        return 0
+    sys.stdout.write(json.dumps(build_hook_output(payload)))
+    sys.stdout.flush()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/hooks/advisory/test_auto_mode_denial_quick_fix.py

@@ -0,0 +1,113 @@
+"""Behavior tests for the auto mode denial quick-fix advisor."""
+
+from __future__ import annotations
+
+import io
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+advisory_directory = str(Path(__file__).resolve().parent)
+if advisory_directory not in sys.path:
+    sys.path.insert(0, advisory_directory)
+import auto_mode_denial_quick_fix
+
+
+def _denial_payload(**overrides: object) -> dict[str, object]:
+    payload: dict[str, object] = {
+        "hook_event_name": "PermissionDenied",
+        "tool_name": "mcp__github__resolve_review_thread",
+        "tool_input": {"threadId": "PRRT_abc"},
+        "denial_reason": "[Security Weaken] resolving review threads bypasses review",
+        "classifier_verdict": "deny",
+    }
+    payload.update(overrides)
+    return payload
+
+
+def test_should_name_the_bracketed_rule() -> None:
+    assert (
+        auto_mode_denial_quick_fix.rule_label_from("[Git Destructive] force") == "Git Destructive"
+    )
+
+
+def test_should_fall_back_when_the_reason_has_no_label() -> None:
+    assert auto_mode_denial_quick_fix.rule_label_from("Blocked by classifier") == "unnamed rule"
+
+
+def test_should_summarize_a_bash_call_by_its_command() -> None:
+    summary = auto_mode_denial_quick_fix.action_summary_from(
+        {"command": "git push\n --force origin x"}
+    )
+    assert summary == "git push --force origin x"
+
+
+def test_should_cut_a_long_summary_to_the_limit() -> None:
+    summary = auto_mode_denial_quick_fix.action_summary_from({"command": "x" * 500})
+    assert len(summary) == 160
+    assert summary.endswith("...")
+
+
+def test_should_escape_single_quotes_in_the_powershell_entry() -> None:
+    block = auto_mode_denial_quick_fix.powershell_block_for("it's allowed")
+    assert "$entry = 'it''s allowed'" in block
+    assert "$allowList.Add('$defaults')" in block
+
+
+def test_should_propose_rule_entry_and_block_for_a_classifier_denial() -> None:
+    hook_output = auto_mode_denial_quick_fix.build_hook_output(_denial_payload())
+    context_text = hook_output["hookSpecificOutput"]["additionalContext"]
+    assert "rule [Security Weaken]" in context_text
+    assert (
+        "Security Weaken exception: mcp__github__resolve_review_thread calls like" in context_text
+    )
+    assert "```powershell" in context_text
+    assert "retry" not in hook_output["hookSpecificOutput"]
+    assert hook_output["systemMessage"].startswith(
+        "Auto mode blocked mcp__github__resolve_review_thread"
+    )
+
+
+def test_should_omit_the_block_when_no_verdict_exists() -> None:
+    payload = _denial_payload(denial_reason="classifier unavailable")
+    del payload["classifier_verdict"]
+    context_text = auto_mode_denial_quick_fix.build_hook_output(payload)["hookSpecificOutput"][
+        "additionalContext"
+    ]
+    assert "no classifier verdict" in context_text
+    assert "powershell" not in context_text
+
+
+def test_should_print_the_output_from_stdin(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    monkeypatch.setattr(sys, "stdin", io.StringIO(json.dumps(_denial_payload())))
+    assert auto_mode_denial_quick_fix.main() == 0
+    assert (
+        json.loads(capsys.readouterr().out)["hookSpecificOutput"]["hookEventName"]
+        == "PermissionDenied"
+    )
+
+
+def test_should_stay_quiet_on_malformed_input(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    monkeypatch.setattr(sys, "stdin", io.StringIO("not json"))
+    assert auto_mode_denial_quick_fix.main() == 0
+    assert capsys.readouterr().out == ""
+
+
+def test_should_write_the_entry_with_defaults_when_powershell_runs(tmp_path: Path) -> None:
+    block = (
+        auto_mode_denial_quick_fix.powershell_block_for("it's allowed")
+        .replace("claude auto-mode config", "")
+        .replace("Join-Path $HOME", f"Join-Path '{tmp_path}'")
+    )
+    subprocess.run(["pwsh", "-NoProfile", "-Command", block], check=True)
+    written_settings = json.loads(
+        (tmp_path / ".claude" / "settings.json").read_text(encoding="utf-8")
+    )
+    assert written_settings["autoMode"]["allow"] == ["$defaults", "it's allowed"]

package/hooks/hooks.json

@@ -335,6 +335,18 @@
           }
         ]
       }
+    ],
+    "PermissionDenied": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/advisory/auto_mode_denial_quick_fix.py",
+            "timeout": 10
+          }
+        ]
+      }
     ]
   }
 }

package/hooks/hooks_constants/auto_mode_denial_quick_fix_constants.py

@@ -0,0 +1,79 @@
+"""Constants for the auto mode denial quick-fix advisor.
+
+The advisor is a PermissionDenied hook. It never retries the call. It turns
+each auto mode denial into a proposed fix: the rule name, a draft
+``autoMode.allow`` entry, and a PowerShell 7 block that adds the entry to
+``~/.claude/settings.json`` with ``"$defaults"`` kept in the list.
+"""
+
+from __future__ import annotations
+
+__all__ = [
+    "HOOK_EVENT_NAME",
+    "RULE_LABEL_PATTERN",
+    "UNNAMED_RULE_LABEL",
+    "MAXIMUM_ACTION_SUMMARY_CHARACTERS",
+    "TRUNCATION_MARKER",
+    "SUMMARY_WORD_SEPARATOR",
+    "ALL_COMMAND_INPUT_KEYS",
+    "ALLOW_ENTRY_TEMPLATE",
+    "POWERSHELL_BLOCK_TEMPLATE",
+    "VERDICT_CONTEXT_TEMPLATE",
+    "NO_VERDICT_CONTEXT_TEMPLATE",
+    "USER_MESSAGE_TEMPLATE",
+]
+
+HOOK_EVENT_NAME = "PermissionDenied"
+RULE_LABEL_PATTERN = r"\[([^\]]+)\]"
+UNNAMED_RULE_LABEL = "unnamed rule"
+MAXIMUM_ACTION_SUMMARY_CHARACTERS = 160
+TRUNCATION_MARKER = "..."
+SUMMARY_WORD_SEPARATOR = " "
+ALL_COMMAND_INPUT_KEYS = ("command", "url", "file_path", "path")
+
+ALLOW_ENTRY_TEMPLATE = (
+    "{rule_label} exception: {tool_name} calls like `{action_summary}` "
+    "are allowed when they serve the task the user gave."
+)
+
+POWERSHELL_BLOCK_TEMPLATE = """\
+$settingsPath = Join-Path $HOME '.claude/settings.json'
+New-Item -ItemType Directory -Force -Path (Split-Path $settingsPath) | Out-Null
+$settings = if (Test-Path $settingsPath) { Get-Content -Raw $settingsPath | ConvertFrom-Json -AsHashtable } else { @{} }
+if (-not $settings.ContainsKey('autoMode')) { $settings['autoMode'] = @{} }
+$allowList = [System.Collections.Generic.List[string]]::new()
+if ($settings['autoMode'].ContainsKey('allow')) { $allowList.AddRange([string[]]@($settings['autoMode']['allow'])) } else { $allowList.Add('$defaults') }
+$entry = '{escaped_entry}'
+if ($allowList -notcontains $entry) { $allowList.Add($entry) }
+$settings['autoMode']['allow'] = $allowList.ToArray()
+$settings | ConvertTo-Json -Depth 32 | Set-Content -Encoding utf8NoBOM $settingsPath
+claude auto-mode config"""
+
+VERDICT_CONTEXT_TEMPLATE = """\
+=== AUTO MODE DENIAL QUICK FIX ===
+Auto mode denied {tool_name} under rule [{rule_label}].
+Denial reason: {denial_reason}
+Denied action: {action_summary}
+
+In your next message to the user, propose these two fixes. Do not retry and do not run the block yourself.
+1. One-off: the user replies with a message that names this exact action and its target; then you retry once.
+2. Lasting: the user runs this PowerShell 7 block on their machine. It adds one autoMode.allow entry to ~/.claude/settings.json and keeps "$defaults". Narrow the entry text to this action before you send it.
+
+```powershell
+{powershell_block}
+```
+
+For cloud sessions, the same entry must land in the ~/.claude/settings.json that the session's setup installs.
+Read the rule wording with: claude auto-mode defaults --label '{rule_label}'"""
+
+NO_VERDICT_CONTEXT_TEMPLATE = """\
+=== AUTO MODE DENIAL QUICK FIX ===
+Auto mode denied {tool_name} with no classifier verdict.
+Denial reason: {denial_reason}
+Denied action: {action_summary}
+
+An autoMode.allow entry cannot clear a denial with no verdict. Tell the user the action and the reason, and ask them to run it themselves or to retry it later."""
+
+USER_MESSAGE_TEMPLATE = (
+    "Auto mode blocked {tool_name} [{rule_label}]. Claude will propose a quick fix."
+)

package/package.json

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

package/scripts/dev_env_scripts_constants/claude_account_constants.py

@@ -130,16 +130,16 @@ WINDOWS_OS_NAME: str = "nt"
 TEXT_ENCODING: str = "utf-8"
 """Encoding for the launcher file and the JSON reports."""
 
-MAIN_WEEKLY_USED_CEILING_PERCENT: float = 90.0
+MAIN_WEEKLY_USED_CEILING_PERCENT: float = 99.0
 """Main takes jobs only while its weekly use is under this percent."""
 
-MAIN_SESSION_USED_CEILING_PERCENT: float = 50.0
+MAIN_SESSION_USED_CEILING_PERCENT: float = 95.0
 """Main takes jobs only while its 5-hour use is under this percent."""
 
-SECOND_WEEKLY_USED_CEILING_PERCENT: float = 95.0
+SECOND_WEEKLY_USED_CEILING_PERCENT: float = 99.0
 """The second account takes jobs while its weekly use is under this percent."""
 
-SECOND_SESSION_USED_CEILING_PERCENT: float = 90.0
+SECOND_SESSION_USED_CEILING_PERCENT: float = 95.0
 """The second account takes jobs while its 5-hour use is under this percent."""
 
 FULL_PERCENT: float = 100.0

package/scripts/dev_env_scripts_constants/test_claude_account_constants.py

@@ -1,4 +1,4 @@
-"""The second-account thresholds keep the main account the protected one."""
+"""The picker report and meter keys stay distinct."""
 
 from __future__ import annotations
 
@@ -11,18 +11,9 @@ from dev_env_scripts_constants.claude_account_constants import (
     JSON_SESSION_USED_PERCENT_KEY,
     JSON_WEEKLY_RESETS_AT_KEY,
     JSON_WEEKLY_USED_PERCENT_KEY,
-    MAIN_SESSION_USED_CEILING_PERCENT,
-    MAIN_WEEKLY_USED_CEILING_PERCENT,
-    SECOND_SESSION_USED_CEILING_PERCENT,
-    SECOND_WEEKLY_USED_CEILING_PERCENT,
 )
 
 
-def test_main_ceilings_sit_below_the_second_account_ceilings() -> None:
-    assert MAIN_WEEKLY_USED_CEILING_PERCENT < SECOND_WEEKLY_USED_CEILING_PERCENT
-    assert MAIN_SESSION_USED_CEILING_PERCENT < SECOND_SESSION_USED_CEILING_PERCENT
-
-
 def test_picker_report_keys_never_collide() -> None:
     all_report_keys = [
         JSON_ACCOUNT_KEY,

package/scripts/test_account_broker.py

@@ -112,8 +112,8 @@ def test_should_keep_list_order_when_tighter_windows_tie() -> None:
 @pytest.mark.parametrize(
     ("weekly_reset", "weekly_left", "short_left"),
     (
-        (NOW + timedelta(hours=4), 10, 80),
-        (NOW + timedelta(hours=4), 20, 50),
+        (NOW + timedelta(hours=4), 1, 80),
+        (NOW + timedelta(hours=4), 20, 5),
     ),
 )
 def test_should_guard_main_at_each_limit(
@@ -158,7 +158,7 @@ def test_should_pick_an_extra_with_more_room_than_main() -> None:
     assert decision.account == extra.account
 
 
-@pytest.mark.parametrize(("main_short_left", "expected_name"), ((51, "main"), (50, "extra")))
+@pytest.mark.parametrize(("main_short_left", "expected_name"), ((6, "main"), (5, "extra")))
 def test_should_pick_main_only_while_under_its_5_hour_ceiling(
     main_short_left: float, expected_name: str
 ) -> None:
@@ -166,7 +166,7 @@ def test_should_pick_main_only_while_under_its_5_hour_ceiling(
         _account("main", Product.CLAUDE, main=True),
         _meters(main_short_left, 95, weekly_reset=NOW + timedelta(days=5)),
     )
-    extra = Reading(_account("extra", Product.CLAUDE), _meters(20, 20))
+    extra = Reading(_account("extra", Product.CLAUDE), _meters(20, 2))
 
     decision = choose_from_readings(Product.CLAUDE, (main, extra), now=NOW)
 
@@ -190,7 +190,7 @@ def test_should_wait_for_main_5_hour_reset_while_its_week_resets_days_away() ->
     short_reset = NOW + timedelta(hours=2)
     main = Reading(
         _account("main", Product.CLAUDE, main=True),
-        _meters(40, 50, short_reset=short_reset, weekly_reset=NOW + timedelta(days=3)),
+        _meters(5, 50, short_reset=short_reset, weekly_reset=NOW + timedelta(days=3)),
     )
 
     decision = choose_from_readings(Product.CLAUDE, (main,), now=NOW)
@@ -202,8 +202,8 @@ def test_should_wait_for_main_5_hour_reset_while_its_week_resets_days_away() ->
 @pytest.mark.parametrize(
     ("short_left", "weekly_left", "weekly_reset", "expected_reset"),
     (
-        (40, 20, NOW + timedelta(hours=4), NOW + timedelta(hours=2)),
-        (80, 5, NOW + timedelta(hours=4), NOW + timedelta(hours=4)),
+        (5, 20, NOW + timedelta(hours=4), NOW + timedelta(hours=2)),
+        (80, 1, NOW + timedelta(hours=4), NOW + timedelta(hours=4)),
     ),
 )
 def test_should_wait_for_the_meter_or_window_that_blocks_main(
@@ -292,7 +292,7 @@ def test_should_wait_until_both_blocking_windows_reset() -> None:
 
 def test_should_use_claude_extra_floors_and_wait_for_unread() -> None:
     blocked = Reading(
-        _account("blocked", Product.CLAUDE), _meters(10, 5)
+        _account("blocked", Product.CLAUDE), _meters(5, 1)
     )
     unread = Reading(_account("unread", Product.CLAUDE), None)
 
@@ -462,14 +462,14 @@ _EV_CLAUDE = _account("ev", Product.CLAUDE)
             id="every-meter-unreadable",
         ),
         pytest.param(
-            (Reading(_MAIN_CLAUDE, _meters(40, 50, short_reset=NOW + timedelta(minutes=30))), Reading(_EV_CLAUDE, None)),
+            (Reading(_MAIN_CLAUDE, _meters(5, 50, short_reset=NOW + timedelta(minutes=30))), Reading(_EV_CLAUDE, None)),
             {},
             "no readable account has room; meter unreadable for ev; next reset at 2026-10-03T00:30:00+00:00",
             NOW + timedelta(minutes=30),
             id="unreadable-beside-a-reset-before-the-check",
         ),
         pytest.param(
-            (Reading(_MAIN_CLAUDE, _meters(40, 50, short_reset=NOW + timedelta(hours=2))), Reading(_EV_CLAUDE, None)),
+            (Reading(_MAIN_CLAUDE, _meters(5, 50, short_reset=NOW + timedelta(hours=2))), Reading(_EV_CLAUDE, None)),
             {},
             "no readable account has room; meter unreadable for ev; next check at 2026-10-03T01:00:00+00:00",
             NOW + timedelta(hours=1),
@@ -484,7 +484,7 @@ _EV_CLAUDE = _account("ev", Product.CLAUDE)
         ),
         pytest.param(
             (
-                Reading(_MAIN_CLAUDE, _meters(40, 50, short_reset=NOW + timedelta(hours=2))),
+                Reading(_MAIN_CLAUDE, _meters(5, 50, short_reset=NOW + timedelta(hours=2))),
                 Reading(_EV_CLAUDE, _meters(5, 80, short_reset=NOW + timedelta(hours=3))),
             ),
             {},
@@ -493,7 +493,7 @@ _EV_CLAUDE = _account("ev", Product.CLAUDE)
             id="every-meter-read-with-known-resets",
         ),
         pytest.param(
-            (Reading(_MAIN_CLAUDE, Meters(40, None, 50, None)),),
+            (Reading(_MAIN_CLAUDE, Meters(5, None, 50, None)),),
             {},
             "no account has room; next check at 2026-10-03T01:00:00+00:00",
             NOW + timedelta(hours=1),