claude-dev-env 1.50.3 → 1.51.0

package/scripts/sync_to_cursor/rules.py

@@ -13,18 +13,18 @@ from sync_to_cursor.config import MAX_RULE_BODY_LINES
 def _parse_h2_sections(markdown: str) -> dict[str, str]:
     parts = re.split(r"^## ", markdown, flags=re.MULTILINE)
     sections: dict[str, str] = {}
-    for part in parts[1:]:
-        title_line, _, body = part.partition("\n")
+    for each_part in parts[1:]:
+        title_line, _, body = each_part.partition("\n")
         sections[title_line.strip()] = body.strip()
     return sections
 
 
 def _filter_core_principles(body: str) -> str:
     lines = []
-    for line in body.splitlines():
-        if "readability standard" in line:
+    for each_line in body.splitlines():
+        if "readability standard" in each_line:
             continue
-        lines.append(line)
+        lines.append(each_line)
     return "\n".join(lines).strip()
 
 
@@ -56,14 +56,54 @@ def _strip_code_standards_blockquote(markdown: str) -> str:
     return "\n".join(out).strip()
 
 
-def merge_code_standards(sources: tuple[Path, ...]) -> str:
+_merged_mapping_key_order = (
+    "code-standards",
+    "tasklings-preferences",
+    "right-sized-engineering",
+    "bdd",
+    "test-quality",
+    "research-mode",
+    "conservative-action",
+    "explore-thoroughly",
+)
+
+_code_standards_section_order = (
+    "COMMENT PRESERVATION (ABSOLUTE RULE)",
+    "CORE PRINCIPLES",
+    "⚡ HOOK-ENFORCED RULES",
+    "3. REUSE CONSTANTS / 4. CONFIG LOCATIONS",
+    "5. NO ABBREVIATIONS",
+    "6. COMPLETE TYPE HINTS",
+    "9. SELF-CONTAINED COMPONENTS",
+)
+
+_test_quality_section_order = (
+    "Delete Useless Tests",
+    "Test Dependencies MUST FAIL",
+    "Core Testing Principles",
+    "React Testing Patterns",
+    "Test File Organization",
+)
+
+
+def merge_code_standards(all_sources: tuple[Path, ...]) -> str:
+    """Merge the code-standards rule and CODE_RULES doc into one Cursor rule body.
+
+    Args:
+        all_sources: The code-standards rule path then the CODE_RULES doc path.
+
+    Returns:
+        The merged Cursor rule body, truncated to the maximum rule body length.
+    """
     code_standards_markdown = _strip_code_standards_blockquote(
-        sources[0].read_text(encoding="utf-8")
+        all_sources[0].read_text(encoding="utf-8")
     )
     code_standards_markdown = "\n".join(
-        line for line in code_standards_markdown.splitlines() if not line.strip().startswith("- TDD ")
+        each_line
+        for each_line in code_standards_markdown.splitlines()
+        if not each_line.strip().startswith("- TDD ")
     )
-    code_rules_markdown = sources[1].read_text(encoding="utf-8")
+    code_rules_markdown = all_sources[1].read_text(encoding="utf-8")
     sections_by_heading = _parse_h2_sections(code_rules_markdown)
     if not sections_by_heading:
         pointer_fallback_note = (
@@ -72,63 +112,71 @@ def merge_code_standards(sources: tuple[Path, ...]) -> str:
         )
         chunks = [code_standards_markdown, "", pointer_fallback_note]
         return _limit_lines("\n\n".join(chunks), MAX_RULE_BODY_LINES)
-    include_order = [
-        "COMMENT PRESERVATION (ABSOLUTE RULE)",
-        "CORE PRINCIPLES",
-        "⚡ HOOK-ENFORCED RULES",
-        "4. CONFIG LOCATIONS",
-        "5. NO ABBREVIATIONS",
-        "6. COMPLETE TYPE HINTS",
-        "9. SELF-CONTAINED COMPONENTS",
-    ]
     chunks = [
         code_standards_markdown,
         "",
         "## Reference (full text: `.cursor/docs/CODE_RULES.md`)",
     ]
