claude-dev-env 2.13.0 → 2.14.1

package/hooks/blocking/code_rules_dead_module_constant.py

@@ -29,13 +29,20 @@ The scan is deliberately conservative to keep false positives near zero:
   exported constant live.
 - When the package-tree scan leaves a constant unreferenced, the scan widens to
   the repository root (the nearest ``.git`` ancestor). The widened pass counts a
-  sibling-tree reference only when a module imports the name through a
-  ``from <module> import`` whose final dotted segment equals the written
-  module's filename stem, so a genuine cross-tree consumer of this constants
-  module keeps the constant live while a same-named constant exported by an
-  unrelated module never masks a dead one. The widened pass reads a repository
-  file only to test whether its text names the written module's filename stem;
-  a file that never mentions the stem cannot carry such an import, so it is
+  sibling-tree reference in two shapes. The first is an import of the name
+  through a ``from <module> import`` whose final dotted segment equals the
+  written module's filename stem. The second is an attribute read on a binding
+  of the written module itself: a consumer that writes
+  ``import pkg.config.constants``, the same with an alias,
+  ``from pkg.config import constants``, or the same with an alias, and then
+  reads each constant as an attribute on that binding (``alias.NAME``,
+  ``pkg.config.constants.NAME``), keeps every name it reads that way live. Both
+  shapes are bound to the written module's stem, so a genuine cross-tree
+  consumer of this constants module keeps the constant live while a same-named
+  constant exported by an unrelated module never masks a dead one. The widened
+  pass reads a repository file only to test whether its text names the written
+  module's filename stem; neither shape can appear in a file that never spells
+  the stem, so such a file is
   skipped without spending scan-cap budget, keeping the widened pass bounded to
   the handful of candidate importer files even in a large repository. A module
   outside any repository is
@@ -65,6 +72,7 @@ if _blocking_directory not in sys.path:
 if _hooks_directory not in sys.path:
     sys.path.insert(0, _hooks_directory)
 
