feat: short-circuit post_commit_reminder when all reviews passed

Move the post-commit reminder hook from bash into a Python hook that
checks whether all non-catch-all review rules matching the committed
files already have .passed markers. When they do (or no applicable
rules exist), emit "No re-review needed" instead of nagging the agent.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: nhorton

plugins/claude/hooks/post_commit_reminder.sh

@@ -1,13 +1,6 @@
 #!/usr/bin/env bash
-# Post-commit reminder hook
-# Triggers after Bash tool uses that contain "git commit" to remind
-# the agent to run the review skill.
-
+# Post-commit reminder hook — delegates to deepwork Python hook.
 INPUT=$(cat)
-COMMAND=$(echo "$INPUT" | jq -r '.tool_input.command // empty')
-
-if echo "$COMMAND" | grep -q 'git commit'; then
-  cat << 'EOF'
-{"hookSpecificOutput":{"hookEventName":"PostToolUse","additionalContext":"You **MUST** use AskUserQuestion tool to offer to the user to run the `review` skill to review the changes you just committed if you have not run a review recently."}}
-EOF
-fi
+export DEEPWORK_HOOK_PLATFORM="claude"
+echo "${INPUT}" | deepwork hook post_commit_reminder
+exit $?

specs/deepwork/cli_plugins/PLUG-REQ-001-claude-code-plugin.md

@@ -55,7 +55,9 @@ The Claude Code plugin is the primary distribution mechanism for DeepWork on the
 ### PLUG-REQ-001.7: Post-Commit Review Reminder
 
 1. The plugin MUST register a `PostToolUse` hook on the `Bash` tool via `plugins/claude/hooks/hooks.json`.
-2. When the agent runs a `git commit` command, the hook MUST prompt the agent to offer the user a review of the committed changes.
+2. When the agent runs a `git commit` command and at least one review rule that matches the committed files has not been marked as passed, the hook MUST prompt the agent to offer the user a review of the committed changes.
+3. Catch-all review rules (include patterns that are pure `*`/`**` globs) MUST be excluded from this determination.
+4. When every applicable review rule for the committed files is already marked as passed (or no non-catch-all rule matches), the hook MUST return a context notice stating that no re-review is needed instead of prompting.
 
 ### PLUG-REQ-001.8: Skill Directory Conventions
 

src/deepwork/hooks/post_commit_reminder.py

