claude-dev-env 8.54.7 → 8.54.9

package/_shared/pr-loop/scripts/fix_pr_test_proof.py

@@ -5,7 +5,7 @@
     title "docs: ..."                               -> pass, nothing to prove
     title "fix: ..." changing only docs or .github  -> pass, nothing to prove
     title "fix: ..." with no changed Python test    -> fail
-    title "fix: ..." with no changed Python or Node test -> fail
+    title "fix: ..." with no changed Python, Node, or plugin test -> fail
     changed test passes on head, fails on base      -> pass
     changed test passes on both                     -> fail
     any changed test fails on head                  -> fail
@@ -14,8 +14,10 @@ Python tests reuse the regression gate's detached worktree: the changed test
 files are copied onto the base checkout, which runs them with import isolation.
 Node tests (``*.test.mjs``, ``*.test.js``, ``*.test.cjs``) run through
 ``node --test`` on the head, then on a detached base checkout that holds a copy
-of the changed test files. The fix is proven when at least one language's
-changed tests fail on the base.
+of the changed test files. Plugin tests (``*.test.ts``, ``*.test.tsx`` under a
+directory that holds ``.claude-plugin/``) run through ``claude plugin test`` in
+each plugin root on the head, then on the same kind of detached base checkout.
+The fix is proven when at least one language's changed tests fail on the base.
 """
 
 import argparse
@@ -23,7 +25,9 @@ import shutil
 import subprocess
 import sys
 import tempfile
+from collections.abc import Callable
 from enum import Enum
+from functools import partial
 from pathlib import Path
 
 from code_rules_gate_parts import staged_test_regression, staged_test_running
@@ -32,6 +36,8 @@ from code_rules_gate_parts.wrapper_plumb_check import is_test_path
 from pr_loop_shared_constants.fix_pr_test_proof_constants import (
     ALL_NODE_TEST_COMMAND,
     ALL_NODE_TEST_SUFFIXES,
+    ALL_PLUGIN_TEST_COMMAND,
+    ALL_PLUGIN_TEST_SUFFIXES,
     ALL_PRODUCTION_CODE_SUFFIXES,
     CI_CONFIG_DIRECTORY_NAME,
     FAILED_EXIT_CODE,
@@ -44,6 +50,7 @@ from pr_loop_shared_constants.fix_pr_test_proof_constants import (
     NODE_BASE_WORKTREE_TEMP_DIRECTORY_PREFIX,
     NOT_A_FIX_MESSAGE,
     PASSED_EXIT_CODE,
+    PLUGIN_MANIFEST_DIRECTORY_NAME,
     PROVEN_MESSAGE,
     WORKTREE_FAILED_MESSAGE,
 )
@@ -102,6 +109,25 @@ def _changed_node_tests(all_changed_paths: list[Path]) -> list[Path]:
     ]
 
 
+def _plugin_root(test_path: Path, repository_root: Path) -> Path | None:
+    for each_directory in test_path.parents:
+        if (each_directory / PLUGIN_MANIFEST_DIRECTORY_NAME).is_dir():
+            return each_directory
+        if each_directory == repository_root:
+            return None
+    return None
+
+
+def _changed_plugin_tests(all_changed_paths: list[Path], repository_root: Path) -> list[Path]:
+    return [
+        each_path
+        for each_path in all_changed_paths
+        if each_path.name.endswith(ALL_PLUGIN_TEST_SUFFIXES)
+        and each_path.is_file()
+        and _plugin_root(each_path, repository_root) is not None
+    ]
+
+
 def _python_proof_verdict(
     all_changed_tests: list[Path], repository_root: Path, base_revision: str
 ) -> ProofVerdict:
@@ -130,7 +156,7 @@ def _python_proof_verdict(
     return ProofVerdict.PROVEN
 
 
-def _node_tests_pass(working_directory: Path, all_relative_tests: list[Path]) -> bool:
+def _node_tests_pass(all_relative_tests: list[Path], working_directory: Path) -> bool:
     node_run = subprocess.run(
         [*ALL_NODE_TEST_COMMAND, *(each_path.as_posix() for each_path in all_relative_tests)],
         cwd=working_directory,
@@ -141,6 +167,20 @@ def _node_tests_pass(working_directory: Path, all_relative_tests: list[Path]) ->
     return node_run.returncode == 0
 
 
+def _plugin_tests_pass(all_relative_plugin_roots: list[Path], working_directory: Path) -> bool:
+    return all(
+        subprocess.run(
+            ALL_PLUGIN_TEST_COMMAND,
+            cwd=working_directory / each_relative_root,
+            capture_output=True,
+            text=True,
+            check=False,
+        ).returncode
+        == 0
+        for each_relative_root in all_relative_plugin_roots
+    )
+
+
 def _copy_tests_onto(
     base_worktree: Path, repository_root: Path, all_relative_tests: list[Path]
 ) -> None:
@@ -150,11 +190,14 @@ def _copy_tests_onto(
         shutil.copy2(repository_root / each_relative_test, base_test_path)
 
 
-def _node_proof_verdict(
-    all_changed_tests: list[Path], repository_root: Path, base_revision: str
+def _head_and_base_proof_verdict(
+    all_changed_tests: list[Path],
+    repository_root: Path,
+    base_revision: str,
+    tests_pass: Callable[[Path], bool],
 ) -> ProofVerdict:
     all_relative_tests = [each_path.relative_to(repository_root) for each_path in all_changed_tests]
-    if not _node_tests_pass(repository_root, all_relative_tests):
+    if not tests_pass(repository_root):
         sys.stderr.write(HEAD_FAILURE_MESSAGE.format(group_root=repository_root) + "\n")
         return ProofVerdict.HEAD_FAILED
     with tempfile.TemporaryDirectory(
@@ -168,7 +211,7 @@ def _node_proof_verdict(
             return ProofVerdict.BASE_UNAVAILABLE
         try:
             _copy_tests_onto(base_worktree, repository_root, all_relative_tests)
-            passes_on_base = _node_tests_pass(base_worktree, all_relative_tests)
+            passes_on_base = tests_pass(base_worktree)
         finally:
             staged_test_regression._remove_baseline_worktree(repository_root, base_worktree)
     if passes_on_base:
@@ -177,6 +220,36 @@ def _node_proof_verdict(
     return ProofVerdict.PROVEN
 
 
+def _node_proof_verdict(
+    all_changed_tests: list[Path], repository_root: Path, base_revision: str
+) -> ProofVerdict:
+    all_relative_tests = [each_path.relative_to(repository_root) for each_path in all_changed_tests]
+    return _head_and_base_proof_verdict(
+        all_changed_tests,
+        repository_root,
+        base_revision,
+        partial(_node_tests_pass, all_relative_tests),
+    )
+
+
+def _plugin_proof_verdict(
+    all_changed_tests: list[Path], repository_root: Path, base_revision: str
+) -> ProofVerdict:
+    all_relative_plugin_roots = sorted(
+        {
+            each_root.relative_to(repository_root)
+            for each_path in all_changed_tests
+            if (each_root := _plugin_root(each_path, repository_root)) is not None
+        }
+    )
+    return _head_and_base_proof_verdict(
+        all_changed_tests,
+        repository_root,
+        base_revision,
+        partial(_plugin_tests_pass, all_relative_plugin_roots),
+    )
+
+
 def _proof_exit_code(
     all_verdicts: list[ProofVerdict], base_revision: str
 ) -> int:
@@ -213,7 +286,8 @@ def main(all_arguments: list[str]) -> int:
         return PASSED_EXIT_CODE
     all_changed_python_tests = _changed_python_tests(all_changed_paths)
     all_changed_node_tests = _changed_node_tests(all_changed_paths)
-    if not all_changed_python_tests and not all_changed_node_tests:
+    all_changed_plugin_tests = _changed_plugin_tests(all_changed_paths, repository_root)
+    if not (all_changed_python_tests or all_changed_node_tests or all_changed_plugin_tests):
         sys.stderr.write(NO_CHANGED_TEST_MESSAGE + "\n")
         return FAILED_EXIT_CODE
     base_revision = parsed_arguments.base_revision
@@ -226,6 +300,10 @@ def main(all_arguments: list[str]) -> int:
         all_verdicts.append(
             _node_proof_verdict(all_changed_node_tests, repository_root, base_revision)
         )
+    if all_changed_plugin_tests:
+        all_verdicts.append(
+            _plugin_proof_verdict(all_changed_plugin_tests, repository_root, base_revision)
+        )
     return _proof_exit_code(all_verdicts, base_revision)
 
 

package/_shared/pr-loop/scripts/pr_loop_shared_constants/fix_pr_test_proof_constants.py

@@ -17,6 +17,9 @@ ALL_PRODUCTION_CODE_SUFFIXES: tuple[str, ...] = (
 )
 ALL_NODE_TEST_SUFFIXES: tuple[str, ...] = (".test.mjs", ".test.js", ".test.cjs")
 ALL_NODE_TEST_COMMAND: tuple[str, ...] = ("node", "--test")
+ALL_PLUGIN_TEST_SUFFIXES: tuple[str, ...] = (".test.ts", ".test.tsx")
+ALL_PLUGIN_TEST_COMMAND: tuple[str, ...] = ("claude", "plugin", "test", ".")
+PLUGIN_MANIFEST_DIRECTORY_NAME: str = ".claude-plugin"
 NODE_BASE_WORKTREE_TEMP_DIRECTORY_PREFIX: str = "fix_pr_test_proof_node_base_"
 NODE_BASE_WORKTREE_DIRECTORY_NAME: str = "tree"
 CI_CONFIG_DIRECTORY_NAME: str = ".github"
@@ -28,7 +31,7 @@ NO_PRODUCTION_CHANGE_MESSAGE: str = (
     "fix_pr_test_proof: the fix changes no production code; nothing to prove."
 )
 NO_CHANGED_TEST_MESSAGE: str = (
-    "fix_pr_test_proof: this fix changes production code and no Python or Node test. "
+    "fix_pr_test_proof: this fix changes production code and no Python, Node, or plugin test. "
     "Add a test that fails on the base and passes on the head."
 )
 WORKTREE_FAILED_MESSAGE: str = (

package/_shared/pr-loop/scripts/test_fix_pr_test_proof.py

@@ -1,7 +1,7 @@
 """Behavioral tests for the fix pull request test-proof check.
 
