claude-dev-env 8.31.1 → 8.32.1

package/bin/install.test.mjs

@@ -54,6 +54,8 @@ import {
 } from './install.mjs';
 import { EVER_SHIPPED_SKILL_NAMES } from './ever-shipped-skills.mjs';
 import {
+    PACKAGE_GUIDANCE_BLOCK_END,
+    PACKAGE_GUIDANCE_BLOCK_START,
     SKILL_LOAD_BLOCK_START,
     SKILL_LOAD_INSTRUCTION,
     QUESTION_PRESENTATION_BLOCK_START,
@@ -3162,6 +3164,109 @@ test('--no-pstack skips the plugin and delivers Codex question guidance', t => {
     );
 });
 
+const PSTACK_TEST_PACKAGE_GUIDANCE = readFileSync(
+    join(dirname(fileURLToPath(import.meta.url)), '..', 'AGENTS.md'),
+    'utf8',
+);
+
+function assertHoldsPackageGuidance(codexGuidance) {
+    assert.ok(codexGuidance.includes(`${PACKAGE_GUIDANCE_BLOCK_START}\n${PSTACK_TEST_PACKAGE_GUIDANCE}`));
+    assert.ok(codexGuidance.includes(PACKAGE_GUIDANCE_BLOCK_END));
+}
+
+test('a fresh full install writes the package guidance into Codex AGENTS.md', t => {
+    const sandbox = pstackPluginSandbox(t);
+
+    runPstackInstaller(sandbox.homeDirectory, [], sandbox.environment);
+
+    const codexGuidance = readFileSync(join(sandbox.homeDirectory, '.codex', 'AGENTS.md'), 'utf8');
+    assertHoldsPackageGuidance(codexGuidance);
+    assert.ok(codexGuidance.startsWith(`${SKILL_LOAD_BLOCK_START}\n${SKILL_LOAD_INSTRUCTION}\n`));
+    assert.ok(codexGuidance.includes(QUESTION_PRESENTATION_BLOCK_START));
+});
+
+test('--no-pstack writes package and question guidance without the skill-load block', t => {
+    const sandbox = pstackPluginSandbox(t);
+
+    runPstackInstaller(sandbox.homeDirectory, ['--no-pstack'], sandbox.environment);
+
+    assert.deepEqual(
+        sandbox.recordedCommands().filter(eachCommand => eachCommand.startsWith('codex plugin')),
+        [],
+    );
+    const codexGuidance = readFileSync(join(sandbox.homeDirectory, '.codex', 'AGENTS.md'), 'utf8');
+    assertHoldsPackageGuidance(codexGuidance);
+    assert.ok(codexGuidance.includes(QUESTION_PRESENTATION_BLOCK_START));
+    assert.equal(codexGuidance.includes(SKILL_LOAD_BLOCK_START), false);
+});
+
+test('--no-pstack replaces an outdated package block and keeps the text around it', t => {
+    const sandbox = pstackPluginSandbox(t);
+    const codexHome = join(sandbox.homeDirectory, '.codex');
+    mkdirSync(codexHome, { recursive: true });
+    writeFileSync(
+        join(codexHome, 'AGENTS.md'),
+        `My notes\n${PACKAGE_GUIDANCE_BLOCK_START}\nOld guidance\n${PACKAGE_GUIDANCE_BLOCK_END}\nMore notes\n`,
+    );
+
+    runPstackInstaller(sandbox.homeDirectory, ['--no-pstack'], sandbox.environment);
+
+    const codexGuidance = readFileSync(join(codexHome, 'AGENTS.md'), 'utf8');
+    assert.ok(codexGuidance.startsWith(`My notes\n${PACKAGE_GUIDANCE_BLOCK_START}\n${PSTACK_TEST_PACKAGE_GUIDANCE}`));
+    assert.ok(codexGuidance.includes(`${PACKAGE_GUIDANCE_BLOCK_END}\nMore notes\n`));
+    assert.equal(codexGuidance.includes('Old guidance'), false);
+    assert.equal(codexGuidance.includes(SKILL_LOAD_BLOCK_START), false);
+});
+
+for (const linkTargetDirectory of ['.claude', '.agents']) {
+    test(`--no-pstack turns a Codex link to the ${linkTargetDirectory} package guidance into a file`, t => {
+        const sandbox = pstackPluginSandbox(t);
+        const codexHome = join(sandbox.homeDirectory, '.codex');
+        const codexAgentsPath = join(codexHome, 'AGENTS.md');
+        mkdirSync(codexHome, { recursive: true });
+        symlinkSync(join(sandbox.homeDirectory, linkTargetDirectory, 'AGENTS.md'), codexAgentsPath);
+
+        runPstackInstaller(sandbox.homeDirectory, ['--no-pstack'], sandbox.environment);
+
+        assert.equal(lstatSync(codexAgentsPath).isSymbolicLink(), false);
+        const codexGuidance = readFileSync(codexAgentsPath, 'utf8');
+        assertHoldsPackageGuidance(codexGuidance);
+        assert.ok(codexGuidance.includes(QUESTION_PRESENTATION_BLOCK_START));
+        assert.equal(codexGuidance.includes(SKILL_LOAD_BLOCK_START), false);
+    });
+}
+
+test('--no-pstack leaves a Codex link to a file the package does not own unchanged', t => {
+    const sandbox = pstackPluginSandbox(t);
+    const codexHome = join(sandbox.homeDirectory, '.codex');
+    const codexAgentsPath = join(codexHome, 'AGENTS.md');
+    const ownGuidancePath = join(sandbox.homeDirectory, 'notes', 'codex.md');
+    mkdirSync(codexHome, { recursive: true });
+    mkdirSync(dirname(ownGuidancePath), { recursive: true });
+    writeFileSync(ownGuidancePath, 'My own Codex notes\n');
+    symlinkSync(ownGuidancePath, codexAgentsPath);
+
+    runPstackInstaller(sandbox.homeDirectory, ['--no-pstack'], sandbox.environment);
+
+    assert.equal(lstatSync(codexAgentsPath).isSymbolicLink(), true);
+    assert.equal(readFileSync(ownGuidancePath, 'utf8'), 'My own Codex notes\n');
+});
+
+test('a pstack install after a --no-pstack install seeds the Codex model sheet', t => {
+    const sandbox = pstackPluginSandbox(t);
+    const codexHome = join(sandbox.homeDirectory, '.codex');
+    runPstackInstaller(sandbox.homeDirectory, ['--no-pstack'], sandbox.environment);
+
+    runPstackInstaller(sandbox.homeDirectory, [], sandbox.environment);
+
+    assert.match(readFileSync(join(codexHome, 'pstack-models.md'), 'utf8'), /^session hook: on$/m);
+    const codexGuidance = readFileSync(join(codexHome, 'AGENTS.md'), 'utf8');
+    assert.match(codexGuidance, /^feature, refactoring: gpt-6-sol$/m);
+    assert.ok(codexGuidance.startsWith(`${SKILL_LOAD_BLOCK_START}\n${SKILL_LOAD_INSTRUCTION}\n`));
+    assertHoldsPackageGuidance(codexGuidance);
+    assert.ok(codexGuidance.includes(QUESTION_PRESENTATION_BLOCK_START));
+});
+
 function continuityCommandCount(configurationPath) {
     if (!existsSync(configurationPath)) return 0;
     const configuration = JSON.parse(readFileSync(configurationPath, 'utf8'));

package/bin/seed-codex-pstack-models.mjs

@@ -1,7 +1,7 @@
 import { copyFileSync, lstatSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, constants as filesystemConstants } from 'node:fs';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { hasOnlyQuestionPresentationBlock } from './codex-skill-load-block.mjs';
+import { hasOnlyPackageManagedBlocks } from './codex-skill-load-block.mjs';
 
 const CODEX_PRESET_PATH = fileURLToPath(new URL('../pstack-codex-models.md', import.meta.url));
 
@@ -16,7 +16,7 @@ export function seedCodexPstackModels(codexHome, writeAgentGuidance = writeFileS
     const agentsEntry = lstatSync(agentsPath, { throwIfNoEntry: false });
     if (agentsEntry && !agentsEntry.isFile()) return null;
     const existingGuidance = agentsEntry ? readFileSync(agentsPath, 'utf8') : '';
-    if (agentsEntry && !hasOnlyQuestionPresentationBlock(existingGuidance)) return null;
+    if (agentsEntry && !hasOnlyPackageManagedBlocks(existingGuidance)) return null;
 
     const preset = readFileSync(CODEX_PRESET_PATH, 'utf8');
     const agentGuidance = preset.replace(/^session hook: on\n?$/m, '');

package/bin/seed-codex-pstack-models.test.mjs

@@ -4,7 +4,14 @@ import { existsSync, lstatSync, mkdtempSync, mkdirSync, readFileSync, rmSync, sy
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { seedCodexPstackModels } from './seed-codex-pstack-models.mjs';
-import { QUESTION_PRESENTATION_BLOCK_END, QUESTION_PRESENTATION_BLOCK_START } from './codex-skill-load-block.mjs';
+import {
+    PACKAGE_GUIDANCE_BLOCK_END,
+    PACKAGE_GUIDANCE_BLOCK_START,
+    QUESTION_PRESENTATION_BLOCK_END,
+    QUESTION_PRESENTATION_BLOCK_START,
+    SKILL_LOAD_BLOCK_END,
+    SKILL_LOAD_BLOCK_START,
+} from './codex-skill-load-block.mjs';
 
 const QUESTION_GUIDANCE = `${QUESTION_PRESENTATION_BLOCK_START}\nAsk one question.\n${QUESTION_PRESENTATION_BLOCK_END}\n`;
 
@@ -114,3 +121,47 @@ test('a linked question-only Codex file does not trigger model seeding', (contex
     assert.equal(lstatSync(join(codexHome, 'AGENTS.md')).isSymbolicLink(), true);
     assert.equal(readFileSync(linkedGuidancePath, 'utf8'), QUESTION_GUIDANCE);
 });
+
+const PACKAGE_GUIDANCE = `${PACKAGE_GUIDANCE_BLOCK_START}\nStatus\n${PACKAGE_GUIDANCE_BLOCK_END}\n`;
+const SKILL_LOAD_GUIDANCE = `${SKILL_LOAD_BLOCK_START}\nLoad the skill.\n${SKILL_LOAD_BLOCK_END}\n`;
+
+function codexHomeHolding(context, existingGuidance) {
+    const root = mkdtempSync(join(tmpdir(), 'cde-pstack-models-'));
+    context.after(() => rmSync(root, { recursive: true, force: true }));
+    const codexHome = join(root, '.codex');
+    mkdirSync(codexHome);
+    writeFileSync(join(codexHome, 'AGENTS.md'), existingGuidance);
+    return codexHome;
+}
+
+for (const [label, existingGuidance] of [
+    ['package block', PACKAGE_GUIDANCE],
+    ['package then question blocks', `${PACKAGE_GUIDANCE}\n${QUESTION_GUIDANCE}`],
+    ['question then package blocks', `${QUESTION_GUIDANCE}\n${PACKAGE_GUIDANCE}`],
+    ['all three managed blocks', `${SKILL_LOAD_GUIDANCE}\n${PACKAGE_GUIDANCE}\n${QUESTION_GUIDANCE}`],
+]) {
+    test(`a Codex file holding only the ${label} receives model defaults and keeps its blocks`, (context) => {
+        const codexHome = codexHomeHolding(context, existingGuidance);
+
+        const paths = seedCodexPstackModels(codexHome);
+
+        assert.deepEqual(paths, [join(codexHome, 'pstack-models.md'), join(codexHome, 'AGENTS.md')]);
+        const agents = readFileSync(join(codexHome, 'AGENTS.md'), 'utf8');
+        assert.match(agents, /^feature, refactoring: gpt-6-sol$/m);
+        assert.ok(agents.endsWith(existingGuidance));
+    });
+}
+
+for (const [label, existingGuidance] of [
+    ['an empty file', ''],
+    ['a package block with personal notes', `${PACKAGE_GUIDANCE}My notes\n`],
+    ['personal notes before managed blocks', `My notes\n${PACKAGE_GUIDANCE}\n${QUESTION_GUIDANCE}`],
+]) {
+    test(`${label} does not trigger model seeding`, (context) => {
+        const codexHome = codexHomeHolding(context, existingGuidance);
+
+        assert.equal(seedCodexPstackModels(codexHome), null);
+        assert.equal(existsSync(join(codexHome, 'pstack-models.md')), false);
+        assert.equal(readFileSync(join(codexHome, 'AGENTS.md'), 'utf8'), existingGuidance);
+    });
+}

package/commands/fix-followups.md

@@ -1,10 +1,10 @@
 ---
-description: Fix every non-breaking finding the follow-up ledger holds and open a draft PR for it
+description: Fix every non-breaking finding the follow-up ledger holds and open a PR for it
 argument-hint: [repository root, or blank for the current repository]
 ---
 
 Fix the non-breaking findings a local gate recorded rather than blocked on,
-and deliver them as one draft pull request.
+and deliver them as one pull request.
 
 The repository root is `$ARGUMENTS`, or the current repository when that is
 blank.
@@ -50,7 +50,7 @@ finding names a generated file, regenerate it with the repository's tooling.
 Branch from the repository's default branch. Commit each group on its own,
 with a message naming the check identifier and the files.
 
-Open the pull request as a draft. Write the body as:
+Open the pull request ready for review. Write the body as:
 
 - One `Before:` paragraph saying which findings stood open.
 - One `After:` paragraph saying what the tree now holds.

package/commands/sr-loop.md

@@ -39,7 +39,7 @@ stack's design, intent, and changes.
    code, not the full repo suite), commit once (`git commit -F <file>`, body
    written with the Write tool, Co-Authored-By line, 10-minute timeout — the
    pre-commit gate runs its own tests), and push to the PR head branch. The PR
-   stays draft.
+   keeps its draft or ready state.
 3. Repeat the invocation only after substantive findings or a user request.
    **Skips are sticky:** carry every adjudicated skip
    forward into the next pass as "already adjudicated — do not re-report: ..."
@@ -64,8 +64,9 @@ stack's design, intent, and changes.
 
 ## Finish
 
-When both phases are clean, or only fixed nits remain, mark the target PR ready
-with `gh pr ready`. Confirm that it is no longer a draft.
+When both phases are clean, or only fixed nits remain, a target PR that is a
+draft goes ready with `gh pr ready`. Confirm that it now reads ready. A
+ready target PR stays as it is.
 
 Report: passes run per phase, commits pushed with hashes, fixes applied, and
 the standing skip list with reasons.

package/hooks/advisory/test_pr_done_reminder.py

@@ -242,7 +242,8 @@ def test_main_should_remind_to_open_a_pr_when_the_branch_has_none(
     context = _additional_context(_run_main(monkeypatch, capsys, _payload("git push"), no_pr))
 
     assert "No open pull request found" in context
-    assert "gh pr create --draft" in context
+    assert "Open a pull request with gh pr create." in context
+    assert "--draft" not in context
 
 
 def test_main_should_stay_quiet_on_any_other_gh_failure(

package/hooks/blocking/block_main_commit.py

@@ -23,6 +23,7 @@ if _hooks_dir not in sys.path:
 
 from hooks_constants.hook_block_logger import log_hook_block  # noqa: E402
 
+from hooks_constants.block_main_commit_constants import PULL_REQUEST_INSTRUCTION
 from hooks_constants.subprocess_window import hidden_window_creation_flags
 
 GIT_COMMAND_TIMEOUT_SECONDS = 5
@@ -164,20 +165,11 @@ def parse_bash_command_from_stdin() -> str:
     return bash_command
 
 
-DRAFT_PR_INSTRUCTION = (
-    " Instead: (1) create a feature branch with `git checkout -b <descriptive-branch-name>`, "
-    "(2) commit your changes there, "
-    "(3) push with `git push -u origin <branch-name>`, "
-    "(4) create a draft PR with `gh pr create --draft`. "
-    "If you must commit to main, the user needs to approve explicitly."
-)
-
-
 def build_denial_response(branch_name: str, repo_dir: str | None) -> dict:
     location = f" in {repo_dir}" if repo_dir else ""
     denial_reason = (
         f"BLOCKED: Direct commit to '{branch_name}'{location} is not allowed."
-        + DRAFT_PR_INSTRUCTION
+        + PULL_REQUEST_INSTRUCTION
     )
 
     return {

package/hooks/blocking/test_block_main_commit.py

@@ -74,6 +74,19 @@ def test_blocks_commit_on_protected_branch_from_hook_event_cwd(tmp_path: Path) -
     assert str(repository) in hook_response["hookSpecificOutput"]["permissionDecisionReason"]
 
 
+def test_denial_should_open_a_ready_pull_request(tmp_path: Path) -> None:
+    repository = _create_repository(tmp_path, "main")
+    process_repository = _create_repository(tmp_path, "agent-owned-change")
+
+    completed_process = _run_commit_gate(repository, process_repository)
+
+    denial_reason = json.loads(completed_process.stdout)["hookSpecificOutput"][
+        "permissionDecisionReason"
+    ]
+    assert "open a pull request with `gh pr create`" in denial_reason
+    assert "--draft" not in denial_reason
+
+
 def test_allows_commit_on_owned_branch_from_hook_event_cwd(tmp_path: Path) -> None:
     repository = _create_repository(tmp_path, "agent-owned-change")
     process_repository = _create_repository(tmp_path, "main")

package/hooks/hooks_constants/block_main_commit_constants.py

@@ -0,0 +1,9 @@
+"""Constants for the protected-branch commit gate."""
+
+PULL_REQUEST_INSTRUCTION = (
+    " Instead: (1) create a feature branch with `git checkout -b <descriptive-branch-name>`, "
+    "(2) commit your changes there, "
+    "(3) push with `git push -u origin <branch-name>`, "
+    "(4) open a pull request with `gh pr create`. "
+    "If you must commit to main, the user needs to approve explicitly."
+)

package/hooks/hooks_constants/pr_done_reminder_constants.py

@@ -87,7 +87,7 @@ VERDICT_DONE: str = "DONE. Add the label now:"
 VERDICT_NOT_DONE: str = "NOT DONE. Do not add the done label yet."
 NO_PULL_REQUEST_REMINDER: str = (
     "=== PR DONE CHECKLIST (context reminder, never a block) ===\n"
-    "No open pull request found for this branch. Open a draft PR with gh pr create --draft.\n"
+    "No open pull request found for this branch. Open a pull request with gh pr create.\n"
     "A branch is done only when its PR has clean CI, no merge conflicts, and the done label."
 )
 RECHECK_COMMAND_TEMPLATE: str = (

package/hooks/pyproject.toml

@@ -17,7 +17,6 @@ exclude = [
     "validators/test_files/",
     "test_",
     "abbreviation_checks.py",
-    "git_checks.py",
     "exempt_paths.py",
     "code_rules_typeddict_stub.py",
 ]

package/hooks/validators/README.md

@@ -14,7 +14,6 @@ The checks live in `python_style_checks.py`. Shared source-line splitting, funct
 | `exempt_paths.py` | Shared config, test, and hook-infrastructure path exemptions |
 | `fast_save_validators.py` | In-process Write/Edit save-path validator roster |
 | `file_structure_checks.py` | File structure checks for pre-PR validation |
-| `git_checks.py` | Git and GitHub checks for pre-push review |
 | `health_check.py` | Validator availability, dependency, and version checks |
 | `hook_timing_harness.py` | Hook runtime measurement and threshold report |
 | `magic_value_checks.py` | Hardcoded magic-number checks |

package/hooks/validators/health_check.py

@@ -23,7 +23,6 @@ VALIDATOR_FILES = [
     "test_safety_checks.py",
     "file_structure_checks.py",
     "react_checks.py",
-    "git_checks.py",
     "comment_checks.py",
 ]
 

package/hooks/validators/run_all_validators.py

@@ -402,18 +402,6 @@ def run_react_checks(files: List[Path]) -> ValidatorResult:
     )
 
 
-def run_git_checks() -> ValidatorResult:
-    """Run git/GitHub checks."""
-    result = invoke_validator_module("git_checks", [])
-
-    return ValidatorResult(
-        name="Git/PR Workflow",
-        checks="23,24",
-        passed=result.returncode == 0,
-        output=result.stdout or result.stderr or "All checks passed",
-    )
-
-
 def run_comment_checks(files: List[Path]) -> ValidatorResult:
     """Report that comment policy runs through the explicit diff-aware linter."""
     return ValidatorResult(
@@ -1693,7 +1681,6 @@ def main() -> int:
 
     validators.extend([
         ("File Structure", run_file_structure_checks),
-        ("Git/PR", run_git_checks),
     ])
 
     for i, (name, validator_func) in enumerate(validators, 1):

package/hooks/validators/test_run_all_validators.py

@@ -19,7 +19,6 @@ from .run_all_validators import (
     format_timing_report,
     main,
     print_header,
-    run_git_checks,
     run_python_style_checks,
     run_with_fallback,
     validate_proposed_file,
@@ -164,11 +163,9 @@ class TestFixFlag:
     def test_fix_flag_is_accepted(self) -> None:
         """Verify --fix flag is recognized without error."""
         with patch("validators.run_all_validators.get_changed_files") as mock_get_files, \
-             patch("validators.run_all_validators.run_file_structure_checks") as mock_file, \
-             patch("validators.run_all_validators.run_git_checks") as mock_git:
+             patch("validators.run_all_validators.run_file_structure_checks") as mock_file:
             mock_get_files.return_value = []
             mock_file.return_value = _passing_mock_result()
-            mock_git.return_value = _passing_mock_result()
 
             assert _run_main_with_argv(["run_all_validators.py", "--fix"]) == 0
 
@@ -180,11 +177,10 @@ class TestFixFlag:
              patch("validators.run_all_validators.run_test_safety_checks") as mock_test, \
              patch("validators.run_all_validators.run_react_checks") as mock_react, \
              patch("validators.run_all_validators.run_comment_checks") as mock_comment, \
-             patch("validators.run_all_validators.run_file_structure_checks") as mock_file, \
-             patch("validators.run_all_validators.run_git_checks") as mock_git:
+             patch("validators.run_all_validators.run_file_structure_checks") as mock_file:
             mock_get_files.return_value = [Path("test.py")]
             mock_fix.return_value = ["test.py"]
-            for each_mock in (mock_style, mock_test, mock_react, mock_comment, mock_file, mock_git):
+            for each_mock in (mock_style, mock_test, mock_react, mock_comment, mock_file):
                 each_mock.return_value = _passing_mock_result()
 
             _run_main_with_argv(["run_all_validators.py", "--fix"])
@@ -199,10 +195,9 @@ class TestFixFlag:
              patch("validators.run_all_validators.run_test_safety_checks") as mock_test, \
              patch("validators.run_all_validators.run_react_checks") as mock_react, \
              patch("validators.run_all_validators.run_comment_checks") as mock_comment, \
-             patch("validators.run_all_validators.run_file_structure_checks") as mock_file, \
-             patch("validators.run_all_validators.run_git_checks") as mock_git:
+             patch("validators.run_all_validators.run_file_structure_checks") as mock_file:
             mock_get_files.return_value = [Path("test.py")]
-            for each_mock in (mock_style, mock_test, mock_react, mock_comment, mock_file, mock_git):
+            for each_mock in (mock_style, mock_test, mock_react, mock_comment, mock_file):
                 each_mock.return_value = _passing_mock_result()
 
             _run_main_with_argv(["run_all_validators.py"])
@@ -302,32 +297,6 @@ class TestStderrSurfacing:
 
             assert "ImportError" in validator_result.output
 
-    def test_git_check_surfaces_stderr_when_stdout_empty(self) -> None:
-        """When git validator crashes with no stdout, stderr must appear in output."""
-        with patch("validators.run_all_validators.invoke_validator_module") as mock_invoke:
-            crashed_result = MagicMock()
-            crashed_result.returncode = 1
-            crashed_result.stdout = ""
-            crashed_result.stderr = "SyntaxError: invalid syntax in git_checks.py"
-            mock_invoke.return_value = crashed_result
-
-            validator_result = run_git_checks()
-
-            assert "SyntaxError" in validator_result.output
-
-    def test_output_falls_back_to_all_checks_passed_when_both_empty(self) -> None:
-        """When both stdout and stderr are empty and returncode is 0, use fallback."""
-        with patch("validators.run_all_validators.invoke_validator_module") as mock_invoke:
-            clean_result = MagicMock()
-            clean_result.returncode = 0
-            clean_result.stdout = ""
-            clean_result.stderr = ""
-            mock_invoke.return_value = clean_result
-
-            validator_result = run_git_checks()
-
-            assert validator_result.output == "All checks passed"
-
 
 class TestTimingMetrics:
     def test_create_timing_metrics_empty(self) -> None:

package/package.json

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

package/rules/agent-merges-its-own-green-pull-request.md

@@ -50,6 +50,6 @@ Delete nothing by hand. The repository deletes the head branch on merge.
 
 | Rule | Role |
 |---|---|
-| [`git-workflow.md`](git-workflow.md) | Draft first, and confirm each required context fired after the push |
+| [`git-workflow.md`](git-workflow.md) | Open ready for review, and confirm each required context fired after the push |
 | [`ci-owns-the-gate.md`](ci-owns-the-gate.md) | The gate runs once, and it runs on CI |
 | [`correction-lens.md`](correction-lens.md) | A correction becomes a control at the highest layer that can hold it |

package/rules/flag-non-breaking-findings.md

@@ -84,7 +84,7 @@ escalates rather than opening one more quiet pull request. The number is the
 repository's setting, and raising or lowering it is one edit there.
 
 The `/fix-followups` command drives the whole pass: it reads the brief, fixes
-each rule group, opens a draft pull request, and clears the ledger.
+each rule group, opens a pull request, and clears the ledger.
 
 ## Worked example
 

package/rules/git-workflow.md

@@ -15,7 +15,8 @@ User-level rule: applies to **every** git repo that uses GitHub with `gh`. Small
 
 ## Pull request submission rules
 
-**Create every pull request as a draft.** Use `gh pr create --draft`.
+**Open every pull request ready for review.** Pass `--draft` only when the owner asks
+for a draft.
 
 **A release bot's PR body is machine input. Leave it alone.** Release automation reads
 back the body of its own merged pull request to decide it owns that merge. Rewriting the
@@ -45,12 +46,6 @@ Use `.agents/skills/pull-request/scripts/recover_legacy_author.py
 author record. Do not infer a record from age alone. Keep every other record
 untouched.
 
-## Git golden rules
-
-1. **Draft before push.** Put a pull request in draft state before you push to it.
-   - Before push: `gh pr ready --undo`
-   - After review approved: `gh pr ready`
-
 ## Confirm the required checks fired, and let CI run them
 
 The gate runs once, and it runs on CI. Push the branch and read its verdict.

package/rules/review-closure-is-a-check.md

@@ -50,5 +50,5 @@ A repository that merges through a merge queue also runs the check on `merge_gro
 | Rule | Role |
 |---|---|
 | [`agent-merges-its-own-green-pull-request.md`](agent-merges-its-own-green-pull-request.md) | The agent that drives a pull request merges it once its gate passes |
-| [`git-workflow.md`](git-workflow.md) | Draft first, and confirm each required context fired after the push |
+| [`git-workflow.md`](git-workflow.md) | Open ready for review, and confirm each required context fired after the push |
 | [`correction-lens.md`](correction-lens.md) | A correction becomes a control at the highest layer that can hold it |

package/scripts/dev_env_scripts_constants/followup_constants.py

@@ -72,7 +72,7 @@ USAGE_TEXT: str = (
 )
 
 BRIEF_HEADER: str = (
-    "Fix every finding below in one change, then open a draft pull request "
+    "Fix every finding below in one change, then open a pull request "
     "for it. Each finding is non-breaking, so the change that raised it "
     "already shipped. Keep the fixes mechanical, touch no behavior, and run "
     "the repository's own checks before pushing."

package/scripts/test_followup_cli.py

@@ -130,7 +130,8 @@ def test_brief_names_every_recorded_finding_and_the_repository(tmp_path: Path) -
     assert exit_code == 0
     assert "instruction-git-mode" in output_text
     assert "wrong mode" in output_text
-    assert "draft pull request" in output_text
+    assert "open a pull request for it" in output_text
+    assert "draft pull request" not in output_text
 
 
 def test_brief_asks_for_no_work_on_an_empty_ledger(tmp_path: Path) -> None:

package/hooks/validators/git_checks.py

@@ -1,110 +0,0 @@
-"""Git and GitHub validation checks for pre-push review."""
-
-import json
-import subprocess
-import sys
-from dataclasses import dataclass
-from typing import List
-
-from hooks_constants.subprocess_window import hidden_window_creation_flags
-
-SUBPROCESS_TIMEOUT_SECONDS = 30
-
-
-@dataclass
-class Violation:
-    """Represents a validation violation."""
-    file: str
-    line: int
-    message: str
-
-
-def get_current_branch() -> str:
-    """Get the current git branch name."""
-    try:
-        result = subprocess.run(
-            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
-            capture_output=True,
-            text=True,
-            check=True,
-            timeout=SUBPROCESS_TIMEOUT_SECONDS,
-            creationflags=hidden_window_creation_flags(),
-        )
-        return result.stdout.strip()
-    except (FileNotFoundError, subprocess.CalledProcessError, subprocess.TimeoutExpired):
-        return ""
-
-
-def check_draft_pr_state() -> List[Violation]:
-    """
-    Check that PR is in draft state.
-
-    Returns empty list if:
-    - No PR exists for current branch
-    - gh CLI not available
-    - PR is in draft state
-
-    Returns violation if:
-    - PR is not in draft state
-    """
-    branch = get_current_branch()
-    if not branch:
-        return []
-
-    try:
-        pr_info = subprocess.run(
-            ["gh", "pr", "list", "--head", branch, "--json", "number,isDraft"],
-            capture_output=True,
-            text=True,
-            check=True,
-            timeout=SUBPROCESS_TIMEOUT_SECONDS,
-            creationflags=hidden_window_creation_flags(),
-        )
-    except FileNotFoundError:
-        return []
-    except subprocess.CalledProcessError:
-        return []
-    except subprocess.TimeoutExpired:
-        return []
-
-    if not pr_info.stdout.strip():
-        return []
-
-    try:
-        pr_data = json.loads(pr_info.stdout)
-    except json.JSONDecodeError:
-        return []
-
-    if not pr_data:
-        return []
-
-    is_draft = pr_data[0].get("isDraft", False)
-
-    if is_draft:
-        return []
-
-    return [
-        Violation(
-            file="",
-            line=0,
-            message="PR must be in draft state before pushing. Run: gh pr ready --undo",
-        )
-    ]
-
-
-def main() -> None:
-    """Run all git checks and exit with appropriate code."""
-    violations: List[Violation] = []
-
-    violations.extend(check_draft_pr_state())
-
-    if violations:
-        for violation in violations:
-            print(violation.message)
-        sys.exit(1)
-
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()