claude-dev-env 4.2.0 → 7.0.0

package/hooks/hooks_constants/test_bash_post_call_dispatcher_constants.py

@@ -1,23 +1,33 @@
 """Behavioral tests for the Bash PostToolUse dispatcher's hosted-hook roster."""
 
+from hooks_constants import bash_post_call_dispatcher_constants as constants
 from hooks_constants.bash_post_call_dispatcher_constants import (
     ALL_BASH_POST_TOOL_USE_HOSTED_HOOK_ENTRIES,
 )
 from hooks_constants.bash_pre_tool_use_dispatcher_constants import BASH_TOOL_NAME
 
 
-def test_roster_names_the_gh_pr_author_restore_hook() -> None:
+def test_roster_runs_the_recorder_then_the_pr_done_reminder() -> None:
     all_script_paths = [
         each_entry.script_relative_path for each_entry in ALL_BASH_POST_TOOL_USE_HOSTED_HOOK_ENTRIES
     ]
-    assert "blocking/gh_pr_author_restore.py" in all_script_paths
+    assert all_script_paths == [
+        "observability/test_failure_recorder.py",
+        "advisory/pr_done_reminder.py",
+    ]
 
 
-def test_roster_names_the_test_failure_recorder_hook() -> None:
-    all_script_paths = [
-        each_entry.script_relative_path for each_entry in ALL_BASH_POST_TOOL_USE_HOSTED_HOOK_ENTRIES
-    ]
-    assert "observability/test_failure_recorder.py" in all_script_paths
+def test_pr_done_reminder_also_serves_the_powershell_tool() -> None:
+    reminder_entry = ALL_BASH_POST_TOOL_USE_HOSTED_HOOK_ENTRIES[-1]
+    assert reminder_entry.script_relative_path == "advisory/pr_done_reminder.py"
+    assert "PowerShell" in reminder_entry.applicable_tool_names
+
+
+def test_context_forwarding_keys_match_the_hook_output_contract() -> None:
+    assert constants.POST_TOOL_USE_HOOK_EVENT_NAME == "PostToolUse"
+    assert constants.HOOK_SPECIFIC_OUTPUT_KEY == "hookSpecificOutput"
+    assert constants.ADDITIONAL_CONTEXT_KEY == "additionalContext"
+    assert constants.ADDITIONAL_CONTEXT_JOIN_SEPARATOR == "\n\n"
 
 
 def test_every_roster_entry_applies_to_bash() -> None:

package/hooks/hooks_constants/test_bash_pre_tool_use_dispatcher_constants.py

@@ -20,28 +20,21 @@ POWERSHELL_TOOL_NAME = ALL_CONSTANT_BINDINGS["POWERSHELL_TOOL_NAME"]
 
 _EXPECTED_BASH_ORDER = (
     "blocking/destructive_command_blocker.py",
-    "blocking/gh_body_arg_blocker.py",
     "blocking/shell_substitution_blocker.py",
     "blocking/piped_pytest_blocker.py",
     "blocking/cursor_cli_python_misfire_blocker.py",
     "blocking/unscoped_search_blocker.py",
     "blocking/nas_ssh_binary_enforcer.py",
-    "blocking/volatile_path_in_post_blocker.py",
     "blocking/pii_prevention_blocker.py",
-    "blocking/conventional_pr_title_gate.py",
     "blocking/block_main_commit.py",
     "blocking/session_edit_stage_gate.py",
-    "blocking/test_preflight_check.py",
     "blocking/windows_rmtree_blocker.py",
-    "blocking/gh_pr_author_enforcer.py",
-    "blocking/pr_description_writer_gate.py",
 )
 
 _POWERSHELL_APPLICABLE = (
     "blocking/cursor_cli_python_misfire_blocker.py",
     "blocking/unscoped_search_blocker.py",
     "blocking/pii_prevention_blocker.py",
-    "blocking/pr_description_writer_gate.py",
 )
 
 

package/hooks/hooks_constants/test_failure_recorder_constants.py

@@ -6,9 +6,7 @@ tokens that keep the recognizer to one unchained command, the pytest program
 and Python interpreter basenames, and the flag-token marker the path
 extractor uses to skip an option rather than an existing test file argument.
 
