claude-dev-env 8.0.0 → 8.2.0

package/scripts/test_active_capability_references.py

@@ -13,12 +13,10 @@ from active_capability_references import (
     build_capability_inventory,
     classify_capability_reference,
     extract_active_capability_names,
+    retired_capability_names,
     strip_inert_fenced_blocks,
     unresolved_active_capabilities,
 )
-from dev_env_scripts_constants.active_capability_constants import (
-    ALL_BANNED_ACTIVE_CAPABILITY_NAMES,
-)
 
 PACKAGE_ROOT = Path(__file__).resolve().parent.parent
 
@@ -43,66 +41,135 @@ def test_strip_inert_fenced_blocks_drops_historical_examples() -> None:
     assert "/sr-loop" in stripped
 
 
-def test_extract_active_capability_names_finds_slash_and_backticks() -> None:
-    markdown = "Run /privacy-hygiene then open `issue-tracker`.\n"
+def test_extract_active_capability_names_finds_invocations_and_manifests() -> None:
+    markdown = (
+        "Run /privacy-hygiene then open `issue-tracker/SKILL.md`.\n"
+        "See the guide at [review guide](../reviews/SKILL.md).\n"
+    )
     all_hits = extract_active_capability_names(markdown)
     all_names = {each_name for _line, each_name in all_hits}
-    assert "privacy-hygiene" in all_names
-    assert "issue-tracker" in all_names
+    assert all_names == {"privacy-hygiene", "issue-tracker", "reviews"}
+
+
+def test_urls_and_deep_paths_name_no_capability() -> None:
+    markdown = (
+        "Read [the advisor guide](https://code.claude.com/docs/en/advisor).\n"
+        "Call `POST /repos/{owner}/{repo}/issues/{number}/comments`.\n"
+        "The default role is `bugteam`.\n"
+    )
+    assert extract_active_capability_names(markdown) == []
+
+
+def test_retired_names_come_from_the_shipped_inventory() -> None:
+    inventory = build_capability_inventory(PACKAGE_ROOT)
+    all_retired_names = retired_capability_names(PACKAGE_ROOT, inventory)
+    assert "qbug" in all_retired_names
+    assert "findbugs" in all_retired_names
+    assert not all_retired_names.intersection(inventory.all_known_names())
 
 
-def test_banned_names_always_fail_classification() -> None:
-    for each_banned_name in sorted(ALL_BANNED_ACTIVE_CAPABILITY_NAMES):
-        reason = classify_capability_reference(each_banned_name)
+def test_a_retired_name_fails_classification() -> None:
+    inventory = build_capability_inventory(PACKAGE_ROOT)
+    all_retired_names = retired_capability_names(PACKAGE_ROOT, inventory)
+    for each_retired_name in sorted(all_retired_names):
+        reason = classify_capability_reference(each_retired_name, all_retired_names)
         assert reason is not None
-        assert each_banned_name in reason
+        assert each_retired_name in reason
 
 
-def test_known_and_unknown_non_banned_names_pass() -> None:
+def test_shipped_and_unknown_names_pass() -> None:
     inventory = build_capability_inventory(PACKAGE_ROOT)
-    known_name = next(iter(inventory.all_skill_names), "e-code-review")
-    assert classify_capability_reference(known_name) is None
-    assert classify_capability_reference("not-a-real-capability") is None
+    all_retired_names = retired_capability_names(PACKAGE_ROOT, inventory)
+    for each_shipped_name in sorted(inventory.all_known_names()):
+        assert (
+            classify_capability_reference(each_shipped_name, all_retired_names) is None
+        ), each_shipped_name
+    assert classify_capability_reference("not-a-capability", all_retired_names) is None
 
 
-def test_unresolved_reports_file_and_line_for_fixture(tmp_path: Path) -> None:
+def test_a_skill_dropped_from_the_tree_reports_without_a_hand_kept_list(
+    tmp_path: Path,
+) -> None:
     package_root = tmp_path / "pkg"
