tdd-cli 0.11.0__tar.gz → 0.12.1__tar.gz

{tdd_cli-0.11.0 → tdd_cli-0.12.1}/CHANGELOG.md

@@ -6,6 +6,43 @@ and the project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.12.1] - 2026-09-17
+
+### Fixed
+
+- **cargo: a test target whose name differs from its file's stem** (#134): the adapter derived the
+  target from the `Running tests/<file>.rs` header's path, which is only the target's name under
+  cargo's default of one binary per `tests/*.rs`. A crate that sets `autotests = false` and declares
+  its own `[[test]]` — many files compiled into one binary named something else — was unreachable:
+  collection ran `--test <stem>` and cargo answered ``no test target named `<stem>` in default-run
+  packages``, so every cycle target came back `not_collected`, whatever id the plan declared. The
+  target is now read from the artifact the header names (`…/deps/bridge_tests-<hash>`), which is
+  also the only thing distinguishing two crates in a workspace whose test files are both
+  `tests/main.rs`. The crate manifests supply the mapping back: target → the file it is built from
+  for `target_path` and the collection file set, and the declared spelling for `--test`, since cargo
+  writes a target's `-` as `_` in the artifact. Manifests are located by walking up from the declared
+  `test_paths`, not from `_test_files()`, which does not expand a wildcard directory pattern such as
+  `crates/*/tests/`. Under the default layout target and stem still agree and nothing changes.
+
+## [0.12.0] - 2026-09-17
+
+### Changed
+
+- **Close sweep runs all gates before any suite** (#129): lint and typecheck now run for every
+  project in the sweep set before any project's suite executes. A failing gate short-circuits the
+  sweep immediately — no suite runs, and `next_action` returns `fix_regression` with the failing
+  gate entry. Previously each project ran its suite first and only then checked its gates.
+- **`Adapter._gate` stops at the first failing command** (#129): the first non-zero exit ends the
+  gate; subsequent commands in the same gate list are not executed.
+- **Gate memoisation** (#129): a gate whose project tree hash is unchanged since it last passed
+  within the same run is skipped (no command executed) and recorded with `skipped = 1` in
+  `gate_result`. A failed gate or a changed tree always re-runs.
+- **`fix_regression` detail wording** (#129): the reply for a gate failure now reads
+  `"Close sweep stopped before the suite: lint/typecheck gates failed."` (was `"Close sweep is
+  green but lint/typecheck gates failed."`).
+- **Schema v11** (#129): `gate_result` gains `tree_hash TEXT` and
+  `skipped INTEGER NOT NULL DEFAULT 0`. Existing ledgers are migrated on open via `MIGRATIONS[10]`.
+
 ## [0.11.0] - 2026-09-16
 
 ### Added

{tdd_cli-0.11.0 → tdd_cli-0.12.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tdd-cli
-Version: 0.11.0
+Version: 0.12.1
 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

{tdd_cli-0.11.0 → tdd_cli-0.12.1}/docs/PRD.md

@@ -195,6 +195,18 @@ Typed: `regression`, `target_unfixable`, `bad_red`, `plan_defect`, `tooling`, `c
 Without it the only available label is `regression`, which records a defect the run introduced —
 so the agent must either misreport its own work or leave the failure unfiled.
 
+### GateResult
+One execution (or memo-skip) of one project's lint or typecheck gate during a close sweep.
+
+| Field | Notes |
+|---|---|
+| `id`, `run_id`, `cycle_id`, `project`, `kind` | `kind` is `lint` or `typecheck` |
+| `ok` | `1` = passed (or skipped), `0` = failed |
+| `output` | truncated stdout/stderr of the failing command; empty when `ok = 1` |
+| `tree_hash` | hash of the project tree at the time the gate ran or was skipped (schema v11) |
+| `skipped` | `1` if the gate was memo-skipped (tree unchanged, gate previously passed within this run); `0` otherwise (schema v11) |
+| `at` | |
+
 ---
 
 ## 6. State machine
@@ -561,7 +573,9 @@ For the passed-on-arrival case, which occurred in 4 of 8 executed cycles in the
 - **R9.2** On the transition out of `AWAITING_REFACTOR`, the close sweep runs: the cycle's own
   projects, plus every project **downstream of an artifact the cycle modified** per the
   `consumed_by` edges in §7.1, plus lint and typecheck for each. Projects with
-  `in_close_sweep = false` are always excluded.
+  `in_close_sweep = false` are always excluded. The close sweep runs lint and typecheck for
+  **every project in scope before any suite**; if any gate fails, the sweep returns immediately
+  without running any suite.
 - **R9.3** A **full sweep** — every registered project, lint and typecheck, including
   `in_close_sweep = false` suites — runs once at plan completion.
 - **R9.4** Rationale: a per-cycle sweep of all four projects with `mypy` and `tsc` costs minutes,
@@ -664,7 +678,12 @@ For the passed-on-arrival case, which occurred in 4 of 8 executed cycles in the
 
 ### 9.4 Lint, typecheck and artifacts
 - **R9.11** Lint and typecheck results are part of the close-sweep verdict, surfaced alongside
-  test failures rather than discovered later at commit time.
+  test failures rather than discovered later at commit time. The gate pass stops at the **first
+  failing gate**; `Adapter._gate` stops at the **first failing command** within a gate. A gate
+  whose project tree hash is unchanged since that gate last passed within the same run is
+  **skipped** (no command is executed) and recorded with `skipped = 1` in `gate_result`. Limit:
+  gate configuration that lives outside the project's declared roots (e.g. a top-level
+  `pyproject.toml`) does not affect the tree hash and therefore does not invalidate the memo.
 - **R9.12** Before a run starts and at every cycle close, declared artifacts are checked for
   staleness against their producer. When the tool cannot resolve staleness itself (no `regenerate`
   command, or the regenerate hook produced no commit), it emits `stale_artifact` and blocks the

{tdd_cli-0.11.0 → tdd_cli-0.12.1}/src/tddcli/__init__.py

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

{tdd_cli-0.11.0 → tdd_cli-0.12.1}/src/tddcli/adapters/base.py

@@ -302,9 +302,8 @@ class Adapter:
         return self._gate(self.project.typecheck)
 
     def _gate(self, commands: list[str]) -> GateResult:
-        chunks = []
         for cmd in commands:
             code, out, err = run_command(cmd, self.root, label="gate")
             if code != 0:
-                chunks.append(f"$ {cmd}\n{out}\n{err}".strip())
-        return GateResult(ok=not chunks, output="\n\n".join(chunks)[:4000])
+                return GateResult(ok=False, output=f"$ {cmd}\n{out}\n{err}".strip()[:4000])
+        return GateResult(ok=True)

{tdd_cli-0.11.0 → tdd_cli-0.12.1}/src/tddcli/adapters/cargo_adapter.py

@@ -8,6 +8,16 @@ binary name for a file under `tests/` (`tests/roundtrip.rs` → `roundtrip`); th
     lib::layout::tests::wraps_short
     roundtrip::renders_cover_only
 
+The target is the *binary* name, which is only the file stem under cargo's
+default of one binary per `tests/*.rs`. A crate that sets `autotests = false`
+and declares its own `[[test]]` compiles many files into one binary named
+something else entirely — `tests/main.rs` with a `mod` per file, built as
+`bridge_tests` — and then ids read `bridge_tests::adapter_config::parses`, the
+file is `tests/main.rs`, and `--test bridge_tests` is what runs it. The manifest
+is the only thing relating the two, so it is read; the `Running` header's
+artifact (`…/deps/bridge_tests-<hash>`) is what names the target per block,
+since the header's path is `tests/main.rs` in every crate of a workspace.
+
 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
@@ -49,6 +59,7 @@ from __future__ import annotations
 import re
 import shlex
 import time
+import tomllib
 from pathlib import Path
 
 from .base import (
@@ -63,7 +74,14 @@ from .base import (
 
 # `     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)
+# The artifact in parentheses is captured too: it is the only part of the header
+# that names the *target*, which a crate may name differently from its file
+# (`tests/main.rs` compiled as `bridge_tests`), and the only part that tells two
+# crates' identically-pathed test files apart in a workspace.
+_RUNNING_RE = re.compile(r"^\s*Running (?:unittests (\S+)|(\S+)) \(([^)]*)\)", re.MULTILINE)
+# `bridge_tests-541f4f38a741dff0` → `bridge_tests` (cargo abbreviates the hash
+# in some outputs, so its length is not pinned)
+_ARTIFACT_HASH_RE = re.compile(r"-[0-9a-f]+$")
 _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)
@@ -76,18 +94,36 @@ _COULD_NOT_COMPILE_RE = re.compile(r"could not compile")
 _NO_LIB_RE = re.compile(r"no library targets found")
 
 
+def _artifact_target(artifact: str) -> str | None:
+    """Target name from a `target/debug/deps/<name>-<hash>` artifact path.
+
+    cargo writes `-` in a target name as `_` here, so the result is the mangled
+    spelling; `CargoAdapter._demangle_target` maps it back to the declared one.
+    """
+    stem = Path(artifact).name
+    stripped = _ARTIFACT_HASH_RE.sub("", stem)
+    return stripped or None
+
+
 def _target_of_header(match: re.Match) -> str | None:
-    unit, path = match.group(1), match.group(2)
+    unit, path, artifact = match.group(1), match.group(2), match.group(3)
     if unit is not None:
         return "lib"
     if path.startswith("tests/") and path.endswith(".rs"):
-        return Path(path).stem
+        # The artifact names the target; the path only names the file it was
+        # built from, and those differ whenever a crate declares `[[test]]`
+        # with a `name` of its own.
+        return _artifact_target(artifact) or Path(path).stem
     return None  # examples/benches: not test targets
 
 
 class CargoAdapter(Adapter):
     name = "cargo"
 
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._targets_cache: dict[str, str] | None = None
+
     def stub_hint(self) -> str:
         return (
             "a compiling stub — a function whose body is `todo!()` — so the test"
@@ -99,7 +135,10 @@ class CargoAdapter(Adapter):
         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"
+                " shape: lib::module::tests::name or <test-binary>::name — the"
+                " binary is the tests file's stem unless the crate declares"
+                " [[test]] name, and `cargo test --tests -- --list` prints the"
+                " spelling to use"
             )
         return None
 
@@ -107,7 +146,90 @@ class CargoAdapter(Adapter):
         target, _, _ = native.partition("::")
         if target == "lib":
             return None
-        return f"tests/{target}.rs"
+        declared = self._declared_target(target)
+        path = self._manifest_targets().get(declared)
+        # No `[[test]]` entry: cargo's default, one binary per file, named for it.
+        return path or f"tests/{target}.rs"
+
+    # ------------------------------------------------------------------
+    # Target names vs. their files
+    #
+    # By default a target is named after its file (`tests/roundtrip.rs` →
+    # `roundtrip`), and the two are interchangeable. A crate that sets
+    # `autotests = false` and declares its own `[[test]]` breaks that: several
+    # files compile into one binary whose `name` is unrelated to any of them
+    # (`tests/main.rs` → `bridge_tests`). Only the manifest relates the two.
+    # ------------------------------------------------------------------
+
+    def _manifest_targets(self) -> dict[str, str]:
+        """`{declared [[test]] name: path relative to the project root}`.
+
+        Read from the manifest owning each file under `test_paths`, so a
+        workspace contributes one entry per crate that declares a test target.
+        """
+        if self._targets_cache is None:
+            targets: dict[str, str] = {}
+            for manifest in self._manifests():
+                try:
+                    raw = tomllib.loads(manifest.read_text())
+                except (OSError, tomllib.TOMLDecodeError):
+                    continue
+                for entry in raw.get("test", []) or []:
+                    name, rel = entry.get("name"), entry.get("path")
+                    if not name or not rel:
+                        continue
+                    try:
+                        full = (manifest.parent / rel).resolve().relative_to(self.root.resolve())
+                    except ValueError:
+                        continue
+                    targets[name] = str(full)
+            self._targets_cache = targets
+        return self._targets_cache
+
+    def _manifests(self) -> set[Path]:
+        """The nearest Cargo.toml above each declared test directory.
+
+        Walked from `test_paths` rather than `_test_files()`, which does not
+        expand a wildcard directory pattern (`crates/*/tests/`) — the very shape
+        a workspace of crates uses.
+        """
+        found: set[Path] = set()
+        root = self.root.resolve()
+        for pattern in self.project.test_patterns or []:
+            for match in self.root.glob(pattern.rstrip("/") or "."):
+                start = match.resolve()
+                # Bounded by construction: a glob of the root cannot escape it,
+                # so the ascent always reaches root and stops there.
+                for here in [start, *start.parents]:
+                    candidate = here / "Cargo.toml"
+                    if candidate.is_file():
+                        found.add(candidate)
+                        break
+                    if here == root:
+                        break
+        return found
+
+    def _declared_target(self, target: str) -> str:
+        """The `[[test]] name` behind a collected target name.
+
+        cargo writes a target's `-` as `_` in the artifact filename the id is
+        read from, so `my-tests` is collected as `my_tests`; `--test` wants the
+        declared spelling back.
+        """
+        names = self._manifest_targets()
+        if target in names:
+            return target
+        for declared in names:
+            if declared.replace("-", "_") == target:
+                return declared
+        return target
+
+    def _target_of_file(self, rel: str) -> str:
+        """The target a test file belongs to; its stem under cargo's default."""
+        for declared, path in self._manifest_targets().items():
+            if path == rel:
+                return declared
+        return Path(rel).stem
 
     # ------------------------------------------------------------------
     # Commands
@@ -116,10 +238,12 @@ class CargoAdapter(Adapter):
     def _test_cmd(self) -> str:
         return self.project.test_command or "cargo test --tests"
 
-    @staticmethod
-    def _selector(native_id: str) -> str:
+    def _selector(self, native_id: str) -> str:
         target, _, path = native_id.partition("::")
-        scope = "--lib" if target == "lib" else f"--test {shlex.quote(target)}"
+        if target == "lib":
+            scope = "--lib"
+        else:
+            scope = f"--test {shlex.quote(self._declared_target(target))}"
         return f"{scope} -- --exact {shlex.quote(path)}"
 
     def _targeted_cmd(self, native_id: str) -> str:
@@ -154,18 +278,19 @@ class CargoAdapter(Adapter):
         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::")}
+        files = {self.target_path(t) for t in tests if not t.startswith("lib::")} - {None}
         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"
+            declared = self._target_of_file(rel)
+            cmd = f"{self._targeted_prefix()} --test {shlex.quote(declared)} -- --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)}
+            default = declared.replace("-", "_")
+            result.tests |= {self.qualify(t) for t in self._parse_list(out, default=default)}
         return result
 
     def _targeted_prefix(self) -> str:

{tdd_cli-0.11.0 → tdd_cli-0.12.1}/src/tddcli/advance.py

@@ -520,7 +520,7 @@ def _handle_refactor(engine: Engine, cycle, retried: bool) -> Envelope:
             engine,
             cycle,
             Verb.FIX_REGRESSION,
-            "Close sweep is green but lint/typecheck gates failed.",
+            "Close sweep stopped before the suite: lint/typecheck gates failed.",
             gates=gates,
             commit=sha,
         )

{tdd_cli-0.11.0 → tdd_cli-0.12.1}/src/tddcli/ledger.py

@@ -13,7 +13,7 @@ import sqlite3
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
 
-SCHEMA_VERSION = 10
+SCHEMA_VERSION = 11
 
 
 class LedgerVersionError(RuntimeError):
@@ -45,6 +45,11 @@ MIGRATIONS: dict[int, str] = {
     8: "ALTER TABLE artifact_check ADD COLUMN regenerate_failed INTEGER NOT NULL DEFAULT 0;",
     # v9 -> v10 added start_sha column to run; ALTER TABLE covers old ledgers.
     9: "ALTER TABLE run ADD COLUMN start_sha TEXT;",
+    # v10 -> v11 added tree_hash and skipped columns to gate_result; ALTER TABLE covers old ledgers.
+    10: (
+        "ALTER TABLE gate_result ADD COLUMN tree_hash TEXT;"
+        " ALTER TABLE gate_result ADD COLUMN skipped INTEGER NOT NULL DEFAULT 0;"
+    ),
 }
 
 SCHEMA = """
@@ -158,6 +163,8 @@ CREATE TABLE IF NOT EXISTS gate_result (
     kind TEXT NOT NULL,                 -- lint | typecheck
     ok INTEGER NOT NULL,
     output TEXT,
+    tree_hash TEXT,
+    skipped INTEGER NOT NULL DEFAULT 0,
     at TEXT NOT NULL
 );
 

{tdd_cli-0.11.0 → tdd_cli-0.12.1}/src/tddcli/machine.py

@@ -270,9 +270,58 @@ class Engine:
         unbaselined: dict[str, list[str]] = {}
         unobserved: dict[str, str] = {}
 
+        adapters_by_name = {
+            name: adapters.build(self.config.project(name), self.worktree) for name in names
+        }
+
         for name in names:
-            project = self.config.project(name)
-            adapter = adapters.build(project, self.worktree)
+            adapter = adapters_by_name[name]
+            current_hash = self.tree_hash([name])
+            gate_failed = False
+            for kind, gate_fn in (("lint", adapter.lint), ("typecheck", adapter.typecheck)):
+                last = self.ledger.one(
+                    "SELECT ok, tree_hash FROM gate_result"
+                    " WHERE run_id = ? AND project = ? AND kind = ?"
+                    " ORDER BY id DESC LIMIT 1",
+                    (self.run["id"], name, kind),
+                )
+                if last and last["ok"] == 1 and last["tree_hash"] == current_hash:
+                    self.ledger.insert(
+                        "gate_result",
+                        run_id=self.run["id"],
+                        cycle_id=cycle_row["id"],
+                        project=name,
+                        kind=kind,
+                        ok=1,
+                        output="",
+                        tree_hash=current_hash,
+                        skipped=1,
+                        at=now(),
+                    )
+                    continue
+                gate = gate_fn()
+                self.ledger.insert(
+                    "gate_result",
+                    run_id=self.run["id"],
+                    cycle_id=cycle_row["id"],
+                    project=name,
+                    kind=kind,
+                    ok=int(gate.ok),
+                    output=gate.output,
+                    tree_hash=current_hash,
+                    at=now(),
+                )
+                if not gate.ok:
+                    gates.append((name, kind, gate.output))
+                    gate_failed = True
+                    break
+            if gate_failed:
+                return SweepOutcome(
+                    failures=failures, gates=gates, unbaselined=unbaselined, unobserved=unobserved
+                )
+
+        for name in names:
+            adapter = adapters_by_name[name]
             started = time.monotonic()
             verdict = adapter.run(None)
             heartbeat(
@@ -350,19 +399,6 @@ class Engine:
                 tree_hash=self.tree_hash([name]),
                 started_at=now(),
             )
-            for kind, gate in (("lint", adapter.lint()), ("typecheck", adapter.typecheck())):
-                self.ledger.insert(
-                    "gate_result",
-                    run_id=self.run["id"],
-                    cycle_id=cycle_row["id"],
-                    project=name,
-                    kind=kind,
-                    ok=int(gate.ok),
-                    output=gate.output,
-                    at=now(),
-                )
-                if not gate.ok:
-                    gates.append((name, kind, gate.output))
         return SweepOutcome(
             failures=failures, gates=gates, unbaselined=unbaselined, unobserved=unobserved
         )

{tdd_cli-0.11.0 → tdd_cli-0.12.1}/tests/test_cargo_adapter.py

@@ -13,7 +13,7 @@ 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.base import FAILED, NOT_COLLECTED, NOT_FOUND, PASSED, Collection
 from tddcli.adapters.cargo_adapter import CargoAdapter
 
 TOML = """
@@ -395,3 +395,190 @@ def test_every_invocation_carries_the_project_env(tmp_path):
     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
+
+
+# ---------------------------------------------------------------------------
+# A crate whose test binary is not named after its file
+#
+# `autotests = false` plus a `[[test]]` entry compiles every file under tests/
+# into one binary with a name of its own. The target is then unrelated to the
+# file it was built from, and in a workspace every crate's header reads
+# `Running tests/main.rs` — only the artifact tells them apart.
+# ---------------------------------------------------------------------------
+
+CONSOLIDATED_LIST = """
+     Running tests/main.rs (/work/target/debug/deps/bridge_tests-541f4f38a741dff0)
+
+adapter_config::poll_config_parses_targets_and_maps: test
+adapter_webhook_config::webhook_table_parses_listen_token_and_maps: test
+
+2 tests, 0 benchmarks
+"""
+
+WORKSPACE_LIST = """
+     Running tests/main.rs (/work/target/debug/deps/bridge_tests-541f4f38a741dff0)
+
+adapter_config::poll_config_parses_targets_and_maps: test
+
+     Running tests/main.rs (/work/target/debug/deps/core_tests-9f1e2d3c4b5a6879)
+
+attention_clear::clear_removes_the_alert: test
+
+2 tests, 0 benchmarks
+"""
+
+
+def make_consolidated_adapter(tmp_path: Path) -> CargoAdapter:
+    """A workspace of two crates, each compiling tests/main.rs under its own name."""
+    (tmp_path / "tdd.toml").write_text(
+        "\n".join(
+            [
+                "[project.ws]",
+                'root       = "."',
+                'adapter    = "cargo"',
+                'test_paths = ["crates/*/tests/"]',
+                "",
+            ]
+        )
+    )
+    for crate, target in (("dd-bridge", "bridge_tests"), ("dd-core", "core_tests")):
+        tests = tmp_path / "crates" / crate / "tests"
+        tests.mkdir(parents=True)
+        (tests / "main.rs").write_text("mod adapter_config;\n")
+        (tmp_path / "crates" / crate / "Cargo.toml").write_text(
+            "\n".join(
+                [
+                    "[package]",
+                    f'name = "{crate}"',
+                    "autotests = false",
+                    "",
+                    "[[test]]",
+                    f'name = "{target}"',
+                    'path = "tests/main.rs"',
+                    "",
+                ]
+            )
+        )
+    cfg = config_mod.load(tmp_path)
+    return CargoAdapter(cfg.project("ws"), tmp_path)
+
+
+def test_ids_use_the_binary_name_not_the_file_stem(tmp_path):
+    a = make_consolidated_adapter(tmp_path)
+    assert a._parse_list(CONSOLIDATED_LIST) == {
+        "bridge_tests::adapter_config::poll_config_parses_targets_and_maps",
+        "bridge_tests::adapter_webhook_config::webhook_table_parses_listen_token_and_maps",
+    }
+
+
+def test_identically_pathed_files_are_told_apart_by_their_artifact(tmp_path):
+    a = make_consolidated_adapter(tmp_path)
+    assert a._parse_list(WORKSPACE_LIST) == {
+        "bridge_tests::adapter_config::poll_config_parses_targets_and_maps",
+        "core_tests::attention_clear::clear_removes_the_alert",
+    }
+
+
+def test_targeted_command_scopes_to_the_declared_binary(tmp_path):
+    a = make_consolidated_adapter(tmp_path)
+    assert a._targeted_cmd("bridge_tests::adapter_config::parses") == (
+        "cargo test --test bridge_tests -- --exact adapter_config::parses"
+    )
+
+
+def test_target_path_maps_a_declared_binary_to_the_file_it_is_built_from(tmp_path):
+    a = make_consolidated_adapter(tmp_path)
+    assert a.target_path("bridge_tests::adapter_config::parses") == (
+        "crates/dd-bridge/tests/main.rs"
+    )
+    assert a.target_path("core_tests::attention_clear::clears") == ("crates/dd-core/tests/main.rs")
+
+
+def test_per_file_collection_scopes_to_the_files_binary(tmp_path):
+    a = make_consolidated_adapter(tmp_path)
+    seen: list[str] = []
+
+    def record(cmd, env):
+        seen.append(cmd)
+        return 0, CONSOLIDATED_LIST, ""
+
+    with patch.object(CargoAdapter, "_run_suite", side_effect=record):
+        a._collect_per_file({"crates/dd-bridge/tests/main.rs"}, Collection())
+    assert "--test bridge_tests" in seen[0]
+    assert "--test main" not in seen[0]
+
+
+def test_a_dashed_binary_name_is_run_under_its_declared_spelling(tmp_path):
+    """cargo writes `-` as `_` in the artifact, but `--test` wants the manifest's spelling."""
+    (tmp_path / "tdd.toml").write_text(
+        '[project.ws]\nroot = "."\nadapter = "cargo"\ntest_paths = ["tests/"]\n'
+    )
+    (tmp_path / "tests").mkdir()
+    (tmp_path / "tests" / "main.rs").write_text("mod a;\n")
+    (tmp_path / "Cargo.toml").write_text(
+        '[package]\nname = "w"\nautotests = false\n\n'
+        '[[test]]\nname = "my-tests"\npath = "tests/main.rs"\n'
+    )
+    cfg = config_mod.load(tmp_path)
+    a = CargoAdapter(cfg.project("ws"), tmp_path)
+    assert a._targeted_cmd("my_tests::a::works") == (
+        "cargo test --test my-tests -- --exact a::works"
+    )
+
+
+def test_collection_reports_the_file_each_target_was_built_from(tmp_path):
+    """The set of covered files is the manifest's, not `tests/<target>.rs`."""
+    a = make_consolidated_adapter(tmp_path)
+    with patch.object(CargoAdapter, "_run_suite", return_value=(0, WORKSPACE_LIST, "")):
+        tests, files = a._collect_batch("cargo test --tests -- --list", {})
+    assert files == {"crates/dd-bridge/tests/main.rs", "crates/dd-core/tests/main.rs"}
+    assert "ws::bridge_tests::adapter_config::poll_config_parses_targets_and_maps" in tests
+
+
+def test_a_malformed_artifact_falls_back_to_the_file_stem(tmp_path):
+    """Nothing usable in the parentheses: the file stem is still cargo's default."""
+    a = make_adapter(tmp_path)
+    output = (
+        "     Running tests/roundtrip.rs (/work/target/debug/deps/-1d2c3b4a)\n"
+        "\nrenders_cover_only: test\n"
+    )
+    assert a._parse_list(output) == {"roundtrip::renders_cover_only"}
+
+
+def test_a_test_entry_without_a_path_resolves_through_cargos_default(tmp_path):
+    """`[[test]] name = "x"` with no `path` means `tests/x.rs`; no mapping needed."""
+    (tmp_path / "tdd.toml").write_text(
+        '[project.ws]\nroot = "."\nadapter = "cargo"\ntest_paths = ["tests/"]\n'
+    )
+    (tmp_path / "tests").mkdir()
+    (tmp_path / "tests" / "roundtrip.rs").write_text("#[test] fn t() {}\n")
+    (tmp_path / "Cargo.toml").write_text('[package]\nname = "w"\n\n[[test]]\nname = "roundtrip"\n')
+    cfg = config_mod.load(tmp_path)
+    a = CargoAdapter(cfg.project("ws"), tmp_path)
+    assert a._manifest_targets() == {}
+    assert a.target_path("roundtrip::t") == "tests/roundtrip.rs"
+    assert a._targeted_cmd("roundtrip::t") == ("cargo test --test roundtrip -- --exact t")
+
+
+def test_a_file_shaped_test_path_still_finds_the_manifest(tmp_path):
+    """`test_paths` may name files (`tests/*.rs`), not only directories."""
+    (tmp_path / "tdd.toml").write_text(
+        '[project.ws]\nroot = "."\nadapter = "cargo"\ntest_paths = ["tests/*.rs"]\n'
+    )
+    (tmp_path / "tests").mkdir()
+    (tmp_path / "tests" / "main.rs").write_text("mod a;\n")
+    (tmp_path / "Cargo.toml").write_text(
+        '[package]\nname = "w"\nautotests = false\n\n'
+        '[[test]]\nname = "w_tests"\npath = "tests/main.rs"\n'
+    )
+    cfg = config_mod.load(tmp_path)
+    a = CargoAdapter(cfg.project("ws"), tmp_path)
+    assert a._manifest_targets() == {"w_tests": "tests/main.rs"}
+
+
+def test_a_crate_with_no_manifest_keeps_cargos_default_mapping(tmp_path):
+    """No Cargo.toml above the tests dir: the walk stops at the root, nothing is claimed."""
+    a = make_adapter(tmp_path)  # kernel/tests/roundtrip.rs, no Cargo.toml anywhere
+    assert a._manifest_targets() == {}
+    assert a.target_path("roundtrip::renders_cover_only") == "tests/roundtrip.rs"
+    assert a._target_of_file("tests/roundtrip.rs") == "roundtrip"