claude-dev-env 1.17.5 → 1.19.1

package/hooks/blocking/content-search-to-zoekt-redirector.py

@@ -8,7 +8,10 @@ import sys
 from content_search_zoekt_bash_block_reason import block_reason_for_bash_command
 from content_search_zoekt_block_payload import build_block_payload
 from content_search_zoekt_indexed_paths import is_in_indexed_repo, is_specific_file
-from content_search_zoekt_redirect_guidance import get_zoekt_redirect_guidance
+from content_search_zoekt_redirect_guidance import (
+    get_zoekt_redirect_guidance,
+    get_zoekt_redirect_reason_brief,
+)
 
 
 def main() -> None:
@@ -45,7 +48,8 @@ def main() -> None:
     short_label = f"blocked {block_reason}; use Zoekt MCP"
     payload = build_block_payload(
         brief_label=short_label,
-        permission_decision_reason=get_zoekt_redirect_guidance(),
+        permission_decision_reason=get_zoekt_redirect_reason_brief(),
+        additional_context=get_zoekt_redirect_guidance(),
     )
     print(json.dumps(payload))
     sys.exit(0)

package/hooks/blocking/content_search_zoekt_block_payload.py

@@ -4,14 +4,18 @@
 def build_block_payload(
     brief_label: str,
     permission_decision_reason: str,
+    additional_context: str | None = None,
 ) -> dict:
     destructive_gate_label_prefix = "[destructive-gate]"
+    hook_specific_output: dict = {
+        "hookEventName": "PreToolUse",
+        "permissionDecision": "deny",
+        "permissionDecisionReason": permission_decision_reason,
+    }
+    if additional_context is not None:
+        hook_specific_output["additionalContext"] = additional_context
     return {
-        "hookSpecificOutput": {
-            "hookEventName": "PreToolUse",
-            "permissionDecision": "deny",
-            "permissionDecisionReason": permission_decision_reason,
-        },
+        "hookSpecificOutput": hook_specific_output,
         "systemMessage": f"{destructive_gate_label_prefix} {brief_label}",
         "suppressOutput": True,
     }

package/hooks/blocking/content_search_zoekt_redirect_guidance.py

@@ -1,4 +1,10 @@
-"""Zoekt MCP usage and repo-to-disk path mapping for PreToolUse permissionDecisionReason."""
+"""Zoekt MCP usage and repo-to-disk path mapping for PreToolUse outputs."""
+
+
+def get_zoekt_redirect_reason_brief() -> str:
+    return (
+        "Use Zoekt MCP (e.g. mcp__zoekt__search) instead of Grep/Search in Zoekt-indexed trees."
+    )
 
 
 def get_zoekt_redirect_guidance() -> str:

package/hooks/blocking/test_content_search_to_zoekt_redirector_integration.py

@@ -13,7 +13,10 @@ class ContentSearchHookIntegrationTests(unittest.TestCase):
         hook_directory = pathlib.Path(__file__).resolve().parent
         if str(hook_directory) not in sys.path:
             sys.path.insert(0, str(hook_directory))
-        from content_search_zoekt_redirect_guidance import get_zoekt_redirect_guidance
+        from content_search_zoekt_redirect_guidance import (
+            get_zoekt_redirect_guidance,
+            get_zoekt_redirect_reason_brief,
+        )
 
         hook_path = hook_directory / "content-search-to-zoekt-redirector.py"
         destructive_gate_label_prefix = "[destructive-gate]"