-    for title in include_order:
-        body = sections_by_heading.get(title, "")
-        if title == "CORE PRINCIPLES":
+    for each_title in _code_standards_section_order:
+        assert each_title in sections_by_heading, (
+            f"merge_code_standards: expected section absent from CODE_RULES.md: {each_title}"
+        )
+        body = sections_by_heading[each_title]
+        if each_title == "CORE PRINCIPLES":
             body = _filter_core_principles(body)
         if body:
-            chunks.append(f"## {title}\n\n{body}")
+            chunks.append(f"## {each_title}\n\n{body}")
     merged = "\n\n".join(chunks)
     return _limit_lines(merged, MAX_RULE_BODY_LINES)
 
 
-def merge_test_quality(sources: tuple[Path, ...]) -> str:
-    testing = sources[0].read_text(encoding="utf-8").strip()
-    test_quality_markdown = sources[1].read_text(encoding="utf-8")
+def merge_test_quality(all_sources: tuple[Path, ...]) -> str:
+    """Merge the testing rule and TEST_QUALITY doc into one Cursor rule body.
+
+    Args:
+        all_sources: The testing rule path then the TEST_QUALITY doc path.
+
+    Returns:
+        The merged Cursor rule body, truncated to the maximum rule body length.
+    """
+    testing = strip_leading_yaml_frontmatter(
+        all_sources[0].read_text(encoding="utf-8")
+    ).strip()
+    test_quality_markdown = all_sources[1].read_text(encoding="utf-8")
     sections_by_heading = _parse_h2_sections(test_quality_markdown)
-    include_order = [
-        "Delete Useless Tests",
-        "Test Dependencies MUST FAIL",
-        "Core Testing Principles",
-        "React Testing Patterns",
-        "Test File Organization",
-    ]
     chunks = [testing, "", "## Reference (full text: `.cursor/docs/TEST_QUALITY.md`)"]
-    for title in include_order:
-        body = sections_by_heading.get(title, "")
+    for each_title in _test_quality_section_order:
+        assert each_title in sections_by_heading, (
+            f"merge_test_quality: expected section absent from TEST_QUALITY.md: {each_title}"
+        )
+        body = sections_by_heading[each_title]
         if body:
-            chunks.append(f"## {title}\n\n{body}")
+            chunks.append(f"## {each_title}\n\n{body}")
     merged = "\n\n".join(chunks)
     return _limit_lines(merged, MAX_RULE_BODY_LINES)
 
 
 def strip_anthropic_refs(text: str) -> str:
+    """Remove Anthropic source citations and the do-not-act wrapper from rule text.
+
+    Args:
+        text: The rule body to clean.
+
+    Returns:
+        The rule body without Anthropic citation lines or the wrapper tags.
+    """
     out_lines: list[str] = []