-Every case drives a git repository under ``tmp_path`` and a pytest or
-``node --test`` subprocess, the same shape the CI job runs.
+Every case drives a git repository under ``tmp_path`` and a pytest,
+``node --test``, or ``claude plugin test`` subprocess, the same shape the CI job runs.
 """
 
 from pathlib import Path
@@ -39,6 +39,25 @@ NODE_ALWAYS_PASSING_TEST_TEXT = (
     "import { test } from 'node:test';\n\n"
     "test('nothing in particular', () => {});\n"
 )
+PLUGIN_MANIFEST_TEXT = '{"name": "calc"}\n'
+PLUGIN_HOOKS_TEXT = '{ "modules": ["./index.ts"] }\n'
+BUGGY_PLUGIN_PRODUCTION_TEXT = (
+    "export function add(left: number, right: number): number {\n"
+    "  return left - right\n}\n"
+)
+FIXED_PLUGIN_PRODUCTION_TEXT = (
+    "export function add(left: number, right: number): number {\n"
+    "  return left + right\n}\n"
+)
+PLUGIN_PROOF_TEST_TEXT = (
+    "import { test, expect } from 'claude-code/testing'\n"
+    "import { add } from '../hooks/index'\n\n"
+    "test('add sums both operands', () => {\n  expect(add(1, 2)).toBe(3)\n})\n"
+)
+PLUGIN_ALWAYS_PASSING_TEST_TEXT = (
+    "import { test, expect } from 'claude-code/testing'\n\n"
+    "test('nothing in particular', () => {\n  expect(1).toBe(1)\n})\n"
+)
 
 
 def _commit_files(repository_root: Path, all_file_texts: dict[str, str]) -> None:
@@ -66,6 +85,19 @@ def _repository_at_buggy_node_base(tmp_path: Path) -> tuple[Path, str]:
     return repository_root, _head_revision(repository_root)
 
 
+def _repository_at_buggy_plugin_base(tmp_path: Path) -> tuple[Path, str]:
+    repository_root = repository_with_root_pytest_config(tmp_path)
+    _commit_files(
+        repository_root,
+        {
+            "plugins/calc/.claude-plugin/plugin.json": PLUGIN_MANIFEST_TEXT,
+            "plugins/calc/hooks/hooks.json": PLUGIN_HOOKS_TEXT,
+            "plugins/calc/hooks/index.ts": BUGGY_PLUGIN_PRODUCTION_TEXT,
+        },
+    )
+    return repository_root, _head_revision(repository_root)
+
+
 def _run_check(repository_root: Path, title: str, base_revision: str) -> int:
     return fix_pr_test_proof.main(
         [
@@ -100,7 +132,7 @@ def test_a_fix_with_no_changed_test_fails(
     _commit_files(repository_root, {"pkg/calc.py": FIXED_PRODUCTION_TEXT})
 
     assert _run_check(repository_root, "fix: sum operands", base_revision) == 1
-    assert "no Python or Node test" in capsys.readouterr().err
+    assert "no Python, Node, or plugin test" in capsys.readouterr().err
 
 
 def test_a_fix_whose_test_fails_on_base_and_passes_on_head_passes(
@@ -186,6 +218,64 @@ def test_a_node_fix_whose_changed_test_fails_on_head_fails(
     assert "fails on the head" in capsys.readouterr().err
 
 
+def test_a_plugin_fix_with_no_changed_test_fails(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    repository_root, base_revision = _repository_at_buggy_plugin_base(tmp_path)
+    _commit_files(repository_root, {"plugins/calc/hooks/index.ts": FIXED_PLUGIN_PRODUCTION_TEXT})
+
+    assert _run_check(repository_root, "fix(calc): sum operands", base_revision) == 1
+    assert "no Python, Node, or plugin test" in capsys.readouterr().err
+
+
+def test_a_plugin_fix_whose_test_fails_on_base_and_passes_on_head_passes(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    repository_root, base_revision = _repository_at_buggy_plugin_base(tmp_path)
+    _commit_files(
+        repository_root,
+        {
+            "plugins/calc/hooks/index.ts": FIXED_PLUGIN_PRODUCTION_TEXT,
+            "plugins/calc/tests/calc.test.ts": PLUGIN_PROOF_TEST_TEXT,
+        },
+    )
+
+    assert _run_check(repository_root, "fix(calc): sum operands", base_revision) == 0
+    assert "fail on the base and pass on the head" in capsys.readouterr().out
+
+
+def test_a_plugin_fix_whose_changed_test_also_passes_on_base_fails(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    repository_root, base_revision = _repository_at_buggy_plugin_base(tmp_path)
+    _commit_files(
+        repository_root,
+        {
+            "plugins/calc/hooks/index.ts": FIXED_PLUGIN_PRODUCTION_TEXT,
+            "plugins/calc/tests/calc.test.ts": PLUGIN_ALWAYS_PASSING_TEST_TEXT,
+        },
+    )
+
+    assert _run_check(repository_root, "fix(calc): sum operands", base_revision) == 1
+    assert "passes on the base" in capsys.readouterr().err
+
+
+def test_a_plugin_fix_whose_changed_test_fails_on_head_fails(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    repository_root, base_revision = _repository_at_buggy_plugin_base(tmp_path)
+    _commit_files(
+        repository_root,
+        {
+            "plugins/calc/tests/calc.test.ts": PLUGIN_PROOF_TEST_TEXT,
+            "plugins/calc/hooks/extra.ts": "export const VALUE = 1\n",
+        },
+    )
+
+    assert _run_check(repository_root, "fix(calc): sum operands", base_revision) == 1
+    assert "fails on the head" in capsys.readouterr().err
+
+
 BUGGY_GREETING_TEXT = 'def greet() -> str:\n    return "helo"\n'
 FIXED_GREETING_TEXT = 'def greet() -> str:\n    return "hello"\n'
 GREETING_TEST_TEXT = (
@@ -222,7 +312,7 @@ def test_a_fix_without_its_own_test_fails_when_the_base_branch_moved_with_a_test
     )
 
     assert _run_check(repository_root, "fix: sum operands", MERGE_REF_FIRST_PARENT) == 1
-    assert "no Python or Node test" in capsys.readouterr().err
+    assert "no Python, Node, or plugin test" in capsys.readouterr().err
 
 
 def test_a_fix_on_a_moved_base_branch_judges_only_its_own_test(

package/package.json

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

package/scripts/account_broker.py

@@ -48,6 +48,7 @@ from dev_env_scripts_constants.account_broker_constants import (
     ALL_PARENT_CLAUDE_SESSION_VARIABLES,
     COMMAND_MISSING_EXIT_CODE,
     REPORT_INDENT_SPACES,
+    TIMEOUT_EXIT_CODE,
     WAIT_EXIT_CODE,
     utc_time_text as _time_text,
 )
@@ -287,13 +288,16 @@ def _attempt_once(context: _RunContext, decision: Decision) -> JobOutcome | None
     account = decision.account
     try:
         completion = _invoke(context, account)
-    except (OSError, subprocess.TimeoutExpired) as error:
-        status = "timeout" if isinstance(error, subprocess.TimeoutExpired) else "start_failed"
-        _record_spent_attempt(context, account, status, COMMAND_MISSING_EXIT_CODE)
+    except subprocess.TimeoutExpired as error:
+        _record_spent_attempt(context, account, "timeout", TIMEOUT_EXIT_CODE)
+        context.report.final_decision = decision
+        return JobOutcome(TIMEOUT_EXIT_CODE, "", str(error), account.name, tuple(context.all_attempts), "timeout", None, None)
+    except OSError as error:
+        _record_spent_attempt(context, account, "start_failed", COMMAND_MISSING_EXIT_CODE)
         context.start_failure_text = str(error)
-        if isinstance(error, subprocess.TimeoutExpired) or not context.all_readings:
+        if not context.all_readings:
             context.report.final_decision = decision
-            final_status = "advisor_blocked" if context.product is Product.CLAUDE else status
+            final_status = "advisor_blocked" if context.product is Product.CLAUDE else "start_failed"
             return JobOutcome(COMMAND_MISSING_EXIT_CODE, "", str(error), account.name, tuple(context.all_attempts), final_status, None, None)
         return None
     combined = f"{completion.stdout}{completion.stderr}".casefold()

package/scripts/claude_account_worker.py

@@ -27,8 +27,6 @@ from dev_env_scripts_constants.claude_account_worker_constants import (
     PROMPT_FILE_FLAG,
     REPORT_FILE_FLAG,
     SINGLE_PROMPT_FLAG,
-    TIMEOUT_ATTEMPT_STATUS,
-    TIMEOUT_EXIT_CODE,
     TIMEOUT_MINUTES_FLAG,
     UTF8_ENCODING,
 )
@@ -104,11 +102,10 @@ def run_worker(
     if outcome.status in {"wait", "exhausted"}:
         report = wait_report("wait", _wait_reason(outcome), outcome.wait_reset_at)
         return finalize_report(report_file, report)
-    is_timed_out = bool(outcome.attempts) and outcome.attempts[-1][1] == TIMEOUT_ATTEMPT_STATUS
     report = make_report(
         outcome.account_name or "none",
-        TIMEOUT_ATTEMPT_STATUS if is_timed_out else outcome.status,
-        exit_code=TIMEOUT_EXIT_CODE if is_timed_out else outcome.returncode,
+        outcome.status,
+        exit_code=outcome.returncode,
         duration_seconds=duration_seconds,
         stdout_text=outcome.stdout,
     )

package/scripts/dev_env_scripts_constants/account_broker_constants.py

@@ -50,6 +50,7 @@ ALL_CODEX_FLOORS = {
 
 WAIT_EXIT_CODE = 3
 COMMAND_MISSING_EXIT_CODE = 127
+TIMEOUT_EXIT_CODE = 124
 REPORT_INDENT_SPACES = 2
 BROKER_STATE_DIRECTORY_NAME = "account-broker"
 BROKER_STATE_FILE_NAME = "state.json"

package/scripts/dev_env_scripts_constants/claude_account_worker_constants.py

@@ -13,10 +13,6 @@ MINIMUM_TIMEOUT_MINUTES: int = 1
 
 LAUNCH_FAILURE_EXIT_CODE: int = 1
 
-TIMEOUT_EXIT_CODE: int = 124
-
-TIMEOUT_ATTEMPT_STATUS: str = "timeout"
-
 CONFIGURATION_FAILURE_EXIT_CODE: int = 2
 
 WAIT_DURATION_SECONDS: float = 0.0
@@ -104,8 +100,6 @@ __all__ = [
     "SINGLE_PROMPT_FLAG",
     "STDOUT_TAIL_CHARACTER_LIMIT",
     "SUMMARY_LINE_TEMPLATE",
-    "TIMEOUT_ATTEMPT_STATUS",
-    "TIMEOUT_EXIT_CODE",
     "TIMEOUT_MINUTES_FLAG",
     "UTF8_ENCODING",
     "WAIT_DURATION_SECONDS",

package/scripts/test_account_broker.py

@@ -687,6 +687,7 @@ def test_should_stop_after_timeout_without_running_job_again(
     assert invoked_homes == ["first"]
     assert outcome.attempts == (("first", "timeout"),)
     assert outcome.status == "timeout"
+    assert outcome.returncode == 124
     assert outcome.account_name == "first"
     assert report.final_decision.account.name == "first"
     assert account_broker.main(("choose", "--product", "codex")) == 0
@@ -696,12 +697,12 @@ def test_should_stop_after_timeout_without_running_job_again(
 @pytest.mark.parametrize(
     ("product", "roster_names", "start_error", "expected_code"),
     (
-        (Product.CLAUDE, ("first",), subprocess.TimeoutExpired("job", 1), 4),
-        (Product.CODEX, ("first",), subprocess.TimeoutExpired("job", 1), 127),
+        (Product.CLAUDE, ("first",), subprocess.TimeoutExpired("job", 1), 124),
+        (Product.CODEX, ("first",), subprocess.TimeoutExpired("job", 1), 124),
         (Product.CODEX, (), OSError("missing command"), 127),
     ),
 )
-def test_should_exit_four_only_for_a_blocked_claude_job(
+def test_should_exit_with_job_failure_code(
     monkeypatch: pytest.MonkeyPatch,
     tmp_path: Path,
     product: Product,

package/scripts/test_claude_account_worker.py

@@ -165,7 +165,7 @@ def test_should_preserve_served_failure_code(
 def test_should_exit_124_with_timeout_reason_when_the_broker_attempt_timed_out(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:
-    timed_out = JobOutcome(127, "", "timed out", "extra_2", (("extra_2", "timeout"),), "advisor_blocked", None, None)
+    timed_out = JobOutcome(124, "", "timed out", "extra_2", (("extra_2", "timeout"),), "timeout", None, None)
 
     exit_code, report, _ = _run_worker(monkeypatch, tmp_path, timed_out)