counterproof 1.0.0__py3-none-any.whl

counterproof/__init__.py

@@ -0,0 +1,12 @@
+"""Counterproof: is an AI-written change actually proven by its tests?"""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("counterproof")
+except PackageNotFoundError:  # pragma: no cover - running from a source tree
+    __version__ = "0.0.0+unknown"
+
+__all__ = ["__version__"]

counterproof/__main__.py

@@ -0,0 +1,3 @@
+from counterproof.cli import main
+
+main()

counterproof/adapters/__init__.py

@@ -0,0 +1 @@
+"""Test-runner adapters behind one interface (FR-AD)."""

counterproof/adapters/base.py

@@ -0,0 +1,163 @@
+"""Common adapter interface (PRD section 7.3) and shared failure classification."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Final, Protocol
+
+from counterproof.adapters.junit import JUnitCase
+from counterproof.models import FailureKind, RunResult, TestId
+from counterproof.workspace.manager import Workspace
+
+NOT_REPORTED: Final = "no result reported"
+"""Message for requested tests missing from the report (for example after a collection abort)."""
+
+FileLine = tuple[str, int]
+"""Workspace-relative POSIX path and 1-based line number."""
+CoverageMap = dict[FileLine, set[str]]
+
+
+@dataclass(frozen=True)
+class PrepResult:
+    ok: bool
+    message: str = ""
+    interpreter: str | None = None
+    env: dict[str, str] = field(default_factory=dict)
+    capabilities: frozenset[str] = frozenset()
+
+
+class CollectionError(Exception):
+    """Test discovery failed (syntax error, import error at collection time)."""
+
+    def __init__(self, message: str, output: str = "") -> None:
+        super().__init__(message)
+        self.output = output
+
+
+class Adapter(Protocol):
+    name: str
+
+    def detect(self, repo: Path) -> float: ...
+
+    def is_test_file(self, path: str) -> bool: ...
+
+    def prepare(self, ws: Workspace) -> PrepResult: ...
+
+    def list_tests(self, ws: Workspace, files: list[str] | None = None) -> list[TestId]: ...
+
+    def run(
+        self,
+        ws: Workspace,
+        tests: list[str],
+        *,
+        timeout_s: float,
+        fail_fast: bool,
+        junit_path: Path,
+        coverage_file: Path | None = None,
+    ) -> RunResult: ...
+
+    def coverage_map(
+        self,
+        ws: Workspace,
+        tests: list[str],
+        *,
+        timeout_s: float,
+        junit_path: Path,
+        coverage_file: Path,
+    ) -> CoverageMap | None: ...
+
+    def related_tests(self, src_files: list[str], all_tests: list[TestId]) -> list[TestId]: ...
+
+    def failure_kind(self, case: JUnitCase) -> FailureKind: ...
+
+    def run_script(
+        self, ws: Workspace, script: Path, args: list[str], *, timeout_s: float = 120.0
+    ) -> str | None: ...
+
+
+_COLLECTION_HINTS: Final = re.compile(
+    r"(collection failure|ERROR collecting|SyntaxError|IndentationError|"
+    r"ImportError while importing test module)"
+)
+_ENV_HINTS: Final = re.compile(
+    r"(ModuleNotFoundError: No module named|ConnectionRefusedError|ConnectionError|"
+    r"socket\.gaierror|Temporary failure in name resolution)"
+)
+_ASSERTION_HINTS: Final = re.compile(
+    r"(AssertionError|^assert |\nE\s+assert |DID NOT RAISE|Failed: DID NOT|"
+    r"AssertionError:|expect\(|toBe|toEqual)"
+)
+
+
+def classify_failure(case: JUnitCase, *, timed_out: bool = False) -> FailureKind:
+    """FR-AD-04, change-agnostic part.
+
+    ``API_ABSENT`` needs to know which symbols the change added, so the red-green probe (M2)
+    refines ``EXCEPTION_BEHAVIOURAL`` and ``ENV`` results into ``API_ABSENT`` where it applies.
+    """
+    if timed_out:
+        return "TIMEOUT"
+    blob = f"{case.message}\n{case.text}"
+    if case.is_collection_error or _COLLECTION_HINTS.search(blob):
+        return "COLLECTION"
+    if _ASSERTION_HINTS.search(blob):
+        return "ASSERTION"
+    if _ENV_HINTS.search(blob):
+        return "ENV"
+    return "EXCEPTION_BEHAVIOURAL"
+
+
+_API_HINTS: Final = re.compile(
+    r"(ImportError|cannot import name|AttributeError|has no attribute|TypeError|"
+    r"unexpected keyword argument|positional argument|is not a function|is not callable|"
+    r"ModuleNotFoundError|is not a constructor|does not provide an export named|"
+    r"Failed to load url|Failed to resolve import|Cannot find module)"
+)
+# JavaScript: `(0 , __vi_import_0__.splitCents) is not a function`, missing ESM exports and
+# modules that do not exist on the old code.
+_JS_NOT_CALLABLE: Final = re.compile(r"([A-Za-z_$][\w$]*)\)? is not a (?:function|constructor)")
+_JS_EXPORT: Final = re.compile(r"does not provide an export named '([\w$]+)'")
+_JS_MODULE: Final = re.compile(
+    r"(?:Failed to load url|Failed to resolve import|Cannot find module)\s+['\"]?([^'\"\s)]+)"
+)
+_QUOTED: Final = re.compile(r"['\"]([A-Za-z_][\w.]*)['\"]")
+_UNEXPECTED_KW: Final = re.compile(r"(\w+)\(\) got an unexpected keyword argument '(\w+)'")
+_POSITIONAL: Final = re.compile(r"(\w+)\(\) takes .* positional arguments? but .* given")
+
+
+def refine_api_absent(
+    kind: FailureKind,
+    text: str,
+    added_symbols: set[str],
+    new_modules: set[str],
+) -> FailureKind:
+    """FR-AD-04 ``API_ABSENT``: the failure names a symbol, argument or module the change added.
+
+    ``added_symbols`` holds names and ``func(param)`` pairs from :func:`pyast.added_symbols`.
+    A test that cannot even call the old code is weak evidence (FR-RG-05), not a behavioural
+    failure, so it must not count as red-green proof.
+    """
+    if kind not in {"EXCEPTION_BEHAVIOURAL", "ENV", "COLLECTION"} or not _API_HINTS.search(text):
+        return kind
+    names = {s for s in added_symbols if "(" not in s}
+    params = {tuple(s[:-1].split("(", 1)) for s in added_symbols if "(" in s}
+    for quoted in _QUOTED.findall(text):
+        if quoted in names or quoted.rsplit(".", 1)[-1] in names or quoted in new_modules:
+            return "API_ABSENT"
+    for func, arg in _UNEXPECTED_KW.findall(text):
+        if (func, arg) in params:
+            return "API_ABSENT"
+    for func in _POSITIONAL.findall(text):
+        if any(f == func for f, _ in params):
+            return "API_ABSENT"
+    for name in [*_JS_NOT_CALLABLE.findall(text), *_JS_EXPORT.findall(text)]:
+        if name in names:
+            return "API_ABSENT"
+    module_stems = {m.rsplit(".", 1)[-1] for m in new_modules}
+    for spec in _JS_MODULE.findall(text):
+        stem = re.split(r"[/\\]", spec)[-1].split(".", 1)[0]
+        if stem and stem in module_stems:
+            return "API_ABSENT"
+    return kind

counterproof/adapters/detect.py

@@ -0,0 +1,71 @@
+"""StackDetector: choose adapters from project manifests (PRD section 6.1, FR-AD-06).
+
+Every adapter scores the repository; those at or above :data:`MIN_CONFIDENCE` are active.
+A run uses the adapter that owns the changed code: Python files belong to pytest, TS/JS
+files to Vitest or Jest. Projects in subdirectories of a monorepo (a nested
+``package.json`` or ``pyproject.toml``) are not run separately yet.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+from typing import Final
+
+from counterproof.adapters.base import Adapter
+from counterproof.adapters.jest_adapter import JestAdapter
+from counterproof.adapters.pytest_adapter import PytestAdapter
+from counterproof.adapters.vitest_adapter import VitestAdapter
+from counterproof.models import ChangeSet
+from counterproof.probes import lang
+
+MIN_CONFIDENCE: Final = 0.5
+_LANGUAGE: Final = {"pytest": "python", "vitest": "typescript", "jest": "typescript"}
+
+
+def detect_adapters(
+    repo: Path,
+    *,
+    env_pass: Sequence[str] = (),
+    source_env: Mapping[str, str] | None = None,
+    deps_root: Path | None = None,
+) -> list[Adapter]:
+    """Adapters whose confidence for ``repo`` is at least :data:`MIN_CONFIDENCE`.
+
+    ``repo`` is the tree to inspect (the head worktree); ``deps_root`` is where untracked
+    dependencies live (the user's repository: its ``.venv`` and ``node_modules``).
+    """
+    deps = deps_root or repo
+    candidates: list[Adapter] = [
+        PytestAdapter(deps, env_pass=env_pass, source_env=source_env),
+        VitestAdapter(deps, env_pass=env_pass, source_env=source_env),
+        JestAdapter(deps, env_pass=env_pass, source_env=source_env),
+    ]
+    scored = [(a.detect(repo), i, a) for i, a in enumerate(candidates)]
+    return [
+        a for score, _, a in sorted(scored, key=lambda s: (-s[0], s[1])) if score >= MIN_CONFIDENCE
+    ]
+
+
+def owner_language(path: str) -> str | None:
+    if lang.is_python(path):
+        return "python"
+    if lang.is_typescript(path):
+        return "typescript"
+    return None
+
+
+def choose_adapter(adapters: Sequence[Adapter], change: ChangeSet) -> Adapter | None:
+    """FR-AD-06: the active adapter whose language owns most of the changed code files."""
+    if not adapters:
+        return None
+    counts: dict[str, int] = {}
+    for f in change.files:
+        language = owner_language(f.path)
+        if language and f.role in {"source", "test"}:
+            counts[language] = counts.get(language, 0) + 1
+    if not counts:
+        return adapters[0]
+    ranked = sorted(adapters, key=lambda a: -counts.get(_LANGUAGE.get(a.name, ""), 0))
+    best = ranked[0]
+    return best if counts.get(_LANGUAGE.get(best.name, ""), 0) else adapters[0]