@@ -38,6 +41,10 @@ class ContentSearchHookIntegrationTests(unittest.TestCase):
         )
         self.assertEqual(
             payload["hookSpecificOutput"]["permissionDecisionReason"],
+            get_zoekt_redirect_reason_brief(),
+        )
+        self.assertEqual(
+            payload["hookSpecificOutput"]["additionalContext"],
             get_zoekt_redirect_guidance(),
         )
         self.assertEqual(

package/hooks/blocking/test_content_search_to_zoekt_redirector_unit.py

@@ -11,7 +11,10 @@ if str(HOOK_DIRECTORY) not in sys.path:
     sys.path.insert(0, str(HOOK_DIRECTORY))
 
 from content_search_zoekt_block_payload import build_block_payload
-from content_search_zoekt_redirect_guidance import get_zoekt_redirect_guidance
+from content_search_zoekt_redirect_guidance import (
+    get_zoekt_redirect_guidance,
+    get_zoekt_redirect_reason_brief,
+)
 
 
 class BuildBlockPayloadTests(unittest.TestCase):
@@ -32,12 +35,14 @@ class BuildBlockPayloadTests(unittest.TestCase):
         self.assertEqual(payload["suppressOutput"], True)
         self.assertNotIn("decision", payload)
         self.assertNotIn("reason", payload)
+        self.assertNotIn("additionalContext", payload["hookSpecificOutput"])
 
     def test_serialized_payload_under_documented_context_cap(self) -> None:
         cap_characters = 10_000
         payload = build_block_payload(
             brief_label="blocked Bash(grep); use Zoekt MCP",
-            permission_decision_reason=get_zoekt_redirect_guidance(),
+            permission_decision_reason=get_zoekt_redirect_reason_brief(),
+            additional_context=get_zoekt_redirect_guidance(),
         )
         serialized = json.dumps(payload)
         self.assertLessEqual(

package/hooks/hooks.json

@@ -2,6 +2,16 @@
   "description": "Code standards enforcement, safety guards, and development workflow hooks",
   "hooks": {
     "PreToolUse": [
+      {
+        "matcher": "Grep|Search",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/blocking/content-search-to-zoekt-redirector.py",
+            "timeout": 10
+          }
+        ]
+      },
       {
         "matcher": "Write|Edit",
         "hooks": [
@@ -84,6 +94,11 @@
             "type": "command",
             "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/blocking/test-preflight-check.py",
             "timeout": 10
+          },
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/blocking/content-search-to-zoekt-redirector.py",
+            "timeout": 10
           }
         ]
       },

package/package.json

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

package/hooks/HOOK_SPECS_PROMPT_WORKFLOW.md

@@ -1,64 +0,0 @@
-# Prompt Workflow Hook Specs
-
-Deterministic runtime gates for prompt workflows.
-
-## PreToolUse Task/Agent (removed)
-
-The former `agent-execution-intent-gate.py` hook is **removed**. Native Agent/Task launches do not carry stable custom metadata; enforcing scope text on every spawn blocked legitimate `/agent-prompt` and refinement delegations. Scope and checklist rules remain enforced by the Stop guard when a prompt-workflow response is detected.
-
-## Gate: Leakage + Checklist + Scope (file-based validation loop)
-
-- Validator: `hooks/blocking/prompt_workflow_validate.py`
-- Invocation: CLI against `data/prompts/.draft-prompt.xml` (exit 0 allowed, exit 2 blocked)
-- Fail conditions:
-  - Raw internal refinement object appears in assistant output without explicit debug intent
-  - Prompt-workflow response detected but deterministic checklist container is missing
-  - Prompt-workflow response detected and required deterministic checklist rows are missing
-  - Prompt-workflow response detected and required scope anchors are missing
-  - Prompt-workflow response detected and runtime context-control signals are missing
-  - Scope-bound text uses banned ambiguous scope terms
-  - Banned negative keywords found inside fenced XML artifact
-  - Fenced XML artifact missing required sections
-- Enforcement: The drafting subagent writes the draft file, runs the validator, reads stderr violations (each prefixed with `[reason_code]`), edits the file, and re-runs until exit 0.
-
-## Required Scope Anchors
-
-- `target_local_roots`
-- `target_canonical_roots`
-- `target_file_globs`
-- `comparison_basis`
-- `completion_boundary`
-
-## Required Deterministic Checklist Rows
-
-- `structured_scoped_instructions`
-- `sequential_steps_present`
-- `positive_framing`
-- `acceptance_criteria_defined`
-- `safety_reversibility_language`
-- `reversible_action_and_safety_check_guidance`
-- `concrete_output_contract`
-- `scope_boundary_present`
-- `explicit_scope_anchors_present`
-- `all_instructions_artifact_bound`
-- `scope_terms_explicit_and_anchored`
-- `completion_boundary_measurable`
-- `citation_grounding_policy_present`
-- `source_priority_rules_present`
-
-## Runtime Context-Control Signals
-
-- `base_minimal_instruction_layer: true`
-- `on_demand_skill_loading: true`
-
-These two signals are checked by the validator CLI whenever a prompt-workflow response is detected.
-
-## Deterministic Boundary
-
-These hooks enforce only structural/runtime checks. Semantic quality remains in auditor layer.
-
-## Reviewing Flattened Transcript Exports
-
-- Live prompt-workflow responses still require an explicit `Audit:` line plus one outer `xml` fence. The Stop guard and clipboard path continue to evaluate that literal boundary.
-- Saved transcript exports can flatten blocked retry turns and omit the outer fence lines. Normalize those files with `prompt_workflow_gate_core.normalize_prompt_workflow_export(...)`, then evaluate the rebuilt message with `extract_fenced_xml_content(...)` or `extract_fenced_xml_content_from_export(...)`.
-- Fence-relative evals review the **last successful Audit + artifact pair** after normalization. Earlier blocked retries in the flattened transcript remain diagnostic evidence and do not count as extra delivered artifacts.