-    for line in text.splitlines():
-        s = line.strip()
-        if s.startswith("Source:") and (
-            "anthropic" in s.lower()
-            or "claude.com" in s.lower()
-            or "docs.anthropic" in s.lower()
+    for each_line in text.splitlines():
+        stripped_line = each_line.strip()
+        if stripped_line.startswith("Source:") and (
+            "anthropic" in stripped_line.lower()
+            or "claude.com" in stripped_line.lower()
+            or "docs.anthropic" in stripped_line.lower()
         ):
             continue
-        if "docs.anthropic.com" in line:
+        if "docs.anthropic.com" in each_line:
             continue
-        out_lines.append(line)
+        out_lines.append(each_line)
     text = "\n".join(out_lines)
     text = re.sub(
         r"<do_not_act_before_instructions>\s*",
@@ -149,7 +197,14 @@ def near_verbatim(text: str) -> str:
 
 
 def strip_leading_yaml_frontmatter(text: str) -> str:
-    """Remove leading `---` ... `---` block (e.g. Claude `paths:`) so Cursor `.mdc` uses its own frontmatter."""
+    """Remove a leading `---` ... `---` block so Cursor `.mdc` keeps its own frontmatter.
+
+    Args:
+        text: The rule body that may open with a Claude YAML frontmatter block.
+
+    Returns:
+        The rule body with any leading frontmatter block removed.
+    """
     lines = text.splitlines()
     if not lines or lines[0].strip() != "---":
         return text
@@ -164,15 +219,29 @@ TransformName = Literal["verbatim", "near_verbatim", "merge_code_standards", "me
 
 def apply_transform(
     name: TransformName,
-    sources: tuple[Path, ...],
+    all_sources: tuple[Path, ...],
     *,
     strip_leading_frontmatter: bool = False,
 ) -> str:
+    """Run the named transform over the source files and return the rule body.
+
+    Args:
+        name: The transform identifier selecting how the sources combine.
+        all_sources: The source files the transform reads.
+        strip_leading_frontmatter: When True, drop a leading YAML frontmatter
+            block from the raw concatenation before a verbatim transform.
+
+    Returns:
+        The transformed Cursor rule body.
+
+    Raises:
+        AssertionError: When *name* is not a recognized transform identifier.
+    """
     if name == "merge_code_standards":
-        return merge_code_standards(sources)
+        return merge_code_standards(all_sources)
     if name == "merge_test_quality":
-        return merge_test_quality(sources)
-    raw = "\n\n".join(p.read_text(encoding="utf-8") for p in sources)
+        return merge_test_quality(all_sources)
+    raw = "\n\n".join(each_source.read_text(encoding="utf-8") for each_source in all_sources)
     if strip_leading_frontmatter:
         raw = strip_leading_yaml_frontmatter(raw)
     if name == "verbatim":
@@ -216,7 +285,14 @@ def _full_mdc(mapping: RuleMapping, body: str) -> str:
 
 
 def _read_paths_glob(rule_file: Path) -> str | None:
-    """Read `paths:` list from a Claude rule's YAML frontmatter; return as comma-separated Cursor glob string."""
+    """Read the `paths:` list from a Claude rule's YAML frontmatter as a Cursor glob.
+
+    Args:
+        rule_file: The Claude rule file whose frontmatter may declare `paths:`.
+
+    Returns:
+        The comma-separated glob string, or None when the rule declares no paths.
+    """
     if not rule_file.is_file():
         return None
     lines = rule_file.read_text(encoding="utf-8").splitlines()
@@ -224,26 +300,46 @@ def _read_paths_glob(rule_file: Path) -> str | None:
         return None
     is_in_paths = False
     all_paths: list[str] = []
-    for line in lines[1:]:
-        if line.strip() == "---":
+    for each_line in lines[1:]:
+        if each_line.strip() == "---":
             break
-        if line.startswith("paths:"):
+        if each_line.startswith("paths:"):
             is_in_paths = True
             continue
         if is_in_paths:
-            if line.startswith(" ") or line.startswith("\t"):
-                path_value = line.strip().lstrip("-").strip().strip('"').strip("'")
-                if path_value:
-                    all_paths.append(path_value)
+            if each_line.startswith(" ") or each_line.startswith("\t"):
+                stripped_path = each_line.strip().lstrip("-").strip().strip('"').strip("'")
+                if stripped_path:
+                    all_paths.append(stripped_path)
             else:
                 is_in_paths = False
     return ",".join(all_paths) if all_paths else None
 
 
-def build_mappings(claude: Path) -> tuple[RuleMapping, ...]:
-    rules_directory = claude / "rules"
-    docs_directory = claude / "docs"
-    test_globs = "**/*.test.*,**/*.spec.*,**/test_*,**/*_test.*"
+def _require_paths_glob(rule_file: Path) -> str | None:
+    """Return the path glob for an optional rule, requiring frontmatter when it exists.
+
+    Args:
+        rule_file: The Claude rule file whose frontmatter may declare `paths:`.
+
+    Returns:
+        The comma-separated glob string, or None when the rule file is absent.
+
+    Raises:
+        AssertionError: When the rule file exists but declares no `paths:`
+            frontmatter, which would silently disable the rule in Cursor.
+    """
+    if not rule_file.is_file():
+        return None
+    paths_glob = _read_paths_glob(rule_file)
+    assert paths_glob is not None, (
+        f"{rule_file.name}: path-scoped rule exists but declares no `paths:` frontmatter; "
+        "add a `paths:` list or remove the file"
+    )
+    return paths_glob
+
+
+def _always_apply_mappings(rules_directory: Path, docs_directory: Path) -> tuple[RuleMapping, ...]:
     return (
         RuleMapping(
             "code-standards",
@@ -254,16 +350,6 @@ def build_mappings(claude: Path) -> tuple[RuleMapping, ...]:
             "Core code standards: naming, types, config, hook-enforced rules",
             "merge_code_standards",
         ),
-        RuleMapping(
-            "tasklings-preferences",
-            (rules_directory / "tasklings-preferences.md",),
-            "tasklings-preferences.mdc",
-            False,
-            _read_paths_glob(rules_directory / "tasklings-preferences.md"),
-            "Tasklings: Prefer / Do / Always engineering preferences (scoped path)",
-            "verbatim",
-            True,
-        ),
         RuleMapping(
             "right-sized-engineering",
             (rules_directory / "right-sized-engineering.md",),
@@ -282,15 +368,6 @@ def build_mappings(claude: Path) -> tuple[RuleMapping, ...]:
             "BDD: discovery-driven protocol (outside-in; Illustrate→Formulate→Automate)",
             "verbatim",
         ),
-        RuleMapping(
-            "test-quality",
-            (rules_directory / "testing.md", docs_directory / "TEST_QUALITY.md"),
-            "test-quality.mdc",
-            False,
-            test_globs,
-            "Testing quality for test files",
-            "merge_test_quality",
-        ),
         RuleMapping(
             "research-mode",
             (rules_directory / "research-mode.md",),
@@ -319,3 +396,48 @@ def build_mappings(claude: Path) -> tuple[RuleMapping, ...]:
             "near_verbatim",
         ),
     )
+
+
+def _path_scoped_mappings(rules_directory: Path, docs_directory: Path) -> tuple[RuleMapping, ...]:
+    return (
+        RuleMapping(
+            "tasklings-preferences",
+            (rules_directory / "tasklings-preferences.md",),
+            "tasklings-preferences.mdc",
+            False,
+            _require_paths_glob(rules_directory / "tasklings-preferences.md"),
+            "Tasklings: Prefer / Do / Always engineering preferences (scoped path)",
+            "verbatim",
+            True,
+        ),
+        RuleMapping(
+            "test-quality",
+            (rules_directory / "testing.md", docs_directory / "TEST_QUALITY.md"),
+            "test-quality.mdc",
+            False,
+            _require_paths_glob(rules_directory / "testing.md"),
+            "Testing quality for test files",
+            "merge_test_quality",
+        ),
+    )
+
+
+def build_mappings(claude: Path) -> tuple[RuleMapping, ...]:
+    """Resolve every rule into a concrete Cursor mapping against a Claude layout.
+
+    Args:
+        claude: The Claude layout root holding the `rules` and `docs` directories.
+
+    Returns:
+        One RuleMapping per rule, each path-scoped rule carrying a glob derived
+        from its source rule's `paths:` frontmatter.
+    """
+    rules_directory = claude / "rules"
+    docs_directory = claude / "docs"
+    all_mappings = (
+        *_always_apply_mappings(rules_directory, docs_directory),
+        *_path_scoped_mappings(rules_directory, docs_directory),
+    )
+    mapping_by_key = {each_mapping.key: each_mapping for each_mapping in all_mappings}
+    assert set(mapping_by_key) == set(_merged_mapping_key_order)
+    return tuple(mapping_by_key[each_key] for each_key in _merged_mapping_key_order)

package/scripts/tests/test_sync_to_cursor.py

@@ -14,7 +14,19 @@ if str(_SCRIPTS_DIR) not in sys.path:
 
 import sync_to_cursor as mod
 from sync_to_cursor.engine import run as run_sync_to_cursor
-from sync_to_cursor.rules import _read_paths_glob
+from sync_to_cursor.rules import (
+    _code_standards_section_order,
+    _parse_h2_sections,
+    _read_paths_glob,
+    _test_quality_section_order,
+    build_mappings,
+    strip_leading_yaml_frontmatter,
+)
+
+_CLAUDE_DEV_ENV_DIR = _SCRIPTS_DIR.parent
+_REAL_TESTING_RULE = _CLAUDE_DEV_ENV_DIR / "rules" / "testing.md"
+_REAL_CODE_RULES_DOC = _CLAUDE_DEV_ENV_DIR / "docs" / "CODE_RULES.md"
+_REAL_TEST_QUALITY_DOC = _CLAUDE_DEV_ENV_DIR / "docs" / "TEST_QUALITY.md"
 
 
 def _minimal_rule_files(claude_rules: Path) -> None:
@@ -28,7 +40,10 @@ def _minimal_rule_files(claude_rules: Path) -> None:
     )
     (claude_rules / "right-sized-engineering.md").write_text("# RSE\n", encoding="utf-8")
     (claude_rules / "bdd.md").write_text("# BDD\n", encoding="utf-8")
-    (claude_rules / "testing.md").write_text("# Testing\n", encoding="utf-8")
+    (claude_rules / "testing.md").write_text(
+        "---\npaths:\n  - \"**/test_*.py\"\n---\n\n# Testing\n",
+        encoding="utf-8",
+    )
     (claude_rules / "research-mode.md").write_text("# RM\n", encoding="utf-8")
     (claude_rules / "conservative-action.md").write_text("# CA\n", encoding="utf-8")
     (claude_rules / "explore-thoroughly.md").write_text("# ET\n", encoding="utf-8")
@@ -36,8 +51,12 @@ def _minimal_rule_files(claude_rules: Path) -> None:
 
 def _minimal_code_rules_and_test_quality(claude_docs: Path) -> tuple[bytes, bytes]:
     claude_docs.mkdir(parents=True, exist_ok=True)
-    cr = b"## CORE PRINCIPLES\n\nalpha\n"
-    tq = b"## Core Testing Principles\n\nbeta\n"
+    cr = (
+        "\n\n".join(f"## {title}\n\nalpha" for title in _code_standards_section_order) + "\n"
+    ).encode("utf-8")
+    tq = (
+        "\n\n".join(f"## {title}\n\nbeta" for title in _test_quality_section_order) + "\n"
+    ).encode("utf-8")
     (claude_docs / "CODE_RULES.md").write_bytes(cr)
     (claude_docs / "TEST_QUALITY.md").write_bytes(tq)
     return cr, tq
@@ -168,6 +187,18 @@ def test_check_skips_optional_mapping_when_source_missing(
     assert run_sync_to_cursor(["--check"]) == 0, "--check must pass when only optional sources are missing"
 
 
+def test_test_quality_glob_derived_from_testing_frontmatter() -> None:
+    expected_glob = _read_paths_glob(_REAL_TESTING_RULE)
+    assert expected_glob, "testing.md must declare a non-empty paths frontmatter"
+    pinned_glob = "**/test_*.py,**/*_test.py,**/*.test.*,**/*.spec.*,**/conftest.py,**/tests/**"
+    assert expected_glob == pinned_glob
+    test_quality_mapping = next(
+        mapping for mapping in build_mappings(_CLAUDE_DEV_ENV_DIR) if mapping.key == "test-quality"
+    )
+    assert test_quality_mapping.globs == expected_glob
+    assert test_quality_mapping.globs == pinned_glob
+
+
 def test_tasklings_glob_derived_from_frontmatter(tmp_path: Path) -> None:
     rules_directory = tmp_path / "rules"
     rules_directory.mkdir(parents=True)
@@ -185,18 +216,7 @@ def test_merge_reference_headers_point_at_cursor_docs(tmp_path: Path) -> None:
     rules_directory.mkdir(parents=True, exist_ok=True)
     docs_directory.mkdir(parents=True, exist_ok=True)
     (rules_directory / "code-standards.md").write_text("# CS\n", encoding="utf-8")
-    cr_body = "\n\n".join(
-        f"## {t}\n\nbody"
-        for t in [
-            "COMMENT PRESERVATION (ABSOLUTE RULE)",
-            "CORE PRINCIPLES",
-            "⚡ HOOK-ENFORCED RULES",
-            "4. CONFIG LOCATIONS",
-            "5. NO ABBREVIATIONS",
-            "6. COMPLETE TYPE HINTS",
-            "9. SELF-CONTAINED COMPONENTS",
-        ]
-    )
+    cr_body = "\n\n".join(f"## {t}\n\nbody" for t in _code_standards_section_order)
     (docs_directory / "CODE_RULES.md").write_text(cr_body, encoding="utf-8")
     merged = mod.merge_code_standards(
         (rules_directory / "code-standards.md", docs_directory / "CODE_RULES.md")
@@ -204,18 +224,94 @@ def test_merge_reference_headers_point_at_cursor_docs(tmp_path: Path) -> None:
     assert ".cursor/docs/CODE_RULES.md" in merged
 
     (rules_directory / "testing.md").write_text("# T\n", encoding="utf-8")
-    tq_body = "\n\n".join(
-        f"## {t}\n\nbody"
-        for t in [
-            "Delete Useless Tests",
-            "Test Dependencies MUST FAIL",
-            "Core Testing Principles",
-            "React Testing Patterns",
-            "Test File Organization",
-        ]
-    )
+    tq_body = "\n\n".join(f"## {t}\n\nbody" for t in _test_quality_section_order)
     (docs_directory / "TEST_QUALITY.md").write_text(tq_body, encoding="utf-8")
     merged_tq = mod.merge_test_quality(
         (rules_directory / "testing.md", docs_directory / "TEST_QUALITY.md")
     )
     assert ".cursor/docs/TEST_QUALITY.md" in merged_tq
+
+
+def test_code_standards_section_order_titles_all_exist_in_real_doc() -> None:
+    real_headings = set(_parse_h2_sections(_REAL_CODE_RULES_DOC.read_text(encoding="utf-8")))
+    missing_titles = [title for title in _code_standards_section_order if title not in real_headings]
+    assert missing_titles == [], (
+        f"_code_standards_section_order titles absent from {_REAL_CODE_RULES_DOC.name}: "
+        f"{missing_titles}"
+    )
+
+
+def test_test_quality_section_order_titles_all_exist_in_real_doc() -> None:
+    real_headings = set(_parse_h2_sections(_REAL_TEST_QUALITY_DOC.read_text(encoding="utf-8")))
+    missing_titles = [title for title in _test_quality_section_order if title not in real_headings]
+    assert missing_titles == [], (
+        f"_test_quality_section_order titles absent from {_REAL_TEST_QUALITY_DOC.name}: "
+        f"{missing_titles}"
+    )
+
+
+def test_merge_code_standards_raises_when_expected_section_absent(tmp_path: Path) -> None:
+    rules_directory = tmp_path / "rules"
+    docs_directory = tmp_path / "docs"
+    rules_directory.mkdir(parents=True, exist_ok=True)
+    docs_directory.mkdir(parents=True, exist_ok=True)
+    (rules_directory / "code-standards.md").write_text("# CS\n", encoding="utf-8")
+    present_titles = [
+        title for title in _code_standards_section_order if title != "5. NO ABBREVIATIONS"
+    ]
+    cr_body = "\n\n".join(f"## {title}\n\nbody" for title in present_titles)
+    (docs_directory / "CODE_RULES.md").write_text(cr_body, encoding="utf-8")
+    with pytest.raises(AssertionError, match="5. NO ABBREVIATIONS"):
+        mod.merge_code_standards(
+            (rules_directory / "code-standards.md", docs_directory / "CODE_RULES.md")
+        )
+
+
+def test_build_mappings_raises_when_testing_lacks_paths_frontmatter(tmp_path: Path) -> None:
+    claude = tmp_path / ".claude"
+    _minimal_rule_files(claude / "rules")
+    _minimal_code_rules_and_test_quality(claude / "docs")
+    (claude / "rules" / "testing.md").write_text("# Testing\n", encoding="utf-8")
+    with pytest.raises(AssertionError, match="testing.md"):
+        build_mappings(claude)
+
+
+def test_merge_test_quality_raises_when_expected_section_absent(tmp_path: Path) -> None:
+    rules_directory = tmp_path / "rules"
+    docs_directory = tmp_path / "docs"
+    rules_directory.mkdir(parents=True, exist_ok=True)
+    docs_directory.mkdir(parents=True, exist_ok=True)
+    (rules_directory / "testing.md").write_text("# T\n", encoding="utf-8")
+    present_titles = [
+        title for title in _test_quality_section_order if title != "Core Testing Principles"
+    ]
+    tq_body = "\n\n".join(f"## {title}\n\nbody" for title in present_titles)
+    (docs_directory / "TEST_QUALITY.md").write_text(tq_body, encoding="utf-8")
+    with pytest.raises(AssertionError, match="Core Testing Principles"):
+        mod.merge_test_quality(
+            (rules_directory / "testing.md", docs_directory / "TEST_QUALITY.md")
+        )
+
+
+def test_merge_test_quality_strips_leading_paths_frontmatter(tmp_path: Path) -> None:
+    docs_directory = tmp_path / "docs"
+    docs_directory.mkdir(parents=True, exist_ok=True)
+    test_quality_body = "\n\n".join(
+        f"## {title}\n\nbody" for title in _test_quality_section_order
+    )
+    (docs_directory / "TEST_QUALITY.md").write_text(test_quality_body, encoding="utf-8")
+    merged = mod.merge_test_quality(
+        (_REAL_TESTING_RULE, docs_directory / "TEST_QUALITY.md")
+    )
+    testing_text = _REAL_TESTING_RULE.read_text(encoding="utf-8")
+    first_content_line = next(
+        line for line in strip_leading_yaml_frontmatter(testing_text).splitlines()
+        if line.strip()
+    )
+    merged_lines = merged.splitlines()
+    assert merged_lines[0] != "---", "merged body must not open with a leaked frontmatter fence"
+    assert merged_lines[0] == first_content_line
+    body_before_reference = "\n".join(
+        merged_lines[: merged_lines.index("## Reference (full text: `.cursor/docs/TEST_QUALITY.md`)")]
+    )
+    assert "paths:" not in body_before_reference, "testing.md paths frontmatter leaked into rule body"

package/skills/_shared/pr-loop/scripts/skills_pr_loop_constants/path_resolver_constants.py

@@ -43,6 +43,8 @@ ALL_AUDIT_CATEGORY_ENTRIES = [
     ("L", "Behavior-equivalence for refactors"),
     ("M", "Producer/consumer cardinality vs collection-type contract"),
     ("N", "Test-name scenario verifier"),
+    ("O", "Docstring / fixture-prose vs implementation drift"),
+    ("P", "Name / regex / word-list vs behavior-contract precision"),
 ]
 
 AUDIT_RUBRIC_REFERENCE_TEXT = (

package/skills/_shared/pr-loop/scripts/test_build_audit_prompt.py

@@ -1,4 +1,4 @@
-"""Tests pinning build_audit_prompt's emitted A-N category taxonomy."""
+"""Tests pinning build_audit_prompt's emitted A-P category taxonomy."""
 
 from __future__ import annotations
 
@@ -18,7 +18,7 @@ from skills_pr_loop_constants.path_resolver_constants import (
 )
 
 _CATEGORY_RUBRICS_DIR = _SCRIPTS_DIR.parents[3] / "audit-rubrics" / "category_rubrics"
-_HEADING_PATTERN = re.compile(r"^# Category ([A-N]) — (.+)$")
+_HEADING_PATTERN = re.compile(r"^# Category ([A-P]) — (.+)$")
 
 
 def _load_build_audit_prompt() -> ModuleType:
@@ -60,12 +60,12 @@ def _build_audit_root() -> Element:
     )
 
 
-def test_bug_categories_carry_ids_a_through_n_in_order() -> None:
+def test_bug_categories_carry_ids_a_through_p_in_order() -> None:
     root = _build_audit_root()
     bug_categories = root.find("bug_categories")
     assert bug_categories is not None
     all_emitted_ids = [each_category.get("id") for each_category in bug_categories]
-    all_expected_ids = list("ABCDEFGHIJKLMN")
+    all_expected_ids = list("ABCDEFGHIJKLMNOP")
     assert all_emitted_ids == all_expected_ids
 
 
@@ -90,3 +90,50 @@ def test_rubric_reference_element_names_category_rubrics_directory() -> None:
     assert rubric_reference is not None
     assert rubric_reference.text is not None
     assert "audit-rubrics/category_rubrics" in rubric_reference.text
+
+
+def test_prompt_skeleton_sub_bucket_counts_match_rubric_rows() -> None:
+    """Each prompt skeleton's numeric sub-bucket count equals its rubric's row count.
+
+    For every (letter, label) the prompts dir holds a category-<letter>- file.
+    The skeleton above the first standalone --- line states "decomposed into N
+    sub-buckets"; that N must equal the rubric's count of | <letter>N | rows,
+    and a numeric walk-instruction range (For each sub-bucket X1-Xn) must end
+    at that same row count. Skeletons with a [N] placeholder are skipped.
+    """
+    prompts_directory = _CATEGORY_RUBRICS_DIR.parent / "prompts"
+    count_pattern = re.compile(r"decomposed into (\d+) sub-buckets")
+    for each_letter, _each_label in ALL_AUDIT_CATEGORY_ENTRIES:
+        all_prompt_matches = sorted(prompts_directory.glob(f"category-{each_letter.lower()}-*.md"))
+        assert all_prompt_matches, f"Missing prompt file for category {each_letter}"
+        all_skeleton_lines: list[str] = []
+        for each_line in all_prompt_matches[0].read_text(encoding="utf-8").splitlines():
+            if each_line == "---":
+                break
+            all_skeleton_lines.append(each_line)
+        skeleton_text = "\n".join(all_skeleton_lines)
+        each_count_match = count_pattern.search(skeleton_text)
+        if each_count_match is None:
+            assert "decomposed into [N] sub-buckets" in skeleton_text, (
+                f"Category {each_letter}: skeleton neither states a numeric "
+                "sub-bucket count nor carries the [N] placeholder"
+            )
+            continue
+        all_rubric_matches = sorted(_CATEGORY_RUBRICS_DIR.glob(f"category-{each_letter.lower()}-*.md"))
+        assert all_rubric_matches, f"Missing rubric file for category {each_letter}"
+        rubric_row_pattern = re.compile(r"^\| " + each_letter + r"\d+ \|", re.MULTILINE)
+        sub_bucket_row_count = len(rubric_row_pattern.findall(all_rubric_matches[0].read_text(encoding="utf-8")))
+        assert int(each_count_match.group(1)) == sub_bucket_row_count, (
+            f"Category {each_letter}: skeleton says {each_count_match.group(1)} sub-buckets "
+            f"but rubric has {sub_bucket_row_count} rows"
+        )
+        walk_range_pattern = re.compile(
+            rf"For each sub-bucket {each_letter}1[-–]{each_letter}(\d+)"
+        )
+        each_walk_match = walk_range_pattern.search(skeleton_text)
+        if each_walk_match is not None:
+            assert int(each_walk_match.group(1)) == sub_bucket_row_count, (
+                f"Category {each_letter}: walk instruction ends at "
+                f"{each_letter}{each_walk_match.group(1)} but rubric has "
+                f"{sub_bucket_row_count} rows"
+            )