claude-dev-env 1.92.1 → 1.93.0

package/hooks/validators/test_python_style_checks.py

@@ -1,27 +1,26 @@
 """Tests for Python style checks."""
 
 import ast
-import tempfile
+import os
+import subprocess
+import sys
 from pathlib import Path
-from typing import List
 
 import pytest
 
 from .python_style_checks import (
     Violation,
+    check_blank_lines_between_functions,
     check_imports_at_top,
     check_no_empty_line_after_decorators,
-    check_single_empty_line_between_functions,
     check_view_function_naming,
     fix_file,
+    fix_function_spacing,
     validate_file,
 )
 
-
-# Test data: Code samples
 GOOD_IMPORTS = '''import os
 import sys
-from typing import List
 
 def foo() -> None:
     pass
@@ -38,6 +37,13 @@ BAD_IMPORTS_AFTER_CONSTANT = '''MY_CONSTANT = 42
 import os
 '''
 
+ASYNC_BAD_INLINE_IMPORT = '''import asyncio
+
+async def foo() -> None:
+    import json
+    await asyncio.sleep(0)
+'''
+
 GOOD_DECORATOR_NO_BLANK = '''@decorator
 def foo() -> None:
     pass
@@ -49,9 +55,18 @@ def foo() -> None:
     pass
 '''
 
-GOOD_SINGLE_LINE_BETWEEN_FUNCTIONS = '''def foo() -> None:
+ASYNC_BAD_DECORATOR_WITH_BLANK = '''import asyncio
+
+@asyncio.coroutine
+
+async def foo() -> None:
+    pass
+'''
+
+GOOD_TWO_LINES_BETWEEN_FUNCTIONS = '''def foo() -> None:
     pass
 
+
 def bar() -> None:
     pass
 '''
@@ -62,14 +77,30 @@ def bar() -> None:
     pass
 '''
 
-BAD_MULTIPLE_LINES_BETWEEN_FUNCTIONS = '''def foo() -> None:
+BAD_ONE_LINE_BETWEEN_FUNCTIONS = '''def foo() -> None:
     pass
 
+def bar() -> None:
+    pass
+'''
+
+BAD_THREE_LINES_BETWEEN_FUNCTIONS = '''def foo() -> None:
+    pass
+
+
 
 def bar() -> None:
     pass
 '''
 
+ASYNC_GOOD_TWO_LINES_BETWEEN = '''async def foo() -> None:
+    pass
+
+
+async def bar() -> None:
+    pass
+'''
+
 GOOD_VIEW_NAMING = '''def user_profile_view(request):
     pass
 
@@ -80,77 +111,75 @@ def get_tasks_view(request, user_id):
 BAD_VIEW_NAMING = '''def user_profile(request):
     pass
 
-def getTasks(request, user_id):
+def get_tasks(request, user_id):
     pass
 '''
 
-GOOD_NON_VIEW_FUNCTION = '''def helper_function(data):
+GOOD_NON_VIEW_FUNCTION = '''def helper_function(payload):
     pass
 
-def process_data(items):
+def process_records(items):
     pass
 '''
 
-# Async function test samples
-ASYNC_GOOD_DECORATOR_NO_BLANK = '''import asyncio
+ASYNC_BAD_VIEW_NAMING = '''async def user_profile(request):
+    pass
 
-@asyncio.coroutine
-async def foo() -> None:
-    await asyncio.sleep(0)
+async def get_tasks(request, user_id):
+    pass
 '''
 
-ASYNC_BAD_DECORATOR_WITH_BLANK = '''import asyncio
+DECORATED_NEXT_TWO_LINES = '''def foo() -> None:
+    pass
 
-@asyncio.coroutine
 
-async def foo() -> None:
-    await asyncio.sleep(0)
+@decorator
+def bar() -> None:
+    pass
 '''
 
-ASYNC_GOOD_SINGLE_LINE_BETWEEN = '''import asyncio
-
-async def foo() -> None:
-    await asyncio.sleep(0)
+ONE_BLANK_BEFORE_DECORATED = '''def foo() -> None:
+    pass
 
