claude-dev-env 2.11.0 → 2.13.0

package/agents/pr-description-writer.md

@@ -1,94 +1,24 @@
 ---
 name: pr-description-writer
-description: "Optional agent for PR descriptions and PR comments. Authors bodies in one of three Anthropic-derived shapes (Trivial / Standard / Heavy) so PRs match merged-PR style in `anthropics/claude-code`, `anthropics/claude-code-action`, and `anthropics/claude-code-sdk-python`, and pass the `pr_description_enforcer` PreToolUse hook's body audit on `gh pr create`, `gh pr edit`, and `gh pr comment`."
+description: "Optional agent that drafts factual pull request descriptions and comments from the current diff and validates each statement against the master review guides."
 tools: Read,Grep,Glob,Bash
 ---
 
 # PR Description Writer
 
-You write PR bodies and PR comments. Your output follows Anthropic Claude Code house style. The style derives from a 120-PR sample across `anthropics/claude-code`, `anthropics/claude-code-action`, and `anthropics/claude-code-sdk-python`. Pick a shape that matches the diff size. Open with an imperative verb. Explain WHY the change exists in prose a reviewer can scan. The companion reference `packages/claude-dev-env/docs/PR_DESCRIPTION_GUIDE.md` carries the full header catalog and the readability escape-hatch flow.
+Write the body from the current pull request diff and task. Use the [description guide](../skills/descriptions/SKILL.md#required-content) for required content and [description shape](../skills/descriptions/SKILL.md#description-shape). Use the [comment guide](../skills/comments/SKILL.md#writing-useful-review-comments) for a review comment.
 
-## The three shapes
+## Draft the body
 
-Choose one shape per body. Mixing shapes signals confusion to the reviewer.
+1. Inspect the cumulative diff, the current pull request body, and the validation results.
+2. State the behavior change, its scope, and the validation that ran.
+3. Preserve accurate issue links and curated sections from the current body.
+4. Use headings when they help a reviewer scan the change.
 
-### Trivial — diff ≤ 10 lines
+## Publish through GitHub CLI
 
-One to three sentences of prose. Zero headers. No `## Summary`, no `## Test plan`. The opening verb describes the change directly.
+Place markdown in a BOM-free temporary file and pass its path with `--body-file`. Follow [gh CLI conventions](../rules/gh-cli-conventions.md#body-content-goes-in-a-file).
 
-```markdown
-Bump bun to 1.3.14. Picks up the bugfix for the runtime panic on empty stdin.
-```
+## Check the draft
 
-### Standard — diff 11–500 lines
-
-Opens with an imperative-verb paragraph. Optional headers drawn from the Anthropic set: `## Summary`, `## Problem`, `## Fix`, `## Changes`, `## Test plan`, `## Tests`, `## Testing`, `## Approach`, `## Root cause`. Most Standard PRs use one or two — pick the ones the change earns.
-
-```markdown
-Adds a syllable-counted Flesch reading score to the PR description enforcer. Bodies above the readability ceiling surface a targeted block message before the strike counter increments.
-
-## Test plan
-
-- [ ] `pytest packages/claude-dev-env/hooks/blocking/test_pr_description_enforcer.py`
-- [ ] Open a draft PR with a 45-word sentence and confirm the metric block fires
-```
-
-### Heavy — diff > 500 lines, or a cross-cutting bug fix
-
-Two required header categories. Body MUST contain at least one of `## Problem` or `## Summary`. Body MUST contain at least one of `## Test plan`, `## Testing`, `## Tests`, `## Verification`, or `## Validation`. Add `## Fix`, `## Changes`, `## Root cause`, or `## Approach` when the change earns them.
-
-```markdown
-## Problem
-
-Long-running `gh api` review fetches drop pages silently when the reviewer count crosses 30. Bugbot findings on PRs past the first review cycle stay hidden.
-
-## Fix
-
-Routes every `gh api .../reviews` and `.../comments` call through `--paginate --slurp | jq` so the cross-page filter sees the full set.
-
-## Test plan
-
-- [ ] Mock paginated API and assert `jq` filter operates on the merged stream
-- [ ] Replay PR #467 review history and confirm the late bugbot comment surfaces
-```
-
-## Style rules
-
-- Open with an imperative verb: `Adds`, `Fixes`, `Updates`, `Removes`, `Ports`, `Tightens`. 51% of prose-opening Anthropic PRs follow this pattern.
-- Do not open with `This PR`. The phrase appears in 1 of 120 corpus PRs. The enforcer hook treats `This PR adds/fixes/updates…` as a hard block.
-- Backticked identifiers (`function_name`, `--flag`, `CONST`) belong in intro prose. Anthropic PRs use them routinely.
-- Em-dashes — like these — work as parenthetical separators. 48% of corpus PRs use them.
-- Focus on WHY. The diff shows WHAT.
-- No code snippets in the description body. Reviewers read the diff for code.
-- No implementation-detail dumping. `Add a 5-second timeout` beats ``Add `pullStartedAt: Date.now()` parameter to the `runPull()` callback``.
-- No filler. Strike `In this PR I have made the following changes:` and start with the action.
-
-## Gotchas
-
-- **Self-closing reference.** Do not write `Fixes #<the PR's own number>` in a `gh pr edit` or `gh pr comment` body. The enforcer hook reads the positional after `pr edit` or `pr comment` and blocks the body when the self-reference matches.
-- **Trivial shape with `## Summary` header.** A four-line body wrapped in `## Summary` trips the ceremony-on-Trivial check. Keep tiny bodies as plain prose.
-- **Heavy shape missing a testing header.** A 600-line PR body with `## Problem` and `## Fix` but no `## Test plan` / `## Testing` / `## Tests` block trips the Heavy required-headers check.
-- **`This PR` opening on any shape.** Hard block regardless of size.
-- **Dual-mode dispatch (unique pattern in `hooks/blocking/`).** The `pr_description_enforcer.py` hook reads `sys.argv` for `--readability-*` CLI flags as well as its stdin-JSON hook input. This dual-mode pattern is the only one of its kind across the blocking hooks directory. When extending the hook, preserve the precedence: CLI flags handled first and exited; stdin-JSON path falls through.
-
-## Readability targets
-
-The enforcer hook computes a Flesch Reading Ease score plus sentence-length metrics on the intro paragraph and the first body section combined.
-
-| Metric | Target |
-|---|---|
-| Longest sentence | ≤ 28 words |
-| Average sentence | ≤ 18 words |
-| Flesch Reading Ease | ≥ 50 |
-
-The hook tracks a per-user strike counter at `~/.claude/state/pr_description_readability_strikes.json`. The first two readability failures emit a metric-specific block (e.g., `Readability: longest sentence is 32 words (maximum 28); split or rewrite the longest sentence`). The third triggering failure fires an escape-hatch message listing four recovery actions. The full action list lives in `PR_DESCRIPTION_GUIDE.md` under "Escape hatch".
-
-Hit the targets on first attempt by writing short sentences in common Anglo-Saxon words. The average tracks the corpus median of 14.5.
-
-## Refusals
-
-Decline to write a body when:
-
-- The PR has zero diff lines (genuinely empty).
-- The user describes intent that contradicts the diff (e.g., "describe this as a bug fix" when the diff adds a feature).
-- The user requests a shape that violates the hook (e.g., `## Summary` on a one-line bump). Offer the correct shape.
+Confirm every statement matches the diff and current pull request state. Return the final markdown and the file path ready for publication.

package/bin/install.mjs

@@ -115,8 +115,10 @@ export const CORE_INCLUDE_DIRECTORIES = [
 ];
 
 export const CORE_SKILLS = [
+    'imagegen',
     'orchestrator', 'orchestrator-refresh', 'team-advisor', 'grokify',
     'grok-spawn',
+    'small-cl', 'comments', 'reviews', 'descriptions', 'emergencies',
     'anthropic-plan', 'everything-search',
     'privacy-hygiene',
     'issue-tracker',
@@ -928,7 +930,6 @@ export const FOLDED_HOOK_RELATIVE_PATHS = new Set([
     'blocking/state_description_blocker.py',
     'blocking/subprocess_budget_completeness.py',
     'blocking/hook_prose_detector_consistency.py',
-    'blocking/verified_commit_message_accuracy_blocker.py',
     'blocking/workflow_substitution_slot_blocker.py',
     'blocking/claude_md_orphan_file_blocker.py',
     'blocking/env_var_table_code_drift_blocker.py',
@@ -1491,23 +1492,58 @@ function loadPackageManagedDenyEntries() {
 }
 
 /**
- * Merge package-owned permission defaults into ~/.claude/settings.json.
+ * Load deny entries an earlier manifest records as package-managed.
  *
- * @returns {{addedCount: number, alreadyPresentCount: number, managedDenyEntries: string[]}}
+ * @returns {string[]}
+ */
+function loadPriorManagedDenyEntries() {
+    if (!existsSync(MANIFEST_FILE)) return [];
+    try {
+        const priorManifest = JSON.parse(readFileSync(MANIFEST_FILE, 'utf8'));
+        return managedDenyEntriesFromPackageSettings({
+            permissions: priorManifest?.[MANIFEST_MANAGED_PERMISSIONS_KEY],
+        });
+    } catch {
+        return [];
+    }
+}
+
+/**
+ * Reconcile package-managed permission defaults with ~/.claude/settings.json.
+ *
+ * @returns {{addedCount: number, alreadyPresentCount: number, removedCount: number, managedDenyEntries: string[]}}
  */
 function mergeManagedPermissions() {
-    const managedDenyEntries = loadPackageManagedDenyEntries();
-    if (managedDenyEntries.length === 0) {
-        return { addedCount: 0, alreadyPresentCount: 0, managedDenyEntries: [] };
+    const allCurrentManagedDenyEntries = loadPackageManagedDenyEntries();
+    const allPriorManagedDenyEntries = loadPriorManagedDenyEntries();
+    const allCurrentManagedDenyEntrySet = new Set(allCurrentManagedDenyEntries);
+    const allRetiredManagedDenyEntries = allPriorManagedDenyEntries.filter(
+        eachEntry => !allCurrentManagedDenyEntrySet.has(eachEntry),
+    );
+    const hasCurrentManagedDenyEntries = allCurrentManagedDenyEntries.length > 0;
+    const hasRetiredManagedDenyEntries = allRetiredManagedDenyEntries.length > 0;
+    if (!hasCurrentManagedDenyEntries && !hasRetiredManagedDenyEntries) {
+        return {
+            addedCount: 0,
+            alreadyPresentCount: 0,
+            removedCount: 0,
+            managedDenyEntries: [],
+        };
     }
     const settingsPath = join(CLAUDE_HOME, SETTINGS_FILE_NAME);
     const settingsExisted = existsSync(settingsPath);
     const settings = loadClaudeSettingsObjectOrExit(settingsPath);
-    const mergeOutcome = mergeManagedPermissionsIntoSettings(settings, managedDenyEntries);
-    if (mergeOutcome.addedCount > 0 || !settingsExisted) {
+    const pruneOutcome = pruneManagedPermissionsFromSettings(settings, allRetiredManagedDenyEntries);
+    const mergeOutcome = hasCurrentManagedDenyEntries
+        ? mergeManagedPermissionsIntoSettings(settings, allCurrentManagedDenyEntries)
+        : { addedCount: 0, alreadyPresentCount: 0, managedDenyEntries: [] };
+    const shouldWriteSettings = pruneOutcome.removedCount > 0
+        || mergeOutcome.addedCount > 0
+        || (!settingsExisted && hasCurrentManagedDenyEntries);
+    if (shouldWriteSettings) {
         writeFileSync(settingsPath, JSON.stringify(settings, null, 4) + '\n');
     }
-    return mergeOutcome;
+    return { ...mergeOutcome, removedCount: pruneOutcome.removedCount };
 }
 
 /**
@@ -2010,6 +2046,9 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
 
     const permissionMerge = mergeManagedPermissions();
     summary.managedPermissions = permissionMerge;
+    if (permissionMerge.removedCount > 0) {
+        console.log(`  Permissions: ${permissionMerge.removedCount} retired managed deny(s) removed`);
+    }
     if (permissionMerge.managedDenyEntries.length > 0) {
         console.log(
             `  Permissions: ${permissionMerge.addedCount} managed deny(s) added, `

package/bin/install.prune.test.mjs

@@ -37,6 +37,13 @@ const RUNTIME_ARTIFACT_RELATIVE_SEGMENTS = ['scripts', '__pycache__', 'helper.cp
 const DEPENDENCY_STUB_PACKAGE_SEGMENTS = ['@jl-cmd', 'prompt-generator'];
 const DEPENDENCY_SUPPLIED_SKILL_DIRECTORY = 'dependency-supplied-skill';
 const SCOPED_GROUP_SKILL_DIRECTORY = 'orchestrator';
+const CORE_REVIEW_GUIDE_SKILL_DIRECTORIES = [
+    'small-cl',
+    'comments',
+    'reviews',
+    'descriptions',
+    'emergencies',
+];
 const PRIOR_RUN_BACKUP_DIRECTORY_NAMES = [
     '2020-01-01T00-00-00-000Z',
     '2021-06-15T12-30-45-123Z',
@@ -829,6 +836,25 @@ test('a scoped --only install records the skill names it installed', () => {
     }
 });
 
+test('a scoped core install ships the canonical review guide skills', () => {
+    const sandbox = createSandbox();
+    try {
+        runInstaller(sandbox.homeDirectory, ['--only', 'core']);
+
+        const missingGuideSkillNames = CORE_REVIEW_GUIDE_SKILL_DIRECTORIES.filter(
+            eachSkillName => !existsSync(join(sandbox.skillsDirectory, eachSkillName, 'SKILL.md')),
+        );
+        assert.deepEqual(missingGuideSkillNames, []);
+
+        const recordedSkillNames = new Set(readManifest(sandbox.manifestPath).skills);
+        for (const eachSkillName of CORE_REVIEW_GUIDE_SKILL_DIRECTORIES) {
+            assert.equal(recordedSkillNames.has(eachSkillName), true);
+        }
+    } finally {
+        rmSync(sandbox.homeDirectory, { recursive: true, force: true });
+    }
+});
+
 test('the prune skip is scoped: once the dependency resolves a later full install prunes normally', () => {
     const sandbox = createSandbox();
     try {

package/bin/install.settings-defaults.test.mjs

@@ -26,12 +26,15 @@ const PACKAGE_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
 const PACKAGE_SETTINGS_PATH = join(PACKAGE_ROOT, 'settings.json');
 const INSTALL_ENTRY = join(PACKAGE_ROOT, 'bin', 'install.mjs');
 
-const EXPECTED_DENY_ENTRIES = [
+const EXPECTED_DENY_ENTRIES = [];
+const SAMPLE_MANAGED_DENY_ENTRIES = ['Edit($HOME/.claude/managed-test/**)'];
+const LEGACY_MANAGED_DENY_ENTRIES = [
     'Edit($HOME/.claude/verification/**)',
     'Write($HOME/.claude/code-review-stamps/**)',
     'Edit($HOME/.claude/code-review-stamps/**)',
     'MultiEdit($HOME/.claude/code-review-stamps/**)',
 ];
+const USER_OWNED_DENY_ENTRY = 'Bash(rm -rf /)';
 
 function packageDenyEntries() {
     const packageSettings = JSON.parse(readFileSync(PACKAGE_SETTINGS_PATH, 'utf8'));
@@ -53,19 +56,18 @@ function runInstallerInSandbox(sandboxHome, installerArguments = []) {
     });
 }
 
-test('package settings.json publishes exactly the four managed deny entries', () => {
+test('package settings.json publishes no managed deny entries', () => {
     const denyEntries = packageDenyEntries();
-    assert.equal(denyEntries.length, 4);
     assert.deepEqual(denyEntries, EXPECTED_DENY_ENTRIES);
 });
 
 test('an array-valued permissions field is replaced so managed denies survive a round trip', () => {
     const targetSettings = { permissions: [] };
-    const result = mergeManagedPermissionsIntoSettings(targetSettings, EXPECTED_DENY_ENTRIES);
-    assert.equal(result.addedCount, EXPECTED_DENY_ENTRIES.length);
+    const result = mergeManagedPermissionsIntoSettings(targetSettings, SAMPLE_MANAGED_DENY_ENTRIES);
+    assert.equal(result.addedCount, SAMPLE_MANAGED_DENY_ENTRIES.length);
     assert.equal(Array.isArray(targetSettings.permissions), false);
     const roundTripped = JSON.parse(JSON.stringify(targetSettings));
-    assert.deepEqual(roundTripped.permissions.deny, EXPECTED_DENY_ENTRIES);
+    assert.deepEqual(roundTripped.permissions.deny, SAMPLE_MANAGED_DENY_ENTRIES);
 });
 
 test('npm pack includes package settings.json in the published artifact', () => {
@@ -88,25 +90,28 @@ test('npm pack includes package settings.json in the published artifact', () =>
     );
 });
 
-test('mergeManagedPermissionsIntoSettings adds each package deny exactly once', () => {
+test('mergeManagedPermissionsIntoSettings adds each managed deny exactly once', () => {
     const target = {
         permissions: {
             allow: ['Bash(git status)'],
             deny: ['Bash(rm -rf /)'],
         },
     };
-    const first = mergeManagedPermissionsIntoSettings(target, EXPECTED_DENY_ENTRIES);
-    assert.equal(first.addedCount, 4);
+    const first = mergeManagedPermissionsIntoSettings(target, SAMPLE_MANAGED_DENY_ENTRIES);
+    assert.equal(first.addedCount, SAMPLE_MANAGED_DENY_ENTRIES.length);
     assert.equal(first.alreadyPresentCount, 0);
-    assert.equal(target.permissions.deny.filter((each) => EXPECTED_DENY_ENTRIES.includes(each)).length, 4);
+    const managedDenyCount = target.permissions.deny.filter((each) => (
+        SAMPLE_MANAGED_DENY_ENTRIES.includes(each)
+    )).length;
+    assert.equal(managedDenyCount, SAMPLE_MANAGED_DENY_ENTRIES.length);
     assert.ok(target.permissions.deny.includes('Bash(rm -rf /)'));
     assert.deepEqual(target.permissions.allow, ['Bash(git status)']);
 
-    const second = mergeManagedPermissionsIntoSettings(target, EXPECTED_DENY_ENTRIES);
+    const second = mergeManagedPermissionsIntoSettings(target, SAMPLE_MANAGED_DENY_ENTRIES);
     assert.equal(second.addedCount, 0);
-    assert.equal(second.alreadyPresentCount, 4);
+    assert.equal(second.alreadyPresentCount, SAMPLE_MANAGED_DENY_ENTRIES.length);
     assert.equal(
-        target.permissions.deny.filter((each) => each === EXPECTED_DENY_ENTRIES[0]).length,
+        target.permissions.deny.filter((each) => each === SAMPLE_MANAGED_DENY_ENTRIES[0]).length,
         1,
     );
 });
@@ -118,18 +123,18 @@ test('pruneManagedPermissionsFromSettings removes only package-owned deny entrie
             ask: ['Edit(./**)'],
             deny: [
                 'Bash(rm -rf /)',
-                ...EXPECTED_DENY_ENTRIES,
+                ...SAMPLE_MANAGED_DENY_ENTRIES,
             ],
         },
     };
-    const outcome = pruneManagedPermissionsFromSettings(target, EXPECTED_DENY_ENTRIES);
-    assert.equal(outcome.removedCount, 4);
+    const outcome = pruneManagedPermissionsFromSettings(target, SAMPLE_MANAGED_DENY_ENTRIES);
+    assert.equal(outcome.removedCount, SAMPLE_MANAGED_DENY_ENTRIES.length);
     assert.deepEqual(target.permissions.deny, ['Bash(rm -rf /)']);
     assert.deepEqual(target.permissions.allow, ['Bash(git status)']);
     assert.deepEqual(target.permissions.ask, ['Edit(./**)']);
 });
 
-test('sandbox install adds all four deny entries once and is idempotent on repeat', () => {
+test('sandbox install keeps default managed denies empty on repeat', () => {
     const sandboxHome = mkdtempSync(join(tmpdir(), 'cde-settings-defaults-'));
     try {
         const firstInstall = runInstallerInSandbox(sandboxHome, []);
@@ -139,30 +144,52 @@ test('sandbox install adds all four deny entries once and is idempotent on repea
         assert.ok(existsSync(settingsPath), 'settings.json written');
         const firstSettings = JSON.parse(readFileSync(settingsPath, 'utf8'));
         const firstDeny = firstSettings.permissions?.deny ?? [];
-        for (const eachEntry of EXPECTED_DENY_ENTRIES) {
-            assert.ok(firstDeny.includes(eachEntry), `missing deny: ${eachEntry}`);
-            assert.equal(
-                firstDeny.filter((candidate) => candidate === eachEntry).length,
-                1,
-                `deny not unique: ${eachEntry}`,
-            );
-        }
+        assert.deepEqual(firstDeny, EXPECTED_DENY_ENTRIES);
 
         const manifestPath = join(sandboxHome, '.claude', '.claude-dev-env-manifest.json');
         const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
-        assert.deepEqual(manifest.managedPermissions?.deny, EXPECTED_DENY_ENTRIES);
+        assert.deepEqual(manifest.managedPermissions?.deny ?? [], EXPECTED_DENY_ENTRIES);
 
         const secondInstall = runInstallerInSandbox(sandboxHome, []);
         assert.equal(secondInstall.status, 0, secondInstall.stderr || secondInstall.stdout);
         const secondSettings = JSON.parse(readFileSync(settingsPath, 'utf8'));
         const secondDeny = secondSettings.permissions?.deny ?? [];
-        for (const eachEntry of EXPECTED_DENY_ENTRIES) {
-            assert.equal(
-                secondDeny.filter((candidate) => candidate === eachEntry).length,
-                1,
-                `repeat install duplicated deny: ${eachEntry}`,
-            );
-        }
+        assert.deepEqual(secondDeny, EXPECTED_DENY_ENTRIES);
+    } finally {
+        rmSync(sandboxHome, { recursive: true, force: true });
+    }
+});
+
+test('a normal upgrade retires manifest-owned denies and preserves user entries', () => {
+    const sandboxHome = mkdtempSync(join(tmpdir(), 'cde-settings-upgrade-'));
+    try {
+        const initialInstall = runInstallerInSandbox(sandboxHome, []);
+        assert.equal(initialInstall.status, 0, initialInstall.stderr || initialInstall.stdout);
+
+        const settingsPath = join(sandboxHome, '.claude', 'settings.json');
+        const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+        settings.permissions = {
+            allow: ['Bash(git status)'],
+            ask: ['Edit(./**)'],
+            deny: [USER_OWNED_DENY_ENTRY, ...LEGACY_MANAGED_DENY_ENTRIES],
+        };
+        writeFileSync(settingsPath, JSON.stringify(settings, null, 4) + '\n');
+
+        const manifestPath = join(sandboxHome, '.claude', '.claude-dev-env-manifest.json');
+        const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+        manifest.managedPermissions = { deny: LEGACY_MANAGED_DENY_ENTRIES };
+        writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
+
+        const upgradedInstall = runInstallerInSandbox(sandboxHome, []);
+        assert.equal(upgradedInstall.status, 0, upgradedInstall.stderr || upgradedInstall.stdout);
+
+        const upgradedSettings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+        assert.deepEqual(upgradedSettings.permissions?.deny, [USER_OWNED_DENY_ENTRY]);
+        assert.deepEqual(upgradedSettings.permissions?.allow, ['Bash(git status)']);
+        assert.deepEqual(upgradedSettings.permissions?.ask, ['Edit(./**)']);
+
+        const upgradedManifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+        assert.equal(Object.hasOwn(upgradedManifest, 'managedPermissions'), false);
     } finally {
         rmSync(sandboxHome, { recursive: true, force: true });
     }

package/bin/install.test.mjs

@@ -953,7 +953,6 @@ const OLD_FOLDED_HOOKS_SETTINGS = {
                     { type: 'command', command: 'py -3 C:/Users/x/.claude/hooks/blocking/state_description_blocker.py', timeout: 10 },
                     { type: 'command', command: 'py -3 C:/Users/x/.claude/hooks/blocking/subprocess_budget_completeness.py', timeout: 10 },
                     { type: 'command', command: 'py -3 C:/Users/x/.claude/hooks/blocking/hook_prose_detector_consistency.py', timeout: 10 },
-                    { type: 'command', command: 'py -3 C:/Users/x/.claude/hooks/blocking/verified_commit_message_accuracy_blocker.py', timeout: 10 },
                 ],
             },
             {
@@ -971,8 +970,8 @@ const OLD_FOLDED_HOOKS_SETTINGS = {
 };
 
 
-test('FOLDED_HOOK_RELATIVE_PATHS contains all 16 hooks removed from hooks.json plus the retired md_to_html_blocker', () => {
-    assert.equal(FOLDED_HOOK_RELATIVE_PATHS.size, 17);
+test('FOLDED_HOOK_RELATIVE_PATHS contains all 15 hooks removed from hooks.json plus the retired md_to_html_blocker', () => {
+    assert.equal(FOLDED_HOOK_RELATIVE_PATHS.size, 16);
     assert.ok(FOLDED_HOOK_RELATIVE_PATHS.has('blocking/write_existing_file_blocker.py'));
     assert.ok(FOLDED_HOOK_RELATIVE_PATHS.has('blocking/plain_language_blocker.py'));
     assert.ok(FOLDED_HOOK_RELATIVE_PATHS.has('blocking/code_rules_enforcer.py'));
@@ -992,7 +991,6 @@ test('FOLDED_HOOK_RELATIVE_PATHS lists every hook the PreToolUse dispatcher host
         'blocking/state_description_blocker.py',
         'blocking/subprocess_budget_completeness.py',
         'blocking/hook_prose_detector_consistency.py',
-        'blocking/verified_commit_message_accuracy_blocker.py',
         'blocking/workflow_substitution_slot_blocker.py',
         'blocking/claude_md_orphan_file_blocker.py',
         'blocking/env_var_table_code_drift_blocker.py',

package/commands/CLAUDE.md

@@ -15,6 +15,7 @@ Slash-command definitions installed into `~/.claude/commands/` by `bin/install.m
 | `pr-comments.md` | `/pr-comments` | Fetches and formats PR review comments for response |
 | `review-plan.md` | `/review-plan` | Reviews the current plan packet against code standards |
 | `right-size.md` | `/right-size` | Checks an implementation against the Right-Sized Engineering rules |
+| `sr-loop.md` | `/sr-loop` | Runs the converging cleanup loop: /simplify passes until clean, then a code-review fix pass |
 | `sum.md` | `/sum` | Generates a formatted session summary for quick pickup in a new session |
 
 ## Format

package/commands/sr-loop.md

@@ -0,0 +1,52 @@
+---
+description: Converging cleanup loop - repeat /simplify until clean, then repeat /code-review --fix until clean
+argument-hint: [PR URL, branch, or blank for the current diff]
+---
+
+Run the converging cleanup loop on the target: `$ARGUMENTS` (blank means the
+current branch's diff). Each phase invokes an existing skill with the Skill
+tool and repeats it until a pass returns zero new findings.
+
+## Phase A — loop /simplify
+
+1. Invoke the `simplify` skill on the target (the same review the user gets
+   from `/simplify <target>`). Let it run its 4-lens fan-out and apply its
+   fixes.
+2. After each pass: run the scoped test suite (test files beside the touched
+   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.
+3. Repeat the invocation. **Skips are sticky:** carry every adjudicated skip
+   forward into the next pass as "already adjudicated — do not re-report: ..."
+   context, or the loop never converges.
+4. Phase A converges when a full pass returns zero new findings, or when a
+   pass's new findings are all nits — doc phrasing, naming, comment altitude,
+   or any fix below a behavior change. On a nit-only pass: apply the fixes,
+   test, commit, push, and stop with no confirming pass. When the previous
+   pass changed only a line or two, a single combined-lens confirmation agent
+   may serve as the final pass.
+
+## Phase B — loop /code-review low --fix
+
+1. Invoke the `code-review` skill with arguments `low --fix` on the same
+   target. Let it report findings and apply its fixes.
+2. After any pass that changed files: test, commit, push as in Phase A.
+3. Repeat until a pass reports zero findings, or until a pass reports only
+   nits — then fix, test, commit, push, and stop with no confirming pass.
+   Phase B usually converges in one pass when Phase A ran first.
+
+## Finish
+
+Report: passes run per phase, commits pushed with hashes, fixes applied, and
+the standing skip list with reasons.
+
+## Constraints (observed under headless runs)
+
+- Run this loop in the main session. A wrapper subagent cannot see the
+  `code-review` skill, and a nested agent's own subagent reports route to the
+  main session instead of back to it.
+- Scope test runs to the touched files; a full-suite run can outlive one
+  foreground tool call.
+- A hung or newly slow test suite is a finding to investigate, not an
+  inconvenience.

package/docs/CLAUDE.md

@@ -11,7 +11,6 @@ Reference documentation installed into `~/.claude/docs/` by `bin/install.mjs`. T
 | `BDD_DISCOVERY_PROTOCOL.md` | Example Mapping algorithm for discovery before implementation; based on Smart & Molak *BDD in Action* §6.4 |
 | `BDD_SCENARIO_QUALITY.md` | Seven scenario quality patterns (§7.6-style catalog) |
 | `BDD_TEST_LAYOUT.md` | `describe/when/should` test layout and soap-opera personas |
-| `PR_DESCRIPTION_GUIDE.md` | Authoritative reference for the `pr-description-writer` agent; PR body shapes derived from a 120-PR Anthropic corpus |
 | `DJANGO_PATTERNS.md` | Django-specific coding patterns |
 | `REACT_PATTERNS.md` | React-specific coding patterns |
 | `agent-spawn-protocol.md` | Full agent-spawn protocol behind the `rules/agent-spawn-protocol.md` kernel: context-sufficiency check, `/prompt-generator` prompt crafting, and the spawn step |

package/docs/references/CLAUDE.md

@@ -7,7 +7,6 @@ Pointer documents to external sources, standard terminology, and internal tool o
 | File | Purpose |
 |---|---|
 | `dead-code-elimination.md` | External sources and standard terms behind CODE_RULES §9.8 (remove code you orphan): DCE, tree shaking, reachability analysis, and the Lava Flow anti-pattern |
-| `code-review-enforcement.md` | How the code-review gates work: the two required efforts (push at low, PR creation at xhigh), the stamp bound to the branch-surface hash, the single sanctioned minter, the two-layer stamp-directory guard, and the bypass surfaces the gates leave open |
 | `prose-style-enforcement.md` | How `CLAUDE_PROSE_STYLE_ENFORCEMENT` arms opinionated prose gates (default off) while AskUserQuestion lean-block stays always on |
 | `advisor-tool.md` | Canonical consult bones for any stronger reviewer: when to call, hard rule before first write, how to treat advice; maps to the Anthropic advisor tool |
 | `team-advisor-skill.md` | `/team-advisor` map: sole-consumer warm bind, ref index, and advisor selection |

package/hooks/CLAUDE.md

@@ -8,7 +8,7 @@ Python hook scripts wired into Claude Code's lifecycle via `settings.json`. Each
 |---|---|
 | `advisory/` | Hooks that warn but do not block (`permissionDecision: "ask"`) |
 | `blocking/` | Hooks that deny tool calls when a rule is violated |
-| `blocking/config/` | Shared constants for the verified-commit gate family |
+| `blocking/config/` | Shared constants for blocking hooks |
 | `diagnostic/` | Hooks that record and extract hook-firing records into Neon |
 | `diagnostic/migrations/` | SQL migrations for the `hook_events` Neon schema |
 | `diagnostic/queries/` | Parameterized SQL queries for inspecting blocked commands |

package/hooks/blocking/CLAUDE.md

@@ -6,10 +6,7 @@ PreToolUse hooks that deny (block) tool calls when a rule is violated. The main
 
 | Directory | Role |
 |---|---|
-| `config/` | Shared constants for the verified-commit gate family (`verified_commit_constants.py`) |
 | `tdd_enforcer_parts/` | Concern modules the `tdd_enforcer.py` entry hook wires together: path classification, content analysis, candidate-path resolution, freshness, git-tracking restore detection, decisions, and constants |
-| `verified_commit_gate_parts/` | Concern modules the `verified_commit_gate.py` entry hook wires together: command tokenization, directory-change resolution, gated git-invocation resolution, deny-reason resolution, and deny-payload assembly |
-| `code_review_stamp_write_blocker_parts/` | Concern modules the `code_review_stamp_directory_write_blocker.py` entry hook wires together: the split directory-change-into-stamp matcher and the obfuscated-stamp-path-write matcher |
 | `claude_md_orphan_file_blocker_parts/` | Concern modules the `claude_md_orphan_file_blocker.py` entry hook wires together: reference extraction, subtree scan, scan plan, decision, and constants |
 | `package_inventory_stale_blocker_parts/` | Concern modules the `package_inventory_stale_blocker.py` entry hook wires together: inventory detection, decision, and constants |
 | `inventory_intent_records/` | The shared per-session pending-intent store both inventory blockers read to break the file/row add-order deadlock |
@@ -73,11 +70,6 @@ The check modules it calls are the `code_rules_<concern>.py` files below.
 | `block_main_commit.py` | PreToolUse (Bash) | `git commit`/`git push` directly to `main` |
 | `bot_mention_comment_blocker.py` | PreToolUse (Write/Edit) | PR review comments that @-mention a bot |
 | `claude_md_orphan_file_blocker.py` | PreToolUse (Write/Edit/MultiEdit) | Per-directory `CLAUDE.md` table cells naming a bare filename absent from the directory subtree |
-| `code_review_pr_create_gate.py` | PreToolUse (Bash/MCP GitHub) | `gh pr create` or the MCP `create_pull_request` tool without a clean `xhigh` code-review stamp covering the branch surface |
-| `code_review_push_gate.py` | PreToolUse (Bash/PowerShell) | `git push` without a clean `low` code-review stamp covering the branch surface |
-| `code_review_stamp_directory_write_blocker.py` | PreToolUse (Bash/PowerShell/Write/Edit/MultiEdit) | Shell or file-tool writes into `~/.claude/code-review-stamps/`, and shell references to the stamp store module or its mint call, outside the sanctioned invoker |
-| `code_verifier_spawn_preflight_gate.py` | PreToolUse (Agent) | Spawning the `code-verifier` subagent when the branch has a merge conflict vs its base or a CODE_RULES violation on a working-tree-added line, or the CODE_RULES engine fails to load |
-| `convergence_gate_blocker.py` | PreToolUse (Bash) | Convergence workflow actions on a conflicting PR |
 | `conventional_pr_title_gate.py` | PreToolUse (Bash) | `gh pr create`/`gh pr edit` with a `--title` that is not a Conventional Commit, in a repo whose CI runs a semantic-pull-request title check |
 | `destructive_command_blocker.py` | PreToolUse (Bash/PowerShell) | Shell commands with destructive literals (`rm -rf`, `git reset --hard`, etc.) |
 | `docstring_rule_gate_count_blocker.py` | PreToolUse (Write/Edit/MultiEdit) | A stale spelled-out gate-validator count in `docstring-prose-matches-implementation.md` — the "N more gate validators" / "M gated slices" count drifting from the `check_docstring_*` validators the prose names |
@@ -101,13 +93,10 @@ The check modules it calls are the `code_rules_<concern>.py` files below.
 | `pii_scanner.py` | library | Pure text scanners shared by `pii_prevention_blocker.py` |
 | `piped_pytest_blocker.py` | PreToolUse (Bash) | A pytest run whose output feeds a pipe, where the pipeline reports the exit code of the command on the right |
 | `plain_language_blocker.py` | PreToolUse (Write/Edit/AskUserQuestion) | Heavy or jargon words in user-facing prose when `CLAUDE_PROSE_STYLE_ENFORCEMENT` is on (default off); AskUserQuestion lean-block structure stays always on |
-| `pr_converge_bugteam_enforcer.py` | PreToolUse | Enforces that bugteam runs in parallel with bugbot in pr-converge loops |
-| `pr_description_enforcer.py` | PreToolUse (Bash) | `gh pr create`/`edit`/`comment` bodies that fail the Anthropic claude-code style audit, proof-shaped `gh pr comment` bodies missing proof-of-work parts, and `gh pr ready` while the PR carries no passing proof comment |
 | `precommit_code_rules_gate.py` | PreToolUse (Bash) | Staged changes that fail the CODE_RULES gate at commit time |
 | `pytest_testpaths_orphan_blocker.py` | PreToolUse (Write/Edit/MultiEdit) | New `test_*.py` files created under a directory absent from a package's explicit pytest `testpaths` allowlist |
 | `question_to_user_enforcer.py` | Stop | User-directed questions not routed through `AskUserQuestion` |
-| `reviewer_spawn_gate.py` | PreToolUse (Bash) | A sentinel-marked autoconverge reviewer-spawn command (Copilot review request, Bugbot rerun comment) run while `reviewer_availability.py` reports that reviewer down or out of quota |
-| `send_user_file_open_locally_blocker.py` | PreToolUse (SendUserFile) | A desk-side file attach (`SendUserFile` with `status` not `proactive`); points to opening the file locally via `Show-Asset.ps1` |
+| `send_user_file_open_locally_blocker.py` | PreToolUse (SendUserFile) | A desk-side file attach (`SendUserFile` with `status` not `proactive`); points to opening the file with its native Windows app |
 | `sensitive_file_protector.py` | PreToolUse (Write/Edit) | Writes to sensitive credential or config files |
 | `session_edit_stage_gate.py` | PreToolUse (Bash) | A `git commit` that would drop files edited this session because they are tracked but left unstaged |
 | `session_handoff_blocker.py` | Stop | Responses suggesting a new session mid-task |
@@ -117,10 +106,6 @@ The check modules it calls are the `code_rules_<concern>.py` files below.
 | `subprocess_budget_completeness.py` | PreToolUse | Subprocess calls missing required budget arguments |
 | `tdd_enforcer.py` | PreToolUse (Write/Edit) | Production code written without a matching failing test |
 | `unscoped_search_blocker.py` | PreToolUse (Bash/PowerShell) | A `find` or recursive listing that walks from the filesystem root, a drive root, bare home, or a network share root |
-| `verdict_directory_write_blocker.py` | PreToolUse (Bash/PowerShell) | Shell writes into `~/.claude/verification/` |
-| `verified_commit_gate.py` | PreToolUse (Bash/PowerShell) | `git commit`/`git push` without a passing verifier verdict |
-| `verified_commit_message_accuracy_blocker.py` | PreToolUse | Commit messages that misstate what the diff has |
-| `verifier_verdict_minter.py` | SubagentStop | Mints a passing verdict file when a `code-verifier` agent finishes cleanly |
 | `volatile_path_in_post_blocker.py` | PreToolUse (Bash/MCP GitHub) | `gh` post commands and GitHub MCP post tools whose body references a volatile path (job scratch dir, worktree, or system temp) that outlives the durable post |
 | `windows_rmtree_blocker.py` | PreToolUse (Write/Edit) | `shutil.rmtree` with `ignore_errors=True` on Windows |
 | `workflow_substitution_slot_blocker.py` | PreToolUse (Write/Edit) | Workflow templates with bare per-iteration tokens missing angle-bracket slots |
@@ -131,18 +116,8 @@ The check modules it calls are the `code_rules_<concern>.py` files below.
 | File | Role |
 |---|---|
 | `_gh_body_arg_utils.py` | Parsing helpers for `gh_body_arg_blocker.py` |
-| `code_review_enforcement_config_bootstrap.py` | Binds `config.code_review_enforcement_constants` to the sibling `config/` file by explicit location, so the code-review gate family resolves its constants regardless of a foreign `config` package's `sys.path` order |
-| `code_review_gate_deny.py` | Shared deny scaffold for the push and PR-create code-review gates: the `hookSpecificOutput` deny-payload builder and the log-and-emit helper, so both gates share one deny shape |
-| `code_review_stamp_store.py` | Reads and writes the per-work-tree code-review stamp files under `~/.claude/code-review-stamps/`, and decides whether a clean stamp at the needed effort covers the live branch surface |
-| `pr_description_body_audit.py` | Body audit logic for `pr_description_enforcer.py` |
-| `pr_description_command_parser.py` | `gh` command parsing for `pr_description_enforcer.py` |
-| `pr_description_pr_number.py` | PR number extraction logic |
-| `pr_description_proof_of_work.py` | Proof-of-work comment audit and `gh pr ready` gate logic for `pr_description_enforcer.py` |
-| `pr_description_readability.py` | Readability checks on PR description bodies |
-| `verification_verdict_store.py` | Reads and writes verdict files under `~/.claude/verification/` |
-| `verified_commit_config_bootstrap.py` | Binds `config.verified_commit_constants` to the sibling `config/` file by explicit location, so the gate family resolves its constants regardless of a foreign `config` package's `sys.path` order |
 
 ## Conventions
 
 - Tests live beside each hook as `test_<hookname>.py` or `test_<hookname>_<suffix>.py`. Run with `python -m pytest <test_file>`.
-- Tunable constants live in `hooks_constants/<hook_name>_constants.py`; the verified-commit family uses `blocking/config/verified_commit_constants.py`.
+- Tunable constants live in `hooks_constants/<hook_name>_constants.py`.

package/hooks/blocking/config/CLAUDE.md

@@ -1,22 +1,10 @@
 # hooks/blocking/config
 
-A Python package that holds shared constants for blocking hooks. Verified-commit gate modules and opinionated prose-style gates import from here.
+A Python package that holds shared constants for blocking hooks. Opinionated prose-style gates import from here.
 
 ## Key files
 
 | File | Contents |
 |---|---|
 | `__init__.py` | Declares this as a regular package (not a namespace package) so it resolves first on `sys.path` |
-| `code_review_enforcement_constants.py` | Stamp and effort tunables for the code-review enforcement gates |
 | `prose_style_enforcement_constants.py` | `CLAUDE_PROSE_STYLE_ENFORCEMENT` opt-in (default off) for opinionated prose gates |
-| `verified_commit_constants.py` | All tunables for the gate: directory names, regex patterns for detecting verdict paths and obfuscation attempts, timeout values, git subcommand sets, bypass marker, and corrective messages |
-| `verified_commit_context_constants.py` | `VERIFY_SKIP_ADDITIONAL_CONTEXT`, the ``# verify-skip`` usage rule the gate attaches to a deny payload's `additionalContext` |
-| `verified_commit_gate_output_constants.py` | `PRE_TOOL_USE_HOOK_EVENT_NAME` and `DENY_PERMISSION_DECISION` (the deny payload's event name and decision string), `GATE_HOOK_MODULE_NAME` (the gate's own module name for block logging), and `REGEX_ALTERNATION_SEPARATOR` (the `\|` join for the directory-change verb alternation in `gated_invocations.py`) |
-
-## Key constants in `verified_commit_constants.py`
-
-- `VERIFICATION_BYPASS_MARKER` — the `# verify-skip` comment that exempts a single commit/push from the gate
-- `MINTING_AGENT_TYPE` — `"code-verifier"`, the agent type whose SubagentStop hook mints verdicts
-- `VERDICT_DIRECTORY_NAME` — `"verification"`, the directory under `~/.claude/` that holds verdict JSON files
-- `DOCS_ONLY_EXTENSIONS` — extensions (`.md`, `.txt`, images) whose changes are mechanically exempt from the gate
-- `CORRECTIVE_MESSAGE` / `VERDICT_DIRECTORY_GUARD_MESSAGE` — user-facing block messages