-``BASH_TOOL_NAME`` lives in ``gh_pr_author_swap_constants`` already; this
-module reuses that name rather than a second literal. The pytest-program and
-interpreter recognition here is deliberately its own small, stdlib-only
+The pytest-program and interpreter recognition here is deliberately its own small, stdlib-only
 check rather than a reuse of ``piped_pytest_blocker_constants`` /
 ``pytest_invocation``: those solve the harder pipe-and-wrapper problem and
 pull in a much larger transitive import for every Bash call regardless of
@@ -19,6 +17,8 @@ from __future__ import annotations
 
 import re
 
+BASH_TOOL_NAME = "Bash"
+
 ALL_PYTEST_MENTION_SUBSTRINGS: tuple[str, ...] = ("pytest", "py.test")
 EXIT_CODE_ERROR_PREFIX: str = "Error: Exit code "
 OPTION_TOKEN_PREFIX: str = "-"

package/hooks/hooks_constants/test_gh_post_body_texts_constants.py

@@ -0,0 +1,19 @@
+"""Tests for GitHub post body extraction constants."""
+
+from hooks_constants import gh_post_body_texts_constants as constants
+
+
+def test_post_actions_cover_pull_requests_and_issues() -> None:
+    assert constants.ALL_GH_POST_SUBCOMMANDS == {
+        "issue": frozenset({"comment", "create", "edit"}),
+        "pr": frozenset({"comment", "create", "edit", "review"}),
+    }
+    assert constants.ALL_MCP_BODY_PARAM_NAMES == ("body", "comment")
+
+
+def test_parser_constants_are_stable() -> None:
+    assert constants.BODY_FILE_ENCODING == "utf-8"
+    assert constants.BODY_FLAG_WITH_VALUE_STEP == 2
+    assert constants.GH_COMMAND_NAME == "gh"
+    assert constants.MINIMUM_POST_SUBCOMMAND_TOKEN_COUNT == 2
+    assert constants.TOKEN_JOIN_SEPARATOR == " "

package/hooks/hooks_constants/test_pr_done_reminder_constants.py

@@ -0,0 +1,40 @@
+"""Pin the PR done reminder's command shape and checklist wording."""
+
+from __future__ import annotations
+
+from hooks_constants import pr_done_reminder_constants as constants
+
+
+def test_gh_probe_asks_for_every_field_the_checklist_reads() -> None:
+    assert constants.ALL_GH_PR_VIEW_ARGUMENTS[:3] == ("gh", "pr", "view")
+    all_requested_fields = constants.ALL_GH_PR_VIEW_ARGUMENTS[-1].split(",")
+    for each_field in ("number", "url", "isDraft", "mergeable", "statusCheckRollup", "labels"):
+        assert each_field in all_requested_fields
+
+
+def test_git_global_options_that_take_a_value_are_named() -> None:
+    assert constants.ALL_GIT_OPTIONS_WITH_VALUE == frozenset({"-C", "-c"})
+
+
+def test_powershell_wrappers_and_their_command_flags_are_named() -> None:
+    assert "pwsh" in constants.ALL_POWERSHELL_PROGRAM_NAMES
+    assert "powershell" in constants.ALL_POWERSHELL_PROGRAM_NAMES
+    assert "-command" in constants.ALL_POWERSHELL_COMMAND_FLAGS
+    assert "-c" in constants.ALL_POWERSHELL_COMMAND_FLAGS
+
+
+def test_checklist_lines_join_on_a_single_newline() -> None:
+    assert constants.REMINDER_LINE_SEPARATOR == "\n"
+
+
+def test_every_mergeable_value_has_a_hint() -> None:
+    assert set(constants.ALL_REMINDER_HINTS_BY_MERGEABLE) == {
+        constants.MERGEABLE_CLEAN_VALUE,
+        constants.MERGEABLE_CONFLICTING_VALUE,
+        constants.MERGEABLE_UNKNOWN_VALUE,
+    }
+
+
+def test_header_says_it_never_blocks() -> None:
+    assert "never a block" in constants.REMINDER_HEADER
+    assert "never a block" in constants.NO_PULL_REQUEST_REMINDER

package/hooks/hooks_constants/test_pre_tool_use_dispatcher_constants.py

