tdd-cli 0.9.0__tar.gz → 0.10.0__tar.gz

{tdd_cli-0.9.0 → tdd_cli-0.10.0}/CHANGELOG.md

@@ -6,6 +6,19 @@ and the project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.10.0] - 2026-09-05
+
+### Added
+
+- **cargo adapter** — Rust driver through `cargo test`. Ids are `<target>::<path>`
+  (`lib::…` for unit tests, `<tests-file-stem>::…` for integration tests) and compose
+  to `--lib`/`--test <name>` + `-- --exact <path>` for targeted runs. Verdicts are
+  parsed from cargo's per-test console lines, attributed to targets by the
+  `Running …` headers with stderr merged; doc-tests are excluded. A compile error maps
+  to `not_collected`, matching gradle/xctest. Collection is `cargo test --tests --
+  --list` with a per-file `--test <stem>` fallback; `tdd doctor`'s collectable gate is
+  `cargo test --no-run`. Target lint requires the `::` separator.
+
 ## [0.9.0] - 2026-09-03
 
 ### Added

{tdd_cli-0.9.0 → tdd_cli-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tdd-cli
-Version: 0.9.0
+Version: 0.10.0
 Summary: Ledger-backed TDD process controller for autonomous coding agents
 Project-URL: Homepage, https://github.com/geuben/tdd-cli
 Project-URL: Repository, https://github.com/geuben/tdd-cli
@@ -341,7 +341,7 @@ the next plan is written.
 
 ## Adapters
 
-`pytest`, `vitest`, `gradle`, `xctest`, and `exec` are built in. The pytest adapter runs
+`pytest`, `vitest`, `gradle`, `xctest`, `cargo`, and `exec` are built in. The pytest adapter runs
 the suite through the project's own environment manager, detected from its marker files —
 `uv.lock`, `poetry.lock`, `Pipfile`, `pdm.lock`, or `[tool.poetry]` in `pyproject.toml` —
 checked at the project root first, then the worktree root (workspace layouts keep one
@@ -393,6 +393,23 @@ lease        = "ios-simulator"
 timeout      = 900
 ```
 
+The `cargo` adapter drives Rust crates through `cargo test`. Test ids are
+`<target>::<path>` — `lib::layout::tests::wraps_short` for a `#[cfg(test)]` unit test,
+`roundtrip::renders_cover_only` for `tests/roundtrip.rs` — so a targeted run composes to
+cargo's own selectors (`--lib` / `--test <name>` plus `-- --exact <path>`) with no
+translation. Verdicts come from cargo's per-test console lines, attributed to targets by
+the `Running …` headers (stderr is merged so the order survives); doc-tests are excluded
+(`--tests`). A *compile* failure maps to `not_collected`, as for gradle and xctest: write a
+compiling stub (`todo!()`), then observe the panic. Declare `tests/` as `test_paths`, not
+`src/` — unit-test modules live inside production files and must not be staged as tests.
+
+```toml
+[project.kernel]
+root       = "kernel"
+adapter    = "cargo"
+test_paths = ["tests/"]
+```
+
 Third-party adapters register under the
 `tddcli.adapters` entry-point group:
 

{tdd_cli-0.9.0 → tdd_cli-0.10.0}/README.md

@@ -313,7 +313,7 @@ the next plan is written.
 
 ## Adapters
 
-`pytest`, `vitest`, `gradle`, `xctest`, and `exec` are built in. The pytest adapter runs
+`pytest`, `vitest`, `gradle`, `xctest`, `cargo`, and `exec` are built in. The pytest adapter runs
 the suite through the project's own environment manager, detected from its marker files —
 `uv.lock`, `poetry.lock`, `Pipfile`, `pdm.lock`, or `[tool.poetry]` in `pyproject.toml` —
 checked at the project root first, then the worktree root (workspace layouts keep one
@@ -365,6 +365,23 @@ lease        = "ios-simulator"
 timeout      = 900
 ```
 
+The `cargo` adapter drives Rust crates through `cargo test`. Test ids are
+`<target>::<path>` — `lib::layout::tests::wraps_short` for a `#[cfg(test)]` unit test,
+`roundtrip::renders_cover_only` for `tests/roundtrip.rs` — so a targeted run composes to
+cargo's own selectors (`--lib` / `--test <name>` plus `-- --exact <path>`) with no
+translation. Verdicts come from cargo's per-test console lines, attributed to targets by
+the `Running …` headers (stderr is merged so the order survives); doc-tests are excluded
+(`--tests`). A *compile* failure maps to `not_collected`, as for gradle and xctest: write a
+compiling stub (`todo!()`), then observe the panic. Declare `tests/` as `test_paths`, not
+`src/` — unit-test modules live inside production files and must not be staged as tests.
+
+```toml
+[project.kernel]
+root       = "kernel"
+adapter    = "cargo"
+test_paths = ["tests/"]
+```
+
 Third-party adapters register under the
 `tddcli.adapters` entry-point group:
 

{tdd_cli-0.9.0 → tdd_cli-0.10.0}/pyproject.toml

@@ -47,10 +47,11 @@ packages = ["src/tddcli"]
 include = ["src", "tests", "examples", "README.md", "LICENSE", "CHANGELOG.md", "SECURITY.md"]
 
 [dependency-groups]
-dev = ["pytest>=8.0", "pytest-json-report>=1.5", "ruff>=0.5", "zizmor>=1.29"]
+dev = ["pytest>=8.0", "pytest-json-report>=1.5", "pytest-xdist>=3.5", "ruff>=0.5", "zizmor>=1.29"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
+addopts = ["-n", "auto"]
 
 [tool.ruff]
 line-length = 100

{tdd_cli-0.9.0 → tdd_cli-0.10.0}/src/tddcli/__init__.py

@@ -3,4 +3,4 @@
 State is derived from observed test execution, never asserted by the caller.
 """
 
-__version__ = "0.9.0"
+__version__ = "0.10.0"

{tdd_cli-0.9.0 → tdd_cli-0.10.0}/src/tddcli/adapters/__init__.py

@@ -4,6 +4,7 @@ import importlib.metadata
 from pathlib import Path
 
 from .base import Adapter, Collection, GateResult, Verdict
+from .cargo_adapter import CargoAdapter
 from .exec_adapter import ExecAdapter
 from .gradle_adapter import GradleAdapter
 from .pytest_adapter import PytestAdapter
@@ -11,6 +12,7 @@ from .vitest_adapter import VitestAdapter
 from .xctest_adapter import XCTestAdapter
 
 REGISTRY: dict[str, type[Adapter]] = {
+    "cargo": CargoAdapter,
     "exec": ExecAdapter,
     "gradle": GradleAdapter,
     "pytest": PytestAdapter,

tdd_cli-0.10.0/src/tddcli/adapters/cargo_adapter.py

@@ -0,0 +1,321 @@
+"""cargo adapter — Rust driver through `cargo test` (§10).
+
+Test ids are `<target>::<path>`: the *target* is `lib` for unit tests compiled
+into the library (`#[cfg(test)]` modules under `src/`) or the integration-test
+binary name for a file under `tests/` (`tests/roundtrip.rs` → `roundtrip`); the
+*path* is the test's module path exactly as cargo prints it:
+
+    lib::layout::tests::wraps_short
+    roundtrip::renders_cover_only
+
+A targeted run composes to cargo's own selectors without translation —
+`cargo test --lib -- --exact layout::tests::wraps_short` or
+`cargo test --test roundtrip -- --exact renders_cover_only` — and nothing else
+is appended.
+
+Console output *is* the oracle here: `cargo test` writes no result file, but
+its per-test lines (`test <path> ... ok|FAILED|ignored`) are stable, and each
+target's block is preceded by a `Running unittests src/lib.rs (…)` /
+`Running tests/<name>.rs (…)` header that names the target. cargo prints the
+headers on stderr and the test lines on stdout, so every invocation is run with
+`2>&1` to keep them interleaved in order; attribution is "the most recent
+header". Doc-tests (`Doc-tests <crate>`) have no stable ids and are excluded by
+running `cargo test --tests` by default.
+
+A *compile* failure maps to `not_collected`, not `failed`. Rust has no separate
+collection phase — a test naming a missing symbol fails `rustc`, not the run —
+so it is treated like Python's import error and Kotlin's compile error: write a
+compiling stub (a function whose body is `todo!()`), then observe the
+assertion failure. The discriminator is `error: could not compile` (or an
+`error[E…]` diagnostic) with no test line produced.
+
+Only files under `test_paths` are tests for staging purposes. Declare
+`tests/`, not `src/`: a `#[cfg(test)]` module lives inside a production file,
+and classifying `src/` as tests would stage implementation in RED commits.
+Cycle targets therefore live in `tests/*.rs`; `lib::` ids are still collected
+and scored so the baseline sees them.
+
+Config (`tdd.toml`):
+
+    [project.kernel]
+    root         = "transcript-kernel"
+    adapter      = "cargo"
+    test_paths   = ["tests/"]
+    test_command = "cargo test --tests"      # default when omitted
+"""
+
+from __future__ import annotations
+
+import re
+import shlex
+import time
+from pathlib import Path
+
+from .base import (
+    FAILED,
+    NOT_COLLECTED,
+    PASSED,
+    Adapter,
+    GateResult,
+    Verdict,
+    clip_failure,
+)
+
+# `     Running unittests src/lib.rs (target/debug/deps/x-abc)` → target "lib"
+# `     Running tests/roundtrip.rs (target/debug/deps/roundtrip-abc)` → "roundtrip"
+_RUNNING_RE = re.compile(r"^\s*Running (?:unittests (\S+)|(\S+)) \(", re.MULTILINE)
+_DOCTEST_RE = re.compile(r"^\s*Doc-tests ", re.MULTILINE)
+# `test layout::tests::wraps_short ... ok` / `... FAILED` / `... ignored`
+_TEST_LINE_RE = re.compile(r"^test (\S+) \.\.\. (ok|FAILED|ignored)\s*$", re.MULTILINE)
+# `layout::tests::wraps_short: test` (from `-- --list`)
+_LIST_LINE_RE = re.compile(r"^(\S+): test\s*$", re.MULTILINE)
+# `---- layout::tests::wraps_short stdout ----` opens a failure block
+_FAILURE_BLOCK_RE = re.compile(r"^---- (\S+) stdout ----\s*$", re.MULTILINE)
+_COMPILE_ERROR_RE = re.compile(r"^error(?:\[E\d+\])?: ", re.MULTILINE)
+_COULD_NOT_COMPILE_RE = re.compile(r"could not compile")
+_NO_LIB_RE = re.compile(r"no library targets found")
+
+
+def _target_of_header(match: re.Match) -> str | None:
+    unit, path = match.group(1), match.group(2)
+    if unit is not None:
+        return "lib"
+    if path.startswith("tests/") and path.endswith(".rs"):
+        return Path(path).stem
+    return None  # examples/benches: not test targets
+
+
+class CargoAdapter(Adapter):
+    name = "cargo"
+
+    def stub_hint(self) -> str:
+        return (
+            "a compiling stub — a function whose body is `todo!()` — so the test"
+            " fails on its assertion/panic rather than on `rustc`; a missing"
+            " symbol is a *compile* failure (not_collected), not RED"
+        )
+
+    def lint_target_id(self, native: str) -> str | None:
+        if "::" not in native:
+            return (
+                f"cargo target ids must be '<target>::<path>' (got {native!r}); expected"
+                " shape: lib::module::tests::name or <tests-file-stem>::name"
+            )
+        return None
+
+    def target_path(self, native: str) -> str | None:
+        target, _, _ = native.partition("::")
+        if target == "lib":
+            return None
+        return f"tests/{target}.rs"
+
+    # ------------------------------------------------------------------
+    # Commands
+    # ------------------------------------------------------------------
+
+    def _test_cmd(self) -> str:
+        return self.project.test_command or "cargo test --tests"
+
+    @staticmethod
+    def _selector(native_id: str) -> str:
+        target, _, path = native_id.partition("::")
+        scope = "--lib" if target == "lib" else f"--test {shlex.quote(target)}"
+        return f"{scope} -- --exact {shlex.quote(path)}"
+
+    def _targeted_cmd(self, native_id: str) -> str:
+        """`cargo test <flags…>` from the declared command, with the suite-wide
+        target selector (`--tests`) dropped so the per-target scope can be set."""
+        return f"{self._targeted_prefix()} {self._selector(native_id)}"
+
+    # ------------------------------------------------------------------
+    # Discovery — integration test files
+    # ------------------------------------------------------------------
+
+    def _test_files(self) -> list[Path]:
+        found: set[Path] = set()
+        for pattern in self.project.test_patterns or []:
+            if pattern.endswith("/"):
+                base = self.root / pattern
+                if base.is_dir():
+                    found.update(p for p in base.glob("*.rs") if p.is_file())
+            else:
+                found.update(p for p in self.root.glob(pattern) if p.is_file())
+        return sorted(found)
+
+    # ------------------------------------------------------------------
+    # Collection — `cargo test … -- --list`, attributed by target header
+    # ------------------------------------------------------------------
+
+    def _collect_invocations(self):
+        return [(f"{self._test_cmd()} -- --list", self._suite_env(None))]
+
+    def _collect_batch(self, command, env):
+        code, out, _err = self._run_suite(f"{command} 2>&1", env)
+        if code != 0 or _COULD_NOT_COMPILE_RE.search(out):
+            return None
+        tests = self._parse_list(out)
+        files = {f"tests/{t.split('::', 1)[0]}.rs" for t in tests if not t.startswith("lib::")}
+        return {self.qualify(t) for t in tests}, files
+
+    def _collect_per_file(self, rels, result):
+        for rel in sorted(rels):
+            stem = Path(rel).stem
+            cmd = f"{self._targeted_prefix()} --test {shlex.quote(stem)} -- --list 2>&1"
+            code, out, _err = self._run_suite(cmd, self._suite_env(None))
+            if code != 0 or _COULD_NOT_COMPILE_RE.search(out):
+                result.failed_files[rel] = clip_failure(self._errors(out))
+                continue
+            result.tests |= {self.qualify(t) for t in self._parse_list(out, default=stem)}
+        return result
+
+    def _targeted_prefix(self) -> str:
+        parts = shlex.split(self._test_cmd())
+        parts = [p for p in parts if p != "--tests"]
+        if "--" in parts:
+            parts = parts[: parts.index("--")]
+        return shlex.join(parts)
+
+    @staticmethod
+    def _parse_list(output: str, default: str | None = None) -> set[str]:
+        """Walk `--list` output, prefixing each `path: test` line with the target
+        named by the most recent `Running …` header (or `default` when the
+        invocation was already scoped to one target)."""
+        tests: set[str] = set()
+        target = default
+        for line in output.splitlines():
+            header = _RUNNING_RE.match(line)
+            if header:
+                target = _target_of_header(header)
+                continue
+            if _DOCTEST_RE.match(line):
+                target = None
+                continue
+            entry = _LIST_LINE_RE.match(line)
+            if entry and target is not None:
+                tests.add(f"{target}::{entry.group(1)}")
+        return tests
+
+    def collectable(self) -> GateResult:
+        code, out, err = self._run_suite(
+            f"{self._targeted_prefix()} --no-run 2>&1", self._suite_env(None)
+        )
+        if code == 0:
+            return GateResult(ok=True)
+        return GateResult(ok=False, output=clip_failure(self._errors(out + err)))
+
+    # ------------------------------------------------------------------
+    # Results
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _parse_run(output: str, default: str | None = None):
+        """`(passed, failed, failures)` from a merged `cargo test` console."""
+        passed: set[str] = set()
+        failed: set[str] = set()
+        failures: dict[str, str] = {}
+        target = default
+        # Position of each header, alongside the target it switches to — used to
+        # attribute a failure block by the header most recently seen before it,
+        # since two targets can share a test path (e.g. both name a test
+        # `tests::it_works`) and a path-only lookup would collide between them.
+        header_spans: list[tuple[int, str | None]] = []
+        pos = 0
+        for line in output.splitlines(keepends=True):
+            header = _RUNNING_RE.match(line)
+            if header:
+                target = _target_of_header(header)
+                header_spans.append((pos, target))
+            elif _DOCTEST_RE.match(line):
+                target = None
+                header_spans.append((pos, target))
+            else:
+                entry = _TEST_LINE_RE.match(line)
+                if entry and target is not None:
+                    path, outcome = entry.groups()
+                    tid = f"{target}::{path}"
+                    if outcome == "ok":
+                        passed.add(tid)
+                    elif outcome == "FAILED":
+                        failed.add(tid)
+            pos += len(line)
+
+        def _target_at(offset: int) -> str | None:
+            current = default
+            for start, tgt in header_spans:
+                if start > offset:
+                    break
+                current = tgt
+            return current
+
+        # Failure blocks: from `---- <path> stdout ----` up to the next block or
+        # the trailing `failures:` summary list.
+        blocks = list(_FAILURE_BLOCK_RE.finditer(output))
+        for i, m in enumerate(blocks):
+            end = blocks[i + 1].start() if i + 1 < len(blocks) else len(output)
+            body = output[m.end() : end]
+            body = body.split("\nfailures:\n", 1)[0].strip()
+            path = m.group(1)
+            tid = f"{_target_at(m.start()) or 'lib'}::{path}"
+            failures[tid] = clip_failure(body) if body else "test failed"
+        return passed, failed, failures
+
+    @staticmethod
+    def _errors(combined: str) -> str:
+        lines = [
+            ln
+            for ln in combined.splitlines()
+            if _COMPILE_ERROR_RE.match(ln) or "-->" in ln or "could not compile" in ln
+        ]
+        return "\n".join(lines) if lines else combined
+
+    def run(self, target: str | None = None) -> Verdict:
+        verdict = Verdict(project=self.project.name, adapter=self.name, target=target)
+        env = self._suite_env(None)
+
+        native = self.strip(target) if target is not None else None
+        if native is not None:
+            cmd = self._targeted_cmd(native)
+            default = native.partition("::")[0]
+        else:
+            cmd = self._test_cmd()
+            default = None
+
+        started = time.monotonic()
+        code, out, err = self._run_suite(f"{cmd} 2>&1", env)
+        verdict.duration_ms = int((time.monotonic() - started) * 1000)
+        combined = out + err
+
+        passed, failed, failures = self._parse_run(combined, default=default)
+        verdict.passed = sorted(self.qualify(t) for t in passed)
+        verdict.failed = sorted(self.qualify(t) for t in failed)
+
+        if not passed and not failed:
+            if _COULD_NOT_COMPILE_RE.search(combined) or (
+                code != 0 and _COMPILE_ERROR_RE.search(combined)
+            ):
+                errors = clip_failure(self._errors(combined))
+                if target is not None:
+                    verdict.target_outcome = NOT_COLLECTED
+                    verdict.target_failure = errors
+                else:
+                    verdict.error = errors
+            elif target is not None and _NO_LIB_RE.search(combined):
+                verdict.target_outcome = NOT_COLLECTED
+                verdict.target_failure = clip_failure(combined)
+            # else: filter matched nothing → NOT_FOUND; empty full run is clean
+            return verdict
+
+        if target is None or native is None:
+            return verdict
+
+        if target in verdict.passed:
+            verdict.target_outcome = PASSED
+        elif target in verdict.failed:
+            verdict.target_outcome = FAILED
+            text = failures.get(native, "test failed")
+            verdict.target_failure = text
+            verdict.target_evidence = next(
+                (ln for ln in text.splitlines() if "panicked" in ln or "assertion" in ln),
+                next((ln for ln in text.splitlines() if ln.strip()), ""),
+            )
+        return verdict

{tdd_cli-0.9.0 → tdd_cli-0.10.0}/tests/conftest.py

@@ -64,7 +64,6 @@ def repo(tmp_path, ledger_home):
         ".pytest_cache/\n__pycache__/\n*.pyc\n.coverage\njsonreport*.json\n"
     )
 
-    git(root.parent, "init", "-q", str(root)) if False else None
     subprocess.run(["git", "init", "-q", str(root)], check=True)
     git(root, "config", "user.email", "test@example.com")
     git(root, "config", "user.name", "Test")

tdd_cli-0.10.0/tests/test_cargo_adapter.py

@@ -0,0 +1,395 @@
+"""cargo adapter — pinned against real `cargo test` console output.
+
+All tests run without a Rust toolchain: they exercise console parsing, id
+namespacing and command construction against output captured from cargo
+1.98 (2026-09-05), exactly as test_gradle_adapter.py does for Gradle.
+`_run_suite` is mocked.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import patch
+
+from tddcli import config as config_mod
+from tddcli.adapters import available
+from tddcli.adapters.base import FAILED, NOT_COLLECTED, NOT_FOUND, PASSED
+from tddcli.adapters.cargo_adapter import CargoAdapter
+
+TOML = """
+[project.kernel]
+root       = "kernel"
+adapter    = "cargo"
+test_paths = ["tests/"]
+"""
+
+TOML_WITH_ENV = """
+[project.kernel]
+root       = "kernel"
+adapter    = "cargo"
+test_paths = ["tests/"]
+env        = { CARGO_HOME = "/opt/cargo" }
+"""
+
+TOML_CUSTOM_CMD = """
+[project.kernel]
+root         = "kernel"
+adapter      = "cargo"
+test_paths   = ["tests/"]
+test_command = "cargo test --tests --features fuzzing"
+"""
+
+# `cargo test --tests 2>&1` — one lib unit test fails, one integration test passes.
+FULL_RUN = """\
+   Compiling probe_kernel v0.1.0 (/work/kernel)
+    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.49s
+     Running unittests src/lib.rs (/work/target/debug/deps/probe_kernel-f0a2d29d7c4f02a1)
+
+running 3 tests
+test layout::tests::fails_on_purpose ... FAILED
+test tests::version_is_one ... ok
+test layout::tests::wraps_short ... ok
+
+failures:
+
+---- layout::tests::fails_on_purpose stdout ----
+
+thread 'layout::tests::fails_on_purpose' (173172849) panicked at src/lib.rs:7:41:
+assertion `left == right` failed: expected width mismatch
+  left: 2
+ right: 3
+note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
+
+
+failures:
+    layout::tests::fails_on_purpose
+
+test result: FAILED. 2 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+error: test failed, to rerun pass `--lib`
+     Running tests/roundtrip.rs (/work/target/debug/deps/roundtrip-1d2c3b4a5f6e7d8c)
+
+running 1 test
+test renders_cover_only ... ok
+
+test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+"""
+
+# Two targets each fail a test at the same bare path (`tests::it_works`) — the
+# panic text must attribute to the target whose header preceded each block,
+# not collide on the shared path.
+COLLIDING_PATHS_RUN = """\
+     Running unittests src/lib.rs (/work/target/debug/deps/probe_kernel-aaaa)
+
+running 1 test
+test tests::it_works ... FAILED
+
+failures:
+
+---- tests::it_works stdout ----
+
+thread 'tests::it_works' panicked at src/lib.rs:3:5:
+lib assertion failed
+
+
+failures:
+    tests::it_works
+
+test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+error: test failed, to rerun pass `--lib`
+     Running tests/roundtrip.rs (/work/target/debug/deps/roundtrip-bbbb)
+
+running 1 test
+test tests::it_works ... FAILED
+
+failures:
+
+---- tests::it_works stdout ----
+
+thread 'tests::it_works' panicked at tests/roundtrip.rs:5:5:
+roundtrip assertion failed
+
+
+failures:
+    tests::it_works
+
+test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+"""
+
+# `cargo test --tests -- --list 2>&1`
+LIST_OUTPUT = """\
+    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.02s
+     Running unittests src/lib.rs (/work/target/debug/deps/probe_kernel-f0a2d29d7c4f02a1)
+layout::tests::fails_on_purpose: test
+layout::tests::wraps_short: test
+tests::version_is_one: test
+
+3 tests, 0 benchmarks
+     Running tests/roundtrip.rs (/work/target/debug/deps/roundtrip-1d2c3b4a5f6e7d8c)
+renders_cover_only: test
+
+1 test, 0 benchmarks
+   Doc-tests probe_kernel
+some_doc_example: test
+
+1 test, 0 benchmarks
+"""
+
+# `cargo test --test roundtrip -- --exact renders_cover_only 2>&1`
+TARGETED_PASS = """\
+    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.02s
+     Running tests/roundtrip.rs (/work/target/debug/deps/roundtrip-1d2c3b4a5f6e7d8c)
+
+running 1 test
+test renders_cover_only ... ok
+
+test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+"""
+
+# `cargo test --lib -- --exact layout::tests::nope 2>&1` — filter matched nothing.
+TARGETED_NOT_FOUND = """\
+    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.02s
+     Running unittests src/lib.rs (/work/target/debug/deps/probe_kernel-f0a2d29d7c4f02a1)
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 3 filtered out; finished in 0.00s
+
+"""
+
+# A type error in the crate: nothing ran.
+COMPILE_ERROR = """\
+   Compiling probe_kernel v0.1.0 (/work/kernel)
+error[E0308]: mismatched types
+  --> src/lib.rs:12:28
+   |
+12 | fn broken() { let x: u32 = "s"; }
+   |                      ---   ^^^ expected `u32`, found `&str`
+   |                      |
+   |                      expected due to this
+
+For more information about this error, try `rustc --explain E0308`.
+error: could not compile `probe_kernel` (lib test) due to 1 previous error
+"""
+
+NO_LIB = "error: no library targets found in package `probe_bin`\n"
+
+LIB_FAIL = "kernel::lib::layout::tests::fails_on_purpose"
+LIB_PASS = "kernel::lib::layout::tests::wraps_short"
+INT_PASS = "kernel::roundtrip::renders_cover_only"
+
+
+def make_adapter(tmp_path: Path, toml: str = TOML) -> CargoAdapter:
+    (tmp_path / "tdd.toml").write_text(toml)
+    (tmp_path / "kernel" / "tests").mkdir(parents=True)
+    (tmp_path / "kernel" / "tests" / "roundtrip.rs").write_text("#[test] fn renders_cover_only() {}\n")
+    cfg = config_mod.load(tmp_path)
+    return CargoAdapter(cfg.project("kernel"), tmp_path)
+
+
+# ---------------------------------------------------------------------------
+# Registration and ids
+# ---------------------------------------------------------------------------
+
+
+def test_cargo_is_a_builtin_adapter():
+    assert "cargo" in available()
+
+
+def test_target_id_lint_requires_target_separator(tmp_path):
+    a = make_adapter(tmp_path)
+    assert a.lint_target_id("renders_cover_only") is not None
+    assert a.lint_target_id("roundtrip::renders_cover_only") is None
+    assert a.lint_target_id("lib::layout::tests::wraps_short") is None
+
+
+def test_target_path_maps_integration_target_to_its_file(tmp_path):
+    a = make_adapter(tmp_path)
+    assert a.target_path("roundtrip::renders_cover_only") == "tests/roundtrip.rs"
+    assert a.target_path("lib::layout::tests::wraps_short") is None
+
+
+# ---------------------------------------------------------------------------
+# Command construction
+# ---------------------------------------------------------------------------
+
+
+def test_targeted_command_scopes_to_the_target_and_uses_exact(tmp_path):
+    a = make_adapter(tmp_path)
+    assert a._targeted_cmd("roundtrip::renders_cover_only") == (
+        "cargo test --test roundtrip -- --exact renders_cover_only"
+    )
+    assert a._targeted_cmd("lib::layout::tests::wraps_short") == (
+        "cargo test --lib -- --exact layout::tests::wraps_short"
+    )
+
+
+def test_targeted_command_keeps_declared_flags_but_drops_tests_selector(tmp_path):
+    a = make_adapter(tmp_path, TOML_CUSTOM_CMD)
+    assert a._targeted_cmd("roundtrip::renders_cover_only") == (
+        "cargo test --features fuzzing --test roundtrip -- --exact renders_cover_only"
+    )
+
+
+def test_run_merges_stderr_into_stdout(tmp_path):
+    a = make_adapter(tmp_path)
+    with patch.object(CargoAdapter, "_run_suite", return_value=(0, TARGETED_PASS, "")) as rs:
+        a.run(INT_PASS)
+    cmd = rs.call_args.args[0]
+    assert cmd.endswith("2>&1"), cmd
+
+
+# ---------------------------------------------------------------------------
+# Suite run parsing
+# ---------------------------------------------------------------------------
+
+
+def test_full_run_attributes_tests_to_targets_by_header(tmp_path):
+    a = make_adapter(tmp_path)
+    with patch.object(CargoAdapter, "_run_suite", return_value=(101, FULL_RUN, "")):
+        v = a.run()
+    assert v.error is None
+    assert set(v.passed) == {LIB_PASS, "kernel::lib::tests::version_is_one", INT_PASS}
+    assert v.failed == [LIB_FAIL]
+
+
+def test_full_run_does_not_collide_failures_sharing_a_bare_path(tmp_path):
+    a = make_adapter(tmp_path)
+    with patch.object(CargoAdapter, "_run_suite", return_value=(101, COLLIDING_PATHS_RUN, "")):
+        v = a.run()
+    assert set(v.failed) == {"kernel::lib::tests::it_works", "kernel::roundtrip::tests::it_works"}
+
+
+def test_targeted_run_attributes_the_right_target_when_paths_collide(tmp_path):
+    a = make_adapter(tmp_path)
+    with patch.object(CargoAdapter, "_run_suite", return_value=(101, COLLIDING_PATHS_RUN, "")):
+        lib_v = a.run("kernel::lib::tests::it_works")
+    with patch.object(CargoAdapter, "_run_suite", return_value=(101, COLLIDING_PATHS_RUN, "")):
+        int_v = a.run("kernel::roundtrip::tests::it_works")
+    assert lib_v.target_outcome == FAILED
+    assert "lib assertion failed" in lib_v.target_failure
+    assert int_v.target_outcome == FAILED
+    assert "roundtrip assertion failed" in int_v.target_failure
+
+
+def test_targeted_pass(tmp_path):
+    a = make_adapter(tmp_path)
+    with patch.object(CargoAdapter, "_run_suite", return_value=(0, TARGETED_PASS, "")):
+        v = a.run(INT_PASS)
+    assert v.target_outcome == PASSED
+
+
+def test_targeted_failure_carries_panic_message_as_evidence(tmp_path):
+    a = make_adapter(tmp_path)
+    # A targeted lib run prints the same shape as the full run's lib block.
+    with patch.object(CargoAdapter, "_run_suite", return_value=(101, FULL_RUN, "")):
+        v = a.run(LIB_FAIL)
+    assert v.target_outcome == FAILED
+    assert "expected width mismatch" in v.target_failure
+    assert "panicked at src/lib.rs:7:41" in v.target_evidence
+    # The trailing `failures:` summary list is not part of the failure text.
+    assert "    layout::tests::fails_on_purpose" not in v.target_failure
+
+
+def test_targeted_filter_matching_nothing_is_not_found(tmp_path):
+    a = make_adapter(tmp_path)
+    with patch.object(CargoAdapter, "_run_suite", return_value=(0, TARGETED_NOT_FOUND, "")):
+        v = a.run("kernel::lib::layout::tests::nope")
+    assert v.target_outcome == NOT_FOUND
+    assert v.target_failure == ""
+
+
+def test_compile_error_is_not_collected_for_a_target(tmp_path):
+    a = make_adapter(tmp_path)
+    with patch.object(CargoAdapter, "_run_suite", return_value=(101, COMPILE_ERROR, "")):
+        v = a.run(LIB_PASS)
+    assert v.target_outcome == NOT_COLLECTED
+    assert "error[E0308]: mismatched types" in v.target_failure
+    assert "src/lib.rs:12:28" in v.target_failure
+
+
+def test_compile_error_is_a_suite_error_for_a_full_run(tmp_path):
+    a = make_adapter(tmp_path)
+    with patch.object(CargoAdapter, "_run_suite", return_value=(101, COMPILE_ERROR, "")):
+        v = a.run()
+    assert v.error is not None and "could not compile" in v.error
+    assert v.passed == [] and v.failed == []
+
+
+def test_missing_lib_target_is_not_collected(tmp_path):
+    a = make_adapter(tmp_path)
+    with patch.object(CargoAdapter, "_run_suite", return_value=(101, NO_LIB, "")):
+        v = a.run(LIB_PASS)
+    assert v.target_outcome == NOT_COLLECTED
+
+
+# ---------------------------------------------------------------------------
+# Collection
+# ---------------------------------------------------------------------------
+
+
+def test_batch_collection_prefixes_ids_and_skips_doctests(tmp_path):
+    a = make_adapter(tmp_path)
+    with patch.object(CargoAdapter, "_run_suite", return_value=(0, LIST_OUTPUT, "")):
+        c = a.collect()
+    assert c.tests == {
+        LIB_FAIL,
+        LIB_PASS,
+        "kernel::lib::tests::version_is_one",
+        INT_PASS,
+    }
+    assert c.failed_files == {}
+
+
+def test_batch_collection_command_lists_with_merged_streams(tmp_path):
+    a = make_adapter(tmp_path)
+    with patch.object(CargoAdapter, "_run_suite", return_value=(0, LIST_OUTPUT, "")) as rs:
+        a.collect()
+    assert rs.call_args_list[0].args[0] == "cargo test --tests -- --list 2>&1"
+
+
+def test_per_file_collection_records_compile_failure_against_its_file(tmp_path):
+    a = make_adapter(tmp_path)
+    (tmp_path / "kernel" / "tests" / "broken.rs").write_text("fn nope( {}\n")
+
+    def side_effect(cmd, env=None, timeout=None):
+        if cmd.startswith("cargo test --tests -- --list"):
+            return (101, COMPILE_ERROR, "")  # batch fails → per-file loop
+        if "--test broken" in cmd:
+            return (101, COMPILE_ERROR, "")
+        if "--test roundtrip" in cmd:
+            return (0, "renders_cover_only: test\n\n1 test, 0 benchmarks\n", "")
+        raise AssertionError(cmd)
+
+    with patch.object(CargoAdapter, "_run_suite", side_effect=side_effect):
+        c = a.collect()
+    assert INT_PASS in c.tests
+    assert "tests/broken.rs" in c.failed_files
+    assert "could not compile" in c.failed_files["tests/broken.rs"]
+
+
+def test_collectable_is_a_no_run_build(tmp_path):
+    a = make_adapter(tmp_path)
+    with patch.object(CargoAdapter, "_run_suite", return_value=(0, "", "")) as rs:
+        assert a.collectable().ok
+    assert rs.call_args.args[0] == "cargo test --no-run 2>&1"
+    with patch.object(CargoAdapter, "_run_suite", return_value=(101, COMPILE_ERROR, "")):
+        g = a.collectable()
+    assert not g.ok and "E0308" in g.output
+
+
+def test_every_invocation_carries_the_project_env(tmp_path):
+    """`env` is how a repo points at a toolchain outside PATH (e.g. an external-disk
+    rustup); the doctor gate, collection and runs must all see it."""
+    a = make_adapter(tmp_path, TOML_WITH_ENV)
+    with patch.object(CargoAdapter, "_run_suite", return_value=(0, LIST_OUTPUT, "")) as rs:
+        a.collectable()
+        a.collect()
+        a.run(INT_PASS)
+    for call in rs.call_args_list:
+        env = call.args[1] if len(call.args) > 1 else call.kwargs.get("extra_env")
+        assert env == {"CARGO_HOME": "/opt/cargo"}, call