@@ -0,0 +1,82 @@
+"""PostToolUse hook: nudge the agent to run the review skill after a
+git commit -- but only when at least one applicable review has not
+already been marked as passed for the committed files."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+from deepwork.hooks.wrapper import (
+    HookInput,
+    HookOutput,
+    NormalizedEvent,
+    Platform,
+    output_hook_error,
+    run_hook,
+)
+
+REMINDER_CONTEXT = (
+    "You **MUST** use AskUserQuestion tool to offer to the user to run "
+    "the `review` skill to review the changes you just committed if you "
+    "have not run a review recently."
+)
+
+ALL_PASSED_CONTEXT = "No re-review needed - all reviews passed for committed files"
+
+
+def post_commit_reminder_hook(hook_input: HookInput) -> HookOutput:
+    if hook_input.event != NormalizedEvent.AFTER_TOOL:
+        return HookOutput()
+    if hook_input.tool_name != "shell":
+        return HookOutput()
+    command = hook_input.tool_input.get("command", "") or ""
+    if "git commit" not in command:
+        return HookOutput()
+
+    cwd = hook_input.cwd or os.getcwd()
+    project_root = Path(cwd)
+
+    committed = _committed_files(project_root)
+    if committed is None:
+        # Git call failed; fall back to the safe old behavior.
+        return HookOutput(context=REMINDER_CONTEXT)
+
+    try:
+        from deepwork.review.mcp import all_reviews_passed_for_files
+
+        passed = all_reviews_passed_for_files(project_root, committed)
+    except Exception:
+        return HookOutput(context=REMINDER_CONTEXT)
+
+    return HookOutput(context=ALL_PASSED_CONTEXT if passed else REMINDER_CONTEXT)
+
+
+def _committed_files(project_root: Path) -> list[str] | None:
+    """Return files in HEAD's commit, or ``None`` if the git command fails."""
+    try:
+        result = subprocess.run(
+            ["git", "show", "--no-patch", "--name-only", "--format=", "HEAD"],
+            cwd=project_root,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+    except (OSError, subprocess.CalledProcessError):
+        return None
+    return [line for line in result.stdout.splitlines() if line.strip()]
+
+
+def main() -> int:
+    platform = Platform(os.environ.get("DEEPWORK_HOOK_PLATFORM", "claude"))
+    return run_hook(post_commit_reminder_hook, platform)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    try:
+        sys.exit(main())
+    except Exception as e:
+        output_hook_error(e, context="post_commit_reminder hook")
+        sys.exit(0)

src/deepwork/review/mcp.py

@@ -9,7 +9,11 @@
 from deepwork.deepschema.review_bridge import generate_review_rules as gen_schema_rules
 from deepwork.review.discovery import DiscoveryError, load_all_rules
 from deepwork.review.formatter import format_for_claude
-from deepwork.review.instructions import INSTRUCTIONS_DIR, write_instruction_files
+from deepwork.review.instructions import (
+    INSTRUCTIONS_DIR,
+    compute_review_id,
+    write_instruction_files,
+)
 from deepwork.review.matcher import (
     GitDiffError,
     format_source_location,
@@ -216,3 +220,32 @@ def mark_passed(project_root: Path, review_id: str) -> str:
     passed_file.write_bytes(b"")
 
     return f"Review '{review_id}' marked as passed."
+
+
+def all_reviews_passed_for_files(
+    project_root: Path,
+    files: list[str],
+) -> bool:
+    """Return True iff every non-catch-all review rule that matches ``files``
+    has a ``.passed`` marker for its computed review_id.
+
+    Vacuously True when no rules match (or ``files`` is empty).
+
+    Catch-all rules (include patterns that are pure ``*``/``**`` globs) are
+    excluded — matches the scoping used by ``get_configured_reviews`` and
+    ``run_review`` when files are specified explicitly.
+    """
+    rules, _ = load_all_rules(project_root)
+    schema_rules, _ = gen_schema_rules(project_root)
+    rules.extend(schema_rules)
+
+    rules = [r for r in rules if not _rule_is_catch_all(r)]
+
+    tasks = match_files_to_rules(files, rules, project_root)
+
+    instructions_dir = project_root / INSTRUCTIONS_DIR
+    for task in tasks:
+        review_id = compute_review_id(task, project_root)
+        if not (instructions_dir / f"{review_id}.passed").exists():
+            return False
+    return True

tests/unit/plugins/test_claude_plugin.py

@@ -323,25 +323,13 @@ def test_registers_post_tool_use_on_bash(self) -> None:
     def test_hook_script_detects_git_commit(self) -> None:
         # THIS TEST VALIDATES A HARD REQUIREMENT (PLUG-REQ-001.7.2).
         # YOU MUST NOT MODIFY THIS TEST UNLESS THE REQUIREMENT CHANGES
-        """PLUG-REQ-001.7.2: hook script detects git commit and prompts review."""
-        data = json.loads(self.hooks_json_path.read_text())
-        hooks = data["hooks"]["PostToolUse"]
-        bash_hook = next(h for h in hooks if h.get("matcher") == "Bash")
-
-        # Get the hook command path
-        hook_commands = bash_hook.get("hooks", [])
-        assert len(hook_commands) >= 1
-
-        # Read the actual hook script
-        command = hook_commands[0]["command"]
-        # The command uses ${CLAUDE_PLUGIN_ROOT} — resolve relative to plugin dir
-        script_name = command.split("/")[-1]
-        script_path = PLUGIN_DIR / "hooks" / script_name
-        assert script_path.exists(), f"Hook script not found: {script_path}"
-
-        content = script_path.read_text(encoding="utf-8")
-        assert "git commit" in content, "Hook script must detect git commit commands"
-        assert "review" in content.lower(), "Hook script must prompt for review"
+        """PLUG-REQ-001.7.2: Python hook detects git commit and prompts review."""
+        from deepwork.hooks.post_commit_reminder import post_commit_reminder_hook
+
+        hook_py = Path(post_commit_reminder_hook.__code__.co_filename)
+        content = hook_py.read_text(encoding="utf-8")
+        assert "git commit" in content, "Python hook must detect git commit commands"
+        assert "review" in content.lower(), "Python hook must reference review"
 
 
 # ---------------------------------------------------------------------------

tests/unit/review/test_mcp.py

@@ -14,6 +14,7 @@
 from deepwork.review.config import ReviewRule, ReviewTask
 from deepwork.review.mcp import (
     ReviewToolError,
+    all_reviews_passed_for_files,
     get_configured_reviews,
     mark_passed,
     run_review,
@@ -757,3 +758,114 @@ def test_get_configured_reviews_ignores_passed_markers(
         result = get_configured_reviews(tmp_path)
         assert len(result) == 1
         assert result[0]["name"] == "test_rule"
+
+
+@pytest.mark.usefixtures("without_standard_schemas")
+class TestAllReviewsPassedForFiles:
+    """Tests for all_reviews_passed_for_files — validates PLUG-REQ-001.7."""
+
+    @patch("deepwork.review.mcp.gen_schema_rules", return_value=([], []))
+    @patch("deepwork.review.mcp.load_all_rules", return_value=([], []))
+    def test_empty_file_list(self, mock_load: Any, mock_schema: Any, tmp_path: Path) -> None:
+        assert all_reviews_passed_for_files(tmp_path, []) is True
+
+    @patch("deepwork.review.mcp.gen_schema_rules", return_value=([], []))
+    @patch("deepwork.review.mcp.load_all_rules", return_value=([], []))
+    def test_no_rules(self, mock_load: Any, mock_schema: Any, tmp_path: Path) -> None:
+        assert all_reviews_passed_for_files(tmp_path, ["src/app.py"]) is True
+
+    @patch("deepwork.review.mcp.gen_schema_rules", return_value=([], []))
+    @patch("deepwork.review.mcp.load_all_rules")
+    def test_only_catch_all_rule(self, mock_load: Any, mock_schema: Any, tmp_path: Path) -> None:
+        """Catch-all rules are excluded, so only having one means True."""
+        mock_load.return_value = ([_make_catch_all_rule(tmp_path)], [])
+        assert all_reviews_passed_for_files(tmp_path, ["src/app.py"]) is True
+
+    @patch("deepwork.review.mcp.gen_schema_rules", return_value=([], []))
+    @patch("deepwork.review.mcp.load_all_rules")
+    def test_non_matching_rule(self, mock_load: Any, mock_schema: Any, tmp_path: Path) -> None:
+        """A non-catch-all rule that doesn't match the files returns True."""
+        py_rule = _make_rule(tmp_path)  # **/*.py
+        mock_load.return_value = ([py_rule], [])
+        assert all_reviews_passed_for_files(tmp_path, ["src/app.ts"]) is True
+
+    @patch("deepwork.review.mcp.gen_schema_rules", return_value=([], []))
+    @patch("deepwork.review.mcp.load_all_rules")
+    def test_matching_rule_with_passed_marker(
+        self, mock_load: Any, mock_schema: Any, tmp_path: Path
+    ) -> None:
+        from deepwork.review.instructions import INSTRUCTIONS_DIR, compute_review_id
+
+        rule = _make_rule(tmp_path)
+        mock_load.return_value = ([rule], [])
+
+        # Create the file so compute_review_id produces a stable hash
+        (tmp_path / "src").mkdir(parents=True, exist_ok=True)
+        (tmp_path / "src" / "app.py").write_text("print('hello')")
+
+        # First call to get the tasks and compute their IDs
+        from deepwork.review.matcher import match_files_to_rules
+
+        tasks = match_files_to_rules(["src/app.py"], [rule], tmp_path)
+        assert len(tasks) >= 1
+        review_id = compute_review_id(tasks[0], tmp_path)
+
+        # Create the .passed marker
+        instructions_dir = tmp_path / INSTRUCTIONS_DIR
+        instructions_dir.mkdir(parents=True, exist_ok=True)
+        (instructions_dir / f"{review_id}.passed").write_bytes(b"")
+
+        assert all_reviews_passed_for_files(tmp_path, ["src/app.py"]) is True
+
+    @patch("deepwork.review.mcp.gen_schema_rules", return_value=([], []))
+    @patch("deepwork.review.mcp.load_all_rules")
+    def test_matching_rule_without_passed_marker(
+        self, mock_load: Any, mock_schema: Any, tmp_path: Path
+    ) -> None:
+        rule = _make_rule(tmp_path)
+        mock_load.return_value = ([rule], [])
+
+        (tmp_path / "src").mkdir(parents=True, exist_ok=True)
+        (tmp_path / "src" / "app.py").write_text("print('hello')")
+
+        assert all_reviews_passed_for_files(tmp_path, ["src/app.py"]) is False
+
+    @patch("deepwork.review.mcp.gen_schema_rules", return_value=([], []))
+    @patch("deepwork.review.mcp.load_all_rules")
+    def test_mixed_passed_and_not_passed(
+        self, mock_load: Any, mock_schema: Any, tmp_path: Path
+    ) -> None:
+        from deepwork.review.instructions import INSTRUCTIONS_DIR, compute_review_id
+        from deepwork.review.matcher import match_files_to_rules
+
+        rule_py = _make_rule(tmp_path)  # **/*.py
+        rule_ts = ReviewRule(
+            name="ts_rule",
+            description="TS rule.",
+            include_patterns=["**/*.ts"],
+            exclude_patterns=[],
+            strategy="individual",
+            instructions="Review TS.",
+            agent=None,
+            all_changed_filenames=False,
+            unchanged_matching_files=False,
+            precomputed_info_bash_command=None,
+            source_dir=tmp_path,
+            source_file=tmp_path / ".deepreview",
+            source_line=5,
+        )
+        mock_load.return_value = ([rule_py, rule_ts], [])
+
+        (tmp_path / "src").mkdir(parents=True, exist_ok=True)
+        (tmp_path / "src" / "app.py").write_text("py")
+        (tmp_path / "src" / "app.ts").write_text("ts")
+
+        # Mark only the py task as passed
+        py_tasks = match_files_to_rules(["src/app.py"], [rule_py], tmp_path)
+        review_id = compute_review_id(py_tasks[0], tmp_path)
+        instructions_dir = tmp_path / INSTRUCTIONS_DIR
+        instructions_dir.mkdir(parents=True, exist_ok=True)
+        (instructions_dir / f"{review_id}.passed").write_bytes(b"")
+
+        # ts task is not passed → overall False
+        assert all_reviews_passed_for_files(tmp_path, ["src/app.py", "src/app.ts"]) is False