@@ -13,6 +13,9 @@ try:
     if str(_BLOCKING_DIR) not in sys.path:
         sys.path.insert(0, str(_BLOCKING_DIR))
 
+    from hooks_constants.bash_pre_tool_use_dispatcher_constants import (
+        ALL_BASH_HOSTED_HOOK_ENTRIES,
+    )
     from hooks_constants.pre_tool_use_dispatcher_constants import (
         ALL_HOSTED_HOOK_ENTRIES,
         ALL_IMMEDIATE_HARM_SCRIPT_PATHS,
@@ -74,10 +77,12 @@ def test_duplicate_rmtree_helper_blocker_runs_via_runpy() -> None:
     assert entry.native_module_name is None
 
 
-def test_windows_rmtree_blocker_still_registered() -> None:
-    entry = _entry_for("blocking/windows_rmtree_blocker.py")
-    assert entry is not None
-    assert entry.applicable_tool_names == ALL_WRITE_EDIT_MULTI_EDIT_TOOL_NAMES
+def test_windows_rmtree_write_check_is_retired_but_bash_check_remains() -> None:
+    assert _entry_for("blocking/windows_rmtree_blocker.py") is None
+    all_bash_paths = {
+        each_entry.script_relative_path for each_entry in ALL_BASH_HOSTED_HOOK_ENTRIES
+    }
+    assert "blocking/windows_rmtree_blocker.py" in all_bash_paths
 
 
 def test_blocking_hook_crash_deny_reason_surfaces_the_constant() -> None:
@@ -119,22 +124,11 @@ def test_every_hosted_script_path_exists_under_the_hooks_root() -> None:
         )
 
 
-def test_every_native_module_exposes_a_callable_evaluate() -> None:
-    nativized_entries = [
-        each_entry
-        for each_entry in ALL_HOSTED_HOOK_ENTRIES
-        if each_entry.native_module_name is not None
-    ]
-    assert nativized_entries, (
-        "the roster must carry at least one nativized hook for this test to lock the contract"
-    )
-    for each_entry in nativized_entries:
-        native_module = importlib.import_module(each_entry.native_module_name)
-        evaluate_function = getattr(native_module, "evaluate", None)
-        assert callable(evaluate_function), (
-            f"{each_entry.native_module_name} must expose a callable named evaluate, "
-            "matching the native_module_name docstring contract"
-        )
+def test_retired_native_detector_keeps_its_callable_linter_interface() -> None:
+    native_module = importlib.import_module("state_description_blocker")
+    assert native_module.find_violations("The API uses port 8080.", "guide.md") == []
+    assert native_module.find_violations("Previously set via env var.", "guide.md")
+    assert all(each_entry.native_module_name is None for each_entry in ALL_HOSTED_HOOK_ENTRIES)
 
 
 def test_four_way_set_covers_every_mutation_tool_name() -> None:
@@ -144,7 +138,7 @@ def test_four_way_set_covers_every_mutation_tool_name() -> None:
 
 
 def test_immediate_harm_hooks_reach_apply_patch() -> None:
-    """PII, sensitive-path, existing-file, CODE_RULES, and TDD gates all see apply_patch."""
+    """PII, sensitive-path, and existing-file checks retain apply_patch coverage."""
     for each_script_path in ALL_IMMEDIATE_HARM_SCRIPT_PATHS:
         entry = _entry_for(each_script_path)
         assert entry is not None, f"{each_script_path} must stay on the hosted roster"
