code-mower 0.5.0b42__tar.gz → 0.5.0b44__tar.gz

{code_mower-0.5.0b42 → code_mower-0.5.0b44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-mower
-Version: 0.5.0b42
+Version: 0.5.0b44
 Summary: Multi-reviewer AI code audit orchestration
 License-Expression: Apache-2.0
 Requires-Python: >=3.11
@@ -103,11 +103,11 @@ Code Mower currently targets Python 3.11+; Python 3.12 is recommended.
 
 ```bash
 python3.12 --version
-pipx install --python python3.12 code-mower==0.5.0b42
+pipx install --python python3.12 code-mower==0.5.0b44
 code-mower --version
 ```
 
-`0.5.0b42` is a beta release. Until Code Mower publishes a stable `1.0`
+`0.5.0b44` is a beta release. Until Code Mower publishes a stable `1.0`
 line, use the explicit beta version above or allow prereleases with:
 
 ```bash
@@ -155,7 +155,7 @@ First-time command map: [docs/launch-command-surface.md](docs/launch-command-sur
 
 The current PyPI beta has been rehearsed end-to-end from a clean install:
 [First-User Install Rehearsal](docs/first-user-install-rehearsal.md) records
-the latest 10/10 public-package readiness proof for `code-mower==0.5.0b42`.
+the latest 10/10 public-package readiness proof for `code-mower==0.5.0b44`.
 
 ## Optional: Plan Before Coding
 
@@ -310,9 +310,9 @@ builder provenance, start with
 
 ## Installation Status
 
-The current public beta is `v0.5.0-beta.42` from
+The current public beta is `v0.5.0-beta.44` from
 [codemower-ai/code-mower](https://github.com/codemower-ai/code-mower), published
-as `code-mower==0.5.0b42` on [PyPI](https://pypi.org/project/code-mower/).
+as `code-mower==0.5.0b44` on [PyPI](https://pypi.org/project/code-mower/).
 GitHub releases remain the auditable source for tags, build artifacts, and
 release notes.
 

{code_mower-0.5.0b42 → code_mower-0.5.0b44}/README.md

@@ -88,11 +88,11 @@ Code Mower currently targets Python 3.11+; Python 3.12 is recommended.
 
 ```bash
 python3.12 --version
-pipx install --python python3.12 code-mower==0.5.0b42
+pipx install --python python3.12 code-mower==0.5.0b44
 code-mower --version
 ```
 
-`0.5.0b42` is a beta release. Until Code Mower publishes a stable `1.0`
+`0.5.0b44` is a beta release. Until Code Mower publishes a stable `1.0`
 line, use the explicit beta version above or allow prereleases with:
 
 ```bash
@@ -140,7 +140,7 @@ First-time command map: [docs/launch-command-surface.md](docs/launch-command-sur
 
 The current PyPI beta has been rehearsed end-to-end from a clean install:
 [First-User Install Rehearsal](docs/first-user-install-rehearsal.md) records
-the latest 10/10 public-package readiness proof for `code-mower==0.5.0b42`.
+the latest 10/10 public-package readiness proof for `code-mower==0.5.0b44`.
 
 ## Optional: Plan Before Coding
 
@@ -295,9 +295,9 @@ builder provenance, start with
 
 ## Installation Status
 
-The current public beta is `v0.5.0-beta.42` from
+The current public beta is `v0.5.0-beta.44` from
 [codemower-ai/code-mower](https://github.com/codemower-ai/code-mower), published
-as `code-mower==0.5.0b42` on [PyPI](https://pypi.org/project/code-mower/).
+as `code-mower==0.5.0b44` on [PyPI](https://pypi.org/project/code-mower/).
 GitHub releases remain the auditable source for tags, build artifacts, and
 release notes.
 

{code_mower-0.5.0b42 → code_mower-0.5.0b44}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code-mower"
-version = "0.5.0b42"
+version = "0.5.0b44"
 description = "Multi-reviewer AI code audit orchestration"
 requires-python = ">=3.11"
 readme = "README.md"

{code_mower-0.5.0b42 → code_mower-0.5.0b44}/src/code_mower/__init__.py

@@ -1,3 +1,3 @@
 """Code Mower package."""
 
-__version__ = "0.5.0b42"
+__version__ = "0.5.0b44"

{code_mower-0.5.0b42 → code_mower-0.5.0b44}/src/code_mower/calibration/auto_discovery.py

@@ -12,6 +12,7 @@ from typing import Any, Mapping, Sequence
 from .corpus import parse_int
 from .identity import safe_slug
 from .run_status import RUN_STATUS_BLOCKED, RUN_STATUS_PASS, RUN_STATUS_UNKNOWN
+from ..provider_runners import is_fixture_verdict_comment
 
 AUTO_DISCOVERY_SCHEMA = "code_mower.calibrationAutoDiscover.v1"
 TRUTH_EXPECTATION_UNKNOWN = "unknown"
@@ -147,6 +148,8 @@ def _audit_runs_from_comments(comments: Sequence[Any]) -> list[dict[str, Any]]:
         body = str(comment.get("body") or "")
         if not body:
             continue
+        if is_fixture_verdict_comment(body):
+            continue
         for match in AUDIT_STATE_RE.finditer(body):
             state = match.group("state")
             reviewer = _provider_from_audit_state(match.group("provider"), state)

{code_mower-0.5.0b42 → code_mower-0.5.0b44}/src/code_mower/claude_audit_pr.py

@@ -32,11 +32,13 @@ if __package__ in {None, "", "tools"}:
         from tools.audit_progress import AuditProgress, run_subprocess_with_progress
         from tools.claude_cli_environment import clean_claude_cli_env, env_flag
         from tools.provider_runners import (
+            audit_runtime_quarantine_reason as _audit_runtime_quarantine_reason,
             clip_text as _clip_text,
             fetch_pull_request,
             fetch_base_ref_sha as _shared_fetch_base_ref_sha,
             fetch_pr_head_sha as _shared_fetch_pr_head_sha,
             fetch_pr_head_sha_unless_local_matches as _shared_fetch_pr_head_sha_unless_local_matches,
+            is_fixture_structured_verdict as _is_fixture_structured_verdict,
             limit_comment_body,
             one_line as _one_line,
             parse_repo_paths as _parse_repo_paths,
@@ -58,11 +60,13 @@ if __package__ in {None, "", "tools"}:
         from audit_progress import AuditProgress, run_subprocess_with_progress  # type: ignore
         from claude_cli_environment import clean_claude_cli_env, env_flag  # type: ignore
         from provider_runners import (  # type: ignore
+            audit_runtime_quarantine_reason as _audit_runtime_quarantine_reason,
             clip_text as _clip_text,
             fetch_pull_request,
             fetch_base_ref_sha as _shared_fetch_base_ref_sha,
             fetch_pr_head_sha as _shared_fetch_pr_head_sha,
             fetch_pr_head_sha_unless_local_matches as _shared_fetch_pr_head_sha_unless_local_matches,
+            is_fixture_structured_verdict as _is_fixture_structured_verdict,
             limit_comment_body,
             one_line as _one_line,
             parse_repo_paths as _parse_repo_paths,
@@ -82,11 +86,13 @@ else:  # pragma: no cover - exercised after package extraction.
     from .claude_cli_environment import clean_claude_cli_env, env_flag
     from .provider_runners import (
         FetchedHeadMismatch,
+        audit_runtime_quarantine_reason as _audit_runtime_quarantine_reason,
         clip_text as _clip_text,
         fetch_base_ref_sha as _shared_fetch_base_ref_sha,
         fetch_pull_request,
         fetch_pr_head_sha as _shared_fetch_pr_head_sha,
         fetch_pr_head_sha_unless_local_matches as _shared_fetch_pr_head_sha_unless_local_matches,
+        is_fixture_structured_verdict as _is_fixture_structured_verdict,
         limit_comment_body,
         one_line as _one_line,
         parse_repo_paths as _parse_repo_paths,
@@ -112,6 +118,11 @@ MAX_SUMMARY_CHARS = 4_000
 MAX_FINDING_TITLE_CHARS = 300
 MAX_FINDING_FILE_CHARS = 500
 MAX_FINDING_DETAIL_CHARS = 4_000
+MAX_CLAUDE_AUDIT_ATTEMPTS = 2
+MIN_BLOCKED_VERDICT_PROSE_CHARS = 80
+SCHEMA_PLACEHOLDER_TEXT = frozenset({"test", "example", "placeholder"})
+CLAUDE_RAW_OUTPUT_SCHEMA = "code_mower.claudeAuditRawOutput.v1"
+BLOCKER_SEVERITIES = frozenset({"P0", "P1", "P2"})
 
 STALE_TRAILER = "<!-- CLAUDE_AUDIT_STATE: needs-claude-audit -->"
 DONE_TRAILER = "<!-- CLAUDE_AUDIT_STATE: claude-audit-done -->"
@@ -181,6 +192,8 @@ class ClaudeVerdict:
     p2_count: int = 0
     p3_count: int = 0
     mismatch_note: str = ""
+    summary: str = ""
+    findings: Tuple[Dict[str, Any], ...] = field(default_factory=tuple)
 
     @property
     def blocker_count(self) -> int:
@@ -207,6 +220,7 @@ class ClaudeAuditResult:
 class DiffContext:
     stat: str
     diff: str
+    changed_files: Tuple[str, ...]
     was_truncated: bool
     requested_max_bytes: int
     hard_limit_bytes: int
@@ -337,7 +351,7 @@ def parse_structured_claude_verdict(data: Any) -> ClaudeVerdict:
 
         p_counts[int(severity[1])] += 1
         if len(rendered_findings) < MAX_RENDERED_FINDINGS:
-            rendered_findings.append(raw_finding)
+            rendered_findings.append(dict(raw_finding))
 
     blocker_count = p_counts[0] + p_counts[1] + p_counts[2]
     if blocker_count > 0:
@@ -362,9 +376,162 @@ def parse_structured_claude_verdict(data: Any) -> ClaudeVerdict:
         p2_count=p_counts[2],
         p3_count=p_counts[3],
         mismatch_note=mismatch_note,
+        summary=summary,
+        findings=tuple(dict(finding) for finding in raw_findings),
     )
 
 
+def _placeholder_equal(value: object) -> bool:
+    return str(value or "").strip().lower() in SCHEMA_PLACEHOLDER_TEXT
+
+
+def _normalize_diff_path(value: object) -> str:
+    path = str(value or "").strip().replace("\\", "/")
+    while path.startswith("./"):
+        path = path[2:]
+    if path.startswith(("a/", "b/")):
+        path = path[2:]
+    return path
+
+
+def _diff_file_matches(file_path: str, allowed_files: set[str]) -> bool:
+    if file_path in allowed_files:
+        return True
+    suffix_matches = [
+        path
+        for path in allowed_files
+        if path.endswith(f"/{file_path}") or file_path.endswith(f"/{path}")
+    ]
+    return len(suffix_matches) == 1
+
+
+def _claude_verdict_guardrail_reason(
+    parsed: ClaudeVerdict,
+    changed_files: Tuple[str, ...],
+) -> Optional[str]:
+    if parsed.verdict == "UNKNOWN":
+        return None
+
+    if _placeholder_equal(parsed.summary):
+        return "structured verdict summary matched a schema placeholder value"
+
+    allowed_files = {_normalize_diff_path(path) for path in changed_files}
+    allowed_files.discard("")
+    for idx, finding in enumerate(parsed.findings):
+        where = f"findings[{idx}]"
+        if _placeholder_equal(finding.get("title")):
+            return f"{where}.title matched a schema placeholder value"
+        if _placeholder_equal(finding.get("detail")):
+            return f"{where}.detail matched a schema placeholder value"
+
+        file_path = _normalize_diff_path(finding.get("file"))
+        severity = str(finding.get("severity") or "")
+        if (
+            severity in BLOCKER_SEVERITIES
+            and (not file_path or not _diff_file_matches(file_path, allowed_files))
+        ):
+            return f"{where}.file {file_path!r} is not present in the PR diff"
+
+    if (
+        parsed.verdict == "BLOCKED"
+        and len(parsed.prose.strip()) < MIN_BLOCKED_VERDICT_PROSE_CHARS
+    ):
+        return "structured blocked verdict body is too short to be credible"
+
+    return None
+
+
+def _apply_claude_verdict_guardrails(
+    parsed: ClaudeVerdict,
+    changed_files: Tuple[str, ...],
+) -> Tuple[ClaudeVerdict, Optional[str]]:
+    reason = _claude_verdict_guardrail_reason(parsed, changed_files)
+    if reason is None:
+        return parsed, None
+    return _unknown_structured_verdict(reason), reason
+
+
+def _fixture_structured_quarantine_reason(parsed: ClaudeVerdict) -> Optional[str]:
+    if _is_fixture_structured_verdict(parsed.summary, list(parsed.findings)):
+        return "fixture-shaped structured verdict rejected by guardrail"
+    return None
+
+
+def _quarantine_is_test_only(reason: Optional[str]) -> bool:
+    return reason == "PYTEST_CURRENT_TEST is set"
+
+
+def _comment_with_runtime_quarantine_note(comment_body: str, reason: str) -> str:
+    note = (
+        "\nRuntime quarantine: local verdict artifact was quarantined because "
+        f"{reason}. Posting UNKNOWN so the lane requeues visibly.\n"
+    )
+    marker = f"\n\n{STALE_TRAILER}"
+    if marker in comment_body:
+        body = comment_body.replace(marker, note + "\n" + STALE_TRAILER, 1)
+    else:
+        body = comment_body.rstrip() + note + "\n" + STALE_TRAILER + "\n"
+    return limit_comment_body(body, STALE_TRAILER, provider_name="Claude")
+
+
+def _write_claude_raw_output_sidecar(
+    artifact_path: Optional[Path],
+    attempts: List[Dict[str, Any]],
+) -> None:
+    if artifact_path is None:
+        return
+    sidecar_path = artifact_path.with_suffix(".claude-raw-output.json")
+    payload = {"schema": CLAUDE_RAW_OUTPUT_SCHEMA, "attempts": attempts}
+    try:
+        text = json.dumps(payload, indent=2, sort_keys=True) + "\n"
+        sidecar_path.write_text(text, encoding="utf-8")
+    except OSError as exc:
+        print(
+            f"warning: failed to write Claude raw output sidecar {sidecar_path}: {exc}",
+            file=sys.stderr,
+        )
+
+
+def _guardrail_retry_prompt(
+    prompt: str,
+    reason: str,
+    changed_files: Tuple[str, ...],
+) -> str:
+    files = "\n".join(f"- {path}" for path in changed_files[:50])
+    if len(changed_files) > 50:
+        files += f"\n- ... {len(changed_files) - 50} additional file(s) omitted"
+    return (
+        f"{prompt.rstrip()}\n\n"
+        "Trusted wrapper retry instruction:\n"
+        f"The previous structured verdict was rejected: {reason}. "
+        "Return a fresh JSON verdict only. Do not use placeholder values such "
+        "as 'test', 'example', or 'placeholder'. P0/P1/P2 findings must cite a "
+        "file from the PR diff, using the repository-relative path or a unique "
+        "suffix. PR diff files:\n"
+        f"{files}\n"
+    )
+
+
+def _record_posted_comment_url(
+    artifact_path: Optional[Path],
+    posted_comment_url: Optional[str],
+) -> None:
+    if artifact_path is None or not posted_comment_url:
+        return
+    try:
+        payload = json.loads(artifact_path.read_text(encoding="utf-8"))
+        if not isinstance(payload, dict):
+            return
+        payload["posted_comment_url"] = posted_comment_url
+        text = json.dumps(payload, indent=2, sort_keys=True) + "\n"
+        artifact_path.write_text(text, encoding="utf-8")
+    except (OSError, json.JSONDecodeError) as exc:
+        print(
+            f"warning: failed to update audit verdict artifact {artifact_path}: {exc}",
+            file=sys.stderr,
+        )
+
+
 def _claude_env() -> Dict[str, str]:
     preserve_auth_overrides = env_flag(os.environ.get("CODE_MOWER_CLAUDE_KEEP_AUTH_ENV"))
     env, _removed = clean_claude_cli_env(
@@ -505,6 +672,13 @@ def _build_diff_context(
         raise FetchedHeadMismatch(expected_head_sha, fetched_head_ref)
     diff_range = f"{fetched_base_ref}...{fetched_head_ref}"
     stat = _run_git(local_repo, ["diff", "--stat", "--find-renames", diff_range])
+    changed_files_text = _run_git(
+        local_repo,
+        ["-c", "core.quotePath=false", "diff", "--name-only", "--find-renames", diff_range],
+    )
+    changed_files = tuple(
+        line.strip() for line in changed_files_text.splitlines() if line.strip()
+    )
     included_diff, full_diff_bytes, was_truncated = _run_git_limited(
         local_repo,
         ["diff", "--find-renames", "--unified=80", diff_range],
@@ -518,6 +692,7 @@ def _build_diff_context(
     return DiffContext(
         stat=stat,
         diff=included_diff,
+        changed_files=changed_files,
         was_truncated=was_truncated,
         requested_max_bytes=max_diff_bytes,
         hard_limit_bytes=hard_limit,
@@ -850,6 +1025,9 @@ def audit_pr(config: ClaudeAuditConfig, repo: str, pr_number: int) -> ClaudeAudi
             parsed=parsed,
         )
         if not config.dry_run:
+            quarantine_reason = _audit_runtime_quarantine_reason(
+                comment_body=comment_body,
+            )
             artifact_path = write_audit_verdict_artifact(
                 lane_id="claude-audit",
                 repo=repo,
@@ -859,6 +1037,7 @@ def audit_pr(config: ClaudeAuditConfig, repo: str, pr_number: int) -> ClaudeAudi
                 verdict=result.verdict,
                 trailer=result.trailer,
                 comment_body=comment_body,
+                quarantine_reason=quarantine_reason,
             )
             result.verdict_artifact_path = artifact_path
             if artifact_path is not None:
@@ -867,13 +1046,35 @@ def audit_pr(config: ClaudeAuditConfig, repo: str, pr_number: int) -> ClaudeAudi
                     file=sys.stderr,
                     flush=True,
                 )
-            posted = post_pr_comment(repo, pr_number, comment_body, token=config.github_token)
-            result.posted_comment_url = posted.get("html_url")
-            print(
-                f"posted {repo}#{pr_number} verdict=STALE "
-                f"url={result.posted_comment_url}",
-                file=sys.stderr,
-            )
+            if quarantine_reason:
+                print(
+                    "  runtime guard quarantined verdict artifact: "
+                    f"{quarantine_reason}",
+                    file=sys.stderr,
+                    flush=True,
+                )
+            if quarantine_reason and _quarantine_is_test_only(quarantine_reason):
+                print("  skipped GitHub post for pytest-only quarantine", file=sys.stderr, flush=True)
+            else:
+                if quarantine_reason:
+                    result.verdict = "UNKNOWN"
+                    result.trailer = STALE_TRAILER
+                    comment_body = _comment_with_runtime_quarantine_note(
+                        comment_body,
+                        quarantine_reason,
+                    )
+                    result.comment_body = comment_body
+                posted = post_pr_comment(repo, pr_number, comment_body, token=config.github_token)
+                result.posted_comment_url = posted.get("html_url")
+                _record_posted_comment_url(
+                    result.verdict_artifact_path,
+                    result.posted_comment_url,
+                )
+                print(
+                    f"posted {repo}#{pr_number} verdict=STALE "
+                    f"url={result.posted_comment_url}",
+                    file=sys.stderr,
+                )
         config.progress.emit(
             "audit",
             status="finish",
@@ -927,8 +1128,48 @@ def audit_pr(config: ClaudeAuditConfig, repo: str, pr_number: int) -> ClaudeAudi
         ),
     )
 
+    raw_output_attempts: List[Dict[str, Any]] = []
+    parsed = _unknown_structured_verdict("Claude audit did not run")
+    claude_stdout = ""
+    claude_stderr = ""
+    attempt_prompt = prompt
+    final_fixture_reason: Optional[str] = None
     t0 = time.time()
-    parsed, claude_stdout, claude_stderr = run_claude_audit(config, prompt)
+    for attempt in range(1, MAX_CLAUDE_AUDIT_ATTEMPTS + 1):
+        parsed_candidate, attempt_stdout, attempt_stderr = run_claude_audit(
+            config,
+            attempt_prompt,
+        )
+        claude_stdout = attempt_stdout
+        claude_stderr = attempt_stderr
+        parsed, guardrail_reason = _apply_claude_verdict_guardrails(
+            parsed_candidate,
+            diff_context.changed_files,
+        )
+        final_fixture_reason = _fixture_structured_quarantine_reason(parsed_candidate)
+        raw_output_attempts.append(
+            {
+                "attempt": attempt,
+                "stdout": attempt_stdout,
+                "stderr": attempt_stderr,
+                "verdict": parsed_candidate.verdict,
+                "guardrail_rejection": guardrail_reason,
+            }
+        )
+        if guardrail_reason and attempt < MAX_CLAUDE_AUDIT_ATTEMPTS:
+            print(
+                "  structured-verdict guardrail rejected Claude output: "
+                f"{guardrail_reason}; retrying once",
+                file=sys.stderr,
+                flush=True,
+            )
+            attempt_prompt = _guardrail_retry_prompt(
+                prompt,
+                guardrail_reason,
+                diff_context.changed_files,
+            )
+            continue
+        break
     dt = time.time() - t0
     print(f"  claude audit completed in {dt:.0f}s", file=sys.stderr, flush=True)
     if parsed.mismatch_note:
@@ -984,6 +1225,10 @@ def audit_pr(config: ClaudeAuditConfig, repo: str, pr_number: int) -> ClaudeAudi
     )
 
     if not config.dry_run:
+        quarantine_reason = _audit_runtime_quarantine_reason(
+            comment_body=comment_body,
+            fixture_reason=final_fixture_reason if parsed.verdict == "UNKNOWN" else None,
+        )
         artifact_path = write_audit_verdict_artifact(
             lane_id="claude-audit",
             repo=repo,
@@ -993,6 +1238,7 @@ def audit_pr(config: ClaudeAuditConfig, repo: str, pr_number: int) -> ClaudeAudi
             verdict=result_verdict,
             trailer=trailer,
             comment_body=comment_body,
+            quarantine_reason=quarantine_reason,
         )
         result.verdict_artifact_path = artifact_path
         if artifact_path is not None:
@@ -1001,17 +1247,40 @@ def audit_pr(config: ClaudeAuditConfig, repo: str, pr_number: int) -> ClaudeAudi
                 file=sys.stderr,
                 flush=True,
             )
-        posted = post_pr_comment(repo, pr_number, comment_body, token=config.github_token)
-        result.posted_comment_url = posted.get("html_url")
-        print(
-            f"posted {repo}#{pr_number} verdict={result_verdict} "
-            f"url={result.posted_comment_url}",
-            file=sys.stderr,
-        )
+            _write_claude_raw_output_sidecar(artifact_path, raw_output_attempts)
+        if quarantine_reason:
+            print(
+                "  runtime guard quarantined verdict artifact: "
+                f"{quarantine_reason}",
+                file=sys.stderr,
+                flush=True,
+            )
+        if quarantine_reason and _quarantine_is_test_only(quarantine_reason):
+            print("  skipped GitHub post for pytest-only quarantine", file=sys.stderr, flush=True)
+        else:
+            if quarantine_reason:
+                result.verdict = "UNKNOWN"
+                result.trailer = STALE_TRAILER
+                comment_body = _comment_with_runtime_quarantine_note(
+                    comment_body,
+                    quarantine_reason,
+                )
+                result.comment_body = comment_body
+            posted = post_pr_comment(repo, pr_number, comment_body, token=config.github_token)
+            result.posted_comment_url = posted.get("html_url")
+            _record_posted_comment_url(
+                result.verdict_artifact_path,
+                result.posted_comment_url,
+            )
+            print(
+                f"posted {repo}#{pr_number} verdict={result_verdict} "
+                f"url={result.posted_comment_url}",
+                file=sys.stderr,
+            )
     config.progress.emit(
         "audit",
         status="finish",
-        detail=f"{repo}#{pr_number} verdict={result_verdict}",
+        detail=f"{repo}#{pr_number} verdict={result.verdict}",
     )
     return result
 

{code_mower-0.5.0b42 → code_mower-0.5.0b44}/src/code_mower/cli.py

@@ -14,7 +14,7 @@ from pathlib import Path
 if __package__ in {None, ""}:
     raise SystemExit(
         "code_mower.cli is a packaged entrypoint. Install Code Mower with "
-        "`pipx install code-mower==0.5.0b42`, or run source checkouts with "
+        "`pipx install code-mower==0.5.0b44`, or run source checkouts with "
         "`PYTHONPATH=src python -m code_mower.cli`."
     )
 

{code_mower-0.5.0b42 → code_mower-0.5.0b44}/src/code_mower/code_mower_telemetry.py

@@ -18,12 +18,16 @@ if __package__ in {None, ""}:
     sys.path.insert(0, str(module_dir.parent))
     if module_dir.name == "code_mower":  # pragma: no cover - extracted direct CLI.
         from code_mower import audit_handoff_log
+        from code_mower.provider_runners import is_fixture_verdict_artifact
     else:
         from tools import audit_handoff_log
+        from tools.provider_runners import is_fixture_verdict_artifact
 elif __package__ == "tools":
     from tools import audit_handoff_log
+    from tools.provider_runners import is_fixture_verdict_artifact
 else:  # pragma: no cover - exercised after package extraction.
     from . import audit_handoff_log
+    from .provider_runners import is_fixture_verdict_artifact
 
 
 PASS_VERDICTS = {"completed", "done", "pass", "passed", "success", "succeeded"}
@@ -31,7 +35,6 @@ BLOCKED_VERDICTS = {"block", "blocked", "fail", "failed", "failure"}
 VERDICT_ARTIFACT_SCHEMA = "code_mower.auditVerdictArtifact.v1"
 BENCHMARK_EVENT_SCHEMA = "code_mower.benchmarkEvent.v1"
 VERDICT_ARTIFACT_DIR_ENV = "CODE_MOWER_VERDICT_ARTIFACT_DIR"
-DEFAULT_VERDICT_ARTIFACT_DIR = Path.home() / ".cache" / "code-mower-audits" / "verdicts"
 SEVERITY_RE = re.compile(r"\b(P[0-3])=(\d+)\b")
 AUDIT_TRAILER_RE = re.compile(
     r"<!--\s*(?P<prefix>[A-Z0-9_]+_AUDIT_STATE)\s*:\s*(?P<label>[a-z0-9_.-]+)\s*-->",
@@ -43,7 +46,10 @@ def default_verdict_artifact_dir() -> Path:
     configured = os.environ.get(VERDICT_ARTIFACT_DIR_ENV, "").strip()
     if configured:
         return Path(configured).expanduser()
-    return DEFAULT_VERDICT_ARTIFACT_DIR
+    cache_home = os.environ.get("XDG_CACHE_HOME", "").strip()
+    if cache_home:
+        return Path(cache_home).expanduser() / "code-mower-audits" / "verdicts"
+    return Path.home() / ".cache" / "code-mower-audits" / "verdicts"
 
 
 def _normalize_repo_slug(value: str) -> str:
@@ -249,6 +255,8 @@ def export_reviewer_run_events_from_verdicts(
             raise ValueError(f"{path}: verdict artifact must be a JSON object")
         if payload.get("schema") != VERDICT_ARTIFACT_SCHEMA:
             continue
+        if is_fixture_verdict_artifact(payload):
+            continue
         artifact_repo = _normalize_repo_slug(
             str(payload.get("repo") or _repo_slug_from_artifact_path(path))
         )