claude-dev-env 8.1.0 → 8.3.0

package/scripts/policy_lint/adapters.py

@@ -427,25 +427,25 @@ def accepts_plans(document: Document) -> bool:
     )
 
 
-def accepts_rules_markdown(document: Document) -> bool:
-    """Return whether the document is Markdown in a rules directory.
+def accepts_instruction_markdown(document: Document) -> bool:
+    """Return whether the document is authored instruction Markdown.
 
     Args:
         document: Candidate document.
 
     Returns:
-        True for a Markdown file directly under a ``rules`` directory.
+        True for Markdown on an instruction surface.
     """
-    return adapter_retired_hook_prose.accepts_rules_markdown(document)
+    return adapter_retired_hook_prose.accepts_instruction_markdown(document)
 
 
 def retired_hook_prose_diagnostics(
     document: Document, repository_root: Path
 ) -> tuple[Diagnostic, ...]:
-    """Report rules prose that credits an unregistered hook with a live action.
+    """Report instruction prose that credits an unregistered hook with a live action.
 
     Args:
-        document: Current rules Markdown text and path.
+        document: Current instruction Markdown text and path.
         repository_root: Request repository root for package resolution.
 
     Returns:

package/scripts/policy_lint/config/constants.py

@@ -92,6 +92,14 @@ VIOLATION_SCOPING_MODULE_NAME = "code_rules_gate_parts.violation_scoping"
 
 RETIRED_HOOK_PROSE_RULE_ID = "retired-hook-prose"
 RULES_DIRECTORY_NAME = "rules"
+ALL_HOOK_PROSE_SURFACE_SEGMENTS = (
+    "/.agents/",
+    "/commands/",
+    "/docs/",
+    "/output-styles/",
+    "/rules/",
+    "/system-prompts/",
+)
 HOOKS_DIRECTORY_NAME = "hooks"
 HOOKS_CONFIGURATION_FILE_NAME = "hooks.json"
 HOOK_CONSTANTS_DIRECTORY_NAME = "hooks_constants"

package/scripts/policy_lint/registry.py

@@ -106,7 +106,7 @@ def _text_document_rules() -> tuple[model.Rule, ...]:
         ),
         build_document_rule(
             "retired-hook-prose",
-            adapters.accepts_rules_markdown,
+            adapters.accepts_instruction_markdown,
             adapters.retired_hook_prose_diagnostics,
         ),
     )

package/scripts/resolve_advisor_model_route.mjs

@@ -36,14 +36,14 @@ if (input !== undefined) {
         routingDecision = routingInputIssue
             ? blockedRoute(routingInputIssue)
             : resolveSubagentModelRoute({
-                agent_type: 'session-advisor',
+                agent_type: 'advisor',
                 ...(input.model !== undefined && input.model !== null ? { model: input.model } : {}),
                 ...(input.reasoning_effort !== undefined ? { reasoning_effort: input.reasoning_effort } : {}),
             }, {
                 policyPath: input.policyPath,
                 trustedSessionMetadata: {
                     authorized: true,
-                    registeredAgentType: 'session-advisor',
+                    registeredAgentType: 'advisor',
                 },
             });
     }

package/scripts/subagent_model_policy.mjs

@@ -298,7 +298,10 @@ function validateRoles(roles) {
         const aliases = validateStringList(roles[role], `roles.${role}`).map(normalizeToken);
         const allAliases = [role, ...aliases];
         for (const alias of allAliases) {
-            if (!isIdentifier(alias)) throw new SubagentModelPolicyError(`invalid role name: ${alias}`);
+            const roleParts = alias.split(':');
+            if (roleParts.length > 2 || !roleParts.every(isIdentifier)) {
+                throw new SubagentModelPolicyError(`invalid role name: ${alias}`);
+            }
             const previousRole = roleByAlias.get(alias);
             if (previousRole && previousRole !== role) {
                 throw new SubagentModelPolicyError(`role alias is ambiguous: ${alias}`);

package/scripts/sync_to_cursor/rules.py

@@ -73,7 +73,7 @@ _merged_mapping_key_order = (
 _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/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/test_grok_headless_runner.py

@@ -7,6 +7,7 @@ include the signature substrings the constants module lists.
 
 from __future__ import annotations
 
+import json
 import subprocess
 import sys
 import time
@@ -336,7 +337,11 @@ def test_argv_includes_agent_when_named(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:
     fake_process = _FakeProcess(returncode=0, stdout='{"ok":true}')
-    agent_name = "code-quality-agent"
+    agent_name = "poteto-agent"
+    skill_path = tmp_path / "poteto-mode" / "SKILL.md"
+    skill_path.parent.mkdir()
+    skill_path.write_text("Keep the requested duty.\n", encoding="utf-8")
+    monkeypatch.setattr(runner, "poteto_mode_skill_path", lambda: skill_path)
     outcome, recorder, _, _, _ = _run_once(
         monkeypatch, tmp_path, fake_process, agent_name=agent_name
     )
@@ -345,6 +350,35 @@ def test_argv_includes_agent_when_named(
     invocation = recorder.invocations[0]
     assert AGENT_FLAG in invocation
     assert agent_name in invocation
+    generated_prompt = Path(invocation[invocation.index(PROMPT_FILE_FLAG) + 1])
+    assert "Keep the requested duty." in generated_prompt.read_text(encoding="utf-8")
+    assert str(skill_path) in generated_prompt.read_text(encoding="utf-8")
+
+
+def test_native_plugin_skill_is_included_in_worker_prompt(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    config_root = tmp_path / "profile"
+    registry_path = config_root / "plugins" / "installed_plugins.json"
+    registry_path.parent.mkdir(parents=True)
+    plugin_root = tmp_path / "plugin" / "version"
+    registry_path.write_text(json.dumps({"plugins": {"pstack@pstack-claude": [
+        {"scope": "user", "installPath": str(plugin_root)},
+    ]}}), encoding="utf-8")
+    skill_path = plugin_root / "skills" / "poteto-mode" / "SKILL.md"
+    skill_path.parent.mkdir(parents=True)
+    skill_path.write_text("Use the native workflow.\n", encoding="utf-8")
+    monkeypatch.setenv("CLAUDE_CONFIG_DIR", str(config_root))
+    outcome, recorder, _, _, _ = _run_once(
+        monkeypatch, tmp_path, _FakeProcess(returncode=0, stdout="done"),
+        agent_name="poteto-agent",
+    )
+    assert outcome.is_ok
+    invocation = recorder.invocations[0]
+    prompt = Path(invocation[invocation.index(PROMPT_FILE_FLAG) + 1]).read_text(encoding="utf-8")
+    assert str(skill_path.resolve()) in prompt
+    assert "Use the native workflow." in prompt
+    assert "Resolve companion skill paths against that source directory." in prompt
 
 
 def test_unique_leader_socket_path_per_call(

package/scripts/test_grok_worker_preflight.py

@@ -80,6 +80,9 @@ class _Recorder:
 def _write_install_layout(claude_home: Path, *, role: str = ROLE_BUGTEAM) -> None:
     claude_home.mkdir(parents=True, exist_ok=True)
     (claude_home / MANIFEST_FILENAME).write_text("{}", encoding=UTF8_ENCODING)
+    skill_path = claude_home / "skills" / "poteto-mode" / "SKILL.md"
+    skill_path.parent.mkdir(parents=True, exist_ok=True)
+    skill_path.write_text("Poteto guidance\n", encoding=UTF8_ENCODING)
     agents_directory = claude_home / AGENTS_SUBDIRECTORY
     agents_directory.mkdir(parents=True, exist_ok=True)
     for each_filename in ALL_AGENT_FILENAMES_BY_ROLE[role]:
@@ -88,6 +91,76 @@ def _write_install_layout(claude_home: Path, *, role: str = ROLE_BUGTEAM) -> Non
         )
 
 
+def test_missing_poteto_skill_rejects_installed_agent(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    _write_install_layout(tmp_path)
+    monkeypatch.setattr(preflight, "claude_config_home", lambda: tmp_path)
+    assert preflight._is_claude_dev_env_config_present(ROLE_BUGTEAM)
+    preflight.poteto_mode_skill_path().unlink()
+    assert not preflight._is_claude_dev_env_config_present(ROLE_BUGTEAM)
+
+
+def _write_native_pstack(config_root: Path, plugin_root: Path) -> Path:
+    registry_path = config_root / "plugins" / "installed_plugins.json"
+    registry_path.parent.mkdir(parents=True, exist_ok=True)
+    registry_path.write_text(
+        json.dumps({"plugins": {"pstack@pstack-claude": [
+            {"scope": "user", "installPath": str(plugin_root)},
+            {"scope": "project", "installPath": str(plugin_root / "other")},
+        ]}}),
+        encoding=UTF8_ENCODING,
+    )
+    skill_path = plugin_root / "skills" / "poteto-mode" / "SKILL.md"
+    skill_path.parent.mkdir(parents=True)
+    skill_path.write_text("Native poteto guidance\n", encoding=UTF8_ENCODING)
+    companion = skill_path.parent / "playbooks" / "bug-fix.md"
+    companion.parent.mkdir()
+    companion.write_text("Fix guidance\n", encoding=UTF8_ENCODING)
+    return skill_path
+
+
+def _damage_native_plugin(config_root: Path, native_skill: Path, damage: str) -> None:
+    if damage == "missing":
+        native_skill.unlink()
+        return
+    if damage == "empty":
+        native_skill.write_text("", encoding=UTF8_ENCODING)
+        return
+    if damage == "encoding":
+        native_skill.write_bytes(b"\xff")
+        return
+    (config_root / "plugins" / "installed_plugins.json").write_text(
+        "{", encoding=UTF8_ENCODING
+    )
+
+
+def test_native_plugin_source_overrides_shared_skill(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    config_root = tmp_path / "profile"
+    _write_install_layout(config_root)
+    native_skill = _write_native_pstack(config_root, tmp_path / "plugin-version")
+    monkeypatch.setenv("CLAUDE_CONFIG_DIR", str(config_root))
+    assert preflight.poteto_mode_skill_path() == native_skill
+    assert (native_skill.parent / "playbooks" / "bug-fix.md").read_text() == "Fix guidance\n"
+    assert preflight._is_claude_dev_env_config_present(ROLE_BUGTEAM)
+
+
+@pytest.mark.parametrize("damage", ["missing", "empty", "encoding", "registry"])
+def test_broken_native_plugin_does_not_fall_back_to_shared_skill(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path, damage: str
+) -> None:
+    config_root = tmp_path / "profile"
+    _write_install_layout(config_root)
+    native_skill = _write_native_pstack(config_root, tmp_path / "plugin-version")
+    monkeypatch.setenv("CLAUDE_CONFIG_DIR", str(config_root))
+    _damage_native_plugin(config_root, native_skill, damage)
+    with pytest.raises(OSError):
+        preflight.poteto_mode_skill_path()
+    assert not preflight._is_claude_dev_env_config_present(ROLE_BUGTEAM)
+
+
 def _install_ok_static_seams(
     monkeypatch: pytest.MonkeyPatch,
     claude_home: Path,

package/scripts/tests/resolve_advisor_model_route.test.mjs

@@ -12,12 +12,12 @@ function runBridge(input) {
     });
 }
 
-test('advisor bridge selects the policy default', () => {
-    const result = runBridge(JSON.stringify({ reasoning_effort: 'xhigh' }));
+test('advisor bridge uses the trusted advisor registration', () => {
+    const result = runBridge(JSON.stringify({ model: 'Astra', reasoning_effort: 'high' }));
     assert.equal(result.status, 0);
     assert.deepEqual(JSON.parse(result.stdout).selected, {
         model: 'gpt-6-astra',
-        effort: 'medium',
+        effort: 'high',
     });
 });
 

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_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]