+from code_rules_probe_chains import _dotted_attribute_chain  # noqa: E402
 from code_rules_shared import (  # noqa: E402
     is_migration_file,
     is_test_file,
@@ -268,13 +276,116 @@ def _module_final_segment(module_path: str | None) -> str:
     return module_path.rsplit(".", 1)[-1]
 
 
-def _qualified_import_member_names(source: str, module_stem: str) -> set[str]:
-    """Return names imported from a module whose filename stem is ``module_stem``.
+def _stem_import_member_names(import_node: ast.ImportFrom, module_stem: str) -> set[str]:
+    """Return the member names a stem-matched ``from ... import`` brings in.
 
-    A cross-package consumer of an exported constant imports it through an
-    explicit ``from <module> import NAME`` whose module path ends in the defining
-    module's filename stem. Collecting only those member names binds a
-    widened-scan reference to the module that actually defines the constant, so a
+    ::
+
+        from pkg.config.constants import NAME  ->  "NAME"
+        from pkg.config.other import NAME      ->  nothing (stem mismatch)
+
+    Args:
+        import_node: A ``from ... import`` statement node.
+        module_stem: The filename stem of the constants module being judged.
+
+    Returns:
+        The imported member names when the module path's final dotted segment
+        equals ``module_stem``, empty otherwise.
+    """
+    if _module_final_segment(import_node.module) != module_stem:
+        return set()
+    return {each_alias.name for each_alias in import_node.names}
+
+
+def _import_module_bindings(all_import_aliases: list[ast.alias], module_stem: str) -> set[str]:
+    """Return the names an import's aliases bind to the constants module object.
+
+    ::
+
+        import pkg.config.constants        ->  "pkg.config.constants"
+        import pkg.config.constants as sg  ->  "sg"
+        from pkg.config import constants   ->  "constants"
+        from . import constants as sg      ->  "sg"
+        import pkg.config.other            ->  nothing (stem mismatch)
+
+    A plain ``import`` names the module by its dotted path, so the final
+    segment is matched against the stem. A ``from ... import`` alias name is a
+    single identifier, which the same final-segment match covers unchanged.
+
+    Args:
+        all_import_aliases: The ``names`` list of an ``Import`` or
+            ``ImportFrom`` node.
+        module_stem: The filename stem of the constants module being judged.
+
+    Returns:
+        The dotted paths and aliases through which the module object is
+        reachable.
+    """
+    binding_names: set[str] = set()
+    for each_alias in all_import_aliases:
+        if _module_final_segment(each_alias.name) != module_stem:
+            continue
+        binding_names.add(each_alias.asname or each_alias.name)
+    return binding_names
+
+
+def _collect_widened_scan_facts(
+    tree: ast.Module, module_stem: str
+) -> tuple[set[str], set[str], list[ast.Attribute]]:
+    """Collect a candidate module's import and attribute facts in one walk.
+
+    Args:
+        tree: The parsed candidate module.
+        module_stem: The filename stem of the constants module being judged.
+
+    Returns:
+        The member names imported through a stem-matched ``from ... import``,
+        the names bound to the constants module object itself, and every
+        attribute node in the module.
+    """
+    member_names: set[str] = set()
+    binding_names: set[str] = set()
+    all_attribute_nodes: list[ast.Attribute] = []
+    for each_node in ast.walk(tree):
+        if isinstance(each_node, ast.ImportFrom):
+            member_names |= _stem_import_member_names(each_node, module_stem)
+        if isinstance(each_node, (ast.Import, ast.ImportFrom)):
+            binding_names |= _import_module_bindings(each_node.names, module_stem)
+        if isinstance(each_node, ast.Attribute):
+            all_attribute_nodes.append(each_node)
+    return member_names, binding_names, all_attribute_nodes
+
+
+def _attribute_read_names(
+    all_attribute_nodes: list[ast.Attribute], all_binding_names: set[str]
+) -> set[str]:
+    """Return the constant names read as attributes on a module-object binding.
+
+    The expression an attribute is read on is spelled back to its dotted source
+    form and matched against the bindings, so an alias read (``sg.NAME``) and a
+    full dotted path (``pkg.config.constants.NAME``) both resolve, while a read
+    on a binding of some other module counts for nothing.
+
+    Args:
+        all_attribute_nodes: Every attribute node in the candidate module.
+        all_binding_names: The names bound to the constants module object.
+
+    Returns:
+        The attribute names read on a binding of the constants module.
+    """
+    if not all_binding_names:
+        return set()
+    return {
+        each_attribute.attr
+        for each_attribute in all_attribute_nodes
+        if _dotted_attribute_chain(each_attribute.value) in all_binding_names
+    }
+
+
+def _widened_scan_reference_names(source: str, module_stem: str) -> set[str]:
+    """Return the names a repository-wide candidate contributes, parsing it once.
+
+    Both counted shapes are bound to the written module's filename stem, so a
     same-named constant exported by an unrelated module never masks a dead one.
 
     Args:
@@ -282,22 +393,18 @@ def _qualified_import_member_names(source: str, module_stem: str) -> set[str]:
         module_stem: The filename stem of the constants module being judged.
 
     Returns:
-        The member names imported from a module whose final dotted segment equals
-        ``module_stem``. A module that fails to parse contributes no names.
+        The members imported through a stem-matched ``from <module> import``,
+        plus the constant names read as attributes on an imported binding of the
+        constants module. A module that fails to parse contributes no names.
     """
     try:
         tree = ast.parse(source)
     except SyntaxError:
         return set()
-    member_names: set[str] = set()
-    for each_node in ast.walk(tree):
-        if not isinstance(each_node, ast.ImportFrom):
-            continue
-        if _module_final_segment(each_node.module) != module_stem:
-            continue
-        for each_alias in each_node.names:
-            member_names.add(each_alias.name)
-    return member_names
+    member_names, binding_names, all_attribute_nodes = _collect_widened_scan_facts(
+        tree, module_stem
+    )
+    return member_names | _attribute_read_names(all_attribute_nodes, binding_names)
 
 
 def _scan_root_for_constants_module(file_path: str) -> Path:
@@ -350,11 +457,13 @@ def _read_candidate_source(file_path: Path, required_substring: str | None) -> s
         required_substring = None                 -> read and keep every file
         required_substring = the module stem      -> keep only files naming it
             from pkg.foo_constants import BAR  ->  names the stem  ->  candidate
+            from pkg import foo_constants as c ->  names the stem  ->  candidate
             def unrelated() -> int: ...        ->  no stem mention ->  skipped
 
-    The widened repository pass looks only for a ``from <module> import`` whose
-    final dotted segment equals the constants module's filename stem, and such an
-    import always spells that stem in the file's text. A file whose text never
+    The widened repository pass looks only for an import bound to the constants
+    module's filename stem — a ``from <module> import`` whose final dotted segment
+    equals the stem, or an import of the module object itself — and every such
+    import spells that stem in the file's text. A file whose text never
     mentions the stem cannot carry the import, so returning None for it lets the
     caller skip the file without spending scan-cap budget, which keeps the widened
     pass bounded to the candidate importer files even under a large repository.
@@ -422,7 +531,9 @@ def _collect_names_under_root(
             in before the walk begins.
         extract_names: Maps one module's source text to the set of names it
             contributes — the generous reference collector for the package-tree
-            pass, the stem-bound import collector for the widened pass.
+            pass, and for the widened pass the stem-bound collector that counts
+            both a stem-matched from-import and an attribute read on a binding
+            of the written module.
         already_scanned_count: The parsed-file count accumulated by a prior
             pass, so the parse cap bounds the combined work of the
             package-tree and widened passes.
@@ -552,12 +663,13 @@ def check_dead_module_constants(
     are governed by the use-count rule instead. A constant is dead when its name
     appears in no ``.py`` module under the enclosing package tree — not imported,
     not read, not listed in another module's ``__all__`` literal, not named in a
-    string annotation — and, in the repository-wide scan the check widens to when
-    the package-tree scan leaves the constant unreferenced, no module imports the
-    name from a ``from <module> import`` whose final dotted segment equals this
-    module's filename stem. Binding the widened scan to the stem keeps a genuine
-    cross-tree consumer counting while a same-named constant exported by an
-    unrelated module never masks a dead one. A module declaring ``__all__``
+    string annotation. When that leaves a constant unreferenced, the scan widens
+    to the repository, where two shapes count: a ``from <module> import`` whose
+    final dotted segment equals this module's filename stem, and an attribute
+    read on a binding of this module (``import pkg.config.constants as alias``
+    then the alias followed by the constant name). Binding both to the stem
+    keeps a same-named constant in an unrelated module from masking a dead one.
+    A module declaring ``__all__``
     narrows the check to the constants its ``__all__`` list names: each must be
     imported or read by another module, and the module's own ``__all__`` entry
     never counts as that consumer, so an exported constant no module consumes is
@@ -616,14 +728,14 @@ def check_dead_module_constants(
     if has_unreferenced_constant:
         repository_root = _repository_root_for(written_path)
         if repository_root is not None and repository_root != scan_root:
-            collect_qualified_imports = partial(
-                _qualified_import_member_names, module_stem=written_path.stem
+            collect_widened_scan_names = partial(
+                _widened_scan_reference_names, module_stem=written_path.stem
             )
             widened_names, _widened_count, widened_cap_was_hit = _collect_names_under_root(
                 repository_root,
                 written_path,
                 set(),
-                collect_qualified_imports,
+                collect_widened_scan_names,
                 already_scanned_count=scanned_file_count,
                 excluded_subtree=scan_root,
                 required_substring=written_path.stem,

package/hooks/blocking/code_rules_probe_chains.py

@@ -1,4 +1,8 @@
-"""Attribute-chain and os.environ alias-resolution primitives for the test-isolation check."""
+"""Attribute-chain and os.environ alias-resolution primitives.
+
+Serves the test-isolation check, and lends ``_dotted_attribute_chain`` to the
+dead-module-constant check's widened attribute-read scan.
+"""
 
 import ast
 import sys
@@ -143,7 +147,7 @@ def _attribute_chain_resolves_to_os_environ(
     return canonical_chain == OS_ENVIRON_DOTTED_NAME
 
 
-def _dotted_attribute_chain(attribute_node: ast.Attribute) -> str | None:
+def _dotted_attribute_chain(attribute_node: ast.expr) -> str | None:
     chain_parts: list[str] = []
     walker: ast.expr = attribute_node
     while isinstance(walker, ast.Attribute):

package/hooks/blocking/config/AGENTS.md

@@ -0,0 +1,10 @@
+# hooks/blocking/config
+
+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` |
+| `prose_style_enforcement_constants.py` | `CLAUDE_PROSE_STYLE_ENFORCEMENT` opt-in (default off) for opinionated prose gates |

package/hooks/blocking/config/CLAUDE.md

@@ -1,10 +1 @@
-# hooks/blocking/config
-
-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` |
-| `prose_style_enforcement_constants.py` | `CLAUDE_PROSE_STYLE_ENFORCEMENT` opt-in (default off) for opinionated prose gates |
+@AGENTS.md

package/hooks/blocking/gh_pr_author_restore.py

@@ -36,6 +36,7 @@ if hooks_parent_directory not in sys.path:
     sys.path.insert(0, hooks_parent_directory)
 
 from _gh_pr_author_swap_utils import (  # noqa: E402
+    _build_restore_failure_message,
     _command_invokes_gh_pr_create_in_stripped,
     _delete_state_file,
     _preprocess_command_for_matching,
@@ -89,8 +90,12 @@ def main() -> None:
         _delete_state_file(state_file)
     else:
         _write_line(
-            f"[gh-pr-author-restore] failed to restore active gh account to {original_account!r}; "
-            f"state file {state_file} left in place so the SessionStart cleanup hook can retry",
+            _build_restore_failure_message(
+                "gh-pr-author-restore",
+                original_account,
+                state_file,
+                "state file",
+            ),
             sys.stderr,
         )
     sys.exit(0)

package/hooks/blocking/intent_only_ending_blocker.py

@@ -1,12 +1,10 @@
 #!/usr/bin/env python3
-"""
-Stop hook that blocks Claude responses ending on a promise about undone work.
+"""Stop hook that blocks a turn ending with a promise of future work.
 
-When a turn ends on a forward-looking statement of intent ("I'll now run the
-tests", "Let me implement the fix") instead of actually doing the work, the
-agent is forced to do the work now with tool calls, or - when genuinely blocked
-on input only the user can supply - route through AskUserQuestion and end
-cleanly. The rule name is long-horizon-autonomy.
+When a turn ends with a forward-looking statement of intent ("I'll now run the
+tests", "Let me implement the fix"), complete the work with tool calls during
+the turn. Route work requiring user-only input through AskUserQuestion. The
+rule name is long-horizon-autonomy.
 """
 
 import json
@@ -104,7 +102,7 @@ def find_intent_only_ending(text: str) -> bool:
 
 
 def main() -> None:
-    """Read the stop-hook payload and block turns that end on a promise of undone work."""
+    """Read the stop-hook payload and block turns that promise future work."""
     try:
         hook_input = json.load(sys.stdin)
     except json.JSONDecodeError:
@@ -125,14 +123,11 @@ def main() -> None:
         sys.exit(0)
 
     block_reason = (
-        "LONG-HORIZON-AUTONOMY GUARDRAIL: Your turn ends on a promise about work "
-        "that is not yet done, rather than doing it. Do the work NOW with tool calls "
-        "instead of describing what you are about to do.\n\n"
-        "If the work is genuinely blocked on input only the user can give, route the "
-        "ask through an AskUserQuestion tool call and end the turn cleanly. Otherwise, "
-        "carry out the stated action this turn.\n\n"
-        "You MUST re-output the complete response with the work actually performed, "
-        "per the long-horizon-autonomy rule."
+        "LONG-HORIZON-AUTONOMY GUARDRAIL: This turn ends with a promise of future "
+        "work. Complete that work with tool calls during this turn. Route questions "
+        "requiring user-only input through AskUserQuestion, then end the turn cleanly.\n\n"
+        "Re-output the complete response with the work performed, per the "
+        "long-horizon-autonomy rule."
     )
     block_response = {
         "decision": "block",

package/hooks/blocking/inventory_intent_records/AGENTS.md

@@ -0,0 +1,26 @@
+# inventory_intent_records
+
+The shared pending-intent store that lets `package_inventory_stale_blocker.py`
+and `claude_md_orphan_file_blocker.py` add a new file and its inventory row in
+one change, in either order. When one blocker denies, it records a note; the
+sibling blocker reads that note to allow the matching second write.
+
+## Modules
+
+| File | Purpose |
+|---|---|
+| `records.py` | Read, record, peek, and consume the per-session file and row intents; a missing or corrupt store reads as no notes |
+| `__init__.py` | Package marker |
+
+## Subdirectories
+
+| Entry | Description |
+|---|---|
+| `config/` | The records-file name shape, the freshness window, the list keys, and the note field names (`intent_records_constants.py`) |
+| `tests/` | pytest suite for the records store |
+
+## Running tests
+
+```bash
+python -m pytest packages/claude-dev-env/hooks/blocking/inventory_intent_records/tests/
+```

package/hooks/blocking/inventory_intent_records/CLAUDE.md

@@ -1,26 +1 @@
-# inventory_intent_records
-
-The shared pending-intent store that lets `package_inventory_stale_blocker.py`
-and `claude_md_orphan_file_blocker.py` add a new file and its inventory row in
-one change, in either order. When one blocker denies, it records a note; the
-sibling blocker reads that note to allow the matching second write.
-
-## Modules
-
-| File | Purpose |
-|---|---|
-| `records.py` | Read, record, peek, and consume the per-session file and row intents; a missing or corrupt store reads as no notes |
-| `__init__.py` | Package marker |
-
-## Subdirectories
-
-| Entry | Description |
-|---|---|
-| `config/` | The records-file name shape, the freshness window, the list keys, and the note field names (`intent_records_constants.py`) |
-| `tests/` | pytest suite for the records store |
-
-## Running tests
-
-```bash
-python -m pytest packages/claude-dev-env/hooks/blocking/inventory_intent_records/tests/
-```
+@AGENTS.md

package/hooks/blocking/package_inventory_stale_blocker_parts/AGENTS.md

@@ -0,0 +1,26 @@
+# package_inventory_stale_blocker_parts
+
+The concern modules `package_inventory_stale_blocker.py` wires together to block a
+new production file its package inventory omits. The entry hook imports them and
+re-exports their surface for the test suite.
+
+## Modules
+
+| File | Purpose |
+|---|---|
+| `inventory_detection.py` | Surveys a directory's `README.md`/`CLAUDE.md`/`SKILL.md`, collects the filenames they name, and reports whether a maintained inventory omits the file being written |
+| `decision.py` | Builds the deny payload naming the omitted file and closing with the retry hint, and emits the decision JSON |
+| `__init__.py` | Package marker |
+
+## Subdirectories
+
+| Entry | Description |
+|---|---|
+| `config/` | The retry hint the deny reason closes with and the inventory-name join separator (`inventory_blocker_constants.py`) |
+| `tests/` | pytest suite with one test module per module above |
+
+## Running tests
+
+```bash
+python -m pytest packages/claude-dev-env/hooks/blocking/package_inventory_stale_blocker_parts/tests/
+```

package/hooks/blocking/package_inventory_stale_blocker_parts/CLAUDE.md

@@ -1,26 +1 @@
-# package_inventory_stale_blocker_parts
-
-The concern modules `package_inventory_stale_blocker.py` wires together to block a
-new production file its package inventory omits. The entry hook imports them and
-re-exports their surface for the test suite.
-
-## Modules
-
-| File | Purpose |
-|---|---|
-| `inventory_detection.py` | Surveys a directory's `README.md`/`CLAUDE.md`/`SKILL.md`, collects the filenames they name, and reports whether a maintained inventory omits the file being written |
-| `decision.py` | Builds the deny payload naming the omitted file and closing with the retry hint, and emits the decision JSON |
-| `__init__.py` | Package marker |
-
-## Subdirectories
-
-| Entry | Description |
-|---|---|
-| `config/` | The retry hint the deny reason closes with and the inventory-name join separator (`inventory_blocker_constants.py`) |
-| `tests/` | pytest suite with one test module per module above |
-
-## Running tests
-
-```bash
-python -m pytest packages/claude-dev-env/hooks/blocking/package_inventory_stale_blocker_parts/tests/
-```
+@AGENTS.md

package/hooks/blocking/pii_prevention_blocker_parts/AGENTS.md

@@ -0,0 +1,24 @@
+# pii_prevention_blocker_parts
+
+The concern modules `pii_prevention_blocker.py` wires together. The entry hook
+imports them and re-exports their surface for the test suite.
+
+## Modules
+
+| File | Purpose |
+|---|---|
+| `repository_exemption.py` | Resolves a commit's origin owner/repo slug, decides whether the repository skips the staged PII scan, and resolves the exact values that repository allows past the scan |
+| `repository_resolution.py` | Reads the repository a commit command targets — composing multiple `-C` values and a leading `cd`/`pushd` — and builds the deny reason naming the path when the repository root does not resolve |
+| `__init__.py` | Package marker |
+
+## Subdirectories
+
+| Entry | Description |
+|---|---|
+| `config/` | The repository-resolution deny-message template and the session-cwd label (`repository_resolution_constants.py`) |
+
+## Running tests
+
+```bash
+python -m pytest packages/claude-dev-env/hooks/blocking/tests/
+```

package/hooks/blocking/pii_prevention_blocker_parts/CLAUDE.md

@@ -1,24 +1 @@
-# pii_prevention_blocker_parts
-
-The concern modules `pii_prevention_blocker.py` wires together. The entry hook
-imports them and re-exports their surface for the test suite.
-
-## Modules
-
-| File | Purpose |
-|---|---|
-| `repository_exemption.py` | Resolves a commit's origin owner/repo slug, decides whether the repository skips the staged PII scan, and resolves the exact values that repository allows past the scan |
-| `repository_resolution.py` | Reads the repository a commit command targets — composing multiple `-C` values and a leading `cd`/`pushd` — and builds the deny reason naming the path when the repository root does not resolve |
-| `__init__.py` | Package marker |
-
-## Subdirectories
-
-| Entry | Description |
-|---|---|
-| `config/` | The repository-resolution deny-message template and the session-cwd label (`repository_resolution_constants.py`) |
-
-## Running tests
-
-```bash
-python -m pytest packages/claude-dev-env/hooks/blocking/tests/
-```
+@AGENTS.md

package/hooks/blocking/tdd_enforcer_parts/AGENTS.md

@@ -0,0 +1,30 @@
+# tdd_enforcer_parts
+
+The concern modules `tdd_enforcer.py` wires together to run the TDD gate. Each
+module owns one concern; the entry hook imports them and re-exports their
+surface for the test suite.
+
+## Modules
+
+| File | Purpose |
+|---|---|
+| `path_classification.py` | Classifies a write target (docs, tests, `.claude` trees) the gate skips, and extracts the written text from a Write, Edit, or MultiEdit payload |
+| `content_analysis.py` | Decides whether a payload is constants-only, and whether an Edit or MultiEdit merely removes or reorders imports |
+| `candidate_paths.py` | Resolves the candidate test files whose freshness can satisfy the gate for a production file |
+| `freshness.py` | Checks whether a candidate test was modified within the window and holds a real test function |
+| `git_tracking.py` | Detects a write that restores a git-tracked file absent on disk, so a remove-then-Write rewrite is exempt from the gate |
+| `decisions.py` | Builds the deny reason and writes the allow or deny decision JSON to stdout |
+| `__init__.py` | Package marker |
+
+## Subdirectories
+
+| Entry | Description |
+|---|---|
+| `config/` | The freshness window, the ancestor-walk limit, the git-tracking command tokens, the source-file extension sets, and the join separator (`tdd_enforcer_constants.py`) |
+| `tests/` | pytest suite with one test module per module above |
+
+## Running tests
+
+```bash
+python -m pytest packages/claude-dev-env/hooks/blocking/tdd_enforcer_parts/tests/
+```

package/hooks/blocking/tdd_enforcer_parts/CLAUDE.md

@@ -1,30 +1 @@
-# tdd_enforcer_parts
-
-The concern modules `tdd_enforcer.py` wires together to run the TDD gate. Each
-module owns one concern; the entry hook imports them and re-exports their
-surface for the test suite.
-
-## Modules
-
-| File | Purpose |
-|---|---|
-| `path_classification.py` | Classifies a write target (docs, tests, `.claude` trees) the gate skips, and extracts the written text from a Write, Edit, or MultiEdit payload |
-| `content_analysis.py` | Decides whether a payload is constants-only, and whether an Edit or MultiEdit merely removes or reorders imports |
-| `candidate_paths.py` | Resolves the candidate test files whose freshness can satisfy the gate for a production file |
-| `freshness.py` | Checks whether a candidate test was modified within the window and holds a real test function |
-| `git_tracking.py` | Detects a write that restores a git-tracked file absent on disk, so a remove-then-Write rewrite is exempt from the gate |
-| `decisions.py` | Builds the deny reason and writes the allow or deny decision JSON to stdout |
-| `__init__.py` | Package marker |
-
-## Subdirectories
-
-| Entry | Description |
-|---|---|
-| `config/` | The freshness window, the ancestor-walk limit, the git-tracking command tokens, the source-file extension sets, and the join separator (`tdd_enforcer_constants.py`) |
-| `tests/` | pytest suite with one test module per module above |
-
-## Running tests
-
-```bash
-python -m pytest packages/claude-dev-env/hooks/blocking/tdd_enforcer_parts/tests/
-```
+@AGENTS.md

package/hooks/blocking/test_claude_md_orphan_file_blocker.py

@@ -47,7 +47,7 @@ TABLE_WITH_SLASH_COMMAND_AND_SUBDIR = (
     "# example\n\n"
     "| Entry | Description |\n"
     "|---|---|\n"
-    "| `/commit` | Slash command |\n"
+    "| `/sr-loop` | Slash command |\n"
     "| `scripts/` | A subdirectory |\n"
     "| Plain prose, no backticks | Not a file |\n"
 )

package/hooks/blocking/test_code_rules_enforcer_banned_prefixes.py

@@ -1,6 +1,6 @@
 """Tests for check_banned_prefixes — flags function names with generic prefixes.
 
-CODE_RULES.md §5 / AGENTS.md "Naming → Function names use specific verbs:
+CODE_RULES.md §5 "Naming → Function names use specific verbs:
 parse_invoice, dispatch_event, migrate_schema. Generic prefixes to replace:
 handle_, process_, manage_, do_."