@@ -154,8 +148,6 @@ def test_immediate_harm_hooks_reach_apply_patch() -> None:
 
 
 _ALL_DEFERRED_LINT_SCRIPT_PATHS = (
-    "blocking/state_description_blocker.py",
-    "blocking/workflow_substitution_slot_blocker.py",
     "blocking/claude_md_orphan_file_blocker.py",
     "blocking/package_inventory_stale_blocker.py",
     "blocking/env_var_table_code_drift_blocker.py",
@@ -164,9 +156,6 @@ _ALL_DEFERRED_LINT_SCRIPT_PATHS = (
     "blocking/docstring_rule_gate_count_blocker.py",
     "blocking/duplicate_rmtree_helper_blocker.py",
     "validation/hook_format_validator.py",
-    "blocking/hook_prose_detector_consistency.py",
-    "blocking/subprocess_budget_completeness.py",
-    "blocking/windows_rmtree_blocker.py",
     "advisory/refactor_guard.py",
     "advisory/migration_safety_advisor.py",
 )
@@ -177,7 +166,7 @@ def test_lint_and_advisory_hooks_stay_off_the_apply_patch_roster() -> None:
 
     apply_patch reaches only a gate whose violation is already real and
     unrecoverable the moment the call returns: a leaked secret, an exposed
-    sensitive path, a blind overwrite, or an untested change landing. Every
+    sensitive path, or a blind overwrite. Every
     hook named here instead judges the quality of the authored content for a
     consequence the write itself does not cause right now: doc-inventory
     drift, prose or naming style, a future-runtime correctness pattern (an
@@ -225,13 +214,12 @@ def test_edit_and_multi_edit_applicable_sets_are_equal() -> None:
     )
 
 
-def test_multi_edit_widened_hooks_reach_multi_edit() -> None:
+def test_retained_boundary_hooks_reach_multi_edit() -> None:
     all_multi_edit_widened_script_paths = (
         "blocking/write_existing_file_blocker.py",
-        "blocking/code_rules_enforcer.py",
-        "blocking/tdd_enforcer.py",
-        "blocking/state_description_blocker.py",
-    )
+        "blocking/sensitive_file_protector.py",
+        "blocking/pii_prevention_blocker.py",
+        )
     for each_script_path in all_multi_edit_widened_script_paths:
         entry = _entry_for(each_script_path)
         assert entry is not None, f"{each_script_path} must stay on the hosted roster"

package/hooks/observability/test_failure_recorder.py

@@ -101,13 +101,13 @@ try:
     for each_bootstrap_directory in (_hooks_root_directory, _blocking_directory):
         if each_bootstrap_directory not in sys.path:
             sys.path.insert(0, each_bootstrap_directory)