package/hooks/blocking/prompt_workflow_clipboard.py

@@ -1,63 +0,0 @@
-#!/usr/bin/env python3
-"""Cross-platform clipboard writes for prompt-workflow XML artifacts."""
-
-from __future__ import annotations
-
-import os
-
-
-def _clipboard_disabled_by_env() -> bool:
-    flag = os.environ.get("PROMPT_WORKFLOW_SKIP_CLIPBOARD", "").strip().lower()
-    return flag in {"1", "true", "yes", "on"}
-
-
-def copy_text_to_system_clipboard(text: str) -> bool:
-    """Write ``text`` to the OS clipboard using Python-only backends.
-
-    Tries :mod:`tkinter` (stdlib) first, then optional ``pyperclip`` if installed.
-    Returns ``True`` when a backend reports success, ``False`` otherwise
-    (missing dependency, headless display, empty payload, or env opt-out).
-    """
-    if not text.strip():
-        return False
-    if _clipboard_disabled_by_env():
-        return False
-    if _copy_via_tkinter(text):
-        return True
-    return _copy_via_pyperclip(text)
-
-
-def _copy_via_tkinter(text: str) -> bool:
-    try:
-        import tkinter as tk
-    except ImportError:
-        return False
-    root: tk.Tk | None = None
-    try:
-        root = tk.Tk()
-        root.withdraw()
-        root.clipboard_clear()
-        root.clipboard_append(text)
-        root.update_idletasks()
-        root.update()
-        return True
-    except Exception:
-        return False
-    finally:
-        if root is not None:
-            try:
-                root.destroy()
-            except Exception:
-                pass
-
-
-def _copy_via_pyperclip(text: str) -> bool:
-    try:
-        import pyperclip
-    except ImportError:
-        return False
-    try:
-        pyperclip.copy(text)
-        return True
-    except Exception:
-        return False

package/hooks/blocking/prompt_workflow_gate_config.py

@@ -1,113 +0,0 @@
-"""Static lists and compiled regexes for prompt-workflow gate checks.
-
-Edit this file to change scope anchors, checklist rows, markers, or keyword lists
-without touching gate logic in prompt_workflow_gate_core.py.
-"""
-
-from __future__ import annotations
-
-import re
-
-REQUIRED_SCOPE_ANCHORS: tuple[str, ...] = (
-    "target_local_roots",
-    "target_canonical_roots",
-    "target_file_globs",
-    "comparison_basis",
-    "completion_boundary",
-)
-
-REQUIRED_CHECKLIST_ROWS: tuple[str, ...] = (
-    "structured_scoped_instructions",
-    "sequential_steps_present",
-    "positive_framing",
-    "acceptance_criteria_defined",
-    "safety_reversibility_language",
-    "reversible_action_and_safety_check_guidance",
-    "concrete_output_contract",
-    "scope_boundary_present",
-    "explicit_scope_anchors_present",
-    "all_instructions_artifact_bound",
-    "scope_terms_explicit_and_anchored",
-    "completion_boundary_measurable",
-    "citation_grounding_policy_present",
-    "source_priority_rules_present",
-    "artifact_language_confidence",
-)
-
-AMBIGUOUS_SCOPE_TERMS: tuple[str, ...] = (
-    "this session",
-    "current files",
-    "here",
-    "above",
-    "as needed",
-)
-
-INTERNAL_OBJECT_MARKERS: tuple[str, ...] = (
-    '"pipeline_mode": "internal_section_refinement_with_final_audit"',
-    '"scope_block": {',
-    '"required_sections": [',
-    '"section_output_contract": {',
-    '"merge_output_contract": {',
-    '"audit_output_contract": {',
-)
-
-PROMPT_WORKFLOW_RESPONSE_MARKERS: tuple[str, ...] = (
-    "checklist_results",
-    "overall_status",
-    "scope anchors",
-    "target_local_roots",
-    "target_canonical_roots",
-    "target_file_globs",
-    "comparison_basis",
-    "completion_boundary",
-)
-
-DEBUG_INTENT_MARKERS: tuple[str, ...] = (
-    "debug",
-    "show internal",
-    "raw internal object",
-    "pipeline object",
-)
-
-NEGATIVE_KEYWORDS_IN_ARTIFACT: tuple[str, ...] = (
-    "no",
-    "not",
-    "don't",
-    "do not",
-    "never",
-    "avoid",
-    "without",
-    "refrain",
-    "stop",
-    "prevent",
-    "exclude",
-    "prohibit",
-    "forbid",
-    "reject",
-    "cannot",
-    "unless",
-)
-
-NEGATIVE_INDIRECT_PATTERNS_IN_ARTIFACT: tuple[str, ...] = (
-    r"instead of\s+\w+",
-    r"rather than\s+\w+",
-    r"as opposed to\s+\w+",
-)
-
-REQUIRED_XML_SECTIONS: tuple[str, ...] = (
-    "role",
-    "background",
-    "instructions",
-    "constraints",
-    "output_format",
-)
-
-COMPILED_NEGATIVE_KEYWORD_PATTERNS: tuple[re.Pattern[str], ...] = tuple(
-    re.compile(rf"\b{re.escape(keyword)}\b", re.IGNORECASE)
-    for keyword in NEGATIVE_KEYWORDS_IN_ARTIFACT
-)
-
-COMPILED_NEGATIVE_INDIRECT_PATTERNS: tuple[re.Pattern[str], ...] = tuple(
-    re.compile(pattern, re.IGNORECASE)
-    for pattern in NEGATIVE_INDIRECT_PATTERNS_IN_ARTIFACT
-)