-    skills = package_root / "skills" / "real-skill"
-    skills.mkdir(parents=True)
-    (skills / "SKILL.md").write_text(
-        "Active instruction: call /qbug now.\n",
+    skill_directory = package_root / "skills" / "kept-skill"
+    skill_directory.mkdir(parents=True)
+    (skill_directory / "SKILL.md").write_text(
+        "Run /dropped-skill after /kept-skill.\n", encoding="utf-8"
+    )
+    (package_root / "agents").mkdir()
+    (package_root / "commands").mkdir()
+    (package_root / "bin").mkdir()
+    (package_root / "bin" / "ever-shipped-skills.mjs").write_text(
+        "export const EVER_SHIPPED_SKILL_NAMES = new Set([\n"
+        "    'kept-skill',\n"
+        "    'dropped-skill',\n"
+        "]);\n",
         encoding="utf-8",
     )
+    all_unresolved = unresolved_active_capabilities(
+        package_root,
+        all_relative_markdown_paths=["skills/kept-skill/SKILL.md"],
+    )
+    assert [each.capability_name for each in all_unresolved] == ["dropped-skill"]
+
+
+def _write_fixture_package(package_root: Path, skill_name: str, prose: str) -> None:
+    skill_directory = package_root / "skills" / skill_name
+    skill_directory.mkdir(parents=True)
+    (skill_directory / "SKILL.md").write_text(prose, encoding="utf-8")
     (package_root / "agents").mkdir()
-    (package_root / "agents" / "real-agent.md").write_text("# agent\n", encoding="utf-8")
+    (package_root / "agents" / "shipped-agent.md").write_text(
+        "# agent\n", encoding="utf-8"
+    )
     (package_root / "commands").mkdir()
-    (package_root / "commands" / "real-cmd.md").write_text("# cmd\n", encoding="utf-8")
+    (package_root / "commands" / "shipped-command.md").write_text(
+        "# command\n", encoding="utf-8"
+    )
+    (package_root / "bin").mkdir()
+    (package_root / "bin" / "ever-shipped-skills.mjs").write_text(
+        "export const EVER_SHIPPED_SKILL_NAMES = new Set([\n"
+        f"    '{skill_name}',\n"
+        "    'qbug',\n"
+        "]);\n",
+        encoding="utf-8",
+    )
+
+
+def test_unresolved_reports_file_and_line_for_fixture(tmp_path: Path) -> None:
+    package_root = tmp_path / "pkg"
+    _write_fixture_package(
+        package_root, "shipped-skill", "Active instruction: call /qbug now.\n"
+    )
     all_unresolved = unresolved_active_capabilities(
         package_root,
-        all_relative_markdown_paths=["skills/real-skill/SKILL.md"],
+        all_relative_markdown_paths=["skills/shipped-skill/SKILL.md"],
     )
     assert all_unresolved
     first = all_unresolved[0]
     assert first.capability_name == "qbug"
     assert first.line_number == 1
-    assert first.file_path == "skills/real-skill/SKILL.md"
-    assert "banned" in first.reason
+    assert first.file_path == "skills/shipped-skill/SKILL.md"
+    assert "retired" in first.reason
 
 
 def test_inert_historical_qbug_does_not_fail(tmp_path: Path) -> None:
     package_root = tmp_path / "pkg"
-    skill_dir = package_root / "skills" / "ok-skill"
-    skill_dir.mkdir(parents=True)
-    (skill_dir / "SKILL.md").write_text(
+    _write_fixture_package(
+        package_root,
+        "ok-skill",
         "```historical\nLegacy /qbug workflow.\n```\nUse /ok-skill.\n",
-        encoding="utf-8",
     )
-    (package_root / "agents").mkdir()
-    (package_root / "commands").mkdir()
     all_unresolved = unresolved_active_capabilities(
         package_root,
         all_relative_markdown_paths=["skills/ok-skill/SKILL.md"],
     )
-    assert all(
-        each.capability_name != "qbug" for each in all_unresolved
+    assert all(each.capability_name != "qbug" for each in all_unresolved)
+
+
+def test_the_package_names_no_retired_capability() -> None:
+    all_unresolved = unresolved_active_capabilities(PACKAGE_ROOT)
+    report = "\n".join(
+        f"{each.file_path}:{each.line_number} {each.capability_name}"
+        for each in all_unresolved
     )
+    assert not all_unresolved, report

package/scripts/tests/test_banned_prose_words.py

@@ -0,0 +1,103 @@
+"""Behavioral tests for the banned emphasis word detector."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from banned_prose_words import (
+    banned_prose_words_in_tree,
+    find_banned_prose_words,
+    governed_paths,
+    governs_path,
+    prose_lines,
+)
+
+
+def test_prose_occurrence_is_reported_with_its_line() -> None:
+    all_hits = find_banned_prose_words("First line.\nThe real cause is a timeout.\n")
+    assert [(each_line, each_word) for each_line, _column, each_word in all_hits] == [
+        (2, "real")
+    ]
+
+
+def test_every_banned_form_is_reported() -> None:
+    document_text = (
+        "It is real.\n"
+        "It is really late.\n"
+        "A real-world case.\n"
+        "The actual value.\n"
+        "It actually ran.\n"
+        "A genuine failure.\n"
+        "It genuinely ran.\n"
+        "It truly ran.\n"
+        "The true cause.\n"
+    )
+    all_words = {each_word for _line, _column, each_word in
+                 find_banned_prose_words(document_text)}
+    assert all_words == {
+        "real",
+        "really",
+        "real-world",
+        "actual",
+        "actually",
+        "genuine",
+        "genuinely",
+        "truly",
+        "true",
+    }
+
+
+def test_code_spans_and_paths_carry_no_finding() -> None:
+    document_text = (
+        "Read `actual_value` from the map.\n"
+        "```python\n"
+        "actual = compute()\n"
+        "```\n"
+        "    while True:\n"
+        "See docs/really-long-name.md for the table.\n"
+        "The flag reads always_apply: true.\n"
+    )
+    assert find_banned_prose_words(document_text) == []
+
+
+def test_predicative_true_carries_no_finding() -> None:
+    document_text = (
+        "The condition is true when the port answers.\n"
+        "A branch that is always true never runs the other arm.\n"
+    )
+    assert find_banned_prose_words(document_text) == []
+
+
+def test_prose_lines_blank_code_and_keep_the_line_count() -> None:
+    document_text = "Prose here.\n```python\nactual = 1\n```\nMore prose.\n"
+    assert prose_lines(document_text) == ["Prose here.", "", "", "", "More prose."]
+
+
+def test_governed_paths_lists_the_shipped_surfaces(tmp_path: Path) -> None:
+    (tmp_path / "rules").mkdir()
+    (tmp_path / "rules" / "one.md").write_text("Prose.\n", encoding="utf-8")
+    (tmp_path / "rules-archived").mkdir()
+    (tmp_path / "rules-archived" / "two.md").write_text("Prose.\n", encoding="utf-8")
+    (tmp_path / "scripts").mkdir()
+    (tmp_path / "scripts" / "three.py").write_text("x = 1\n", encoding="utf-8")
+    assert governed_paths(tmp_path) == ["rules/one.md"]
+
+
+def test_governed_paths_cover_instruction_surfaces_and_skip_archives() -> None:
+    assert governs_path("rules/git-workflow.md")
+    assert governs_path(".agents/skills/eli5/SKILL.md")
+    assert governs_path("audit-rubrics/prompts/category-e-dead-code.md")
+    assert governs_path("system-prompts/software-engineer.xml")
+    assert not governs_path("rules-archived/manifest.md")
+    assert not governs_path("scripts/banned_prose_words.py")
+    assert not governs_path("CHANGELOG.md")
+
+
+def test_shipped_instruction_surfaces_carry_no_banned_word() -> None:
+    package_root = Path(__file__).resolve().parent.parent.parent
+    all_hits = banned_prose_words_in_tree(package_root)
+    report = "\n".join(
+        f"{each_path}:{each_line}:{each_column} {each_word}"
+        for each_path, each_line, each_column, each_word in all_hits[:40]
+    )
+    assert not all_hits, f"{len(all_hits)} banned words on shipped surfaces:\n{report}"

package/scripts/tests/test_codex_compat_materializer.py

@@ -826,7 +826,7 @@ def test_failure_blast_radius_projection_uses_the_canonical_excerpt() -> None:
     projected_instruction = materializer.render_codex_failure_blast_radius(canonical_rule)
 
     assert projected_instruction.startswith("Failure handling for this run")
-    assert "Three real attempts, then park." in projected_instruction
+    assert "Three attempts, then park." in projected_instruction
     assert "Report as: N of M complete" in projected_instruction
 
 
@@ -851,7 +851,7 @@ def test_build_plan_publishes_owned_agents_projection_and_tracks_drift(
     assert manifest_record["source"] == "rules/failure-blast-radius.md"
 
     rule_path.write_text(
-        rule_path.read_text(encoding="utf-8").replace("Three real attempts, then park.", "Three tested attempts, then park."),
+        rule_path.read_text(encoding="utf-8").replace("Three attempts, then park.", "Three tested attempts, then park."),
         encoding="utf-8",
     )
     drifted_plan, _ = build_plan(config, all_agents=[])
@@ -1021,7 +1021,7 @@ def _assert_projection_and_manifest(
 ) -> None:
     assert not retired_owned_path.exists()
     projected_instruction = (target / "AGENTS.md").read_text(encoding="utf-8")
-    assert "Three real attempts, then park." in projected_instruction
+    assert "Three attempts, then park." in projected_instruction
     manifest = json.loads((target / "hooks.json").read_text(encoding="utf-8"))
     assert manifest["hooks"]["PreToolUse"][0]["matcher"] == "apply_patch"
     assert manifest["hooks"]["PreToolUse"][1] == existing_hooks["hooks"]["PreToolUse"][1]

package/scripts/tests/test_engine.py

@@ -16,7 +16,7 @@ from sync_to_cursor.engine import run as run_sync_to_cursor
 _CODE_STANDARDS_SECTION_ORDER = (
     "COMMENT PRESERVATION",
     "CORE PRINCIPLES",
-    "⚡ HOOK-ENFORCED RULES",
+    "⚡ LINT-ENFORCED RULES",
     "3. REUSE CONSTANTS / 4. CONFIG LOCATIONS",
     "5. NO ABBREVIATIONS",
     "6. COMPLETE TYPE HINTS",

package/scripts/tests/test_policy_lint_rules_retired_hook_prose.py

@@ -195,3 +195,49 @@ def test_the_committed_rules_directory_names_no_gate_that_stopped_running() -> N
             )
         )
     assert all_messages == []
+
+
+def _diagnostics_for_path(
+    repository_root: Path, document_path: str, prose: str
+) -> tuple[str, ...]:
+    document = Document(
+        PurePosixPath(document_path),
+        prose,
+        None,
+        None,
+        ContentOrigin.WORKTREE,
+    )
+    all_diagnostics = adapter_retired_hook_prose.retired_hook_prose_diagnostics(
+        document, repository_root
+    )
+    return tuple(each_diagnostic.message for each_diagnostic in all_diagnostics)
+
+
+def test_instruction_surfaces_outside_rules_are_in_scope() -> None:
+    for each_path in (
+        "packages/claude-dev-env/rules/example.md",
+        "packages/claude-dev-env/.agents/skills/example/SKILL.md",
+        "packages/claude-dev-env/.agents/agents/example.md",
+        "packages/claude-dev-env/commands/example.md",
+        "packages/claude-dev-env/docs/example.md",
+    ):
+        document = Document(
+            PurePosixPath(each_path), "", None, None, ContentOrigin.WORKTREE
+        )
+        assert adapter_retired_hook_prose.accepts_instruction_markdown(document), each_path
+
+
+def test_a_skill_claim_for_a_surviving_unregistered_hook_is_reported(
+    tmp_path: Path,
+) -> None:
+    _build_package(tmp_path)
+    (tmp_path / "packages" / "claude-dev-env" / ".agents" / "skills" / "example").mkdir(
+        parents=True
+    )
+    all_messages = _diagnostics_for_path(
+        tmp_path,
+        "packages/claude-dev-env/.agents/skills/example/SKILL.md",
+        "The `windows_rmtree_blocker.py` PreToolUse hook blocks the unsafe pattern.\n",
+    )
+    assert len(all_messages) == 1
+    assert "windows_rmtree_blocker" in all_messages[0]

package/scripts/tests/test_rules.py

@@ -9,7 +9,7 @@ _SCRIPTS_DIR = Path(__file__).resolve().parent.parent
 if str(_SCRIPTS_DIR) not in sys.path:
     sys.path.insert(0, str(_SCRIPTS_DIR))
 
-from sync_to_cursor.rules import build_mappings
+from sync_to_cursor.rules import build_mappings, merge_code_standards
 
 _PACKAGE_ROOT = _SCRIPTS_DIR.parent
 _SKIPPED_RULE_FILE_NAMES = frozenset({"CLAUDE.md", "AGENTS.md"})
@@ -225,3 +225,14 @@ def test_comment_policy_removes_directive_justification_guidance() -> None:
     assert "without clear justification" not in react_patterns
     assert "changed `# noqa` directives are removed or resolved" in category_e_prompt
     assert "every `# noqa` on an import line must be justified" not in category_e_prompt
+
+
+def test_merge_code_standards_resolves_every_heading_it_names() -> None:
+    merged_text = merge_code_standards(
+        (
+            _PACKAGE_ROOT / "rules" / "code-standards.md",
+            _PACKAGE_ROOT / "docs" / "CODE_RULES.md",
+        )
+    )
+    assert "## Reference (full text:" in merged_text
+    assert "## COMMENT PRESERVATION" in merged_text

package/system-prompts/software-engineer.xml

@@ -72,7 +72,7 @@
   inferring are replaced by honest acknowledgment. Second, every recommendation, claim, or piece of advice cites a
   specific source: a file in the current project, an external URL found via web search, a
   named expert or paper, or official documentation. Third, when working from documents, extract
-  the actual text first before analyzing — ground responses in direct quotes, and reference
+  the text first before analyzing — ground responses in direct quotes, and reference
   the quote when making a point.
 
   Creative thinking, brainstorming, and novel ideas are exempt from citation requirements;
@@ -85,7 +85,7 @@
   error message, verify the assumption that produced it, and apply a targeted fix. Commit to
   a viable approach and see it through; switch approaches only when new information directly
   contradicts the original reasoning. Escalate to the user only after investigation is
-  complete and a genuine decision point requires their input.
+  complete and a decision point requires their input.
 
   Treat OWASP top 10 vulnerability classes — command injection, XSS, SQL injection, and
   related categories — as first-class design criteria. Build code that is inherently resistant
@@ -115,7 +115,7 @@
   Types — complete coverage required:
   - Every parameter and return value carries an explicit type hint
   - Replace Any with the most specific type available
-  - Avoid `# type: ignore`; remove it and use a typed boundary or real type (AGENTS Types)
+  - Avoid `# type: ignore`; remove it and use a typed boundary or an explicit type (AGENTS Types)
 
   Configuration — one source of truth:
   - Every constant lives in config/ only
@@ -156,7 +156,7 @@
   desired behaviour. Surface assumptions early so they can be confirmed or corrected.
 
   Illustrate phase. Explore goals, constraints, and concrete examples with the user. Use
-  real scenarios — "given X, when Y happens, the system should Z" — to ground the conversation
+  scenarios — "given X, when Y happens, the system should Z" — to ground the conversation
   in observable outcomes.
 
   Formulate phase. Express behaviour as developer-facing executable specifications using the
@@ -193,7 +193,7 @@
 
   Right-sized engineering: functions over classes, concrete over abstract, YAGNI on API
   surface. Abstract base classes for single implementations, dependency injection frameworks,
-  CQRS, microservices, and multiple inheritance hierarchies belong only when a real second
+  CQRS, microservices, and multiple inheritance hierarchies belong only when a second
   use case has arrived.
 </scope_discipline>
 
@@ -224,7 +224,7 @@
   When multiple tool calls are mutually independent, make all calls in a single response.
   Sequence calls only when a later call requires an earlier call's result. Reading three files:
   call all three Read operations at once. Running independent searches: launch all Grep
-  and Glob calls simultaneously. Use real parameter values only. When uncertain whether calls are
+  and Glob calls simultaneously. Use concrete parameter values only. When uncertain whether calls are
   independent, run them sequentially.
 </agent_workflow>
 
@@ -363,7 +363,7 @@
   Prefer working in memory over creating scratchpad files. Use variables and tool results
   over writing intermediate data to disk.
 
-  When a temporary file is genuinely needed — a helper script, a test fixture, a debug output
+  When a temporary file is needed — a helper script, a test fixture, a debug output
   — track it for cleanup. After each task completes, remove every temporary file, script, or
   helper file created during the task. Leave the working directory cleaner than it was found.