-    from hooks_constants.gh_pr_author_swap_constants import BASH_TOOL_NAME
     from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
     from hooks_constants.test_failure_recorder_constants import (
         ALL_CHAINING_OPERATOR_SUBSTRINGS,
         ALL_PYTEST_MENTION_SUBSTRINGS,
         ALL_PYTEST_PROGRAM_BASENAMES,
         ALL_REDIRECTION_TOKENS,
+        BASH_TOOL_NAME,
         EXIT_CODE_ERROR_PREFIX,
         MODULE_RUN_FLAG,
         NODE_ID_FILE_PATH_SEPARATOR,

package/hooks/pyproject.toml

@@ -24,7 +24,7 @@ exclude = [
 
 
 [[tool.mypy.overrides]]
-module = ["exempt_paths", "code_rules_path_utils", "gh_pr_author_enforcer"]
+module = ["exempt_paths", "code_rules_path_utils"]
 warn_unused_ignores = false
 
 [[tool.mypy.overrides]]

package/hooks/test_gh_post_body_texts.py

@@ -0,0 +1,79 @@
+"""Tests for durable GitHub post body extraction."""
+
+from pathlib import Path
+
+import pytest
+
+from gh_post_body_texts import (
+    extract_gh_post_body_texts_for_privacy_gate,
+    extract_mcp_body_texts,
+)
+
+
+@pytest.mark.parametrize(
+    ("command", "expected_text"),
+    [
+        ('gh pr create --body "pull request text"', "pull request text"),
+        ('gh pr comment 12 --body="comment text"', "comment text"),
+        ('gh issue edit 7 -b "issue text"', "issue text"),
+        ('GH_HOST=github.example gh pr review 8 --body "review text"', "review text"),
+    ],
+)
+def test_inline_post_bodies_are_extracted(command: str, expected_text: str) -> None:
+    all_body_texts, deny_reason = extract_gh_post_body_texts_for_privacy_gate(command)
+    assert all_body_texts == [expected_text]
+    assert deny_reason is None
+
+
+def test_relative_body_file_uses_supplied_working_directory(tmp_path: Path) -> None:
+    body_file = tmp_path / "body.md"
+    body_file.write_text("body file text", encoding="utf-8")
+    all_body_texts, deny_reason = extract_gh_post_body_texts_for_privacy_gate(
+        "gh pr comment 12 --body-file body.md",
+        str(tmp_path),
+    )
+    assert all_body_texts == ["body file text"]
+    assert deny_reason is None
+
+
+@pytest.mark.parametrize("body_file_text", ["missing.md", "$BODY_FILE", "-"])
+def test_unreadable_body_file_fails_closed(body_file_text: str) -> None:
+    all_body_texts, deny_reason = extract_gh_post_body_texts_for_privacy_gate(
+        f"gh pr comment 12 --body-file {body_file_text}"
+    )
+    assert all_body_texts == []
+    assert deny_reason is not None
+    assert "could not be read" in deny_reason
+
+
+def test_invalid_utf8_body_file_fails_closed(tmp_path: Path) -> None:
+    body_file = tmp_path / "body.md"
+    body_file.write_bytes(b"\xff")
+    all_body_texts, deny_reason = extract_gh_post_body_texts_for_privacy_gate(
+        f'gh issue create --body-file "{body_file}"'
+    )
+    assert all_body_texts == []
+    assert deny_reason is not None
+
+
+@pytest.mark.parametrize(
+    "command",
+    [
+        "gh pr view 12",
+        'echo "gh pr comment 12 --body text"',
+        "git status",
+        "",
+    ],
+)
+def test_non_post_commands_have_no_body(command: str) -> None:
+    assert extract_gh_post_body_texts_for_privacy_gate(command) == ([], None)
+
+
+def test_mcp_body_and_comment_values_are_extracted() -> None:
+    assert extract_mcp_body_texts(
+        {"body": "body text", "comment": "comment text", "title": "ignored"}
+    ) == ["body text", "comment text"]
+
+
+def test_mcp_non_string_and_empty_values_are_ignored() -> None:
+    assert extract_mcp_body_texts({"body": "", "comment": 7}) == []

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "4.2.0",
+    "version": "7.0.0",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {
@@ -9,7 +9,7 @@
         "cde": "bin/cde.mjs"
     },
     "scripts": {
-        "test": "node --test \"bin/*.test.mjs\" \".agents/skills/**/*.test.mjs\" \"tests/fresh-session/**/*.test.mjs\""
+        "test": "node --test \"bin/*.test.mjs\" \".agents/skills/**/*.test.mjs\" \"tests/fresh-session/**/*.test.mjs\" \"scripts/ci/*.test.mjs\""
     },
     "files": [
         "bin/",

package/rules/durable-post-artifacts.md

@@ -1,38 +1,50 @@
-# Durable Post Artifacts
+# GitHub post input rules
 
-**When this applies:** Any GitHub post that lives on the server — an issue, a pull request, a comment, or a review — created through `gh` (`gh pr create/comment/edit/review`, `gh issue create/comment/edit`) or a GitHub MCP post tool.
+## When this applies
+
+Use this rule for a GitHub issue, pull request, comment, or review created
+through `gh` or a GitHub MCP post tool.
 
 ## Rule
 
-A post lives forever. Job scratch directories, worktrees, and system temp folders do not — they are cleaned soon after the run that made them. So a post must never point at a path in that scratch. The moment the directory is cleaned, the reference breaks and the reader is left with a dead path.
+A post remains after the job ends. Job scratch directories, worktrees, and
+system temp folders do not. Do not put a path from one of those directories in
+a post.
 
-Handle the two kinds of content differently:
+Handle text and binary content differently:
 
-- **Text data** (logs, tables, diffs, stack traces): paste the actual text inline in the post body. Do not link a scratch file that holds it.
-- **Binary artifacts** (images, screenshots, archives): upload the file to the repository's durable `artifacts` release and link the permanent URL. Use the helper:
+- **Text data** such as logs, tables, diffs, and stack traces belongs inline in
+  the post body. Do not link a scratch file that holds text data.
+- **Binary artifacts** such as images, screenshots, and archives belong in the
+  repository's durable `artifacts` release. Use the helper:
 
   ```
   python3 ~/.claude/scripts/gh_artifact_upload.py <file-path> <owner/repo>
   ```
 
-  It ensures the repository has a prerelease tagged `artifacts`, uploads the file under a `YYYYMMDD_HHMMSS_<name>` asset name, and prints the permanent download URL. Put that URL in the post.
+  The helper creates the `artifacts` prerelease when needed, uploads the file
+  under a `YYYYMMDD_HHMMSS_<name>` asset name, and prints a permanent download
+  URL. Put that URL in the post.
 
 ## Volatile paths that must not appear in a post body
 
-- A job scratch directory (`.claude-profile-a/jobs/`)
-- A worktree (`.claude/worktrees/`)
-- A system temp location (`AppData\Local\Temp`, `%TEMP%`, `$env:TEMP`, `/tmp/`)
-- The job scratch environment variable (`$CLAUDE_JOB_DIR`)
-
-Both slash directions count.
-
-The worktree and job-scratch entries count as a path when either:
+- A job scratch directory: `.claude-profile-a/jobs/`
+- A worktree: `.claude/worktrees/`
+- A system temp location: `AppData\\Local\\Temp`, `%TEMP%`, `$env:TEMP`, or
+  `/tmp/`
+- The job scratch environment variable: `$CLAUDE_JOB_DIR`
 
-- A `/` or `\` sits right before them — a drive-letter path (`C:\Users\me\.claude\worktrees\wt\f.py`), a home path (`~/.claude/worktrees/wt`), or a POSIX absolute path (`/home/me/.claude-profile-a/jobs/j/log.txt`).
-- A path segment follows them — a relative path that names a child under that directory (`see .claude/worktrees/wt-1/notes.md`, a markdown link target, or `cd .claude/worktrees/wt-199`).
+Both slash directions count. The path rule applies when a slash or backslash
+precedes a marker, or when a path segment follows it. A standalone directory
+name does not form a path.
 
-With neither anchor the text names the directory rather than something inside it, and it posts — a quoted config constant, a backticked directory name, or a placeholder form such as `.claude/worktrees/<name>`. Un-backticked prose that puts a word immediately after the marker reads the same as a relative path and is blocked; the placeholder form is the documented escape.
+## Validation
 
-## Enforcement
+Resolve the active managed root (`CLAUDE_CONFIG_DIR` when set, `~/.claude`
+otherwise), then run `<managed-root>/scripts/durable_post_lint.py` before the
+server write. Pass the matching action and body file. Use `pr-create`,
+`pr-edit`, `pr-comment`, `pr-review`, `issue-create`, `issue-edit`,
+`issue-comment`, or `github-mcp-post`.
 
-The `volatile_path_in_post_blocker` PreToolUse hook reads the body of each `gh` post command and each GitHub MCP post call, scans it for these markers, and blocks the post when it finds one. For a `--body-file`, the hook reads the file and scans its contents, so writing the body to a temp file and passing it with `--body-file` stays allowed — what the hook rejects is a volatile path inside the text that gets posted.
+The linter reads the body file and reports a volatile local path without
+printing the body. Fix the body and rerun the linter before posting.

package/rules/gh-cli-conventions.md

@@ -1,26 +1,36 @@
-# gh CLI Conventions
+# gh CLI conventions
 
-Two call shapes the `gh` CLI gets wrong by default.
+Two `gh` call shapes need explicit handling.
 
-## Body content goes in a file
+## Put body content in a file
 
-Every `gh` command carrying markdown body content (`gh pr create/edit/comment/review`, `gh issue create/edit/comment`) uses `--body-file <path>` with a temp file — never a `--body` / `-b` string, where backticks land on GitHub as a literal `` \` ``. Write the temp file BOM-free:
+Every `gh` command that carries markdown body content uses
+`--body-file <path>`. This applies to `gh pr create`, `gh pr edit`,
+`gh pr comment`, `gh pr review`, `gh issue create`, `gh issue edit`, and
+`gh issue comment`. Never pass a `--body` or `-b` string. Write the file as
+BOM-free UTF-8:
 
 ```powershell
 [IO.File]::WriteAllText($bodyPath, $body, [Text.UTF8Encoding]::new($false))
 ```
 
-MCP GitHub tools take `body` as a structured parameter and are unaffected.
+MCP GitHub tools take `body` as a structured parameter. Write the same body to
+a UTF-8 file and run the shared linter before sending that parameter.
 
-`gh_body_arg_blocker.py` (PreToolUse on Bash, hosted by `bash_pre_tool_use_dispatcher`) blocks `--body <arg>` and returns the corrective message.
+For pull requests, use
+`.agents/skills/pull-request/scripts/pull_request.py`. It passes
+`--body-file` to `gh` after the action-aware linter succeeds. For issues and
+GitHub MCP posts, run the linter directly with `issue-create`, `issue-edit`,
+`issue-comment`, or `github-mcp-post` as the action.
 
 ## Paginated reads slurp before they filter
 
-Every `gh api` read of a paginated GitHub list endpoint (PR `reviews` / `comments` / `files`, issue `comments`, `pulls`, `issues`) uses `--paginate --slurp` piped to **external** `jq`. The built-in `--jq` runs per page, so a cross-page operation like `sort_by | last` gives a wrong-but-confident result.
+Every `gh api` read of a paginated GitHub list endpoint uses
+`--paginate --slurp` and pipes the result to external `jq`. This applies to PR
+reviews, comments, and files, plus issue comments, pulls, and issues. The
+built-in `--jq` runs once per page and can produce a wrong cross-page result.
 
-Single-object endpoints (`pulls/<n>`, `issues/<n>`) skip pagination and may use `--jq` directly. For a newest-first walk, sort the slurped array and take the last element; for single-page bounds, cap with a `per_page` query parameter.
-
-## Sibling rules
-
-- [`destructive-commands.md`](destructive-commands.md) — why a body describing `rm -rf` must travel by file path.
-- [`durable-post-artifacts.md`](durable-post-artifacts.md) — what a post body may reference.
+Single-object endpoints such as `pulls/<n>` and `issues/<n>` do not need
+pagination and may use `--jq` directly. For a newest-first walk, sort the
+slurped array and take the last element. For one page, cap the request with a
+`per_page` query parameter.

package/rules/git-workflow.md

@@ -1,8 +1,8 @@
-# Git Workflow
+# Git workflow
 
-User-level rule: applies to **every** git repo that uses GitHub with `gh` (no exceptions for “small” or non-primary repos unless the user says otherwise in the session).
+User-level rule: applies to **every** git repo that uses GitHub with `gh`. Small or non-primary repos follow the same rule unless the user says otherwise in the session.
 
-## Workflow Decision Tree
+## Workflow decision tree
 
 **When to use stacked PRs:** Feature B depends on Feature A's implementation
 
@@ -13,19 +13,32 @@ User-level rule: applies to **every** git repo that uses GitHub with `gh` (no ex
 2. Get reviewed and MERGE infrastructure first
 3. Launch parallel feature PRs that use merged infrastructure
 
-## PR Submission Rules
+## Pull request submission rules
 
 **ALWAYS create PRs as DRAFT:** Use `gh pr create --draft` for ALL PRs
 
-**The pr-description-writer agent writes the body:** Spawn the `pr-description-writer` agent (Agent tool, `subagent_type` `pr-description-writer`), then publish what it returns with `--body-file`. `pr_description_writer_gate.py` (PreToolUse on Bash and PowerShell, hosted by `bash_pre_tool_use_dispatcher`) denies a `gh pr create` when the session records no such spawn. A trailing `# pr-description-skip` comment on the command opts out for a body you write yourself.
+Use the `pr-description-writer` agent before creating a pull request or
+rewriting its full description. Publish its title and body file through
+`.agents/skills/pull-request/scripts/pull_request.py`.
 
-## Git Golden Rules (NON-NEGOTIABLE)
+Resolve the active managed root (`CLAUDE_CONFIG_DIR` when set, `~/.claude`
+otherwise), then run `<managed-root>/scripts/durable_post_lint.py` before any
+pull request, issue, or GitHub MCP post. The linter checks the action-specific
+title, body, and volatile-path rules before credential lookup or network
+access.
+
+Use `.agents/skills/pull-request/scripts/recover_legacy_author.py
+<exact-state-file> --confirm-inactive` only for one explicitly selected legacy
+author record. Do not infer a record from age alone. Keep every other record
+untouched.
+
+## Git golden rules
 
 1. **DRAFT BEFORE PUSH**: When pushing ANYTHING to a PR, it MUST be in draft state first
    - Before push: `gh pr ready --undo`
    - After review approved: `gh pr ready`
 
-## Never Commit Working Documents or Images
+## Never commit working documents or images
 
 **NEVER commit these files to the repo:**
 
@@ -49,4 +62,4 @@ An image a PR needs as visual evidence is not an exception to that row. Upload i
 
 Repair only reported findings, then re-verify after every repair.
 
-Every `gh` post in this workflow uses `--body-file` per `gh-cli-conventions.md` and keeps volatile scratch paths out per `durable-post-artifacts.md`; stage session edits per `re-stage-before-commit.md` before each commit.
+Every `gh` post in this workflow uses `--body-file` per `gh-cli-conventions.md` and keeps volatile scratch paths out per `durable-post-artifacts.md`. Stage session edits per `re-stage-before-commit.md` before each commit.

package/scripts/check.ps1

@@ -152,7 +152,6 @@ if (-not $SkipMypy) {
                 copilot_quota.py `
                 fix_hookspath.py `
                 grant_project_claude_permissions.py `
-                post_audit_thread.py `
                 preflight_self_heal.py `
                 preflight.py `
                 reviewer_availability.py `

package/{.agents/skills/run-claude-dev-env/driver.mjs → scripts/ci/installer-lifecycle.mjs}

@@ -1,29 +1,4 @@
 #!/usr/bin/env node
-/**
- * Smoke driver for the claude-dev-env installer.
- *
- * The installer (bin/install.mjs) writes into os.homedir()/.claude and
- * os.homedir()/.agents and has
- * three global side effects: it copies files under ~/.claude/ and ~/.agents/, sets
- * `git config --global core.hooksPath`, and writes ~/.mypy.ini. There is no
- * flag to redirect the target, so this driver isolates every side effect by
- * spawning the installer with HOME, USERPROFILE, and GIT_CONFIG_GLOBAL all
- * pointed at a throwaway sandbox directory. Node's os.homedir() follows
- * USERPROFILE on Windows and HOME on POSIX, so setting both redirects the
- * install target on either platform without touching the real ~/.claude/.
- *
- * The isolated GIT_CONFIG_GLOBAL is seeded with `safe.directory = *` so the
- * installer's `git status` source-conflict guard runs even when the checkout
- * lives somewhere git flags as dubious ownership (for example a UNC network
- * share), while the installer's `git config --global core.hooksPath` write
- * still lands only in the sandbox config.
- *
- * It runs the three lifecycle commands an agent cares about — `--help`, a full
- * install, and `--uninstall` — and asserts the observable result of each
- * against the sandbox tree. Exit code 0 means every assertion held.
- *
- * Usage: node .claude/skills/run-claude-dev-env/driver.mjs
- */
 
 import { spawnSync } from 'node:child_process';
 import {
@@ -41,7 +16,7 @@ import { tmpdir } from 'node:os';
 import { fileURLToPath } from 'node:url';
 
 const DRIVER_DIRECTORY = dirname(fileURLToPath(import.meta.url));
-const PACKAGE_ROOT = resolve(DRIVER_DIRECTORY, '..', '..', '..');
+const PACKAGE_ROOT = resolve(DRIVER_DIRECTORY, '..', '..');
 const INSTALL_ENTRY = join(PACKAGE_ROOT, 'bin', 'install.mjs');
 
 const checks = [];
@@ -68,7 +43,7 @@ function collectFilesRecursive(directory) {
 
 function runInstaller(sandboxHome, installerArguments) {
     const gitConfigGlobal = join(sandboxHome, '.gitconfig-sandbox');
-    const result = spawnSync(process.execPath, [INSTALL_ENTRY, ...installerArguments], {
+    const installerProcess = spawnSync(process.execPath, [INSTALL_ENTRY, ...installerArguments], {
         cwd: PACKAGE_ROOT,
         encoding: 'utf8',
         env: {
@@ -78,7 +53,7 @@ function runInstaller(sandboxHome, installerArguments) {
             GIT_CONFIG_GLOBAL: gitConfigGlobal,
         },
     });
-    return result;
+    return installerProcess;
 }
 
 function main() {