package/hooks/blocking/prompt_workflow_gate_core.py

@@ -1,289 +0,0 @@
-#!/usr/bin/env python3
-"""Shared deterministic checks for prompt workflow hooks."""
-
-from __future__ import annotations
-
-import re
-import textwrap
-from typing import Iterable
-
-from prompt_workflow_gate_config import (
-    AMBIGUOUS_SCOPE_TERMS,
-    COMPILED_NEGATIVE_INDIRECT_PATTERNS,
-    COMPILED_NEGATIVE_KEYWORD_PATTERNS,
-    DEBUG_INTENT_MARKERS,
-    INTERNAL_OBJECT_MARKERS,
-    PROMPT_WORKFLOW_RESPONSE_MARKERS,
-    REQUIRED_CHECKLIST_ROWS,
-    REQUIRED_SCOPE_ANCHORS,
-    REQUIRED_XML_SECTIONS,
-)
-
-TRIPLE_BACKTICK = "```"
-AUDIT_LINE_PATTERN = re.compile(r"^\s*[●•]?\s*(Audit:\s*.+?)\s*$")
-
-def _line_opens_xml_fence(line: str) -> bool:
-    stripped = line.strip()
-    if not stripped.startswith(TRIPLE_BACKTICK):
-        return False
-    fence_marker_length = len(TRIPLE_BACKTICK)
-    remainder = stripped[fence_marker_length:].strip()
-    return remainder == "xml" or remainder.startswith("xml ")
-
-def _line_is_bare_fence_close(line: str) -> bool:
-    return line.strip() == TRIPLE_BACKTICK
-
-def _line_opens_inner_markdown_fence(line: str) -> bool:
-    stripped = line.strip()
-    if not stripped.startswith(TRIPLE_BACKTICK):
-        return False
-    return stripped != TRIPLE_BACKTICK
-
-def _collect_inner_markdown_fence(
-    lines: list[str],
-    start_index: int,
-) -> tuple[list[str], int]:
-    inner_lines: list[str] = []
-    index = start_index
-    while index < len(lines):
-        current_line = lines[index]
-        inner_lines.append(current_line)
-        index += 1
-        if _line_is_bare_fence_close(current_line):
-            break
-    return inner_lines, index
-
-def _collect_xml_fence_body(
-    lines: list[str],
-    start_index: int,
-) -> tuple[list[str], int]:
-    body_lines: list[str] = []
-    index = start_index
-    while index < len(lines):
-        current_line = lines[index]
-        if _line_is_bare_fence_close(current_line):
-            return body_lines, index + 1
-        if _line_opens_inner_markdown_fence(current_line):
-            inner_lines, index = _collect_inner_markdown_fence(lines, index)
-            body_lines.extend(inner_lines)
-            continue
-        body_lines.append(current_line)
-        index += 1
-    return body_lines, index
-
-def extract_fenced_xml_content(text: str) -> str:
-    """Extract bodies of ```xml fenced blocks.
-
-    The closing delimiter is a line whose stripped text is exactly three backticks.
-    Inner Markdown code fences (for example a line starting with three backticks
-    plus a language tag) are scanned until their own closing backtick line so the
-    outer ``xml`` fence does not end early.
-    """
-    results: list[str] = []
-    lines = text.splitlines()
-    index = 0
-    while index < len(lines):
-        if not _line_opens_xml_fence(lines[index]):
-            index += 1
-            continue
-        body_lines, index = _collect_xml_fence_body(lines, index + 1)
-        results.append("\n".join(body_lines))
-    return "\n".join(results)
-
-def _line_is_audit_line(line: str) -> bool:
-    return AUDIT_LINE_PATTERN.match(line) is not None
-
-def _normalize_audit_line(line: str) -> str:
-    match = AUDIT_LINE_PATTERN.match(line)
-    if match:
-        return match.group(1).strip()
-    return line.strip()
-
-def _line_starts_exported_artifact(line: str) -> bool:
-    stripped = line.strip()
-    if not stripped:
-        return False
-    if _line_opens_xml_fence(stripped):
-        return True
-    exported_artifact_pattern = re.compile(
-        r"^<(\?xml\b|prompt\b|runtime_context\b|role\b|background\b|instructions\b|constraints\b|output_format\b|illustrations\b|open_question\b)",
-    )
-    return exported_artifact_pattern.match(stripped) is not None
-
-def _trim_trailing_blank_lines(lines: list[str]) -> list[str]:
-    trimmed = list(lines)
-    while trimmed and not trimmed[-1].strip():
-        trimmed.pop()
-    return trimmed
-
-def _trim_flattened_export_tail(lines: list[str]) -> list[str]:
-    trimmed = _trim_trailing_blank_lines(lines)
-    while trimmed and trimmed[-1].lstrip().startswith("✻ "):
-        trimmed.pop()
-        trimmed = _trim_trailing_blank_lines(trimmed)
-    return trimmed
-
-def _find_last_audit_index(lines: list[str]) -> int | None:
-    last_audit_index: int | None = None
-    for index, line in enumerate(lines):
-        if _line_is_audit_line(line):
-            last_audit_index = index
-    return last_audit_index
-
-def _find_first_artifact_index(lines: list[str]) -> int | None:
-    for index, line in enumerate(lines):
-        if _line_starts_exported_artifact(line):
-            return index
-    return None
-
-def _rebuild_from_existing_fence(audit_line: str, artifact_text: str) -> str:
-    fenced_body = extract_fenced_xml_content(artifact_text).strip()
-    if not fenced_body:
-        return audit_line
-    return f"{audit_line}\n```xml\n{fenced_body}\n```"
-
-def _rebuild_from_flattened_body(audit_line: str, artifact_text: str) -> str:
-    dedented_body = textwrap.dedent(artifact_text).strip("\n")
-    if not dedented_body:
-        return audit_line
-    return f"{audit_line}\n```xml\n{dedented_body}\n```"
-
-def _rebuild_canonical_export(audit_line: str, artifact_lines: list[str]) -> str:
-    if not artifact_lines:
-        return audit_line
-    artifact_text = "\n".join(artifact_lines).rstrip()
-    if _line_opens_xml_fence(artifact_lines[0]):
-        return _rebuild_from_existing_fence(audit_line, artifact_text)
-    return _rebuild_from_flattened_body(audit_line, artifact_text)
-
-def normalize_prompt_workflow_export(text: str) -> str:
-    """Return the last successful Audit + fenced XML pair from a message or export.
-
-    Saved transcript exports can flatten blocked retry turns and strip the outer
-    ``xml`` fence. This helper keeps only the last successful ``Audit:`` attempt
-    and rebuilds the canonical audit-plus-fence shape used by prompt-workflow
-    hooks and reviewers.
-    """
-    lines = text.splitlines()
-    last_audit_index = _find_last_audit_index(lines)
-    if last_audit_index is None:
-        return text.strip()
-    audit_line = _normalize_audit_line(lines[last_audit_index])
-    artifact_index = _find_first_artifact_index(lines[last_audit_index + 1 :])
-    if artifact_index is None:
-        return audit_line
-    artifact_lines = _trim_flattened_export_tail(
-        lines[last_audit_index + 1 + artifact_index :],
-    )
-    return _rebuild_canonical_export(audit_line, artifact_lines)
-
-def extract_fenced_xml_content_from_export(text: str) -> str:
-    """Extract fenced XML from a canonical message or flattened transcript export."""
-    normalized = normalize_prompt_workflow_export(text)
-    return extract_fenced_xml_content(normalized)
-
-def missing_required_xml_sections(text: str) -> list[str]:
-    fenced_body = extract_fenced_xml_content(text)
-    if not fenced_body.strip():
-        return []
-    missing_sections: list[str] = []
-    for section_name in REQUIRED_XML_SECTIONS:
-        open_tag = re.compile(rf"<{re.escape(section_name)}(\s[^>]*)?>")
-        close_tag = re.compile(rf"</{re.escape(section_name)}>")
-        if not open_tag.search(fenced_body) or not close_tag.search(fenced_body):
-            missing_sections.append(section_name)
-    return missing_sections
-
-def _build_negative_keyword_violation(
-    match: re.Match[str],
-    line_number: int,
-    line_text: str,
-) -> dict[str, str | int]:
-    return {
-        "keyword": match.group(),
-        "line_number": line_number,
-        "line_text": line_text.strip(),
-    }
-
-def _find_pattern_violations(
-    patterns: Iterable[re.Pattern[str]],
-    line_text: str,
-    line_number: int,
-) -> list[dict[str, str | int]]:
-    violations: list[dict[str, str | int]] = []
-    for pattern in patterns:
-        match = pattern.search(line_text)
-        if match:
-            violations.append(
-                _build_negative_keyword_violation(match, line_number, line_text),
-            )
-    return violations
-
-def find_negative_keywords_in_fenced_xml(
-    text: str,
-) -> list[dict[str, str | int]]:
-    fenced_content = extract_fenced_xml_content(text)
-    if not fenced_content:
-        return []
-    all_violations: list[dict[str, str | int]] = []
-    for line_index, each_line in enumerate(fenced_content.splitlines(), start=1):
-        all_violations.extend(
-            _find_pattern_violations(
-                COMPILED_NEGATIVE_KEYWORD_PATTERNS,
-                each_line,
-                line_index,
-            ),
-        )
-        all_violations.extend(
-            _find_pattern_violations(
-                COMPILED_NEGATIVE_INDIRECT_PATTERNS,
-                each_line,
-                line_index,
-            ),
-        )
-    return all_violations
-
-def _contains_any_marker(text: str, markers: Iterable[str]) -> bool:
-    lower_text = text.lower()
-    return any(marker.lower() in lower_text for marker in markers)
-
-def has_debug_intent(text: str) -> bool:
-    return _contains_any_marker(text, DEBUG_INTENT_MARKERS)
-
-def has_internal_object_leak(text: str) -> bool:
-    return _contains_any_marker(text, INTERNAL_OBJECT_MARKERS)
-
-def missing_scope_anchors(text: str) -> list[str]:
-    return [anchor for anchor in REQUIRED_SCOPE_ANCHORS if anchor not in text]
-
-def find_ambiguous_scope_terms(text: str) -> list[str]:
-    if "scope" not in text.lower():
-        return []
-    matches: list[str] = []
-    lower_text = text.lower()
-    for term in AMBIGUOUS_SCOPE_TERMS:
-        if re.search(rf"\b{re.escape(term)}\b", lower_text):
-            matches.append(term)
-    return matches
-
-def has_checklist_container(text: str) -> bool:
-    lower_text = text.lower()
-    return "checklist_results" in lower_text or "checklist:" in lower_text
-
-def missing_checklist_rows(text: str) -> list[str]:
-    return [row for row in REQUIRED_CHECKLIST_ROWS if row not in text]
-
-def is_prompt_workflow_response(text: str) -> bool:
-    lower_text = text.lower()
-    matched_markers = [
-        marker for marker in PROMPT_WORKFLOW_RESPONSE_MARKERS if marker in lower_text
-    ]
-    return len(matched_markers) >= 2
-
-def missing_context_control_signals(text: str) -> list[str]:
-    required_signals: tuple[str, ...] = (
-        "base_minimal_instruction_layer: true",
-        "on_demand_skill_loading: true",
-    )
-    lowered = text.lower()
-    return [signal for signal in required_signals if signal not in lowered]