claude-dev-env 1.65.1 → 1.66.1

package/agents/plan-packet-validator.md

@@ -0,0 +1,34 @@
+---
+name: plan-packet-validator
+description: Fresh-context validator for workflow-generated plan packets. Use after a plan packet is written under docs/plans/<slug>/ to verify source accuracy, completeness, TDD readiness, scope control, handoff quality, and no invented repo behavior. Read-only; never edits files.
+tools: Read, Grep, Glob, Bash
+model: inherit
+color: purple
+---
+
+You validate plan packets. You are not the planner and you do not repair docs.
+
+## Rules
+
+- Never edit files.
+- Require each material claim to be source-backed, user-confirmed, or explicitly listed as a packet assumption.
+- Treat every packet claim as untrusted until you verify it against source files, repo docs, user-confirmed decisions, or packet assumptions.
+- Return findings only for problems that would make a blind build agent implement the wrong thing or need to rediscover core context.
+- Do not raise style-only findings.
+
+## Checks
+
+1. Read `README.md`, `packet.json`, `context/source-map.md`, `implementation/steps.md`, `implementation/tdd-plan.md`, `spec/acceptance.md`, and `handoff/build-prompt.md`.
+2. Read or search the source files named in `source-map.md` and `packet.json`.
+3. Verify referenced paths exist unless the packet clearly labels them as new files.
+4. Verify source facts match actual files.
+5. Verify the implementation steps are enough for a blind build agent.
+6. Verify the TDD sequence starts with failing tests and names the behavior those tests prove.
+7. Verify scope matches the user request and non-goals.
+8. Verify no commands, APIs, schemas, hooks, workflows, agents, or repo conventions are invented.
+9. Verify acceptance criteria prove the requested behavior end to end.
+10. Verify `handoff/build-prompt.md` stands alone without chat history.
+
+## Output
+
+Return the requested structured schema. Set `allPassed` to true only when every check is clean. Each finding must name the packet file, the check, and the exact source-grounded problem.

package/audit-rubrics/category_rubrics/category-n-test-name-scenario-verifier.md

@@ -37,6 +37,12 @@ Customize per-artifact: a pure-function test corpus with no scenario claims redu
 
 ---
 
+## Write-time advisory for the flag-gated N1 slice
+
+`check_flag_gated_scenario_test_naming` in `code_rules_test_assertions.py` (wired into `code_rules_enforcer.py`) catches the deterministic N1 slice at Write/Edit time. When two or more sibling tests in a file `monkeypatch.setattr` the same module-level UPPER_SNAKE flag, that flag governs which branch the code under test runs. A `test_*` whose name carries a scenario clause (`_when_`, `_passes`, `_succeeds`, `_on_clean`) but never patches that flag runs under the flag's default value, so its named condition may not be in effect. The check prints an advisory to stderr and never blocks the write — the breadth of the sibling-pattern heuristic suits a judgment lane, where the author decides whether to patch the flag (and assert the gated path runs) or rename the test. The audit still owns the full N1–N10 surface; the advisory only surfaces this one mechanically-detectable shape early.
+
+---
+
 ## Sample prompt
 
 The reusable Variant C template for Category N is in [`../prompts/category-n-test-name-scenario-verifier.md`](../prompts/category-n-test-name-scenario-verifier.md). Inline every changed test function under `## Source material` along with the production function it claims to cover, so the audit can compare the named scenario against the body's act phase.

package/commands/plan.md

@@ -1,60 +1,14 @@
-Plan a feature with full validation workflow.
+Plan a feature through the workflow-backed `anthropic-plan` skill.
 
-> **MANDATORY:** Load `~/.claude/docs/CODE_RULES.md` for all code standards.
+Invoke `anthropic-plan` with the user request. The skill launches the Claude Code Workflow at:
 
-## Workflow (MANDATORY - NO SKIPPING STEPS)
+`$HOME/.claude/skills/anthropic-plan/workflow/plan-packet.mjs`
 
-### Phase 1: Design
-1. **Invoke `plan` skill** - Discover configs, design through dialogue
+The workflow creates a validated `docs/plans/<slug>/` packet, spawns the fresh `plan-packet-validator` agent, repairs packet findings, and stops before implementation.
 
