specsmith 0.11.5.dev450__tar.gz → 0.11.5.dev452__tar.gz

{specsmith-0.11.5.dev450/src/specsmith.egg-info → specsmith-0.11.5.dev452}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specsmith
-Version: 0.11.5.dev450
+Version: 0.11.5.dev452
 Summary: Applied Epistemic Engineering toolkit — AEE agent sessions, execution profiles, FPGA/HDL governance, tool installer, 50+ CLI commands.
 Author: BitConcepts
 License-Expression: MIT

{specsmith-0.11.5.dev450 → specsmith-0.11.5.dev452}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "specsmith"
-version = "0.11.5.dev450"
+version = "0.11.5.dev452"
 description = "Applied Epistemic Engineering toolkit — AEE agent sessions, execution profiles, FPGA/HDL governance, tool installer, 50+ CLI commands."
 readme = "README.md"
 license = "MIT"

{specsmith-0.11.5.dev450 → specsmith-0.11.5.dev452}/src/specsmith/cli.py

@@ -4778,8 +4778,13 @@ def watch_cmd(project_dir: str, interval: int, no_notify: bool) -> None:
         _has_watchdog = False
     if not _has_watchdog:
         console.print(
-            "[dim]watchdog not installed — using polling mode. "
-            "For faster detection: pip install watchdog[/dim]\n"
+            "[yellow]⚠[/yellow] [dim]watchdog not installed — using polling mode "
+            f"({interval}s interval).[/dim]\n"
+            "  [dim]For native filesystem events, add [bold]watchdog>=4.0[/bold] to your "
+            "project's dev extras:[/dim]\n"
+            "  [dim]  pip install watchdog[/dim]\n"
+            "  [dim]  or add to pyproject.toml: "
+            '[bold][project.optional-dependencies] dev = ["watchdog>=4.0"][/bold][/dim]\n'
         )
 
     from specsmith.auditor import run_audit

{specsmith-0.11.5.dev450 → specsmith-0.11.5.dev452}/src/specsmith/requirements.py

@@ -9,15 +9,18 @@ from pathlib import Path
 
 # Flexible patterns that handle both two-part (REQ-001) and three-part
 # (REQ-CLI-001, REG-012) identifiers used across projects.
+# Letter suffixes (e.g. TEST-NN-002a, TEST-NN-002b) are supported via [a-z]* —
+# without this, the \b word boundary after \d+ would not match when a letter
+# follows digits, causing the ID to be silently skipped (#183).
 _FLEX_REQ = r"REQ-(?:[A-Z][A-Z0-9_]*-)?\d+"
-_FLEX_TEST = r"TEST-(?:[A-Z][A-Z0-9_]*-)?\d+"
+_FLEX_TEST = r"TEST-(?:[A-Z][A-Z0-9_]*-)?\d+[a-z]*"
 
 _REQ_PATTERN = re.compile(r"\b(" + _FLEX_REQ + r")\b")
 _TEST_COVERS_PATTERN = re.compile(
     r"(?:Covers|\*\*Requirement(?:\s+ID)?:?\*\*|Requirement(?:\s+ID)?):?\s*"
     r"(" + _FLEX_REQ + r"(?:\s*,\s*" + _FLEX_REQ + r")*)"
 )
-_TEST_ID_PATTERN = re.compile(r"\b(" + _FLEX_TEST + r")\b")
+_TEST_ID_PATTERN = re.compile(r"\b(TEST-(?:[A-Z][A-Z0-9_]*-)?\d+[a-z]*)\b")
 
 # Heading detectors for REQUIREMENTS.md (two styles supported):
 #   Style A: ## REQ-001 or ## REQ-CLI-001