-async def bar() -> None:
-    await asyncio.sleep(0)
+@decorator
+def bar() -> None:
+    pass
 '''
 
-ASYNC_BAD_MULTIPLE_LINES_BETWEEN = '''import asyncio
-
-async def foo() -> None:
-    await asyncio.sleep(0)
+COMMENT_BETWEEN_FUNCTIONS = '''def foo() -> None:
+    pass
 
 
-async def bar() -> None:
-    await asyncio.sleep(0)
+# helper comment
+def bar() -> None:
+    pass
 '''
 
-ASYNC_GOOD_VIEW_NAMING = '''from django.http import HttpRequest, HttpResponse
+CLASS_BETWEEN_FUNCTIONS = '''def foo() -> None:
+    pass
+
+
+class Middle:
+    pass
 
-async def user_profile_view(request: HttpRequest) -> HttpResponse:
-    return HttpResponse("profile")
 
-async def get_tasks_view(request: HttpRequest, user_id: int) -> HttpResponse:
-    return HttpResponse("tasks")
+def bar() -> None:
+    pass
 '''
 
-ASYNC_BAD_VIEW_NAMING = '''from django.http import HttpRequest, HttpResponse
+MODULE_STATEMENT_BETWEEN_FUNCTIONS = '''def foo() -> None:
+    pass
 
-async def user_profile(request: HttpRequest) -> HttpResponse:
-    return HttpResponse("profile")
 
-async def getTasks(request: HttpRequest, user_id: int) -> HttpResponse:
-    return HttpResponse("tasks")
-'''
+answer = 42
 
-ASYNC_BAD_INLINE_IMPORT = '''import asyncio
 
-async def foo() -> None:
-    import json
-    await asyncio.sleep(0)
+def bar() -> None:
+    pass
 '''
 
+FORM_FEED_BETWEEN_FUNCTIONS = "def foo():\n    pass\n\x0c\n\ndef bar():\n    pass\n"
+
 
 class TestImportsAtTop:
     """Test import positioning validation."""
@@ -203,13 +232,6 @@ class TestNoEmptyLineAfterDecorators:
         assert violations[0].line == 1
         assert "decorator" in violations[0].message.lower()
 