-### Phase 2: Plan
-2. **Invoke `write-plan` skill** - Create detailed TDD implementation plan (CODE_RULES.md compliant)
-3. **Invoke `review-plan` skill** - Validate plan against CODE_RULES.md standards
-4. **Fix violations** - If review-plan finds issues, fix before proceeding
+Usage:
 
-### Phase 3: Approval (NEW PRs only)
-5. **Invoke `plan-checkpoint` skill** - Generate summary gist for reviewer approval
-6. **Wait for approval** - Do not proceed until approved
-
-### Phase 4: Execute
-7. **Invoke `plan-executor` agent** - Execute with full standards enforcement
-8. **Invoke `readability-review` skill** - Validate written code against CODE_RULES.md
-
-### Phase 5: Commit & Review
-9. **Invoke `/commit`** - Create atomic commits
-10. **Push branch** - Push to GitHub (NO PR yet); the git pre-push hook installed via `npx claude-dev-env` fires automatically and blocks on any violation
-11. **Wait for commit review** - User reviews on GitHub
-12. **Create PR** - Only after user approves commit
-
-## Key Rules
-
-- NEVER offer execution until review-plan passes with ZERO violations
-- For NEW PRs: wait for reviewer approval on checkpoint before implementing
-- For PR REVIEW FIXES: skip checkpoint, proceed directly to execution
-- NEVER push if the git pre-push hook fails (it fires automatically via `npx claude-dev-env`)
-- NEVER create PR until user explicitly approves pushed commit
-
-## Skills & Agents Reference
-
-| Step | Tool | Purpose |
-|------|------|---------|
-| Design | `plan` skill | Collaborative design with config discovery |
-| Write | `write-plan` skill | TDD plan with CODE_RULES.md compliance |
-| Review Plan | `review-plan` skill | Validate plan against standards |
-
-## Standards Reference
-
-All code quality standards are in `~/.claude/docs/CODE_RULES.md`:
-- Self-documenting code (no comments)
-- Centralized configs (reuse existing)
-- No magic values
-- No abbreviations
-- Complete type hints
-- All imports shown
-
-## Usage
-
-```
+```text
 /plan add user authentication
 /plan refactor the payment system
 ```

package/hooks/blocking/code_rules_enforcer.py

@@ -117,6 +117,7 @@ from code_rules_string_magic import (  # noqa: E402
 from code_rules_test_assertions import (  # noqa: E402
     check_constant_equality_tests,
     check_existence_check_tests,
+    check_flag_gated_scenario_test_naming,
     check_skip_decorators_in_tests,
 )
 from code_rules_test_branching_except import (  # noqa: E402
@@ -274,6 +275,7 @@ def validate_content(
         )
         all_issues.extend(check_existence_check_tests(content, file_path))
         all_issues.extend(check_constant_equality_tests(content, file_path))
+        check_flag_gated_scenario_test_naming(content, file_path)
         all_issues.extend(check_unused_optional_parameters(content, file_path))
         all_issues.extend(check_collection_prefix(content, file_path))
         all_issues.extend(check_stuttering_collection_prefix(content, file_path))

package/hooks/blocking/code_rules_test_assertions.py

@@ -1,9 +1,12 @@
-"""Skip-decorator, existence-only, and constant-equality test-quality checks."""
+"""Skip-decorator, existence-only, constant-equality, and flag-gated scenario test-quality checks."""
 
 import ast
 import sys
 from pathlib import Path
 
+_SCENARIO_NAME_CLAUSES = ("_when_", "_passes", "_succeeds", "_on_clean")
+_MINIMUM_SIBLING_PATCH_COUNT = 2
+
 _BLOCKING_DIRECTORY = str(Path(__file__).resolve().parent)
 _HOOKS_DIRECTORY = str(Path(__file__).resolve().parent.parent)
 if _BLOCKING_DIRECTORY not in sys.path:
@@ -224,3 +227,122 @@ def check_constant_equality_tests(content: str, file_path: str) -> list[str]:
             )
 
     return issues
+
+
+def _flag_symbol_from_setattr_target(target_node: ast.expr) -> str | None:
+    """Return the UPPER_SNAKE flag symbol a monkeypatch.setattr target names.
+
+    Accepts both target shapes monkeypatch.setattr supports: a dotted string
+    path (``"pkg.module.FLAG"``) and an attribute access (``module.FLAG``). The
+    flag is the final dotted segment when that segment is UPPER_SNAKE_CASE; any
+    other segment shape returns None so only module-level boolean flags qualify.
+
+    Args:
+        target_node: The first positional argument of a ``monkeypatch.setattr``
+            call.
+
+    Returns:
+        The UPPER_SNAKE flag name, or None when the target names no such symbol.
+    """
+    if isinstance(target_node, ast.Constant) and isinstance(target_node.value, str):
+        final_segment = target_node.value.rsplit(".", 1)[-1]
+        return final_segment if _is_upper_snake_name(final_segment) else None
+    if isinstance(target_node, ast.Attribute):
+        return target_node.attr if _is_upper_snake_name(target_node.attr) else None
+    return None
+
+
+def _is_monkeypatch_setattr(call_node: ast.Call) -> bool:
+    """Return True when a Call node is a ``monkeypatch.setattr(...)`` invocation."""
+    function_reference = call_node.func
+    return (
+        isinstance(function_reference, ast.Attribute)
+        and function_reference.attr == "setattr"
+        and isinstance(function_reference.value, ast.Name)
+        and function_reference.value.id == "monkeypatch"
+    )
+
+
+def _flags_patched_in_test(function_node: ast.FunctionDef | ast.AsyncFunctionDef) -> set[str]:
+    """Return the set of UPPER_SNAKE flag symbols a test patches via monkeypatch.setattr."""
+    patched_flags: set[str] = set()
+    for each_node in ast.walk(function_node):
+        if not isinstance(each_node, ast.Call):
+            continue
+        if not _is_monkeypatch_setattr(each_node) or not each_node.args:
+            continue
+        flag_symbol = _flag_symbol_from_setattr_target(each_node.args[0])
+        if flag_symbol is not None:
+            patched_flags.add(flag_symbol)
+    return patched_flags
+
+
+def _name_encodes_scenario(test_name: str) -> bool:
+    """Return True when a test name carries a scenario clause asserting a condition."""
+    return any(each_clause in test_name for each_clause in _SCENARIO_NAME_CLAUSES)
+
+
+def check_flag_gated_scenario_test_naming(content: str, file_path: str) -> list[str]:
+    """Flag a scenario-named test that omits a flag its siblings establish.
+
+    When two or more sibling tests in a file monkeypatch the same module-level
+    UPPER_SNAKE flag, that flag governs which branch the code under test runs.
+    A test whose name asserts a scenario (``_when_``, ``_passes``, ``_succeeds``,
+    ``_on_clean``) but never patches that flag runs under the flag's default
+    value, so its named condition may not be in effect — the audit category N
+    test-name-scenario mismatch. Advisory only; emitted to stderr, never blocks.
+    Only applies to test files; production files are exempt.
+
+    Args:
+        content: The file body under validation.
+        file_path: Path to the file, used for the test-file gate.
+
+    Returns:
+        An empty list; advisories print to stderr so the write proceeds.
+    """
+    if not is_test_file(file_path):
+        return []
+
+    try:
+        syntax_tree = ast.parse(content)
+    except SyntaxError:
+        return []
+
+    test_functions = [
+        each_node
+        for each_node in ast.walk(syntax_tree)
+        if isinstance(each_node, (ast.FunctionDef, ast.AsyncFunctionDef))
+        and each_node.name.startswith("test")
+    ]
+    flags_patched_by_test = {
+        each_test.name: _flags_patched_in_test(each_test) for each_test in test_functions
+    }
+    sibling_patch_count_by_flag: dict[str, int] = {}
+    for patched_flags in flags_patched_by_test.values():
+        for each_flag in patched_flags:
+            sibling_patch_count_by_flag[each_flag] = (
+                sibling_patch_count_by_flag.get(each_flag, 0) + 1
+            )
+    established_flags = {
+        each_flag
+        for each_flag, patch_count in sibling_patch_count_by_flag.items()
+        if patch_count >= _MINIMUM_SIBLING_PATCH_COUNT
+    }
+    if not established_flags:
+        return []
+
+    for each_test in test_functions:
+        if not _name_encodes_scenario(each_test.name):
+            continue
+        unpatched_flags = established_flags - flags_patched_by_test[each_test.name]
+        if unpatched_flags:
+            flag_list = ", ".join(sorted(unpatched_flags))
+            print(
+                f"ADVISORY [CODE_RULES] Line {each_test.lineno}: scenario test"
+                f" {each_test.name!r} never patches {flag_list}, which sibling tests"
+                f" establish — the named scenario may run under the flag default."
+                f" Patch the flag (and assert the gated path runs) or rename the test.",
+                file=sys.stderr,
+            )
+
+    return []

package/hooks/blocking/open_questions_in_plans_blocker.py

@@ -1,7 +1,8 @@
 #!/usr/bin/env python3
 """PreToolUse:Write|Edit|MultiEdit hook — blocks plan files that contain an "Open Questions" section.
 
-Plans under `~/.claude/plans/` (or any `.claude/plans/` directory) must not be
+Plans under `~/.claude/plans/` (or any `.claude/plans/` directory) and packet
+docs under any repo-local `docs/plans/` directory must not be
 written with an unresolved "Open Questions" section. When detected, the agent is
 forced to (1) investigate the codebase for answers itself first, then (2) confirm
 its interpretations via the AskUserQuestion tool in plain everyday language, and
@@ -20,6 +21,8 @@ if _hooks_dir not in sys.path:
 
 from hooks_constants.open_questions_in_plans_blocker_constants import (  # noqa: E402
     CODE_FENCE_PATTERN,
+    DOCS_PLANS_PATH_PREFIX,
+    DOCS_PLANS_PATH_SEGMENT,
     INLINE_CODE_PATTERN,
     MARKDOWN_EXTENSION,
     OPEN_QUESTIONS_HEADING_PATTERN,
@@ -41,6 +44,10 @@ def _is_inside_plans_directory(file_path: str) -> bool:
         return True
     if normalized.startswith(PLANS_PATH_PREFIX):
         return True
+    if DOCS_PLANS_PATH_SEGMENT in normalized:
+        return True
+    if normalized.startswith(DOCS_PLANS_PATH_PREFIX):
+        return True
     return False
 
 

package/hooks/blocking/test_code_rules_enforcer_split_test_assertions.py

@@ -6,6 +6,8 @@ import sys
 from pathlib import Path
 from types import SimpleNamespace
 
+import pytest
+
 _BLOCKING_DIRECTORY = str(Path(__file__).resolve().parent)
 _HOOKS_DIRECTORY = str(Path(__file__).resolve().parent.parent)
 if _BLOCKING_DIRECTORY not in sys.path:
@@ -15,14 +17,34 @@ if _HOOKS_DIRECTORY not in sys.path:
 
 from code_rules_test_assertions import (  # noqa: E402
     check_constant_equality_tests,
+    check_flag_gated_scenario_test_naming,
 )
 
 code_rules_enforcer = SimpleNamespace(
     check_constant_equality_tests=check_constant_equality_tests,
+    check_flag_gated_scenario_test_naming=check_flag_gated_scenario_test_naming,
 )
 
 
 CONSTANT_EQUALITY_TEST_FILE_PATH = "packages/app/tests/test_constants.py"
+SCENARIO_TEST_FILE_PATH = "packages/app/tests/test_submission_runner_loop.py"
+
+_THREE_SIBLINGS_PATCH_THE_FLAG_ONE_SCENARIO_TEST_DOES_NOT = (
+    "def test_should_submit_when_gate_passes(monkeypatch) -> None:\n"
+    "    assert run() == 'submitted'\n"
+    "\n"
+    "def test_should_fail_when_reader_raises(monkeypatch) -> None:\n"
+    "    monkeypatch.setattr('pkg.pipeline.IS_STAGED_VERIFICATION_ENABLED', True)\n"
+    "    assert run() == 'failed'\n"
+    "\n"
+    "def test_should_soft_skip_when_mismatch(monkeypatch) -> None:\n"
+    "    monkeypatch.setattr('pkg.pipeline.IS_STAGED_VERIFICATION_ENABLED', True)\n"
+    "    assert run() == 'skipped'\n"
+    "\n"
+    "def test_should_hard_stop_when_unhealthy(monkeypatch) -> None:\n"
+    "    monkeypatch.setattr('pkg.pipeline.IS_STAGED_VERIFICATION_ENABLED', True)\n"
+    "    assert run() == 'hard_stop'\n"
+)
 
 
 def test_should_not_flag_two_named_constants_compared_to_each_other() -> None:
@@ -54,3 +76,71 @@ def test_should_flag_named_constant_compared_to_literal() -> None:
     assert any("constant-value test" in issue for issue in issues), (
         f"Expected flag when UPPER_SNAKE compared to literal, got: {issues}"
     )
+
+
+def test_should_advise_when_scenario_test_omits_flag_its_siblings_patch(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    issues = code_rules_enforcer.check_flag_gated_scenario_test_naming(
+        _THREE_SIBLINGS_PATCH_THE_FLAG_ONE_SCENARIO_TEST_DOES_NOT,
+        SCENARIO_TEST_FILE_PATH,
+    )
+    advisory_text = capsys.readouterr().err
+    assert issues == [], "Advisory check must never add a blocking issue"
+    assert "test_should_submit_when_gate_passes" in advisory_text, (
+        f"Expected an advisory naming the un-patched scenario test, got: {advisory_text!r}"
+    )
+    assert "IS_STAGED_VERIFICATION_ENABLED" in advisory_text, (
+        f"Expected the advisory to name the established flag, got: {advisory_text!r}"
+    )
+
+
+def test_should_stay_silent_when_scenario_test_patches_the_flag(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    source = (
+        "def test_should_submit_when_gate_passes(monkeypatch) -> None:\n"
+        "    monkeypatch.setattr('pkg.pipeline.IS_STAGED_VERIFICATION_ENABLED', True)\n"
+        "    assert run() == 'submitted'\n"
+        "\n"
+        "def test_should_fail_when_reader_raises(monkeypatch) -> None:\n"
+        "    monkeypatch.setattr('pkg.pipeline.IS_STAGED_VERIFICATION_ENABLED', True)\n"
+        "    assert run() == 'failed'\n"
+    )
+    issues = code_rules_enforcer.check_flag_gated_scenario_test_naming(
+        source, SCENARIO_TEST_FILE_PATH
+    )
+    advisory_text = capsys.readouterr().err
+    assert issues == []
+    assert advisory_text == "", (
+        f"Expected silence when the scenario test patches the flag, got: {advisory_text!r}"
+    )
+
+
+def test_should_stay_silent_when_only_one_sibling_patches_the_flag(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    source = (
+        "def test_should_submit_when_gate_passes(monkeypatch) -> None:\n"
+        "    assert run() == 'submitted'\n"
+        "\n"
+        "def test_should_fail_when_reader_raises(monkeypatch) -> None:\n"
+        "    monkeypatch.setattr('pkg.pipeline.IS_STAGED_VERIFICATION_ENABLED', True)\n"
+        "    assert run() == 'failed'\n"
+    )
+    issues = code_rules_enforcer.check_flag_gated_scenario_test_naming(
+        source, SCENARIO_TEST_FILE_PATH
+    )
+    advisory_text = capsys.readouterr().err
+    assert issues == []
+    assert advisory_text == "", (
+        f"One sibling patch is not an established flag; expected silence, got: {advisory_text!r}"
+    )
+
+
+def test_should_not_advise_for_production_file() -> None:
+    issues = code_rules_enforcer.check_flag_gated_scenario_test_naming(
+        _THREE_SIBLINGS_PATCH_THE_FLAG_ONE_SCENARIO_TEST_DOES_NOT,
+        "packages/app/services/submission_pipeline.py",
+    )
+    assert issues == []

package/hooks/blocking/test_open_questions_in_plans_blocker.py

@@ -1,5 +1,6 @@
 """Tests for open_questions_in_plans_blocker hook."""
 
+import ast
 import json
 import os
 import subprocess
@@ -10,6 +11,13 @@ HOOK_SCRIPT_PATH = os.path.join(
     os.path.dirname(__file__), "open_questions_in_plans_blocker.py"
 )
 
+
+def _read_hook_module_docstring() -> str:
+    source_text = open(HOOK_SCRIPT_PATH, encoding="utf-8").read()
+    module_docstring = ast.get_docstring(ast.parse(source_text))
+    assert module_docstring is not None
+    return module_docstring
+
 _plan_with_open_questions = (
     "## Context\nA plan.\n\n## Open Questions\n- Which auth provider?\n"
 )
@@ -75,6 +83,41 @@ def test_blocks_project_local_plans_directory():
     assert output["hookSpecificOutput"]["permissionDecision"] == "deny"
 
 
+def test_module_docstring_names_docs_plans_directory_family():
+    """The docstring enumerates every directory family the detector fires on,
+    including the repo-local `docs/plans/` family it now blocks."""
+    module_docstring = _read_hook_module_docstring()
+
+    assert "docs/plans/" in module_docstring
+
+
+def test_blocks_repo_docs_plan_packet_directory():
+    """Repo-local `docs/plans/<slug>/` packet docs are plan files too."""
+    result = _run_hook(
+        "Write",
+        {
+            "file_path": "docs/plans/add-login/spec/scope.md",
+            "content": _plan_with_open_questions,
+        },
+    )
+    assert result.returncode == 0
+    output = json.loads(result.stdout)
+    assert output["hookSpecificOutput"]["permissionDecision"] == "deny"
+
+
+def test_blocks_windows_style_repo_docs_plan_packet_directory():
+    result = _run_hook(
+        "Write",
+        {
+            "file_path": "docs\\plans\\add-login\\spec\\scope.md",
+            "content": _plan_with_open_questions,
+        },
+    )
+    assert result.returncode == 0
+    output = json.loads(result.stdout)
+    assert output["hookSpecificOutput"]["permissionDecision"] == "deny"
+
+
 def test_blocks_case_insensitive_heading():
     result = _run_hook(
         "Write",

package/hooks/hooks_constants/code_rules_path_utils_constants.py

@@ -13,6 +13,7 @@ from __future__ import annotations
 
 ALL_CONFIG_DIRECTORY_NAMES = frozenset(
     {
+        "anthropic_plan_scripts_constants",
         "config",
         "hooks_constants",
         "git_hooks_constants",

package/hooks/hooks_constants/open_questions_in_plans_blocker_constants.py

@@ -9,6 +9,8 @@ MARKDOWN_EXTENSION: str = ".md"
 
 PLANS_PATH_SEGMENT: str = "/.claude/plans/"
 PLANS_PATH_PREFIX: str = ".claude/plans/"
+DOCS_PLANS_PATH_SEGMENT: str = "/docs/plans/"
+DOCS_PLANS_PATH_PREFIX: str = "docs/plans/"
 
 PLAN_FILE_ENCODING: str = "utf-8"
 
@@ -25,6 +27,8 @@ INLINE_CODE_PATTERN: Pattern[str] = compile(r"``[^`\n]+``|`[^`\n]+`")
 
 __all__ = [
     "CODE_FENCE_PATTERN",
+    "DOCS_PLANS_PATH_PREFIX",
+    "DOCS_PLANS_PATH_SEGMENT",
     "INLINE_CODE_PATTERN",
     "MARKDOWN_EXTENSION",
     "OPEN_QUESTIONS_HEADING_PATTERN",

package/hooks/hooks_constants/test_open_questions_in_plans_blocker_constants.py

@@ -27,6 +27,16 @@ def test_plans_path_prefix_matches_project_local_plans_directory() -> None:
     assert "PLANS_PATH_PREFIX" in constants_module.__all__
 
 
+def test_docs_plans_path_segment_matches_repo_packet_directory() -> None:
+    assert constants_module.DOCS_PLANS_PATH_SEGMENT == "/docs/plans/"
+    assert "DOCS_PLANS_PATH_SEGMENT" in constants_module.__all__
+
+
+def test_docs_plans_path_prefix_matches_repo_packet_directory() -> None:
+    assert constants_module.DOCS_PLANS_PATH_PREFIX == "docs/plans/"
+    assert "DOCS_PLANS_PATH_PREFIX" in constants_module.__all__
+
+
 def test_open_questions_heading_pattern_matches_atx_heading() -> None:
     assert constants_module.OPEN_QUESTIONS_HEADING_PATTERN.search("## Open Questions\n")
 
@@ -111,9 +121,11 @@ def test_unreadable_file_synthetic_content_triggers_heading_pattern() -> None:
     assert "UNREADABLE_FILE_SYNTHETIC_CONTENT" in constants_module.__all__
 
 
-def test_all_exports_enumerates_eight_public_constants_in_sorted_order() -> None:
+def test_all_exports_enumerates_ten_public_constants_in_sorted_order() -> None:
     expected_exports = [
         "CODE_FENCE_PATTERN",
+        "DOCS_PLANS_PATH_PREFIX",
+        "DOCS_PLANS_PATH_SEGMENT",
         "INLINE_CODE_PATTERN",
         "MARKDOWN_EXTENSION",
         "OPEN_QUESTIONS_HEADING_PATTERN",

package/package.json

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