@@ -111,9 +114,18 @@ def add_req(
 
 
 def trace_reqs(root: Path) -> list[dict[str, object]]:
-    """Map each REQ to its covering TESTs."""
+    """Map each REQ to its covering TESTs.
+
+    In YAML-first mode, reads .specsmith/testcases.json directly — this avoids
+    regex-based ID parsing entirely and correctly handles letter-suffix IDs
+    (e.g. TEST-NN-002a, TEST-NN-002b) that were previously misidentified (#183).
+    Falls back to TESTS.md regex parsing in legacy Markdown mode.
+    """
+    import json as _json
+
     req_path = root / "docs" / "REQUIREMENTS.md"
     test_path = root / "docs" / "TESTS.md"
+    testcases_json = root / ".specsmith" / "testcases.json"
 
     req_ids: list[str] = []
     if req_path.exists():
@@ -121,6 +133,26 @@ def trace_reqs(root: Path) -> list[dict[str, object]]:
 
     covered_by: dict[str, list[str]] = {r: [] for r in req_ids}
 
+    # YAML mode: prefer machine-readable testcases.json — exact IDs, no regex.
+    if testcases_json.is_file():
+        try:
+            records = _json.loads(testcases_json.read_text(encoding="utf-8"))
+            for record in records:
+                if (
+                    isinstance(record, dict)
+                    and isinstance(record.get("requirement_id"), str)
+                    and isinstance(record.get("id"), str)
+                ):
+                    rid = record["requirement_id"]
+                    if rid in covered_by:
+                        covered_by[rid].append(record["id"])
+            return [
+                {"req": r, "tests": tests, "covered": len(tests) > 0}
+                for r, tests in covered_by.items()
+            ]
+        except (OSError, ValueError):
+            pass  # Fall through to TESTS.md regex parsing
+
     if test_path.exists():
         test_text = test_path.read_text(encoding="utf-8")
         current_test = ""

{specsmith-0.11.5.dev450 → specsmith-0.11.5.dev452}/src/specsmith/sync.py

@@ -41,7 +41,8 @@ _DIRECT_HEADING = re.compile(r"^#{1,3}\s+(" + _FLEX_REQ_ID + r")\b")
 _ID_FIELD = re.compile(r"^-\s+\*\*ID:\*\*\s+(" + _FLEX_REQ_ID + r")")
 _FIELD_LINE = re.compile(r"^-\s+\*\*(.+?):\*\*\s+(.+)")
 
-_FLEX_TEST_ID = r"TEST-(?:[A-Z][A-Z0-9_]*-)?\d+"
+# Letter suffixes (e.g. TEST-NN-002a) are supported via [a-z]* — fixes #183.
+_FLEX_TEST_ID = r"TEST-(?:[A-Z][A-Z0-9_]*-)?\d+[a-z]*"
 _TEST_NUMBERED_HEADING = re.compile(r"^#{1,3}\s+(?:TEST-[A-Z0-9_-]+\s+)?(.+?)\s*$")
 _TEST_ID_FIELD = re.compile(r"^-\s+\*\*ID:\*\*\s+(" + _FLEX_TEST_ID + r")")
 

{specsmith-0.11.5.dev450 → specsmith-0.11.5.dev452}/src/specsmith/templates/governance/rules.md.j2

@@ -55,6 +55,21 @@ All proposals MUST state their epistemic boundaries. A proposal without explicit
 
 Hidden assumptions are not acceptable. Declare all epistemic boundaries in the `Assumptions:` field of every proposal.
 
+### H23 — No Bare Sleep Delays in Scripts
+Scripts MUST NOT use `sleep N`, `Start-Sleep`, or equivalent blocking waits as a
+standalone timing mechanism without a guaranteed exit path.
+
+Every wait that depends on an external condition MUST use a polling loop with:
+1. A **maximum iteration count** or **wall-clock timeout**
+2. A **non-zero exit code** on timeout
+3. An **explicit sleep interval** inside the loop body
+
+**Applies to:** `.sh`, `.bash`, `.ps1`, `.cmd`, `.bat`, CI `run:` blocks, Makefile recipes.
+**Does NOT apply to:** production source code (`time.sleep`, `thread::sleep`, etc.).
+
+`specsmith validate` checks scripts for bare sleep patterns without loop/retry constructs
+and emits a warning (H23).
+
 ---
 
 ## Stop Conditions

{specsmith-0.11.5.dev450 → specsmith-0.11.5.dev452}/src/specsmith/templates/python/pyproject.toml.j2

@@ -14,5 +14,12 @@ license = {text = "MIT"}
 {{ project.package_name }} = "{{ project.package_name }}.cli:main"
 {% endif %}
 
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "ruff>=0.4",
+    "watchdog>=4.0",  # specsmith watch — native filesystem events
+]
+
 [tool.setuptools.packages.find]
 where = ["src"]