counterproof/adapters/jest_adapter.py

@@ -0,0 +1,314 @@
+"""JestAdapter (FR-AD-03), checked against Jest 30.5 and jest-junit 17 (November 2026).
+
+* Run: ``jest --ci --reporters=jest-junit --runTestsByPath <files> -t '^(?:names)$'``.
+  jest-junit is configured through its environment variables: ``classname`` is the file
+  path, ``name`` is ``<describe> > ... > <title>`` (ancestors joined by `` > ``), so node
+  ids match Vitest's: ``<file>::<full name>``. Jest's ``-t`` matches the full name joined
+  with spaces. Suite load errors are reported as a case named after the file.
+* List: ``jest --listTests --json`` gives files; test names come from a static scan of each
+  file (tree-sitter). Related tests: ``jest --listTests --findRelatedTests`` (runs nothing).
+* No per-test coverage in v1. Jest's cache goes to the run directory.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+from typing import Final
+
+from counterproof.adapters.base import (
+    NOT_REPORTED,
+    CollectionError,
+    CoverageMap,
+    PrepResult,
+    classify_failure,
+)
+from counterproof.adapters.junit import JUnitCase, parse_junit
+from counterproof.adapters.node import (
+    declared_dependencies,
+    ensure_node_modules,
+    js_regex_escape,
+    node_env,
+    node_version,
+    package_bin,
+    resolve_node,
+)
+from counterproof.change.classify import is_test_path
+from counterproof.evidence.hashing import sha256_bytes, sha256_file
+from counterproof.log import get_logger
+from counterproof.models import FailureInfo, FailureKind, RunResult, TestId, TestOutcome
+from counterproof.probes import tsast
+from counterproof.workspace.manager import Workspace
+from counterproof.workspace.sandbox_docker import SandboxHost
+
+log = get_logger("adapters.jest")
+
+COLLECT_TIMEOUT_S: Final = 180.0
+MAX_CMDLINE_CHARS: Final = 7000
+SUITE_ERROR: Final = "Test suite failed to run"
+CONFIG_FILES: Final = tuple(
+    f"jest.config.{ext}" for ext in ("js", "cjs", "mjs", "ts", "cts", "mts", "json")
+)
+
+
+class JestAdapter(SandboxHost):
+    name = "jest"
+
+    def __init__(
+        self,
+        repo_root: Path,
+        *,
+        env_pass: Sequence[str] = (),
+        source_env: Mapping[str, str] | None = None,
+    ) -> None:
+        self.repo_root = repo_root
+        self.env_pass = tuple(env_pass)
+        self.source_env: Mapping[str, str] = os.environ if source_env is None else source_env
+        self.node = resolve_node(self.source_env)
+        self._listed: Workspace | None = None
+
+    def detect(self, repo: Path) -> float:
+        deps = declared_dependencies(repo)
+        if any((repo / name).is_file() for name in CONFIG_FILES):
+            return 1.0
+        if "jest" in deps and "vitest" not in deps:
+            return 0.9
+        return 0.4 if "jest" in deps else 0.0
+
+    def is_test_file(self, path: str) -> bool:
+        return tsast.is_ts_path(path) and is_test_path(path)
+
+    def child_env(self, ws: Workspace, junit_path: Path | None = None) -> dict[str, str]:
+        env = node_env(self.source_env, self.env_pass, self.node)
+        env.update(
+            JEST_JUNIT_CLASSNAME="{filepath}",
+            JEST_JUNIT_TITLE="{classname} > {title}",
+            JEST_JUNIT_ANCESTOR_SEPARATOR=" > ",
+            JEST_JUNIT_REPORT_TEST_SUITE_ERRORS="true",
+        )
+        if junit_path is not None:
+            env["JEST_JUNIT_OUTPUT_FILE"] = str(junit_path)
+        return env
+
+    def _bin(self, ws: Workspace) -> Path | None:
+        return package_bin(ws.root / "node_modules", "jest", "jest")
+
+    def _node(self) -> str:
+        if self.node is None:
+            raise CollectionError("node not found on PATH (set COUNTERPROOF_NODE)")
+        return self.node
+
+    def _base_cmd(self, ws: Workspace) -> list[str]:
+        return [
+            self._node(),
+            str(self._bin(ws)),
+            "--ci",
+            "--rootDir",
+            str(ws.root),
+            "--cacheDirectory",
+            str(ws.root.parent / f".jest-cache-{ws.name}"),
+            "--watchman=false",
+        ]
+
+    def prepare(self, ws: Workspace) -> PrepResult:
+        if self.node is None:
+            return PrepResult(
+                ok=False, message="node not found on PATH (set COUNTERPROOF_NODE to its path)"
+            )
+        problem = ensure_node_modules(self.repo_root, ws)
+        if problem:
+            return PrepResult(ok=False, message=problem)
+        missing = [p for p in ("jest", "jest-junit") if not (ws.root / "node_modules" / p).is_dir()]
+        if self._bin(ws) is None or missing:
+            return PrepResult(
+                ok=False,
+                message=f"{' and '.join(missing or ['jest'])} not installed in node_modules; "
+                "install the project's dependencies first (FR-AD-05)",
+            )
+        env = self.child_env(ws)
+        version = node_version(self.node, env, ws.root)
+        if version is None:
+            return PrepResult(ok=False, message=f"cannot run {self.node}")
+        data = json.loads(
+            (ws.root / "node_modules" / "jest" / "package.json").read_text(encoding="utf-8")
+        )
+        log.info("jest %s on node %s (%s)", data.get("version"), version, self.node)
+        return PrepResult(
+            ok=True,
+            interpreter=self.node,
+            env=env,
+            capabilities=frozenset({"jest"}),
+            message=f"jest {data.get('version')}, node {version}",
+        )
+
+    def _list_files(self, ws: Workspace, extra: list[str]) -> list[str]:
+        cmd = [*self._base_cmd(ws), "--listTests", "--json", *extra]
+        proc = self.run_process(
+            cmd, cwd=ws.root, env=self.child_env(ws), timeout_s=COLLECT_TIMEOUT_S
+        )
+        start = proc.stdout.find("[")
+        try:
+            files = json.loads(proc.stdout[start:]) if start >= 0 else None
+        except json.JSONDecodeError:
+            files = None
+        if proc.timed_out or proc.exit_code != 0 or not isinstance(files, list):
+            raise CollectionError(
+                f"jest --listTests failed (exit {proc.exit_code})", proc.stdout + proc.stderr
+            )
+        root = ws.root.resolve()
+        out: list[str] = []
+        for f in files:
+            try:
+                out.append(Path(str(f)).resolve().relative_to(root).as_posix())
+            except ValueError:
+                continue
+        return sorted(out)
+
+    def list_tests(self, ws: Workspace, files: list[str] | None = None) -> list[TestId]:
+        problem = ensure_node_modules(self.repo_root, ws)
+        if problem:
+            raise CollectionError(problem)
+        listed = self._list_files(ws, [])
+        if files:
+            listed = [f for f in listed if f in set(files)]
+        self._listed = ws
+        tests: list[TestId] = []
+        for rel in listed:
+            text = (ws.root / rel).read_text(encoding="utf-8", errors="replace")
+            analysed = tsast.analyse_test_file(text, rel)
+            if analysed is None:
+                raise CollectionError(f"cannot parse test file {rel}")
+            tests += [TestId(adapter=self.name, file=rel, name=n) for n in analysed.tests]
+        return tests
+
+    def related_tests(self, src_files: list[str], all_tests: list[TestId]) -> list[TestId]:
+        if self._listed is None or not src_files:
+            return []
+        try:
+            files = set(self._list_files(self._listed, ["--findRelatedTests", *src_files]))
+        except CollectionError as exc:
+            log.warning("jest --findRelatedTests failed: %s", exc)
+            return []
+        return [t for t in all_tests if t.file in files]
+
+    def _targets(self, tests: list[str]) -> list[str]:
+        files = sorted({t.partition("::")[0] for t in tests})
+        names = sorted({t.partition("::")[2].replace(" > ", " ") for t in tests})
+        pattern = "^(?:" + "|".join(js_regex_escape(n) for n in names) + ")$"
+        args = ["--runTestsByPath", *files, "-t", pattern]
+        if sum(len(a) + 1 for a in args) > MAX_CMDLINE_CHARS:
+            return ["--runTestsByPath", *files]
+        return args
+
+    def run(
+        self,
+        ws: Workspace,
+        tests: list[str],
+        *,
+        timeout_s: float,
+        fail_fast: bool,
+        junit_path: Path,
+        coverage_file: Path | None = None,
+    ) -> RunResult:
+        junit_path.parent.mkdir(parents=True, exist_ok=True)
+        junit_path.unlink(missing_ok=True)
+        problem = ensure_node_modules(self.repo_root, ws)
+        cmd = [*self._base_cmd(ws), "--reporters=jest-junit"]
+        if fail_fast:
+            cmd.append("--bail=1")
+        cmd += self._targets(tests)
+        if problem:
+            out, exit_code, duration, timed_out = problem, 1, 0.0, False
+        else:
+            proc = self.run_process(
+                cmd, cwd=ws.root, env=self.child_env(ws, junit_path), timeout_s=timeout_s
+            )
+            out = f"{proc.stdout}\n{proc.stderr}"
+            exit_code, duration, timed_out = proc.exit_code, proc.duration_s, proc.timed_out
+        junit_path.with_suffix(".log").write_text(
+            f"$ {' '.join(cmd)}\n[exit {exit_code}{' TIMEOUT' if timed_out else ''}]\n{out}",
+            encoding="utf-8",
+        )
+        outcomes, failures, durations = self._map_results(
+            parse_junit(junit_path), tests, timed_out=timed_out, fail_fast=fail_fast
+        )
+        return RunResult(
+            tests=outcomes,
+            failures=failures,
+            duration_s=round(duration, 6),
+            command=cmd,
+            exit_code=exit_code,
+            junit_sha256=sha256_file(junit_path) if junit_path.is_file() else sha256_bytes(b""),
+            test_durations=dict(sorted(durations.items())),
+        )
+
+    def _map_results(
+        self, cases: list[JUnitCase], tests: list[str], *, timed_out: bool, fail_fast: bool
+    ) -> tuple[dict[str, TestOutcome], dict[str, FailureInfo], dict[str, float]]:
+        wanted = set(tests)
+        outcomes: dict[str, TestOutcome] = {}
+        failures: dict[str, FailureInfo] = {}
+        durations: dict[str, float] = {}
+        for case in cases:
+            if case.classname == SUITE_ERROR:
+                file = case.name.replace("\\", "/")
+                for t in tests:
+                    if t.partition("::")[0] == file and t not in outcomes:
+                        outcomes[t] = "error"
+                        failures[t] = FailureInfo(
+                            kind="COLLECTION", message=SUITE_ERROR, traceback_excerpt=case.text
+                        )
+                continue
+            file = case.classname.replace("\\", "/")
+            name = case.name.removeprefix(" > ")
+            nodeid = f"{file}::{name}"
+            if nodeid not in wanted:
+                continue
+            outcomes[nodeid] = case.outcome
+            durations[nodeid] = case.time_s
+            if case.outcome in {"fail", "error"}:
+                failures[nodeid] = FailureInfo(
+                    kind=self.failure_kind(case), message=case.message, traceback_excerpt=case.text
+                )
+        stopped_early = fail_fast and any(o in {"fail", "error"} for o in outcomes.values())
+        for t in tests:
+            if t in outcomes:
+                continue
+            if timed_out:
+                outcomes[t] = "timeout"
+                failures[t] = FailureInfo(kind="TIMEOUT", message="run timed out")
+            elif not stopped_early:
+                outcomes[t] = "error"
+                failures[t] = FailureInfo(kind="COLLECTION", message=NOT_REPORTED)
+        return outcomes, failures, durations
+
+    def failure_kind(self, case: JUnitCase) -> FailureKind:
+        return classify_failure(case)
+
+    def run_script(
+        self, ws: Workspace, script: Path, args: list[str], *, timeout_s: float = 120.0
+    ) -> str | None:
+        """Run a generated Jest test file inside the worktree (fast-check fuzzer)."""
+        if ensure_node_modules(self.repo_root, ws) or self.node is None:
+            return None
+        rel = script.relative_to(ws.root).as_posix()
+        proc = self.run_process(
+            [*self._base_cmd(ws), "--runTestsByPath", rel],
+            cwd=ws.root,
+            env=self.child_env(ws),
+            timeout_s=timeout_s,
+        )
+        return None if proc.timed_out or proc.exit_code != 0 else proc.stdout + proc.stderr
+
+    def coverage_map(
+        self,
+        ws: Workspace,
+        tests: list[str],
+        *,
+        timeout_s: float,
+        junit_path: Path,
+        coverage_file: Path,
+    ) -> CoverageMap | None:
+        return None

counterproof/adapters/junit.py

@@ -0,0 +1,93 @@
+"""JUnit XML parsing (pytest ``junit_family=xunit2``; Vitest and Jest later).
+
+pytest identifies a case by ``classname`` (dotted module path, plus classes) and ``name``.
+We map those back to node ids by computing the expected key for every requested node id, so
+parametrised ids and nested classes round-trip exactly. Collection errors appear as a case
+with an empty classname whose ``name`` is the dotted module path.
+"""
+
+from __future__ import annotations
+
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass
+from pathlib import Path, PurePosixPath
+from typing import Final, Literal
+
+CaseOutcome = Literal["pass", "fail", "error", "skip"]
+COLLECTION_FAILURE: Final = "collection failure"
+MAX_TEXT: Final = 4000
+_TAG_OUTCOME: Final[dict[str, CaseOutcome]] = {
+    "failure": "fail",
+    "error": "error",
+    "skipped": "skip",
+}
+
+
+@dataclass(frozen=True)
+class JUnitCase:
+    classname: str
+    name: str
+    outcome: CaseOutcome
+    message: str
+    text: str
+    time_s: float
+
+    @property
+    def is_collection_error(self) -> bool:
+        return self.outcome == "error" and (
+            self.message == COLLECTION_FAILURE or (not self.classname and "." in self.name)
+        )
+
+
+def parse_junit(path: Path) -> list[JUnitCase]:
+    """Parse a junit file; a missing or empty file yields no cases."""
+    if not path.is_file() or path.stat().st_size == 0:
+        return []
+    try:
+        root = ET.parse(path).getroot()  # noqa: S314 - runner-written file in our run dir
+    except ET.ParseError:
+        return []
+    cases: list[JUnitCase] = []
+    for case in root.iter("testcase"):
+        outcome: CaseOutcome = "pass"
+        message = text = ""
+        for child in case:
+            mapped = _TAG_OUTCOME.get(child.tag)
+            if mapped is None:
+                continue
+            outcome = mapped
+            message = child.get("message", "") or ""
+            text = (child.text or "")[:MAX_TEXT]
+            if mapped != "skip":
+                break
+        try:
+            time_s = float(case.get("time", "0") or 0)
+        except ValueError:
+            time_s = 0.0
+        cases.append(
+            JUnitCase(
+                classname=case.get("classname", "") or "",
+                name=case.get("name", "") or "",
+                outcome=outcome,
+                message=message,
+                text=text,
+                time_s=time_s,
+            )
+        )
+    return cases
+
+
+def module_of(file: str) -> str:
+    """``tests/test_a.py`` -> ``tests.test_a``."""
+    pure = PurePosixPath(file)
+    return ".".join([*pure.parent.parts, pure.stem]) if pure.parent.parts else pure.stem
+
+
+def junit_key(nodeid: str) -> tuple[str, str]:
+    """``tests/test_a.py::TestK::test_p[1]`` -> ``("tests.test_a.TestK", "test_p[1]")``."""
+    file, _, rest = nodeid.partition("::")
+    parts = rest.split("::") if rest else []
+    module = module_of(file)
+    if not parts:
+        return "", module
+    return ".".join([module, *parts[:-1]]), parts[-1]