claude-dev-env 2.30.0 → 2.30.1

package/.agents/skills/e-simplify/SKILL.md

@@ -25,7 +25,7 @@ Triggers: `/e-simplify` on the current diff (or a PR/branch/path passed as an ar
 
 ## The process
 
-`/simplify → 4 cleanup agents in parallel → apply the fixes`
+`/simplify → up to 4 cleanup agents in parallel → apply the fixes`
 
 You are improving the quality of the changed code, not hunting for bugs. Review
 it for reuse, simplification, efficiency, and altitude issues, then fix what you
@@ -40,13 +40,25 @@ include the working-tree changes in scope — the review often runs before the
 commit. If a PR number, branch name, or file path was passed as an argument,
 review that target instead. Treat this diff as the review scope.
 
-### Phase 1 — Review (4 cleanup agents in parallel)
+**Diff-size cap.** Run `git diff --shortstat` on the same range Phase 0 used
+to get the diff, and add its insertions and deletions for the changed-line
+count. Default ceiling: 400 changed lines for one run — a tunable default the
+user may adjust. Above the ceiling, narrow the target first — a subdirectory,
+a package, or one file path — and review that narrowed target. Do not launch
+Phase 1 over a diff above the ceiling.
 
-Launch **4 independent review agents** via the Agent tool, all in a
-single message so they run concurrently. Pass each agent the diff and one of
-the four angles below. Each returns its findings with `file`, `line`, a
-one-line `summary`, and the concrete cost (what is duplicated, wasted, or
-harder to maintain).
+### Phase 1 — Review (up to 4 cleanup agents in parallel)
+
+**Lens cap.** Four lenses is the ceiling, not the floor. Default split — also
+tunable — by the `git diff --shortstat` changed-line count from Phase 0:
+under 100 changed lines, run 2 lenses (reuse and simplification); at 100
+changed lines or above, and under the diff-size cap, run all 4 lenses.
+
+Launch the review agents for the lenses in scope for this run — 2 or 4 by the
+cap above — via the Agent tool, all in a single message so they run
+concurrently. Pass each agent the diff and one of the angles below. Each
+returns its findings with `file`, `line`, a one-line `summary`, and the
+concrete cost (what is duplicated, wasted, or harder to maintain).
 
 #### Reuse
 
@@ -79,7 +91,7 @@ special cases.
 
 ### Phase 2 — Apply the fixes
 
-Wait for all four agents to complete, dedup findings that point at the same
+Wait for every launched agent to complete, dedup findings that point at the same
 line or mechanism, and fix each remaining one directly. Skip any finding whose
 fix would change intended behavior, require changes well outside the reviewed
 diff, or that you judge to be a false positive — note the skip rather than

package/hooks/blocking/code_rules_enforcer.py

@@ -799,11 +799,8 @@ def _hook_infrastructure_blocking_issues(
     Returns:
         The in-scope violations for the target at the given phase.
     """
-    effective_content = content if full_file_content is None else full_file_content
-    all_changed_lines = (
-        changed_line_numbers(prior_full_file_content, full_file_content)
-        if full_file_content is not None
-        else None
+    effective_content, all_changed_lines = _effective_content_and_changed_lines(
+        content, full_file_content, prior_full_file_content
     )
     all_issues: list[str] = []
     if phase == FULL_GATE_PHASE:

package/hooks/blocking/shell_substitution_blocker.py

@@ -24,13 +24,28 @@ are treated as literal only when the count of preceding backslashes is odd;
 an even count (including zero) means the backtick is a live substitution.
 
 Bash arithmetic expansion ``$((...))`` is explicitly NOT blocked: it does not
-spawn a subshell and does not defeat the allowlist matcher, so the
-``$(`` pattern uses a negative lookahead to skip the ``$((`` case.
+spawn a subshell and does not defeat the allowlist matcher. Telling it apart
+from a disguised command substitution takes more than counting two open
+parens, because bash itself falls back from arithmetic to command
+substitution when the expansion body does not close as arithmetic. Observed
+against real bash:
+
+    echo $((1 + 2))            prints 3            (arithmetic; not blocked)
+    echo $((cd /tmp) && pwd)   prints the new cwd   (command substitution; blocked)
+    echo $((1+2) )             runs "1+2" as a command, rc=0, no output
+                                                     (command substitution; blocked)
+
+Bash's own rule is the terminator: walk forward from ``$((`` tracking paren
+depth; when depth returns to zero on a closer immediately preceded by
+another ``)`` (an ``))`` pair), the expansion is arithmetic and passes. When
+the closer that brings depth to zero is a lone ``)``, bash has fallen back to
+running a parenthesized command inside the substitution, so it is blocked.
+This hook applies that walk, tracking paren depth from the opening ``$((``.
 
 False positives are still possible when the user is intentionally writing
 shell-script content (for example, authoring a .sh file via heredoc) and the
 substitution is literal payload rather than something to execute. In that
-case, write via the Write tool instead of a Bash heredoc.
+case, author the file with the Write tool, not a Bash heredoc.
 """
 
 from __future__ import annotations
@@ -39,34 +54,95 @@ import json
 import sys
 from pathlib import Path
 
-_hooks_dir = str(Path(__file__).resolve().parent.parent)
-if _hooks_dir not in sys.path:
-    sys.path.insert(0, _hooks_dir)
-
-from hooks_constants.shell_substitution_blocker_constants import (  # noqa: E402
-    BASH_TOOL_NAME,
-    COMMAND_KEY,
-    CORRECTIVE_MESSAGE,
-    DENY_DECISION,
-    DOLLAR_PAREN_PATTERN,
-    EVEN_BACKSLASH_BACKTICK_PATTERN,
-    HOOK_EVENT_NAME,
-    HOOK_EVENT_NAME_KEY,
-    HOOK_SPECIFIC_OUTPUT_KEY,
-    PERMISSION_DECISION_KEY,
-    PERMISSION_DECISION_REASON_KEY,
-    PROCESS_SUBSTITUTION_PATTERN,
-    SINGLE_QUOTED_RUN_PATTERN,
-    STRIPPED_RUN_REPLACEMENT,
-    TOOL_INPUT_KEY,
-    TOOL_NAME_KEY,
-)
+try:
+    from hooks_constants.shell_substitution_blocker_constants import (
+        BASH_TOOL_NAME,
+        CLOSE_PAREN_CHARACTER,
+        COMMAND_KEY,
+        CORRECTIVE_MESSAGE,
+        DENY_DECISION,
+        DOLLAR_PAREN_PATTERN,
+        EVEN_BACKSLASH_BACKTICK_PATTERN,
+        HOOK_EVENT_NAME,
+        HOOK_EVENT_NAME_KEY,
+        HOOK_SPECIFIC_OUTPUT_KEY,
+        OPEN_PAREN_CHARACTER,
+        PAREN_DEPTH_AFTER_DOUBLE_OPEN,
+        PERMISSION_DECISION_KEY,
+        PERMISSION_DECISION_REASON_KEY,
+        PROCESS_SUBSTITUTION_PATTERN,
+        SINGLE_QUOTED_RUN_PATTERN,
+        STRIPPED_RUN_REPLACEMENT,
+        TOOL_INPUT_KEY,
+        TOOL_NAME_KEY,
+    )
+except ModuleNotFoundError:
+    _hooks_dir = str(Path(__file__).resolve().parent.parent)
+    if _hooks_dir not in sys.path:
+        sys.path.insert(0, _hooks_dir)
+    from hooks_constants.shell_substitution_blocker_constants import (
+        BASH_TOOL_NAME,
+        CLOSE_PAREN_CHARACTER,
+        COMMAND_KEY,
+        CORRECTIVE_MESSAGE,
+        DENY_DECISION,
+        DOLLAR_PAREN_PATTERN,
+        EVEN_BACKSLASH_BACKTICK_PATTERN,
+        HOOK_EVENT_NAME,
+        HOOK_EVENT_NAME_KEY,
+        HOOK_SPECIFIC_OUTPUT_KEY,
+        OPEN_PAREN_CHARACTER,
+        PAREN_DEPTH_AFTER_DOUBLE_OPEN,
+        PERMISSION_DECISION_KEY,
+        PERMISSION_DECISION_REASON_KEY,
+        PROCESS_SUBSTITUTION_PATTERN,
+        SINGLE_QUOTED_RUN_PATTERN,
+        STRIPPED_RUN_REPLACEMENT,
+        TOOL_INPUT_KEY,
+        TOOL_NAME_KEY,
+    )
 
 
 def _strip_single_quoted_runs(command: str) -> str:
     return SINGLE_QUOTED_RUN_PATTERN.sub(STRIPPED_RUN_REPLACEMENT, command)
 
 
+def _closes_as_arithmetic_expansion(command: str, scan_start_index: int) -> bool:
+    """Return True when a ``$((`` expansion closes on an ``))`` pair.
+
+    See the module docstring for the real-bash evidence behind this rule.
+    """
+    paren_depth = PAREN_DEPTH_AFTER_DOUBLE_OPEN
+    was_previous_character_close_paren = False
+    for each_index in range(scan_start_index, len(command)):
+        current_character = command[each_index]
+        if current_character == OPEN_PAREN_CHARACTER:
+            paren_depth += 1
+            was_previous_character_close_paren = False
+            continue
+        if current_character != CLOSE_PAREN_CHARACTER:
+            was_previous_character_close_paren = False
+            continue
+        paren_depth -= 1
+        if paren_depth == 0:
+            return was_previous_character_close_paren
+        was_previous_character_close_paren = True
+    return False
+
+
+def _has_unsafe_dollar_paren_expansion(command: str) -> bool:
+    """Return True for a `$(` that is not a safe `$((...))` arithmetic pair."""
+    for each_match in DOLLAR_PAREN_PATTERN.finditer(command):
+        is_arithmetic_style_open = (
+            command[each_match.end() : each_match.end() + 1] == OPEN_PAREN_CHARACTER
+        )
+        if not is_arithmetic_style_open:
+            return True
+        if not _closes_as_arithmetic_expansion(command, each_match.end() + 1):
+            return True
+    return False
+
+
 def has_shell_substitution(command: str) -> bool:
     """Return True when a Bash command carries a live shell substitution.
 
@@ -79,18 +155,18 @@ def has_shell_substitution(command: str) -> bool:
         echo $((2 + 2))                ok:   arithmetic expansion
 
     Single-quoted runs are stripped first because bash substitutes nothing
-    inside them. A backtick preceded by an odd number of backslashes is escaped
-    and stays allowed.
+    inside them. A backtick preceded by an odd backslash count is escaped.
+    A `$((` pair is walked to its terminator (module docstring) to tell
+    real arithmetic from a disguised subshell.
 
     Args:
         command: The raw Bash command string from the tool input.
 
     Returns:
-        True when a substitution the allowlist matcher cannot descend into is
-        present outside single quotes.
+        True when a substitution the matcher cannot descend into is present.
     """
     scannable_command = _strip_single_quoted_runs(command)
-    if DOLLAR_PAREN_PATTERN.search(scannable_command):
+    if _has_unsafe_dollar_paren_expansion(scannable_command):
         return True
     if EVEN_BACKSLASH_BACKTICK_PATTERN.search(scannable_command):
         return True

package/hooks/blocking/test_bash_pre_tool_use_dispatcher.py

@@ -261,6 +261,20 @@ def test_emit_decision_re_emits_silent_deny_fields(
     assert emitted_payload["suppressOutput"] is True
 
 
+def test_dispatcher_denies_subshell_disguised_as_arithmetic_expansion() -> None:
+    """The dispatcher denies a `$((cd X) && Y)` subshell, not only the bare hook.
+
+    `echo $((cd /tmp) && pwd)` opens with a `$((` two-character lookahead
+    match, so a function-level test alone does not prove the block reaches
+    the live Bash tool path.
+    """
+    payload_text = _bash_payload("echo $((cd /tmp) && pwd)")
+    decision, _reason = _decision_from_stdout(
+        _run_process(_DISPATCHER_SCRIPT, payload_text).stdout
+    )
+    assert decision == "deny"
+
+
 def test_dispatch_emits_deny_immediately_and_skips_later_hooks(
     monkeypatch: pytest.MonkeyPatch,
     capsys: pytest.CaptureFixture[str],

package/hooks/blocking/test_code_rules_validation_phase.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import ast
 import contextlib
 import importlib
 import importlib.util
@@ -10,6 +11,7 @@ import re
 import shutil
 import sys
 import tempfile
+import textwrap
 from pathlib import Path
 from types import ModuleType
 from unittest.mock import DEFAULT, MagicMock, patch
@@ -279,3 +281,52 @@ def test_gate_running_selects_the_full_gate(tmp_path: Path) -> None:
     assert scoped_violations is not None
     blocking_violations, _advisory_violations = scoped_violations
     assert any("9999" in each_issue for each_issue in blocking_violations)
+
+
+ALL_CHECK_FUNCTION_NAME_PREFIXES = ("check_", "advise_")
+
+
+def _check_names_called_in(enforcer_function_name: str) -> set[str]:
+    """Return the check-function names called directly inside a phase router.
+
+    Parses the router's own source and collects every direct call to a
+    module-level name beginning with a check prefix, so a roster constant can
+    assert against the calls production really makes rather than against a
+    second hand-written literal.
+
+    Args:
+        enforcer_function_name: The attribute name of the router on the
+            enforcer module, such as ``_python_full_gate_only_issues``.
+
+    Returns:
+        The set of check-function names the router calls directly.
+    """
+    router_source = textwrap.dedent(
+        inspect.getsource(getattr(code_rules_enforcer, enforcer_function_name))
+    )
+    return {
+        each_node.func.id
+        for each_node in ast.walk(ast.parse(router_source))
+        if isinstance(each_node, ast.Call)
+        and isinstance(each_node.func, ast.Name)
+        and each_node.func.id.startswith(ALL_CHECK_FUNCTION_NAME_PREFIXES)
+    }
+
+
+def test_full_gate_only_roster_matches_the_checks_the_router_calls() -> None:
+    """The roster constant tracks the calls in _python_full_gate_only_issues."""
+    assert (
+        _check_names_called_in("_python_full_gate_only_issues")
+        == validation_phase_constants.ALL_FULL_GATE_ONLY_CHECK_NAMES
+    ), "ALL_FULL_GATE_ONLY_CHECK_NAMES must name exactly the router's own calls"
+
+
+def test_hook_infrastructure_edit_lane_roster_matches_the_checks_the_router_calls() -> None:
+    """The roster constant tracks the always-run calls in the hook-infrastructure router."""
+    all_always_run_check_names = _check_names_called_in(
+        "_hook_infrastructure_blocking_issues"
+    ) - validation_phase_constants.ALL_FULL_GATE_ONLY_CHECK_NAMES
+    assert (
+        all_always_run_check_names
+        == validation_phase_constants.ALL_HOOK_INFRASTRUCTURE_EDIT_LANE_CHECK_NAMES
+    ), "ALL_HOOK_INFRASTRUCTURE_EDIT_LANE_CHECK_NAMES must name exactly the router's own calls"

package/hooks/blocking/test_shell_substitution_blocker.py

@@ -122,3 +122,72 @@ def test_allows_arithmetic_expansion() -> None:
         "tool_input": {"command": "echo $((2+2))"},
     }
     assert _run_hook(payload).stdout == ""
+
+
+def test_allows_arithmetic_expansion_with_nested_parens() -> None:
+    payload = {
+        "tool_name": "Bash",
+        "tool_input": {"command": "echo $(( (1+2) * 3 ))"},
+    }
+    assert _run_hook(payload).stdout == ""
+
+
+def test_allows_arithmetic_expansion_whose_body_bash_itself_rejects() -> None:
+    payload = {
+        "tool_name": "Bash",
+        "tool_input": {"command": "echo $((echo hi))"},
+    }
+    assert _run_hook(payload).stdout == ""
+
+
+def test_allows_arithmetic_lookalike_inside_single_quotes() -> None:
+    payload = {
+        "tool_name": "Bash",
+        "tool_input": {"command": "echo '$((cd /tmp) && pwd)'"},
+    }
+    assert _run_hook(payload).stdout == ""
+
+
+def test_denies_subshell_disguised_as_arithmetic_expansion() -> None:
+    payload = {
+        "tool_name": "Bash",
+        "tool_input": {"command": "echo $((cd /tmp) && pwd)"},
+    }
+    response = json.loads(_run_hook(payload).stdout)
+    assert response["hookSpecificOutput"]["permissionDecision"] == "deny"
+
+
+def test_denies_parenthesized_command_word_disguised_as_arithmetic() -> None:
+    payload = {
+        "tool_name": "Bash",
+        "tool_input": {"command": "echo $((1+2) )"},
+    }
+    response = json.loads(_run_hook(payload).stdout)
+    assert response["hookSpecificOutput"]["permissionDecision"] == "deny"
+
+
+def test_denies_command_substitution_nested_inside_arithmetic_expansion() -> None:
+    payload = {
+        "tool_name": "Bash",
+        "tool_input": {"command": "echo $(( $(id -u) + 1 ))"},
+    }
+    response = json.loads(_run_hook(payload).stdout)
+    assert response["hookSpecificOutput"]["permissionDecision"] == "deny"
+
+
+def test_denies_backtick_substitution_nested_inside_arithmetic_expansion() -> None:
+    payload = {
+        "tool_name": "Bash",
+        "tool_input": {"command": "echo $(( `id -u` + 1 ))"},
+    }
+    response = json.loads(_run_hook(payload).stdout)
+    assert response["hookSpecificOutput"]["permissionDecision"] == "deny"
+
+
+def test_denies_nested_command_substitution_without_arithmetic() -> None:
+    payload = {
+        "tool_name": "Bash",
+        "tool_input": {"command": "echo $(echo $(whoami))"},
+    }
+    response = json.loads(_run_hook(payload).stdout)
+    assert response["hookSpecificOutput"]["permissionDecision"] == "deny"

package/hooks/hooks.json

@@ -171,7 +171,7 @@
           },
           {
             "type": "command",
-            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/session/task_list_loop_starter.py",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/session/task_tool_prompt.py",
             "timeout": 10
           },
           {

package/hooks/hooks_constants/code_rules_enforcer_constants.py

@@ -7,7 +7,6 @@ import re
 import tokenize
 
 from hooks_constants.validation_phase_constants import (  # noqa: F401  re-exported for code_rules_enforcer.py
-    ALL_HOOK_INFRASTRUCTURE_EDIT_LANE_CHECK_NAMES,
     ALL_VALIDATION_PHASES,
     EDIT_LANE_PHASE,
     FULL_GATE_PHASE,

package/hooks/hooks_constants/shell_substitution_blocker_constants.py

@@ -41,7 +41,10 @@ PERMISSION_DECISION_KEY = "permissionDecision"
 DENY_DECISION = "deny"
 PERMISSION_DECISION_REASON_KEY = "permissionDecisionReason"
 
-DOLLAR_PAREN_PATTERN = re.compile(r"\$\((?!\()")
+DOLLAR_PAREN_PATTERN = re.compile(r"\$\(")
+OPEN_PAREN_CHARACTER = "("
+CLOSE_PAREN_CHARACTER = ")"
+PAREN_DEPTH_AFTER_DOUBLE_OPEN = 2
 EVEN_BACKSLASH_BACKTICK_PATTERN = re.compile(r"(?<!\\)(?:\\\\)*`")
 PROCESS_SUBSTITUTION_PATTERN = re.compile(r"[<>]\(")
 SINGLE_QUOTED_RUN_PATTERN = re.compile(r"'[^']*'")

package/hooks/hooks_constants/task_tool_prompt_constants.py

@@ -0,0 +1,13 @@
+"""Directive text for the task_tool_prompt SessionStart hook."""
+
+from __future__ import annotations
+
+__all__ = [
+    "TASK_TOOL_DIRECTIVE",
+]
+
+TASK_TOOL_DIRECTIVE = (
+    "TASK TRACKING: Track this session's work with the session's task or todo "
+    "tracking tool, whichever this host provides. Create tasks at the start "
+    "of the session, then update them as work proceeds."
+)

package/hooks/hooks_constants/test_code_rules_enforcer_constants.py

@@ -17,7 +17,6 @@ if str(_HOOKS_ROOT) not in sys.path:
     sys.path.insert(0, str(_HOOKS_ROOT))
 
 from hooks_constants.code_rules_enforcer_constants import (
-    ALL_HOOK_INFRASTRUCTURE_EDIT_LANE_CHECK_NAMES,
     ALL_VALIDATION_PHASES,
     CONFIG_DIRECTORY_SEGMENT,
     CONSTANTS_MODULE_SUFFIX,
@@ -111,11 +110,3 @@ def test_validation_phase_constants_are_reexported_and_render() -> None:
         phase="bogus_phase", all_phases=sorted(ALL_VALIDATION_PHASES)
     )
     assert "bogus_phase" in rendered_message
-
-
-def test_hook_infrastructure_edit_lane_check_names_are_reexported() -> None:
-    assert ALL_HOOK_INFRASTRUCTURE_EDIT_LANE_CHECK_NAMES == {
-        "check_same_file_inline_duplicate_body",
-        "check_zero_payload_function_alias",
-        "check_unanchored_command_dispatch",
-    }

package/hooks/session/task_tool_prompt.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+"""SessionStart hook — direct the session to track work with its task tool.
+
+At session start this hook emits an ``additionalContext`` directive asking
+the session to track its work with the task or todo tracking tool its host
+provides: create tasks at the start of the session, then update them as
+work proceeds.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+
+import _path_setup  # noqa: F401
+
+from hooks_constants.task_tool_prompt_constants import TASK_TOOL_DIRECTIVE
+
+
+def build_session_directive() -> str:
+    """Return the task-tool directive emitted at session start."""
+    return TASK_TOOL_DIRECTIVE
+
+
+def main() -> None:
+    """Emit the task-tool directive as SessionStart additionalContext."""
+    payload = {
+        "hookSpecificOutput": {
+            "hookEventName": "SessionStart",
+            "additionalContext": build_session_directive(),
+        }
+    }
+    sys.stdout.write(json.dumps(payload) + "\n")
+
+
+if __name__ == "__main__":
+    main()

package/hooks/session/test_task_tool_prompt.py

@@ -0,0 +1,65 @@
+"""Tests for task_tool_prompt — SessionStart hook that directs task-tool tracking."""
+
+import importlib
+import json
+import sys
+from io import StringIO
+from pathlib import Path
+from unittest.mock import patch
+
+_SESSION_DIR = Path(__file__).resolve().parent
+_HOOKS_ROOT = _SESSION_DIR.parent
+for each_sys_path_entry in (str(_SESSION_DIR), str(_HOOKS_ROOT)):
+    if each_sys_path_entry not in sys.path:
+        sys.path.insert(0, each_sys_path_entry)
+
+prompt = importlib.import_module("task_tool_prompt")
+task_tool_prompt_constants = importlib.import_module("hooks_constants.task_tool_prompt_constants")
+TASK_TOOL_DIRECTIVE = task_tool_prompt_constants.TASK_TOOL_DIRECTIVE
+
+
+def _run_main() -> str:
+    """Return stdout produced by running the hook's main()."""
+    captured_stdout = StringIO()
+    with patch("sys.stdout", captured_stdout):
+        prompt.main()
+    return captured_stdout.getvalue()
+
+
+class TestSessionDirective:
+    def test_main_emits_additional_context(self) -> None:
+        emitted = json.loads(_run_main())
+        hook_output = emitted["hookSpecificOutput"]
+        assert hook_output["hookEventName"] == "SessionStart"
+        assert "additionalContext" in hook_output
+
+    def test_directive_names_the_tracking_tool(self) -> None:
+        emitted = json.loads(_run_main())
+        assert "task or todo tracking tool" in emitted["hookSpecificOutput"]["additionalContext"]
+
+    def test_directive_names_no_vendor_or_host_product(self) -> None:
+        emitted = json.loads(_run_main())
+        additional_context = emitted["hookSpecificOutput"]["additionalContext"]
+        for each_forbidden_term in ("Claude", "Cursor", "Codex", "TaskCreate", "TodoWrite"):
+            assert each_forbidden_term not in additional_context
+
+    def test_directive_says_create_tasks_at_session_start(self) -> None:
+        emitted = json.loads(_run_main())
+        additional_context = emitted["hookSpecificOutput"]["additionalContext"]
+        assert "start of the session" in additional_context
+
+    def test_directive_says_update_as_work_proceeds(self) -> None:
+        emitted = json.loads(_run_main())
+        additional_context = emitted["hookSpecificOutput"]["additionalContext"]
+        assert "update" in additional_context
+        assert "as work proceeds" in additional_context
+
+    def test_directive_names_no_loop_cadence(self) -> None:
+        emitted = json.loads(_run_main())
+        additional_context = emitted["hookSpecificOutput"]["additionalContext"]
+        assert "/loop" not in additional_context
+        assert "cadence" not in additional_context
+        assert "minute" not in additional_context
+
+    def test_build_session_directive_returns_the_shared_constant(self) -> None:
+        assert prompt.build_session_directive() == TASK_TOOL_DIRECTIVE

package/package.json

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

package/hooks/hooks_constants/task_list_loop_starter_constants.py

@@ -1,19 +0,0 @@
-"""Directive text for the task_list_loop_starter SessionStart hook."""
-
-from __future__ import annotations
-
-__all__ = [
-    "TASK_LIST_MAINTENANCE_INSTRUCTION",
-    "TASK_LIST_LOOP_DIRECTIVE",
-]
-
-TASK_LIST_MAINTENANCE_INSTRUCTION = "build or update the task list using the task tools"
-
-TASK_LIST_LOOP_DIRECTIVE = (
-    "TASK LIST MAINTENANCE: Keep this session's task list current on a 10-minute "
-    "cadence. Reuse the active task-list maintenance loop when available. Start "
-    "Claude Code's built-in /loop skill with a 10-minute interval when this session "
-    "needs its first loop: "
-    f'/loop 10m "{TASK_LIST_MAINTENANCE_INSTRUCTION}". Run that instruction once '
-    "immediately when starting the loop, then let the loop refresh the list every 10 minutes."
-)

package/hooks/session/task_list_loop_starter.py

@@ -1,45 +0,0 @@
-#!/usr/bin/env python3
-"""SessionStart hook — start a task-list maintenance loop for the session.
-
-At session start this hook emits an ``additionalContext`` directive asking Claude
-to keep the session's task list current on a 10-minute cadence. Claude reuses the
-active ``/loop`` skill when available and starts the skill for the session's first
-task-list maintenance loop.
-"""
-
-from __future__ import annotations
-
-import json
-import sys
-from pathlib import Path
-
-_hooks_dir = str(Path(__file__).resolve().parent.parent)
-if _hooks_dir not in sys.path:
-    sys.path.insert(0, _hooks_dir)
-
-from hooks_constants.task_list_loop_starter_constants import (  # noqa: E402
-    TASK_LIST_LOOP_DIRECTIVE,
-)
-
-
-def build_session_directive() -> str:
-    """Return the task-list loop directive emitted at session start."""
-    return TASK_LIST_LOOP_DIRECTIVE
-
-
-def main() -> None:
-    """Emit the task-list loop directive as SessionStart additionalContext."""
-    print(
-        json.dumps(
-            {
-                "hookSpecificOutput": {
-                    "hookEventName": "SessionStart",
-                    "additionalContext": build_session_directive(),
-                }
-            }
-        )
-    )
-
-
-if __name__ == "__main__":
-    main()

package/hooks/session/test_task_list_loop_starter.py

@@ -1,63 +0,0 @@
-"""Tests for task_list_loop_starter — SessionStart hook that starts a task-list loop."""
-
-import json
-import sys
-from io import StringIO
-from pathlib import Path
-from unittest.mock import patch
-
-_SESSION_DIR = Path(__file__).resolve().parent
-_HOOKS_ROOT = _SESSION_DIR.parent
-for each_sys_path_entry in (str(_SESSION_DIR), str(_HOOKS_ROOT)):
-    if each_sys_path_entry not in sys.path:
-        sys.path.insert(0, each_sys_path_entry)
-
-import task_list_loop_starter as starter
-
-from hooks_constants.task_list_loop_starter_constants import (
-    TASK_LIST_LOOP_DIRECTIVE,
-    TASK_LIST_MAINTENANCE_INSTRUCTION,
-)
-
-
-def _run_main() -> str:
-    """Return stdout produced by running the hook's main()."""
-    captured_stdout = StringIO()
-    with patch("sys.stdout", captured_stdout):
-        starter.main()
-    return captured_stdout.getvalue()
-
-
-class TestSessionDirective:
-    def test_main_emits_additional_context(self) -> None:
-        emitted = json.loads(_run_main())
-        hook_output = emitted["hookSpecificOutput"]
-        assert hook_output["hookEventName"] == "SessionStart"
-        assert "additionalContext" in hook_output
-
-    def test_directive_carries_the_one_line_instruction(self) -> None:
-        emitted = json.loads(_run_main())
-        assert TASK_LIST_MAINTENANCE_INSTRUCTION in emitted["hookSpecificOutput"]["additionalContext"]
-
-    def test_directive_names_the_ten_minute_cadence(self) -> None:
-        emitted = json.loads(_run_main())
-        assert "10-minute" in emitted["hookSpecificOutput"]["additionalContext"]
-
-    def test_directive_names_the_loop_command(self) -> None:
-        emitted = json.loads(_run_main())
-        assert "/loop 10m" in emitted["hookSpecificOutput"]["additionalContext"]
-
-    def test_directive_runs_the_instruction_immediately(self) -> None:
-        emitted = json.loads(_run_main())
-        assert "Run that instruction once immediately when starting the loop, then" in emitted[
-            "hookSpecificOutput"
-        ]["additionalContext"]
-
-    def test_directive_reuses_an_existing_loop(self) -> None:
-        emitted = json.loads(_run_main())
-        assert "Reuse the active task-list maintenance loop when available." in emitted[
-            "hookSpecificOutput"
-        ]["additionalContext"]
-
-    def test_build_session_directive_returns_the_shared_constant(self) -> None:
-        assert starter.build_session_directive() == TASK_LIST_LOOP_DIRECTIVE