{specsmith-0.11.5.dev450 → specsmith-0.11.5.dev452}/src/specsmith/validator.py

@@ -63,6 +63,25 @@ _DEADLINE_GUARD_PATTERNS = (
 # Script file extensions to scan (exclude general source dirs to avoid false positives)
 _SCRIPT_EXTENSIONS = {".sh", ".cmd", ".ps1", ".bash"}
 
+# Bare-sleep patterns: standalone timing delays that block indefinitely (H23)
+# Applies to scripts only — NOT to general source code.
+_BARE_SLEEP_PATTERNS = (
+    re.compile(r"^\s*sleep\s+\d", re.MULTILINE | re.IGNORECASE),  # bash: sleep N
+    re.compile(r"^\s*Start-Sleep\b", re.MULTILINE | re.IGNORECASE),  # PowerShell
+)
+
+# Loop / retry constructs that justify a sleep — if any are present the sleep
+# is inside a polling loop and should not be flagged.
+_SLEEP_LOOP_CONTEXT = (
+    re.compile(r"\bfor\b"),
+    re.compile(r"\bwhile\b"),
+    re.compile(r"\buntil\b"),
+    re.compile(r"max_retries", re.IGNORECASE),
+    re.compile(r"max_attempts", re.IGNORECASE),
+    re.compile(r"\bretry\b", re.IGNORECASE),
+    re.compile(r"\bseq\s+\d"),  # bash `for i in $(seq N)`
+)
+
 
 def _check_scaffold_yml(root: Path) -> list[ValidationResult]:
     """Check that scaffold.yml exists and is valid YAML."""
@@ -333,6 +352,78 @@ def _check_blocking_loops(root: Path) -> list[ValidationResult]:
     return results
 
 
+def _check_bare_sleep(root: Path) -> list[ValidationResult]:
+    """Scan script files for bare sleep delays without a loop/retry context (H23).
+
+    A bare sleep is a ``sleep N`` / ``Start-Sleep`` line that appears in a script
+    file that contains NO loop or retry constructs.  This is a timing anti-pattern
+    that blocks indefinitely when the awaited condition never arrives.
+
+    Files with a loop/retry context (``for``, ``while``, ``until``, ``max_retries``)
+    are skipped — the sleep is part of a legitimate polling loop in those cases.
+
+    Emits a warning (not a hard error) to allow gradual adoption.
+    """
+    results: list[ValidationResult] = []
+
+    candidates: list[Path] = []
+    for path in root.iterdir():
+        if path.is_file() and path.suffix.lower() in _SCRIPT_EXTENSIONS:
+            candidates.append(path)
+    scripts_dir = root / "scripts"
+    if scripts_dir.is_dir():
+        for path in scripts_dir.rglob("*"):
+            if path.is_file() and path.suffix.lower() in _SCRIPT_EXTENSIONS:
+                candidates.append(path)
+
+    if not candidates:
+        return results
+
+    flagged: list[str] = []
+    for script_path in candidates:
+        try:
+            text = script_path.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            continue
+
+        has_sleep = any(p.search(text) for p in _BARE_SLEEP_PATTERNS)
+        if not has_sleep:
+            continue
+
+        # Sleep inside a loop/retry context is acceptable
+        has_loop_context = any(p.search(text) for p in _SLEEP_LOOP_CONTEXT)
+        if not has_loop_context:
+            try:
+                rel = script_path.relative_to(root)
+            except ValueError:
+                rel = script_path
+            flagged.append(str(rel))
+
+    if flagged:
+        for name in flagged:
+            results.append(
+                ValidationResult(
+                    name=f"bare-sleep:{name}",
+                    passed=False,
+                    message=(
+                        f"{name}: bare sleep delay without a polling loop (H23 warning). "
+                        "Replace with a retry loop that has a max iteration count and "
+                        "non-zero exit on timeout."
+                    ),
+                )
+            )
+    else:
+        results.append(
+            ValidationResult(
+                name="bare-sleep",
+                passed=True,
+                message=f"{len(candidates)} script file(s) checked — no bare sleep delays found",
+            )
+        )
+
+    return results
+
+
 def run_validate(root: Path) -> ValidationReport:
     """Run all validation checks and return a report."""
     report = ValidationReport()
@@ -341,4 +432,5 @@ def run_validate(root: Path) -> ValidationReport:
     report.results.extend(_check_req_ids_unique(root))
     report.results.extend(_check_architecture_reqs(root))
     report.results.extend(_check_blocking_loops(root))
+    report.results.extend(_check_bare_sleep(root))
     return report

{specsmith-0.11.5.dev450 → specsmith-0.11.5.dev452/src/specsmith.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specsmith
-Version: 0.11.5.dev450
+Version: 0.11.5.dev452
 Summary: Applied Epistemic Engineering toolkit — AEE agent sessions, execution profiles, FPGA/HDL governance, tool installer, 50+ CLI commands.
 Author: BitConcepts
 License-Expression: MIT

specsmith-0.11.5.dev452/tests/test_auditor.py

@@ -0,0 +1,201 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 BitConcepts, LLC. All rights reserved.
+"""Tests for specsmith auditor."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from specsmith.auditor import run_audit
+
+
+@pytest.fixture
+def governed_project(tmp_path: Path) -> Path:
+    """Create a minimal governed project for audit testing."""
+    (tmp_path / "AGENTS.md").write_text("# AGENTS\nShort hub.\n", encoding="utf-8")
+    (tmp_path / "LEDGER.md").write_text("# Ledger\n\n## Session 1\nDone.\n", encoding="utf-8")
+
+    gov = tmp_path / "docs" / "governance"
+    gov.mkdir(parents=True)
+    for f in (
+        "RULES.md",
+        "SESSION-PROTOCOL.md",
+        "LIFECYCLE.md",
+        "ROLES.md",
+        "CONTEXT-BUDGET.md",
+        "VERIFICATION.md",
+        "DRIFT-METRICS.md",
+    ):
+        (gov / f).write_text(f"# {f}\nContent.\n", encoding="utf-8")
+
+    docs = tmp_path / "docs"
+    (docs / "REQUIREMENTS.md").write_text("# Reqs\n", encoding="utf-8")
+    (docs / "TESTS.md").write_text("# Tests\n", encoding="utf-8")
+    (docs / "ARCHITECTURE.md").write_text("# Arch\n", encoding="utf-8")
+    (tmp_path / "CONTRIBUTING.md").write_text("# Contributing\n", encoding="utf-8")
+    (tmp_path / "LICENSE").write_text("MIT License\n", encoding="utf-8")
+    # Scaffold config (at root for backward compat — audit now accepts either location)
+    (tmp_path / "scaffold.yml").write_text(
+        "name: test-project\ntype: cli-python\nspec_version: 0.10.1\nvcs_platform: github\n",
+        encoding="utf-8",
+    )
+
+    return tmp_path
+
+
+class TestAuditHealthy:
+    def test_passes_on_governed_project(self, governed_project: Path) -> None:
+        report = run_audit(governed_project)
+        assert report.healthy
+        assert report.failed == 0
+
+    def test_reports_pass_count(self, governed_project: Path) -> None:
+        report = run_audit(governed_project)
+        assert report.passed > 0
+
+
+class TestAuditDetectsIssues:
+    def test_missing_agents_md(self, tmp_path: Path) -> None:
+        (tmp_path / "LEDGER.md").write_text("# Ledger\n", encoding="utf-8")
+        report = run_audit(tmp_path)
+        failed_names = [r.name for r in report.results if not r.passed]
+        assert "file-exists:AGENTS.md" in failed_names
+
+    def test_missing_ledger(self, tmp_path: Path) -> None:
+        (tmp_path / "AGENTS.md").write_text("# Agents\n", encoding="utf-8")
+        report = run_audit(tmp_path)
+        failed_names = [r.name for r in report.results if not r.passed]
+        assert "file-exists:LEDGER.md" in failed_names
+
+    def test_oversized_ledger(self, governed_project: Path) -> None:
+        big_ledger = "# Ledger\n" + "\n".join(f"Line {i}" for i in range(600))
+        (governed_project / "LEDGER.md").write_text(big_ledger, encoding="utf-8")
+        report = run_audit(governed_project)
+        size_results = [r for r in report.results if r.name == "ledger-size"]
+        assert len(size_results) == 1
+        assert not size_results[0].passed
+
+    def test_req_test_coverage(self, governed_project: Path) -> None:
+        reqs = "# Reqs\n\nREQ-CLI-001: do things\nREQ-CLI-002: more things\n"
+        tests = "# Tests\n\nTEST-CLI-001\nCovers: REQ-CLI-001\n"
+        (governed_project / "docs" / "REQUIREMENTS.md").write_text(reqs, encoding="utf-8")
+        (governed_project / "docs" / "TESTS.md").write_text(tests, encoding="utf-8")
+        report = run_audit(governed_project)
+        coverage = [r for r in report.results if r.name == "req-test-coverage"]
+        assert len(coverage) == 1
+        assert not coverage[0].passed
+        assert "REQ-CLI-002" in coverage[0].message
+
+
+# ---------------------------------------------------------------------------
+# Regression: issue #183 — letter-suffix TEST IDs in req trace
+# ---------------------------------------------------------------------------
+
+
+class TestReqTraceLetterSuffixRegression:
+    """Regression tests for #183 — req trace misidentifies TEST-NN-002a/b.
+
+    Root cause: _TEST_ID_PATTERN used \\d+\\b which fails to match when a
+    letter immediately follows digits (\\b requires a non-word char boundary,
+    but letters are word chars).  This caused current_test to remain pointing
+    at the last successfully-parsed ID (TEST-NN-020), so both TEST-NN-002a and
+    TEST-NN-002b coverage lines were erroneously attributed to TEST-NN-020.
+    """
+
+    def test_letter_suffix_ids_captured_from_tests_md(self, tmp_path: Path) -> None:
+        """trace_reqs must return TEST-NN-002a / TEST-NN-002b, not TEST-NN-020 twice."""
+        from specsmith.requirements import trace_reqs
+
+        docs = tmp_path / "docs"
+        docs.mkdir()
+        (docs / "REQUIREMENTS.md").write_text(
+            "# Requirements\n\n## REQ-NN-001\n- **Status**: defined\n\n"
+            "## REQ-NN-002\n- **Status**: defined\n",
+            encoding="utf-8",
+        )
+        # Simulate the buggy scenario: TEST-NN-020 appears BEFORE TEST-NN-002a/b
+        # so it would stick as current_test if letter suffixes aren't parsed.
+        (docs / "TESTS.md").write_text(
+            "# Tests\n\n"
+            "## TEST-NN-020\n- **Requirement ID**: REQ-NN-001\n\n"
+            "## TEST-NN-002a\n- **Requirement ID**: REQ-NN-002\n\n"
+            "## TEST-NN-002b\n- **Requirement ID**: REQ-NN-002\n",
+            encoding="utf-8",
+        )
+
+        traces = trace_reqs(tmp_path)
+        by_req = {t["req"]: t["tests"] for t in traces}
+
+        # REQ-NN-001 should map to TEST-NN-020 only
+        assert by_req.get("REQ-NN-001") == ["TEST-NN-020"]
+        # REQ-NN-002 must map to TEST-NN-002a and TEST-NN-002b — NOT TEST-NN-020 twice
+        assert "TEST-NN-002a" in by_req.get("REQ-NN-002", [])
+        assert "TEST-NN-002b" in by_req.get("REQ-NN-002", [])
+        assert "TEST-NN-020" not in by_req.get("REQ-NN-002", [])
+
+    def test_no_duplicate_ids_in_trace(self, tmp_path: Path) -> None:
+        """REQ-NN-002 must not have duplicate entries in its test list."""
+        from specsmith.requirements import trace_reqs
+
+        docs = tmp_path / "docs"
+        docs.mkdir()
+        (docs / "REQUIREMENTS.md").write_text(
+            "# Requirements\n\n## REQ-NN-002\n- **Status**: defined\n",
+            encoding="utf-8",
+        )
+        (docs / "TESTS.md").write_text(
+            "# Tests\n\n"
+            "## TEST-NN-002a\n- **Requirement ID**: REQ-NN-002\n\n"
+            "## TEST-NN-002b\n- **Requirement ID**: REQ-NN-002\n",
+            encoding="utf-8",
+        )
+
+        traces = trace_reqs(tmp_path)
+        tests = traces[0]["tests"]
+        assert len(tests) == len(set(tests)), f"Duplicate test IDs: {tests}"
+
+    def test_yaml_mode_uses_testcases_json(self, tmp_path: Path) -> None:
+        """In YAML mode, trace_reqs reads testcases.json directly (no regex)."""
+        import json
+
+        from specsmith.requirements import trace_reqs
+
+        docs = tmp_path / "docs"
+        docs.mkdir()
+        (docs / "REQUIREMENTS.md").write_text(
+            "# Requirements\n\n## REQ-NN-002\n- **Status**: defined\n",
+            encoding="utf-8",
+        )
+        state = tmp_path / ".specsmith"
+        state.mkdir()
+        (state / "testcases.json").write_text(
+            json.dumps(
+                [
+                    {"id": "TEST-NN-002a", "requirement_id": "REQ-NN-002"},
+                    {"id": "TEST-NN-002b", "requirement_id": "REQ-NN-002"},
+                ]
+            ),
+            encoding="utf-8",
+        )
+
+        traces = trace_reqs(tmp_path)
+        by_req = {t["req"]: t["tests"] for t in traces}
+        assert sorted(by_req["REQ-NN-002"]) == ["TEST-NN-002a", "TEST-NN-002b"]
+
+    def test_sync_parse_tests_md_preserves_letter_suffix(self, tmp_path: Path) -> None:
+        """sync.parse_tests_md must not truncate TEST-NN-002a to TEST-NN-002."""
+        from specsmith.sync import parse_tests_md
+
+        text = (
+            "## TEST-NN-002a\n"
+            "- **Requirement ID**: REQ-NN-002\n\n"
+            "## TEST-NN-002b\n"
+            "- **Requirement ID**: REQ-NN-002\n"
+        )
+        records = parse_tests_md(text)
+        ids = [r["id"] for r in records]
+        assert "TEST-NN-002a" in ids
+        assert "TEST-NN-002b" in ids
+        assert "TEST-NN-002" not in ids  # must not be truncated

specsmith-0.11.5.dev450/tests/test_auditor.py

@@ -1,89 +0,0 @@
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 BitConcepts, LLC. All rights reserved.
-"""Tests for specsmith auditor."""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-import pytest
-
-from specsmith.auditor import run_audit
-
-
-@pytest.fixture
-def governed_project(tmp_path: Path) -> Path:
-    """Create a minimal governed project for audit testing."""
-    (tmp_path / "AGENTS.md").write_text("# AGENTS\nShort hub.\n", encoding="utf-8")
-    (tmp_path / "LEDGER.md").write_text("# Ledger\n\n## Session 1\nDone.\n", encoding="utf-8")
-
-    gov = tmp_path / "docs" / "governance"
-    gov.mkdir(parents=True)
-    for f in (
-        "RULES.md",
-        "SESSION-PROTOCOL.md",
-        "LIFECYCLE.md",
-        "ROLES.md",
-        "CONTEXT-BUDGET.md",
-        "VERIFICATION.md",
-        "DRIFT-METRICS.md",
-    ):
-        (gov / f).write_text(f"# {f}\nContent.\n", encoding="utf-8")
-
-    docs = tmp_path / "docs"
-    (docs / "REQUIREMENTS.md").write_text("# Reqs\n", encoding="utf-8")
-    (docs / "TESTS.md").write_text("# Tests\n", encoding="utf-8")
-    (docs / "ARCHITECTURE.md").write_text("# Arch\n", encoding="utf-8")
-    (tmp_path / "CONTRIBUTING.md").write_text("# Contributing\n", encoding="utf-8")
-    (tmp_path / "LICENSE").write_text("MIT License\n", encoding="utf-8")
-    # Scaffold config (at root for backward compat — audit now accepts either location)
-    (tmp_path / "scaffold.yml").write_text(
-        "name: test-project\ntype: cli-python\nspec_version: 0.10.1\nvcs_platform: github\n",
-        encoding="utf-8",
-    )
-
-    return tmp_path
-
-
-class TestAuditHealthy:
-    def test_passes_on_governed_project(self, governed_project: Path) -> None:
-        report = run_audit(governed_project)
-        assert report.healthy
-        assert report.failed == 0
-
-    def test_reports_pass_count(self, governed_project: Path) -> None:
-        report = run_audit(governed_project)
-        assert report.passed > 0
-
-
-class TestAuditDetectsIssues:
-    def test_missing_agents_md(self, tmp_path: Path) -> None:
-        (tmp_path / "LEDGER.md").write_text("# Ledger\n", encoding="utf-8")
-        report = run_audit(tmp_path)
-        failed_names = [r.name for r in report.results if not r.passed]
-        assert "file-exists:AGENTS.md" in failed_names
-
-    def test_missing_ledger(self, tmp_path: Path) -> None:
-        (tmp_path / "AGENTS.md").write_text("# Agents\n", encoding="utf-8")
-        report = run_audit(tmp_path)
-        failed_names = [r.name for r in report.results if not r.passed]
-        assert "file-exists:LEDGER.md" in failed_names
-
-    def test_oversized_ledger(self, governed_project: Path) -> None:
-        big_ledger = "# Ledger\n" + "\n".join(f"Line {i}" for i in range(600))
-        (governed_project / "LEDGER.md").write_text(big_ledger, encoding="utf-8")
-        report = run_audit(governed_project)
-        size_results = [r for r in report.results if r.name == "ledger-size"]
-        assert len(size_results) == 1
-        assert not size_results[0].passed
-
-    def test_req_test_coverage(self, governed_project: Path) -> None:
-        reqs = "# Reqs\n\nREQ-CLI-001: do things\nREQ-CLI-002: more things\n"
-        tests = "# Tests\n\nTEST-CLI-001\nCovers: REQ-CLI-001\n"
-        (governed_project / "docs" / "REQUIREMENTS.md").write_text(reqs, encoding="utf-8")
-        (governed_project / "docs" / "TESTS.md").write_text(tests, encoding="utf-8")
-        report = run_audit(governed_project)
-        coverage = [r for r in report.results if r.name == "req-test-coverage"]
-        assert len(coverage) == 1
-        assert not coverage[0].passed
-        assert "REQ-CLI-002" in coverage[0].message