-    def test_async_no_blank_line_valid(self) -> None:
-        """Decorator directly above async function should pass."""
-        violations = check_no_empty_line_after_decorators(
-            ASYNC_GOOD_DECORATOR_NO_BLANK, "test.py"
-        )
-        assert violations == []
-
     def test_async_blank_line_after_decorator_fails(self) -> None:
         """Blank line after decorator on async function should fail."""
         violations = check_no_empty_line_after_decorators(
@@ -220,46 +242,74 @@ class TestNoEmptyLineAfterDecorators:
         assert "decorator" in violations[0].message.lower()
 
 
-class TestSingleEmptyLineBetweenFunctions:
+class TestBlankLinesBetweenFunctions:
     """Test function spacing validation."""
 
-    def test_single_line_valid(self) -> None:
-        """Exactly one blank line should pass."""
-        violations = check_single_empty_line_between_functions(
-            GOOD_SINGLE_LINE_BETWEEN_FUNCTIONS, "test.py"
+    def test_two_lines_valid(self) -> None:
+        """Exactly two blank lines should pass."""
+        violations = check_blank_lines_between_functions(
+            GOOD_TWO_LINES_BETWEEN_FUNCTIONS, "test.py"
         )
         assert violations == []
 
     def test_no_line_between_functions_fails(self) -> None:
         """No blank line should fail."""
-        violations = check_single_empty_line_between_functions(
+        violations = check_blank_lines_between_functions(
             BAD_NO_LINE_BETWEEN_FUNCTIONS, "test.py"
         )
         assert len(violations) == 1
         assert "empty line" in violations[0].message.lower()
 
-    def test_multiple_lines_between_functions_fails(self) -> None:
-        """Multiple blank lines should fail."""
-        violations = check_single_empty_line_between_functions(
-            BAD_MULTIPLE_LINES_BETWEEN_FUNCTIONS, "test.py"
+    def test_one_line_between_functions_fails(self) -> None:
+        """A single blank line should fail under the two-line rule."""
+        violations = check_blank_lines_between_functions(
+            BAD_ONE_LINE_BETWEEN_FUNCTIONS, "test.py"
+        )
+        assert len(violations) == 1
+        assert "empty line" in violations[0].message.lower()
+
+    def test_three_lines_between_functions_fails(self) -> None:
+        """Three or more blank lines should fail."""
+        violations = check_blank_lines_between_functions(
+            BAD_THREE_LINES_BETWEEN_FUNCTIONS, "test.py"
         )
         assert len(violations) == 1
         assert "empty line" in violations[0].message.lower()
 
-    def test_async_single_line_valid(self) -> None:
-        """Exactly one blank line between async functions should pass."""
-        violations = check_single_empty_line_between_functions(
-            ASYNC_GOOD_SINGLE_LINE_BETWEEN, "test.py"
+    def test_async_two_lines_valid(self) -> None:
+        """Exactly two blank lines between async functions should pass."""
+        violations = check_blank_lines_between_functions(
+            ASYNC_GOOD_TWO_LINES_BETWEEN, "test.py"
         )
         assert violations == []
 
-    def test_async_multiple_lines_fails(self) -> None:
-        """Multiple blank lines between async functions should fail."""
-        violations = check_single_empty_line_between_functions(
-            ASYNC_BAD_MULTIPLE_LINES_BETWEEN, "test.py"
+    def test_decorated_next_function_two_lines_valid(self) -> None:
+        """Two blanks before a decorated next function should pass."""
+        violations = check_blank_lines_between_functions(
+            DECORATED_NEXT_TWO_LINES, "test.py"
         )
-        assert len(violations) == 1
-        assert "empty line" in violations[0].message.lower()
+        assert violations == []
+
+    def test_comment_between_functions_passes(self) -> None:
+        """A comment in the gap leaves the surrounding functions unflagged."""
+        violations = check_blank_lines_between_functions(
+            COMMENT_BETWEEN_FUNCTIONS, "test.py"
+        )
+        assert violations == []
+
+    def test_class_between_functions_passes(self) -> None:
+        """An interposed class leaves the surrounding functions unflagged."""
+        violations = check_blank_lines_between_functions(
+            CLASS_BETWEEN_FUNCTIONS, "test.py"
+        )
+        assert violations == []
+
+    def test_module_statement_between_functions_passes(self) -> None:
+        """A module-level statement in the gap leaves the pair unflagged."""
+        violations = check_blank_lines_between_functions(
+            MODULE_STATEMENT_BETWEEN_FUNCTIONS, "test.py"
+        )
+        assert violations == []
 
 
 class TestViewFunctionNaming:
@@ -276,7 +326,7 @@ class TestViewFunctionNaming:
         tree = ast.parse(BAD_VIEW_NAMING)
         violations = check_view_function_naming(tree, "views.py")
         assert len(violations) == 2
-        assert all("_view" in v.message for v in violations)
+        assert all("_view" in each_violation.message for each_violation in violations)
 
     def test_non_view_file_ignored(self) -> None:
         """Non-views.py files should be ignored."""
@@ -290,63 +340,51 @@ class TestViewFunctionNaming:
         violations = check_view_function_naming(tree, "views.py")
         assert violations == []
 
-    def test_async_view_functions_named_correctly(self) -> None:
-        """Async view functions ending with _view should pass."""
-        tree = ast.parse(ASYNC_GOOD_VIEW_NAMING)
-        violations = check_view_function_naming(tree, "views.py")
-        assert violations == []
-
     def test_async_view_functions_without_suffix_fail(self) -> None:
         """Async view functions not ending with _view should fail."""
         tree = ast.parse(ASYNC_BAD_VIEW_NAMING)
         violations = check_view_function_naming(tree, "views.py")
         assert len(violations) == 2
-        assert all("_view" in v.message for v in violations)
+        assert all("_view" in each_violation.message for each_violation in violations)
 
 
 class TestValidateFile:
     """Test file validation integration."""
 
-    def test_valid_file_passes(self) -> None:
+    def test_valid_file_passes(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
         """File with no violations should pass."""
-        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
-            f.write(GOOD_IMPORTS)
-            f.flush()
-            temp_path = Path(f.name)
-
-        try:
-            violations = validate_file(temp_path)
-            assert violations == []
-        finally:
-            temp_path.unlink()
-
-    def test_invalid_file_returns_violations(self) -> None:
+        monkeypatch.setenv("HOME", str(tmp_path))
+        monkeypatch.setenv("TMPDIR", str(tmp_path))
+        temp_path = tmp_path / "valid_module.py"
+        temp_path.write_text(GOOD_IMPORTS, encoding="utf-8")
+        violations = validate_file(temp_path)
+        assert violations == []
+
+    def test_invalid_file_returns_violations(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
         """File with violations should return them."""
-        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
-            f.write(BAD_IMPORTS_AFTER_CODE)
-            f.flush()
-            temp_path = Path(f.name)
-
-        try:
-            violations = validate_file(temp_path)
-            assert len(violations) > 0
-            assert all(isinstance(v, Violation) for v in violations)
-        finally:
-            temp_path.unlink()
-
-    def test_syntax_error_returns_violation(self) -> None:
+        monkeypatch.setenv("HOME", str(tmp_path))
+        monkeypatch.setenv("TMPDIR", str(tmp_path))
+        temp_path = tmp_path / "invalid_module.py"
+        temp_path.write_text(BAD_IMPORTS_AFTER_CODE, encoding="utf-8")
+        violations = validate_file(temp_path)
+        assert len(violations) > 0
+        assert all(isinstance(each_violation, Violation) for each_violation in violations)
+
+    def test_syntax_error_returns_violation(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
         """File with syntax error should return violation."""
-        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
-            f.write("def foo(\n")  # Invalid syntax
-            f.flush()
-            temp_path = Path(f.name)
-
-        try:
-            violations = validate_file(temp_path)
-            assert len(violations) == 1
-            assert "syntax error" in violations[0].message.lower()
-        finally:
-            temp_path.unlink()
+        monkeypatch.setenv("HOME", str(tmp_path))
+        monkeypatch.setenv("TMPDIR", str(tmp_path))
+        temp_path = tmp_path / "broken_module.py"
+        temp_path.write_text("def foo(\n", encoding="utf-8")
+        violations = validate_file(temp_path)
+        assert len(violations) == 1
+        assert "syntax error" in violations[0].message.lower()
 
 
 class TestViolationClass:
@@ -354,22 +392,26 @@ class TestViolationClass:
 
     def test_violation_creation(self) -> None:
         """Violation should store file, line, message."""
-        v = Violation("test.py", 42, "Test message")
-        assert v.file == "test.py"
-        assert v.line == 42
-        assert v.message == "Test message"
+        violation = Violation("test.py", 42, "Test message")
+        assert violation.file == "test.py"
+        assert violation.line == 42
+        assert violation.message == "Test message"
 
     def test_violation_str_format(self) -> None:
         """Violation should format as file:line: message."""
-        v = Violation("test.py", 42, "Test message")
-        assert str(v) == "test.py:42: Test message"
+        violation = Violation("test.py", 42, "Test message")
+        assert str(violation) == "test.py:42: Test message"
 
 
 class TestAutoFix:
     """Test auto-fix capabilities."""
 
-    def test_fix_empty_line_after_decorator(self) -> None:
+    def test_fix_empty_line_after_decorator(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
         """Auto-fix should remove blank line between decorator and function."""
+        monkeypatch.setenv("HOME", str(tmp_path))
+        monkeypatch.setenv("TMPDIR", str(tmp_path))
         code = '''@decorator
 
 def foo():
@@ -379,59 +421,132 @@ def foo():
 def foo():
     pass
 '''
-        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as temp_file:
-            temp_file.write(code)
-            temp_path = Path(temp_file.name)
-
-        try:
-            fixed = fix_file(temp_path)
-            assert fixed is True
-            result = temp_path.read_text()
-            assert result.strip() == expected.strip()
-        finally:
-            temp_path.unlink()
-
-    def test_fix_multiple_blank_lines_between_functions(self) -> None:
-        """Auto-fix should collapse multiple blank lines to single."""
+        temp_path = tmp_path / "decorator_module.py"
+        temp_path.write_text(code, encoding="utf-8")
+        fixed = fix_file(temp_path)
+        assert fixed is True
+        result_text = temp_path.read_text()
+        assert result_text.strip() == expected.strip()
+
+    def test_fix_collapses_three_blank_lines_to_two(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Auto-fix should collapse three or more blank lines down to two."""
+        monkeypatch.setenv("HOME", str(tmp_path))
+        monkeypatch.setenv("TMPDIR", str(tmp_path))
         code = '''def foo():
     pass
 
 
+
 def bar():
     pass
 '''
         expected = '''def foo():
     pass
 
+
 def bar():
     pass
 '''
-        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as temp_file:
-            temp_file.write(code)
-            temp_path = Path(temp_file.name)
-
-        try:
-            fixed = fix_file(temp_path)
-            assert fixed is True
-            result = temp_path.read_text()
-            assert result.strip() == expected.strip()
-        finally:
-            temp_path.unlink()
-
-    def test_no_fix_needed_returns_false(self) -> None:
-        """Auto-fix should return False when no fixes needed."""
+        temp_path = tmp_path / "spacing_module.py"
+        temp_path.write_text(code, encoding="utf-8")
+        fixed = fix_file(temp_path)
+        assert fixed is True
+        result_text = temp_path.read_text()
+        assert result_text.strip() == expected.strip()
+
+    def test_fix_inserts_missing_blank_lines(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Auto-fix should insert blank lines for under-spaced functions."""
+        monkeypatch.setenv("HOME", str(tmp_path))
+        monkeypatch.setenv("TMPDIR", str(tmp_path))
+        temp_path = tmp_path / "underspaced_module.py"
+        temp_path.write_text(BAD_ONE_LINE_BETWEEN_FUNCTIONS, encoding="utf-8")
+        fixed = fix_file(temp_path)
+        assert fixed is True
+        assert temp_path.read_text() == GOOD_TWO_LINES_BETWEEN_FUNCTIONS
+
+    def test_no_fix_needed_returns_false(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Auto-fix should return False when the file already uses two blank lines."""
+        monkeypatch.setenv("HOME", str(tmp_path))
+        monkeypatch.setenv("TMPDIR", str(tmp_path))
         code = '''def foo():
     pass
 
+
 def bar():
     pass
 '''
-        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as temp_file:
-            temp_file.write(code)
-            temp_path = Path(temp_file.name)
-
-        try:
-            fixed = fix_file(temp_path)
-            assert fixed is False
-        finally:
-            temp_path.unlink()
+        temp_path = tmp_path / "clean_module.py"
+        temp_path.write_text(code, encoding="utf-8")
+        fixed = fix_file(temp_path)
+        assert fixed is False
+
+    def test_form_feed_gap_stays_check_clean_after_fix(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """A form feed in a blank gap converges without corrupting the file."""
+        monkeypatch.setenv("HOME", str(tmp_path))
+        monkeypatch.setenv("TMPDIR", str(tmp_path))
+        assert (
+            check_blank_lines_between_functions(FORM_FEED_BETWEEN_FUNCTIONS, "test.py")
+            == []
+        )
+        temp_path = tmp_path / "form_feed_module.py"
+        temp_path.write_text(FORM_FEED_BETWEEN_FUNCTIONS, encoding="utf-8")
+        fix_file(temp_path)
+        fixed_text = temp_path.read_text()
+        assert check_blank_lines_between_functions(fixed_text, "test.py") == []
+        assert fix_file(temp_path) is False
+
+
+class TestFixFunctionSpacing:
+    """Test blank-line normalization between top-level functions."""
+
+    def test_inserts_two_blank_lines_when_adjacent(self) -> None:
+        """Adjacent functions gain exactly two blank lines."""
+        fixed_source = fix_function_spacing(BAD_NO_LINE_BETWEEN_FUNCTIONS)
+        assert fixed_source == GOOD_TWO_LINES_BETWEEN_FUNCTIONS
+
+    def test_inserts_second_blank_line_when_one(self) -> None:
+        """A single blank line grows to exactly two."""
+        fixed_source = fix_function_spacing(BAD_ONE_LINE_BETWEEN_FUNCTIONS)
+        assert fixed_source == GOOD_TWO_LINES_BETWEEN_FUNCTIONS
+
+    def test_collapses_three_blank_lines_to_two(self) -> None:
+        """Three blank lines collapse to exactly two."""
+        fixed_source = fix_function_spacing(BAD_THREE_LINES_BETWEEN_FUNCTIONS)
+        assert fixed_source == GOOD_TWO_LINES_BETWEEN_FUNCTIONS
+
+    def test_normalizes_before_decorated_function(self) -> None:
+        """Blank lines before a decorated function normalize to two."""
+        fixed_source = fix_function_spacing(ONE_BLANK_BEFORE_DECORATED)
+        assert fixed_source == DECORATED_NEXT_TWO_LINES
+
+
+class TestDirectInvocation:
+    """Test running the checker as a standalone script."""
+
+    def test_direct_invocation_resolves_hooks_constants(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Direct invocation bootstraps hooks_constants without PYTHONPATH."""
+        monkeypatch.setenv("HOME", str(tmp_path))
+        monkeypatch.setenv("TMPDIR", str(tmp_path))
+        script_path = Path(__file__).resolve().parent / "python_style_checks.py"
+        target_path = tmp_path / "clean_sample.py"
+        target_path.write_text(GOOD_IMPORTS, encoding="utf-8")
+        scrubbed_environment = dict(os.environ)
+        scrubbed_environment.pop("PYTHONPATH", None)
+        completed_process = subprocess.run(
+            [sys.executable, "-S", str(script_path), str(target_path)],
+            capture_output=True,
+            text=True,
+            env=scrubbed_environment,
+        )
+        assert "ModuleNotFoundError" not in completed_process.stderr
+        assert completed_process.returncode == 0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "1.92.1",
+    "version": "1.93.0",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {
@@ -36,7 +36,7 @@
     "license": "MIT",
     "repository": {
         "type": "git",
-        "url": "git+https://github.com/jl-cmd/claude-code-config.git",
+        "url": "git+https://github.com/jl-cmd/claude-dev-env.git",
         "directory": "packages/claude-dev-env"
     }
 }

package/rules/CLAUDE.md

@@ -30,10 +30,11 @@ Rule files installed into `~/.claude/rules/` by `bin/install.mjs`. Claude Code l
 | `git-workflow.md` | PR workflow: always create as draft, one commit per review stage, never commit working docs or images |
 | `hook-prose-matches-detector.md` | Hook prose descriptions match what the hook actually detects |
 | `long-horizon-autonomy.md` | Autonomous-run behaviors: act on what you have, do not end on a promise, delegate and keep working |
-| `nas-ssh-invocation.md` | Reach the NAS at `192.168.1.100` through the `System32/OpenSSH` binary with `-o BatchMode=yes`; bare `ssh`/`scp`/`sftp` stalls on an interactive password prompt |
+| `nas-ssh-invocation.md` | Reach the NAS through the `System32/OpenSSH` binary with `-o BatchMode=yes`; bare `ssh`/`scp`/`sftp` stalls on an interactive password prompt |
 | `no-cross-skill-duplicate-helpers.md` | No duplicating shared helpers across skills; use `_shared/` |
 | `no-historical-clutter.md` | Documentation describes current state only; no historical or transitional language |
 | `no-inline-destructive-literals.md` | No destructive-command literals in Bash tool command strings, even as data |
+| `no-justification-noise.md` | Markdown states facts a reader can act on; cut a present-tense sentence that only justifies a stated choice or restates a gain the reader already works out from the behavior or from a rule enforced elsewhere |
 | `env-var-table-code-drift.md` | Every env-var summary table row in a `.md` file names a code file whose source references the variable |
 | `es-exe-file-search.md` | File search on Windows routes through the `es.exe` CLI with a scoped query; the Everything HTTP server stays off |
 | `orphan-css-class.md` | Every `class="..."` attribute in Python-generated markup has a matching selector in the `<style>` block |

package/rules/bdd.md

@@ -2,7 +2,7 @@
 
 **Canonical detail:** `~/.claude/system-prompts/software-engineer.xml` → `<behavior_protocol>`.
 
-**On-demand depth:** `@~/.claude/skills/bdd-protocol/SKILL.md` (Example Mapping §6.4, §7.6 catalog, solo patterns). Tracking design: [jl-cmd/claude-code-config#82](https://github.com/jl-cmd/claude-code-config/issues/82).
+**On-demand depth:** `@~/.claude/skills/bdd-protocol/SKILL.md` (Example Mapping §6.4, §7.6 catalog, solo patterns). Tracking design: [jl-cmd/claude-dev-env#82](https://github.com/jl-cmd/claude-dev-env/issues/82).
 
 **Optional long-form references (load when needed):**