claude-dev-env 8.88.7 → 8.89.0

package/bin/install-constants.mjs

@@ -182,6 +182,9 @@ export const ALL_CODEX_NATIVE_PRE_TOOL_USE_MATCHERS = new Set([
 export const ALL_CODEX_NATIVE_STOP_HOOK_SCRIPT_NAMES = new Set([
     'open_tasks_stop_gate.py',
 ]);
+export const ALL_CODEX_NATIVE_POST_TOOL_USE_HOOK_SCRIPT_NAMES = new Set([
+    'owned_pr_review_loop.py',
+]);
 export const CURSOR_HOOKS_FILE_NAME = 'hooks.json';
 export const CURSOR_HOOKS_SCHEMA_VERSION = 1;
 export const CURSOR_HOOK_TIMEOUT_SECONDS = 10;

package/bin/install.cursor-rules.test.mjs

@@ -135,7 +135,12 @@ test('seeds one editable policy and one native Codex routing hook', () => {
         );
         assert.equal(firstSpawnPromptGroups.length, 1);
         assert.match(firstSpawnPromptGroups[0].hooks[0].command, /skill_loaded_reminder\.py/);
-        assert.deepEqual(Object.keys(firstCodexHooks.hooks), ['PreToolUse', 'UserPromptSubmit', 'Stop']);
+        assert.deepEqual(Object.keys(firstCodexHooks.hooks), ['PreToolUse', 'UserPromptSubmit', 'PostToolUse', 'Stop']);
+        const allCodexPostToolUseCommands = firstCodexHooks.hooks.PostToolUse.flatMap(
+            group => group.hooks.map(hook => hook.command),
+        );
+        assert.equal(allCodexPostToolUseCommands.length, 1, 'Codex gets the owned PR review loop and no other PostToolUse hook');
+        assert.match(allCodexPostToolUseCommands[0], /advisory\/owned_pr_review_loop\.py/);
         const allCodexStopCommands = firstCodexHooks.hooks.Stop.flatMap(group => group.hooks.map(hook => hook.command));
         assert.equal(allCodexStopCommands.length, 1, 'Codex gets the open tasks Stop gate and no other Stop hook');
         assert.match(allCodexStopCommands[0], /open_tasks_stop_gate\.py/);
@@ -310,6 +315,12 @@ test('Codex reinstall removes omitted package hooks and preserves user configura
             eachGroup.hooks.some(eachHook => eachHook.command.includes('open_tasks_stop_gate.py')));
         assert.equal(allPackageStopGroups.length, 1);
         migratedHooks.hooks.Stop = migratedHooks.hooks.Stop.filter(eachGroup => !allPackageStopGroups.includes(eachGroup));
+        const allPackagePostToolUseCommands = migratedHooks.hooks.PostToolUse
+            .flatMap(eachGroup => eachGroup.hooks)
+            .map(eachHook => eachHook.command);
+        assert.equal(allPackagePostToolUseCommands.length, 1);
+        assert.match(allPackagePostToolUseCommands[0], /owned_pr_review_loop\.py/);
+        delete migratedHooks.hooks.PostToolUse;
         assert.deepEqual(migratedHooks, { enabled: false, metadata: 'keep-file', hooks: expectedUserHooks });
         assert.equal(readFileSync(configPath, 'utf8'), disabledConfig);
         const firstInstall = readFileSync(codexHooksPath, 'utf8');

package/bin/install.mjs

@@ -52,6 +52,7 @@ import {
     PYTHON_PROBE_TIMEOUT_MILLISECONDS,
     ALL_CODEX_NATIVE_PRE_TOOL_USE_MATCHERS,
     ALL_CODEX_NATIVE_STOP_HOOK_SCRIPT_NAMES,
+    ALL_CODEX_NATIVE_POST_TOOL_USE_HOOK_SCRIPT_NAMES,
 } from './install-constants.mjs';
 import {
     PSTACK_PLUGIN_SPEC,
@@ -2245,15 +2246,17 @@ function mergeHooksAtPath(
     return groupCount;
 }
 
-function isCodexNativeStopHook(hook) {
-    const scriptName = String(hook?.command ?? '').replace(/\\/g, '/').split('/').pop();
-    return ALL_CODEX_NATIVE_STOP_HOOK_SCRIPT_NAMES.has(scriptName);
+function hookScriptName(hook) {
+    return String(hook?.command ?? '').replace(/\\/g, '/').split('/').pop();
 }
 
-function selectCodexNativeStopGroups(stopGroups) {
-    if (!Array.isArray(stopGroups)) return [];
-    return stopGroups
-        .map(group => ({ ...group, hooks: (group?.hooks ?? []).filter(isCodexNativeStopHook) }))
+function selectCodexNativeGroupsByScriptName(groups, allScriptNames) {
+    if (!Array.isArray(groups)) return [];
+    return groups
+        .map(group => ({
+            ...group,
+            hooks: (group?.hooks ?? []).filter(hook => allScriptNames.has(hookScriptName(hook))),
+        }))
         .filter(group => group.hooks.length > 0);
 }
 
@@ -2267,7 +2270,14 @@ function selectCodexNativeHooksConfig(hooksConfig) {
                 ? preToolUseGroups.filter(group => ALL_CODEX_NATIVE_PRE_TOOL_USE_MATCHERS.has(group?.matcher))
                 : [],
             UserPromptSubmit: Array.isArray(userPromptSubmitGroups) ? userPromptSubmitGroups : [],
-            Stop: selectCodexNativeStopGroups(hooksConfig.hooks?.Stop),
+            PostToolUse: selectCodexNativeGroupsByScriptName(
+                hooksConfig.hooks?.PostToolUse,
+                ALL_CODEX_NATIVE_POST_TOOL_USE_HOOK_SCRIPT_NAMES,
+            ),
+            Stop: selectCodexNativeGroupsByScriptName(
+                hooksConfig.hooks?.Stop,
+                ALL_CODEX_NATIVE_STOP_HOOK_SCRIPT_NAMES,
+            ),
         },
     };
 }

package/hooks/advisory/owned_pr_review_loop.py

@@ -0,0 +1,365 @@
+#!/usr/bin/env python3
+"""PostToolUse context reminder: own the review loop on a new owned pull request.
+
+This hook never blocks. It runs after a shell call or a GitHub MCP
+``create_pull_request`` call. When that call opened a pull request on a
+repository we own, and the repository is not on the preset list of
+repositories that run their own automated review, it adds one instruction
+block to the agent's context::
+
+    === OWNED PR REVIEW LOOP (context reminder, never a block) ===
+    You opened jl-cmd-projects/claude-dev-env#42  https://github.com/...
+    1. Review loop. Load the efficient-review skill ...
+    2. Mark ready. ...
+    3. Babysit. Follow the pstack babysit playbook ...
+    4. Ship. Follow the pstack shipping playbook ...
+
+The pull request URL in the tool response is the proof that a pull request
+opened, so the hook needs no network call and reads the same on Claude Code
+and Codex.
+
+Quiet branches: another tool, a shell command that opens no pull request,
+a harness-reported non-zero exit, a response that says the pull request
+already exists, a response with no pull request URL, an owner outside the
+owned set, and a preset repository each emit nothing.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+import sys
+from pathlib import Path
+
+try:
+    _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.bash_post_call_dispatcher_constants import (
+        EXIT_CODE_ERROR_PREFIX,
+    )
+    from hooks_constants.owned_pr_review_loop_constants import (
+        ALL_DECLARED_URL_KEYS,
+        ALL_GH_API_BODY_OPTIONS,
+        ALL_GH_API_METHOD_OPTIONS,
+        ALL_GH_API_SHORT_OPTIONS,
+        ALL_GH_PR_CREATE_ACTIONS,
+        ALL_MCP_CREATE_PULL_REQUEST_TOOL_SUFFIXES,
+        ALL_OWNED_OWNER_DIGESTS,
+        ALL_PRESET_REPOSITORY_DIGESTS,
+        ALL_SHELL_COMMAND_INPUT_KEYS,
+        ALL_SHELL_TOOL_NAMES,
+        ALREADY_EXISTS_MARKER,
+        GH_API_POST_METHOD,
+        GH_API_PULLS_ENDPOINT_PATTERN,
+        GH_API_SUBCOMMAND,
+        GH_LONG_OPTION_PREFIX,
+        GH_OPTION_VALUE_SEPARATOR,
+        GH_PR_SUBCOMMAND,
+        GH_PROGRAM_NAME,
+        GH_SHORT_OPTION_LENGTH,
+        JSON_OBJECT_OPENER,
+        MCP_OWNER_INPUT_KEY,
+        MCP_REPOSITORY_INPUT_KEY,
+        MCP_TOOL_NAME_PREFIX,
+        NAME_DIGEST_TEXT_ENCODING,
+        PULL_REQUEST_URL_PATTERN,
+        REVIEW_LOOP_CONTEXT_TEMPLATE,
+        SHELL_ARGUMENT_SEPARATOR,
+    )
+    from hooks_constants.post_tool_use_context import (
+        write_post_tool_use_context_to_stdout,
+    )
+    from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
+    from hooks_constants.shell_command_segments import command_tokens, split_into_segments
+    from hooks_constants.shell_command_wrappers import (
+        all_wrapped_command_texts,
+        segment_program_and_arguments,
+    )
+except ImportError as import_error:
+    raise ImportError(
+        "owned_pr_review_loop: cannot import its dependencies; "
+        "ensure the hooks directory is importable."
+    ) from import_error
+
+
+def _is_gh_pr_create(all_arguments: list[str]) -> bool:
+    return (
+        all_arguments[:1] == [GH_PR_SUBCOMMAND]
+        and len(all_arguments) > 1
+        and all_arguments[1] in ALL_GH_PR_CREATE_ACTIONS
+    )
+
+
+def _option_name_and_inline_value(argument: str) -> tuple[str, str | None]:
+    if argument.startswith(GH_LONG_OPTION_PREFIX):
+        option_name, separator, inline_value = argument.partition(GH_OPTION_VALUE_SEPARATOR)
+        return option_name, inline_value if separator else None
+    short_option_name = argument[:GH_SHORT_OPTION_LENGTH]
+    if short_option_name in ALL_GH_API_SHORT_OPTIONS and len(argument) > GH_SHORT_OPTION_LENGTH:
+        return short_option_name, argument[GH_SHORT_OPTION_LENGTH:]
+    return argument, None
+
+
+def _is_gh_api_pulls_post(all_arguments: list[str]) -> bool:
+    if all_arguments[:1] != [GH_API_SUBCOMMAND]:
+        return False
+    if not any(
+        GH_API_PULLS_ENDPOINT_PATTERN.fullmatch(each_argument) for each_argument in all_arguments
+    ):
+        return False
+    explicit_method: str | None = None
+    sends_body = False
+    all_following_arguments = [*all_arguments[1:], ""]
+    for each_argument, each_following_argument in zip(all_arguments, all_following_arguments, strict=True):
+        option_name, inline_value = _option_name_and_inline_value(each_argument)
+        if option_name in ALL_GH_API_BODY_OPTIONS:
+            sends_body = True
+        if option_name in ALL_GH_API_METHOD_OPTIONS:
+            explicit_method = inline_value or each_following_argument
+    if explicit_method:
+        return explicit_method.upper() == GH_API_POST_METHOD
+    return sends_body
+
+
+def _segment_opens_pull_request(all_segment_tokens: list[str]) -> bool:
+    program_name, all_arguments = segment_program_and_arguments(all_segment_tokens)
+    return program_name == GH_PROGRAM_NAME and (
+        _is_gh_pr_create(all_arguments) or _is_gh_api_pulls_post(all_arguments)
+    )
+
+
+def command_creates_pull_request(command: str) -> bool:
+    """Return True when any segment of the shell command opens a pull request.
+
+    Three shapes count::
+
+        gh pr create --fill
+        gh pr new --fill
+        gh api repos/acme/widgets/pulls --input pr.json
+
+    A ``gh api`` call counts only when it targets the pulls collection. An
+    explicit method (``-X POST``, ``-XPOST``, ``--method=POST``) decides
+    alone. With no method, a body (``-f``, ``-F``, ``--field``,
+    ``--raw-field``, ``--input``, or the ``--name=value`` and ``-ftitle=t``
+    forms) means
+    POST, as it does for ``gh``. A ``pwsh -Command "..."``
+    wrapper is unwrapped and its inner text scanned the same way.
+
+    Args:
+        command: The shell command text the agent ran.
+    """
+    return any(
+        _segment_opens_pull_request(each_segment)
+        for each_command_text in all_wrapped_command_texts(command)
+        for each_segment in split_into_segments(command_tokens(each_command_text))
+    )
+
+
+def _is_mcp_create_pull_request(tool_name: str) -> bool:
+    return tool_name.startswith(MCP_TOOL_NAME_PREFIX) and tool_name.endswith(
+        ALL_MCP_CREATE_PULL_REQUEST_TOOL_SUFFIXES
+    )
+
+
+def _shell_command(all_tool_input: dict[str, object]) -> str:
+    for each_key in ALL_SHELL_COMMAND_INPUT_KEYS:
+        command = all_tool_input.get(each_key)
+        if isinstance(command, str):
+            return command
+        if isinstance(command, list) and all(isinstance(each, str) for each in command):
+            return SHELL_ARGUMENT_SEPARATOR.join(command)
+    return ""
+
+
+def _response_text(tool_response: object) -> str:
+    if isinstance(tool_response, str):
+        return tool_response
+    return json.dumps(tool_response)
+
+
+def tool_call_opens_pull_request(tool_name: str, all_tool_input: dict[str, object]) -> bool:
+    """Return True when the tool call is a pull request creation.
+
+    Args:
+        tool_name: The tool name from the hook payload, such as ``Bash``,
+            ``exec_command``, or ``mcp__github__create_pull_request``.
+        all_tool_input: The tool input from the hook payload.
+    """
+    if _is_mcp_create_pull_request(tool_name):
+        return True
+    if tool_name in ALL_SHELL_TOOL_NAMES:
+        return command_creates_pull_request(_shell_command(all_tool_input))
+    return False
+
+
+def _matches_for_input_repository(
+    all_url_matches: list[re.Match[str]], all_tool_input: dict[str, object]
+) -> list[re.Match[str]]:
+    input_owner = str(all_tool_input.get(MCP_OWNER_INPUT_KEY) or "").lower()
+    input_repository = str(all_tool_input.get(MCP_REPOSITORY_INPUT_KEY) or "").lower()
+    if not (input_owner and input_repository):
+        return all_url_matches
+    return [
+        each_match
+        for each_match in all_url_matches
+        if each_match["owner"].lower() == input_owner
+        and each_match["repository"].lower() == input_repository
+    ]
+
+
+def _parsed_json_object_text(text: str) -> object:
+    stripped_text = text.strip()
+    if not stripped_text.startswith(JSON_OBJECT_OPENER):
+        return None
+    try:
+        return json.loads(stripped_text)
+    except json.JSONDecodeError:
+        return None
+
+
+def _all_declared_url_matches(response_value: object) -> list[re.Match[str]]:
+    if isinstance(response_value, str):
+        return _all_declared_url_matches(_parsed_json_object_text(response_value))
+    if isinstance(response_value, list):
+        return [
+            each_match
+            for each_item in response_value
+            for each_match in _all_declared_url_matches(each_item)
+        ]
+    if not isinstance(response_value, dict):
+        return []
+    all_own_matches = [
+        PULL_REQUEST_URL_PATTERN.fullmatch(str(response_value.get(each_key) or ""))
+        for each_key in ALL_DECLARED_URL_KEYS
+    ]
+    return [each_match for each_match in all_own_matches if each_match] + [
+        each_match
+        for each_child in response_value.values()
+        for each_match in _all_declared_url_matches(each_child)
+    ]
+
+
+def _scanned_url_match(
+    all_tool_input: dict[str, object], tool_response: object
+) -> re.Match[str] | None:
+    response_text = _response_text(tool_response)
+    if response_text.startswith(EXIT_CODE_ERROR_PREFIX):
+        return None
+    if ALREADY_EXISTS_MARKER in response_text.lower():
+        return None
+    all_url_matches = _matches_for_input_repository(
+        list(PULL_REQUEST_URL_PATTERN.finditer(response_text)), all_tool_input
+    )
+    return all_url_matches[-1] if all_url_matches else None
+
+
+def opened_pull_request(
+    all_tool_input: dict[str, object], tool_response: object
+) -> dict[str, str] | None:
+    """Return the owner, repository, number, and url of the opened pull request.
+
+    A JSON response declares the new pull request in an ``html_url`` or
+    ``url`` field, as the REST API and the MCP tools do. That field wins over
+    any URL the body cites. With no declared field, the hook scans the text
+    and takes the last URL, since ``gh pr create`` prints it last; a non-zero
+    exit or an "already exists" notice then means no new pull request. When
+    the tool input names an owner and a repository, only a URL for that
+    repository counts.
+
+    Args:
+        all_tool_input: The tool input from the hook payload.
+        tool_response: The tool response from the hook payload.
+
+    Returns:
+        The pull request fields, or None when the response shows no new pull
+        request.
+    """
+    all_declared_matches = _matches_for_input_repository(
+        _all_declared_url_matches(tool_response), all_tool_input
+    )
+    url_match = next(iter(all_declared_matches), None)
+    url_match = url_match or _scanned_url_match(all_tool_input, tool_response)
+    if url_match is None:
+        return None
+    return {**url_match.groupdict(), "url": url_match.group(0)}
+
+
+def name_digest(name: str) -> str:
+    """Return the SHA-256 digest of a name in its normalized form.
+
+    Normalizing keeps only ASCII letters and digits in lower case, so
+    ``"Acme-Widgets/tools"`` and ``"acmewidgetstools"`` share one digest.
+
+    Args:
+        name: An owner name or an ``owner/repository`` full name.
+    """
+    normalized_name = "".join(
+        each_character
+        for each_character in name.lower()
+        if each_character.isascii() and each_character.isalnum()
+    )
+    return hashlib.sha256(normalized_name.encode(NAME_DIGEST_TEXT_ENCODING)).hexdigest()
+
+
+def needs_review_loop(
+    owner: str,
+    repository: str,
+    all_owned_owner_digests: frozenset[str],
+    all_preset_repository_digests: frozenset[str],
+) -> bool:
+    """Return True for an owned repository outside the preset review list.
+
+    Args:
+        owner: The GitHub owner of the repository.
+        repository: The repository name.
+        all_owned_owner_digests: Digests of the owners we own.
+        all_preset_repository_digests: Digests of the ``owner/repository``
+            names that run their own automated review.
+    """
+    return (
+        name_digest(owner) in all_owned_owner_digests
+        and name_digest(f"{owner}/{repository}") not in all_preset_repository_digests
+    )
+
+
+def build_review_loop_context(all_pull_request_fields: dict[str, str]) -> str:
+    """Build the review-loop instruction block for one opened pull request.
+
+    Args:
+        all_pull_request_fields: The owner, repository, number, and url fields.
+    """
+    return REVIEW_LOOP_CONTEXT_TEMPLATE.format(**all_pull_request_fields)
+
+
+def main() -> None:
+    """Add the review-loop instructions after a pull request opens on an owned repository.
+
+    Reads the PostToolUse payload from stdin. Every quiet branch returns with
+    no output, so this hook can never alter or block a tool call.
+    """
+    hook_payload = read_hook_input_dictionary_from_stdin()
+    if hook_payload is None:
+        return
+    tool_name = str(hook_payload.get("tool_name") or "")
+    tool_input = hook_payload.get("tool_input")
+    if not isinstance(tool_input, dict):
+        return
+    if not tool_call_opens_pull_request(tool_name, tool_input):
+        return
+    pull_request = opened_pull_request(tool_input, hook_payload.get("tool_response"))
+    if pull_request is None:
+        return
+    if not needs_review_loop(
+        pull_request["owner"],
+        pull_request["repository"],
+        ALL_OWNED_OWNER_DIGESTS,
+        ALL_PRESET_REPOSITORY_DIGESTS,
+    ):
+        return
+    write_post_tool_use_context_to_stdout(build_review_loop_context(pull_request))
+
+
+if __name__ == "__main__":
+    main()

package/hooks/advisory/test_owned_pr_review_loop.py

@@ -0,0 +1,369 @@
+"""Behavior tests for the owned pull request review-loop context hook.
+
+The hook is a PostToolUse observer. It never blocks. These tests pin which
+tool calls wake it, which repositories get the review-loop block, and that
+every other path stays quiet. Each end-to-end test runs the script as a
+subprocess with a Claude Code or Codex payload on stdin.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+try:
+    advisory_directory = str(Path(__file__).resolve().parent)
+    if advisory_directory not in sys.path:
+        sys.path.insert(0, advisory_directory)
+    import owned_pr_review_loop
+except ImportError as import_error:
+    raise ImportError(
+        "test_owned_pr_review_loop: cannot import its sibling modules; "
+        "ensure the advisory directory is importable."
+    ) from import_error
+
+
+HOOK_SCRIPT_PATH = Path(__file__).resolve().parent / "owned_pr_review_loop.py"
+HOOKS_JSON_PATH = Path(__file__).resolve().parent.parent / "hooks.json"
+OWNED_PR_URL = "https://github.com/jl-cmd-projects/claude-dev-env/pull/42"
+FOREIGN_PR_URL = "https://github.com/acme/widgets/pull/3"
+
+
+def _run_hook(payload: dict[str, object]) -> str:
+    completed = subprocess.run(
+        [sys.executable, str(HOOK_SCRIPT_PATH)],
+        input=json.dumps(payload),
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    assert completed.returncode == 0, completed.stderr
+    return completed.stdout
+
+
+def _shell_payload(
+    command: str, stdout: str, tool_name: str = "Bash", input_key: str = "command"
+) -> dict[str, object]:
+    return {
+        "hook_event_name": "PostToolUse",
+        "tool_name": tool_name,
+        "tool_input": {input_key: command},
+        "tool_response": {"stdout": stdout, "stderr": ""},
+    }
+
+
+def _mcp_payload(tool_name: str, owner: str, repository: str, url: str) -> dict[str, object]:
+    return {
+        "hook_event_name": "PostToolUse",
+        "tool_name": tool_name,
+        "tool_input": {"owner": owner, "repo": repository, "title": "Add a hook"},
+        "tool_response": [{"type": "text", "text": json.dumps({"id": "1", "url": url})}],
+    }
+
+
+def _context_of(stdout: str) -> str:
+    return json.loads(stdout)["hookSpecificOutput"]["additionalContext"]
+
+
+@pytest.mark.parametrize(
+    "command",
+    [
+        "gh pr create --title t --body b",
+        "gh pr new --fill",
+        "git push -u origin feature && gh pr create --fill",
+        'pwsh -Command "gh pr create --fill"',
+        "gh api repos/acme/widgets/pulls --input pr.json",
+        "gh api /repos/acme/widgets/pulls -f title=t -f head=x -f base=main",
+        "gh api -X POST repos/acme/widgets/pulls",
+        "gh api repos/acme/widgets/pulls --input=pr.json",
+        "gh api repos/acme/widgets/pulls --raw-field=title=t",
+        "gh api --method=POST repos/acme/widgets/pulls",
+        "gh api -XPOST repos/acme/widgets/pulls",
+        "gh api repos/acme/widgets/pulls -Ftitle=t -fhead=x",
+    ],
+)
+def test_should_detect_gh_pr_create(command: str) -> None:
+    assert owned_pr_review_loop.command_creates_pull_request(command)
+
+
+@pytest.mark.parametrize(
+    "command",
+    [
+        "gh pr view 42",
+        "git push -u origin feature",
+        "gh pr",
+        "echo gh pr create",
+        "gh api repos/acme/widgets/pulls",
+        "gh api repos/acme/widgets/pulls/42 -X PATCH -f state=closed",
+        "gh api repos/acme/widgets/issues --input issue.json",
+        "gh api --method GET repos/acme/widgets/pulls -f state=open",
+        "gh api -X GET repos/acme/widgets/pulls -f state=open",
+    ],
+)
+def test_should_not_detect_other_commands(command: str) -> None:
+    assert not owned_pr_review_loop.command_creates_pull_request(command)
+
+
+@pytest.mark.parametrize(
+    "tool_name",
+    [
+        "mcp__github__create_pull_request",
+        "mcp__codex_apps__github_create_pull_request",
+    ],
+)
+def test_should_treat_mcp_create_tools_as_pull_request_creation(tool_name: str) -> None:
+    assert owned_pr_review_loop.tool_call_opens_pull_request(tool_name, {})
+
+
+def test_should_read_the_codex_cmd_key_for_shell_tools() -> None:
+    assert owned_pr_review_loop.tool_call_opens_pull_request(
+        "exec_command", {"cmd": ["gh", "pr", "create", "--fill"]}
+    )
+
+
+def test_should_ignore_other_mcp_tools() -> None:
+    assert not owned_pr_review_loop.tool_call_opens_pull_request(
+        "mcp__github__merge_pull_request", {}
+    )
+
+
+def test_should_take_the_last_url_from_gh_output() -> None:
+    pull_request = owned_pr_review_loop.opened_pull_request(
+        {"command": "gh pr create"},
+        {"stdout": f"Warning: see {FOREIGN_PR_URL}\n{OWNED_PR_URL}\n"},
+    )
+    assert pull_request == {
+        "owner": "jl-cmd-projects",
+        "repository": "claude-dev-env",
+        "number": "42",
+        "url": OWNED_PR_URL,
+    }
+
+
+def test_should_take_the_url_for_the_mcp_input_repository() -> None:
+    pull_request = owned_pr_review_loop.opened_pull_request(
+        {"owner": "JL-CMD-PROJECTS", "repo": "claude-dev-env"},
+        f"Opened {OWNED_PR_URL}; see also {FOREIGN_PR_URL}",
+    )
+    assert pull_request is not None
+    assert pull_request["number"] == "42"
+
+
+def test_should_take_the_declared_url_over_urls_cited_in_the_body() -> None:
+    rest_response = json.dumps(
+        {
+            "html_url": OWNED_PR_URL,
+            "body": "Follows https://github.com/jl-cmd-projects/claude-dev-env/pull/7",
+        }
+    )
+    pull_request = owned_pr_review_loop.opened_pull_request(
+        {"command": "gh api repos/jl-cmd-projects/claude-dev-env/pulls --input pr.json"},
+        {"stdout": rest_response},
+    )
+    assert pull_request is not None
+    assert pull_request["number"] == "42"
+
+
+def test_should_take_the_declared_url_from_an_mcp_text_item() -> None:
+    mcp_response = [
+        {
+            "type": "text",
+            "text": json.dumps(
+                {
+                    "url": OWNED_PR_URL,
+                    "body": "Replaces https://github.com/jl-cmd-projects/claude-dev-env/pull/7",
+                }
+            ),
+        }
+    ]
+    pull_request = owned_pr_review_loop.opened_pull_request(
+        {"owner": "jl-cmd-projects", "repo": "claude-dev-env"}, mcp_response
+    )
+    assert pull_request is not None
+    assert pull_request["number"] == "42"
+
+
+def test_should_keep_a_declared_pull_request_whose_body_says_already_exists() -> None:
+    rest_response = json.dumps({"html_url": OWNED_PR_URL, "body": "The helper already exists."})
+    pull_request = owned_pr_review_loop.opened_pull_request(
+        {"command": "gh api repos/jl-cmd-projects/claude-dev-env/pulls --input pr.json"},
+        {"stdout": rest_response},
+    )
+    assert pull_request is not None
+    assert pull_request["url"] == OWNED_PR_URL
+
+
+def test_should_find_no_pull_request_after_a_failed_command() -> None:
+    assert (
+        owned_pr_review_loop.opened_pull_request(
+            {"command": "gh pr create"}, f"Error: Exit code 1\n{OWNED_PR_URL}"
+        )
+        is None
+    )
+
+
+def test_should_find_no_pull_request_when_one_already_exists() -> None:
+    assert (
+        owned_pr_review_loop.opened_pull_request(
+            {"command": "gh pr create"},
+            {"stdout": f'a pull request for branch "x" already exists:\n{OWNED_PR_URL}'},
+        )
+        is None
+    )
+
+
+def test_should_digest_names_in_normalized_form() -> None:
+    assert owned_pr_review_loop.name_digest("Acme-Widgets/Tools") == (
+        owned_pr_review_loop.name_digest("acmewidgetstools")
+    )
+    assert owned_pr_review_loop.name_digest("acme") != (
+        owned_pr_review_loop.name_digest("acmewidgets")
+    )
+
+
+@pytest.mark.parametrize(
+    ("owner", "repository", "expected"),
+    [
+        ("Acme-Widgets", "tools", True),
+        ("acme-widgets", "site", True),
+        ("Acme-Widgets", "reviewed", False),
+        ("Other-Org", "tools", False),
+    ],
+)
+def test_should_require_an_owned_repository_outside_the_preset_list(
+    owner: str, repository: str, expected: bool
+) -> None:
+    all_owned_owner_digests = frozenset({owned_pr_review_loop.name_digest("acme-widgets")})
+    all_preset_repository_digests = frozenset(
+        {owned_pr_review_loop.name_digest("acme-widgets/reviewed")}
+    )
+    assert (
+        owned_pr_review_loop.needs_review_loop(
+            owner, repository, all_owned_owner_digests, all_preset_repository_digests
+        )
+        is expected
+    )
+
+
+@pytest.mark.parametrize(
+    ("owner", "repository", "expected"),
+    [
+        ("jl-cmd-projects", "claude-dev-env", True),
+        ("jl-cmd", "claude-dev-env", True),
+        ("acme", "widgets", False),
+    ],
+)
+def test_should_apply_the_shipped_owner_list(owner: str, repository: str, expected: bool) -> None:
+    assert (
+        owned_pr_review_loop.needs_review_loop(
+            owner,
+            repository,
+            owned_pr_review_loop.ALL_OWNED_OWNER_DIGESTS,
+            owned_pr_review_loop.ALL_PRESET_REPOSITORY_DIGESTS,
+        )
+        is expected
+    )
+
+
+def test_should_name_every_step_and_skill_in_the_context() -> None:
+    context = owned_pr_review_loop.build_review_loop_context(
+        {
+            "owner": "jl-cmd-projects",
+            "repository": "claude-dev-env",
+            "number": "42",
+            "url": OWNED_PR_URL,
+        }
+    )
+    assert "jl-cmd-projects/claude-dev-env#42" in context
+    assert "efficient-review" in context
+    assert "gh pr ready 42 --repo jl-cmd-projects/claude-dev-env" in context
+    assert "poteto-mode/playbooks/babysit.md" in context
+    assert "poteto-mode/playbooks/shipping.md" in context
+    assert "merged" in context
+
+
+def test_main_should_emit_the_loop_after_gh_pr_create_on_an_owned_repository() -> None:
+    stdout = _run_hook(_shell_payload("gh pr create --fill", f"{OWNED_PR_URL}\n"))
+    payload = json.loads(stdout)
+    assert payload["hookSpecificOutput"]["hookEventName"] == "PostToolUse"
+    assert "efficient-review" in _context_of(stdout)
+
+
+def test_main_should_emit_the_loop_after_a_gh_api_pulls_post() -> None:
+    rest_response = json.dumps(
+        {
+            "url": "https://api.github.com/repos/jl-cmd-projects/claude-dev-env/pulls/42",
+            "html_url": OWNED_PR_URL,
+            "_links": {"html": {"href": OWNED_PR_URL}},
+        }
+    )
+    stdout = _run_hook(
+        _shell_payload("gh api repos/jl-cmd-projects/claude-dev-env/pulls --input pr.json", rest_response)
+    )
+    assert "jl-cmd-projects/claude-dev-env#42" in _context_of(stdout)
+
+
+def test_main_should_emit_the_loop_for_a_codex_shell_call() -> None:
+    stdout = _run_hook(
+        _shell_payload(
+            "gh pr create --fill", f"{OWNED_PR_URL}\n", tool_name="exec_command", input_key="cmd"
+        )
+    )
+    assert OWNED_PR_URL in _context_of(stdout)
+
+
+@pytest.mark.parametrize(
+    "tool_name",
+    ["mcp__github__create_pull_request", "mcp__codex_apps__github_create_pull_request"],
+)
+def test_main_should_emit_the_loop_after_an_mcp_create(tool_name: str) -> None:
+    stdout = _run_hook(
+        _mcp_payload(
+            tool_name,
+            "jl-cmd-projects",
+            "DeepStack",
+            "https://github.com/jl-cmd-projects/DeepStack/pull/9",
+        )
+    )
+    assert "jl-cmd-projects/DeepStack#9" in _context_of(stdout)
+
+
+def test_main_should_stay_quiet_for_a_repository_we_do_not_own() -> None:
+    assert _run_hook(_shell_payload("gh pr create --fill", f"{FOREIGN_PR_URL}\n")) == ""
+
+
+def test_main_should_stay_quiet_for_a_command_that_opens_no_pull_request() -> None:
+    assert _run_hook(_shell_payload("gh pr view 42", f"{OWNED_PR_URL}\n")) == ""
+
+
+def test_main_should_stay_quiet_for_a_failed_create() -> None:
+    payload = _shell_payload("gh pr create --fill", "")
+    payload["tool_response"] = "Error: Exit code 1\npull request create failed"
+    assert _run_hook(payload) == ""
+
+
+def test_hooks_json_should_route_shell_and_mcp_create_calls_to_the_hook() -> None:
+    hooks_config = json.loads(HOOKS_JSON_PATH.read_text(encoding="utf-8"))
+    all_matchers = [
+        each_group["matcher"]
+        for each_group in hooks_config["hooks"]["PostToolUse"]
+        if any(
+            "advisory/owned_pr_review_loop.py" in each_hook.get("command", "")
+            for each_hook in each_group["hooks"]
+        )
+    ]
+    assert len(all_matchers) == 1
+    for each_tool_name in (
+        "Bash",
+        "PowerShell",
+        "exec_command",
+        "shell_command",
+        "mcp__github__create_pull_request",
+        "mcp__codex_apps__github_create_pull_request",
+    ):
+        assert re.fullmatch(all_matchers[0], each_tool_name), each_tool_name

package/hooks/features/bash-dispatchers.md

@@ -11,6 +11,7 @@ This family rewrites a Git Bash command when path conversion would change a revi
 - `blocking/cloud_graphql_gate.py` denies the `gh` commands that call GraphQL (`gh api graphql` with any flags before the endpoint, `gh pr`, `gh issue`, `gh project` and `gh discussion` except `gh pr diff` and `gh pr list --web`, `gh status`, `gh org list`, `gh release list`, `gh release view` with a tag, `gh workflow run` without `--ref`, and a few `repo`, `label`, `search`, `ruleset` and `gist` commands, read past `if`, `!` and command substitutions) and an HTTP client or `python -c` style call to `api.github.com/graphql`, with or without a port, inside a cloud session, where the proxy answers GraphQL with HTTP 403, and names the REST routes to run instead.
 - `blocking/bash_post_call_dispatcher.py` runs hosted observers and joins their context output without blocking the call.
 - `advisory/pr_done_reminder.py` adds a pull request checklist after a successful push or pull request creation.
+- `advisory/owned_pr_review_loop.py` adds review-loop instructions after the agent opens a pull request on an owned repository outside the preset list of repositories that run their own automated review: run efficient-review until clean, mark the pull request ready, babysit it, and ship it to merge.
 
 ## When it fires
 
@@ -21,6 +22,7 @@ This family rewrites a Git Bash command when path conversion would change a revi
 - `blocking/cloud_graphql_gate.py` runs inside that dispatcher on `PreToolUse`, matcher `Bash`, timeout `60` seconds, for the Bash and PowerShell tools, when `CLAUDE_CODE_REMOTE` is `true`.
 - `blocking/bash_post_call_dispatcher.py` runs on `PostToolUse`, matcher `Bash|PowerShell`, timeout `60` seconds in `hooks.json`.
 - `advisory/pr_done_reminder.py` runs inside that dispatcher on `PostToolUse`, matcher `Bash|PowerShell`, timeout `60` seconds. `ALL_BASH_POST_TOOL_USE_HOSTED_HOOK_ENTRIES` selects `Bash` and `PowerShell`.
+- `advisory/owned_pr_review_loop.py` runs on `PostToolUse`, matcher `Bash|PowerShell|exec_command|shell_command|mcp__.*__(create_pull_request|github_create_pull_request)`, timeout `10` seconds in `hooks.json`. It wakes on `gh pr create`, `gh pr new`, a POST to `gh api repos/<owner>/<repo>/pulls`, and an MCP pull request creation. The installer also registers it on Codex `PostToolUse` through `ALL_CODEX_NATIVE_POST_TOOL_USE_HOOK_SCRIPT_NAMES`.
 
 ## Proving it
 
@@ -34,6 +36,7 @@ Preconditions:
 - **Cloud GraphQL gate.** Input is a `gh api graphql` command with `CLAUDE_CODE_REMOTE=true`. Run `python -m pytest packages/claude-dev-env/hooks/blocking/test_cloud_graphql_gate.py -q`. The adjacent test observes a denial that names the REST routes, and silence outside a cloud session.
 - **Post-call dispatch.** Input is a Bash call that yields hosted context. Run `python -m pytest packages/claude-dev-env/hooks/blocking/test_bash_post_call_dispatcher.py -q`. The adjacent test observes a joined context payload and exit code zero.
 - **Pull request reminder.** Input is a completed push or pull request creation. Run `python -m pytest packages/claude-dev-env/hooks/advisory/test_pr_done_reminder.py -q`. The adjacent test checks the reminder trigger and checklist verdict.
+- **Owned pull request review loop.** Input is a pull request creation result on an owned repository. Run `python -m pytest packages/claude-dev-env/hooks/advisory/test_owned_pr_review_loop.py -q`. The adjacent test observes the review-loop block for owned repositories and silence for the preset and foreign repositories.
 
 ## Gotchas
 

package/hooks/hooks.json

@@ -456,6 +456,16 @@
           }
         ]
       },
+      {
+        "matcher": "Bash|PowerShell|exec_command|shell_command|mcp__.*__(create_pull_request|github_create_pull_request)",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/advisory/owned_pr_review_loop.py",
+            "timeout": 10
+          }
+        ]
+      },
       {
         "matcher": "Bash",
         "hooks": [

package/hooks/hooks_constants/owned_pr_review_loop_constants.py

@@ -0,0 +1,120 @@
+"""Constants for the owned pull request review-loop context hook.
+
+The hook is a PostToolUse observer. It never blocks. After the agent opens a
+pull request on a repository we own, outside the preset list of repositories
+that run their own automated review, it tells the agent to own an efficient
+review loop and drive the pull request through to merge.
+
+Private owner and repository names stay out of this public tree. Each set holds the
+SHA-256 digest of a name normalized to lower-case ASCII letters and digits,
+the same form ``scripts/private_terms.py`` uses::
+
+    "Acme-Widgets"          -> "acmewidgets"
+    "Acme-Widgets/tools"    -> "acmewidgetstools"
+
+To add an owner or a preset repository, append the digest of its normalized
+form.
+"""
+
+from __future__ import annotations
+
+import re
+
+__all__ = [
+    "NAME_DIGEST_TEXT_ENCODING",
+    "ALL_OWNED_OWNER_DIGESTS",
+    "ALL_PRESET_REPOSITORY_DIGESTS",
+    "ALL_SHELL_TOOL_NAMES",
+    "ALL_SHELL_COMMAND_INPUT_KEYS",
+    "SHELL_ARGUMENT_SEPARATOR",
+    "ALL_GH_PR_CREATE_ACTIONS",
+    "GH_PROGRAM_NAME",
+    "GH_PR_SUBCOMMAND",
+    "GH_API_SUBCOMMAND",
+    "GH_API_PULLS_ENDPOINT_PATTERN",
+    "ALL_GH_API_BODY_OPTIONS",
+    "ALL_GH_API_METHOD_OPTIONS",
+    "GH_API_POST_METHOD",
+    "GH_LONG_OPTION_PREFIX",
+    "GH_SHORT_OPTION_LENGTH",
+    "ALL_GH_API_SHORT_OPTIONS",
+    "GH_OPTION_VALUE_SEPARATOR",
+    "MCP_TOOL_NAME_PREFIX",
+    "ALL_MCP_CREATE_PULL_REQUEST_TOOL_SUFFIXES",
+    "MCP_OWNER_INPUT_KEY",
+    "MCP_REPOSITORY_INPUT_KEY",
+    "PULL_REQUEST_URL_PATTERN",
+    "ALREADY_EXISTS_MARKER",
+    "ALL_DECLARED_URL_KEYS",
+    "JSON_OBJECT_OPENER",
+    "REVIEW_LOOP_CONTEXT_TEMPLATE",
+]
+
+NAME_DIGEST_TEXT_ENCODING: str = "utf-8"
+ALL_OWNED_OWNER_DIGESTS: frozenset[str] = frozenset(
+    {
+        "2e8b9d88060d471690c122e6843f3bec8c95116d643af2f5501e0881b10e83c4",
+        "3a92fc8d256dc1f50dc8794573f80de695516f0f0e5c235118bd0c18be3d4434",
+        "d526db5593d5986500e4770cb6018f2d33c459ed93657487958a6086e52e6147",
+        "95d4d8808440e130d0ee753e0b7530eba4534dd41a7320ad8b710a44d40441f4",
+    }
+)
+ALL_PRESET_REPOSITORY_DIGESTS: frozenset[str] = frozenset(
+    {"d362bee4d80f5474921b917c127f2b0680c0a5261cb352e59de35cc87b00989f"}
+)
+
+ALL_SHELL_TOOL_NAMES: frozenset[str] = frozenset(
+    {"Bash", "PowerShell", "exec_command", "shell_command"}
+)
+ALL_SHELL_COMMAND_INPUT_KEYS: tuple[str, ...] = ("command", "cmd")
+SHELL_ARGUMENT_SEPARATOR: str = " "
+GH_PROGRAM_NAME: str = "gh"
+GH_PR_SUBCOMMAND: str = "pr"
+ALL_GH_PR_CREATE_ACTIONS: frozenset[str] = frozenset({"create", "new"})
+GH_API_SUBCOMMAND: str = "api"
+GH_API_PULLS_ENDPOINT_PATTERN: re.Pattern[str] = re.compile(r"/?repos/[^/\s]+/[^/\s]+/pulls")
+ALL_GH_API_BODY_OPTIONS: frozenset[str] = frozenset(
+    {"-f", "-F", "--field", "--raw-field", "--input"}
+)
+ALL_GH_API_METHOD_OPTIONS: frozenset[str] = frozenset({"-X", "--method"})
+GH_API_POST_METHOD: str = "POST"
+GH_LONG_OPTION_PREFIX: str = "--"
+GH_SHORT_OPTION_LENGTH: int = 2
+ALL_GH_API_SHORT_OPTIONS: frozenset[str] = frozenset({"-f", "-F", "-X"})
+GH_OPTION_VALUE_SEPARATOR: str = "="
+
+MCP_TOOL_NAME_PREFIX: str = "mcp__"
+ALL_MCP_CREATE_PULL_REQUEST_TOOL_SUFFIXES: tuple[str, ...] = (
+    "__create_pull_request",
+    "__github_create_pull_request",
+)
+MCP_OWNER_INPUT_KEY: str = "owner"
+MCP_REPOSITORY_INPUT_KEY: str = "repo"
+
+PULL_REQUEST_URL_PATTERN: re.Pattern[str] = re.compile(
+    r"https://github\.com/(?P<owner>[A-Za-z0-9][A-Za-z0-9-]*)/"
+    r"(?P<repository>[A-Za-z0-9._-]+)/pull/(?P<number>\d+)"
+)
+ALREADY_EXISTS_MARKER: str = "already exists"
+ALL_DECLARED_URL_KEYS: tuple[str, ...] = ("html_url", "url")
+JSON_OBJECT_OPENER: str = "{"
+
+REVIEW_LOOP_CONTEXT_TEMPLATE: str = (
+    "=== OWNED PR REVIEW LOOP (context reminder, never a block) ===\n"
+    "You opened {owner}/{repository}#{number}  {url}\n"
+    "This repository has no automated review, so you own the review and the merge.\n"
+    "1. Review loop. Load the efficient-review skill (/efficient-review). Review the\n"
+    "   branch, check each finding against the code, fix every one that holds, push,\n"
+    "   and review again. Repeat until a pass reports no findings.\n"
+    "2. Mark ready. Once the loop is clean, CI is green, and no review thread is open,\n"
+    "   mark the PR ready for review (gh pr ready {number} --repo {owner}/{repository},\n"
+    "   or update_pull_request with draft false).\n"
+    "3. Babysit. Follow the pstack babysit playbook (poteto-mode/playbooks/babysit.md,\n"
+    "   or the standalone babysit skill outside poteto-mode). Fix failing CI, resolve\n"
+    "   merge conflicts, and answer review threads until the PR is green and mergeable.\n"
+    "   Any new code goes back through step 1 before the next push.\n"
+    "4. Ship. Follow the pstack shipping playbook (poteto-mode/playbooks/shipping.md)\n"
+    "   to land the PR, or the pr-lifecycle skill outside poteto-mode. Read the PR\n"
+    "   back and confirm it reads merged.\n"
+    "Run each step yourself. The task ends at a merged PR or a named blocker."
+)

package/package.json

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