tdd-cli 0.1.0__tar.gz → 0.2.1__tar.gz

{tdd_cli-0.1.0 → tdd_cli-0.2.1}/CHANGELOG.md

@@ -6,6 +6,37 @@ and the project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.2.1] - 2026-08-10
+
+### Added
+
+- `tdd doctor` check `default suite cannot reach override files`: when a
+  project declares overrides, doctor probes the default suite's discovery
+  (pytest: the test command with `--collect-only`; vitest: `vitest list`) and
+  fails if it reaches files an override owns — the premise suite overrides
+  require, which nothing previously enforced.
+
+### Fixed
+
+- A test observed by more than one suite invocation of the union (the default
+  suite's discovery sweeping an override's files, e.g. a bare `pytest` default)
+  is now a loud tooling error naming the overlapping tests and the fix, instead
+  of the target being silently judged by whichever suite reported it first —
+  previously an env-less run whose failure said nothing about the overlap.
+
+## [0.2.0] - 2026-08-10
+
+### Added
+
+- Per-pattern suite overrides (`[[project.<name>.override]]` in `tdd.toml`): an
+  alternate `test_command` — plus optional `collect_command` and `env` — for
+  files the default runner config cannot reach, such as contract tests that need
+  a live backend. Collection and suite runs union the default suite with every
+  override suite, so a cycle can target such a test without widening the default
+  config (which breaks CI and pollutes target adoption with the other suite's
+  tests). Override patterns classify their files as tests without being repeated
+  in `test_paths`; `env` values may reference `${VAR}`, expanded at invocation.
+
 ## [0.1.0] - 2026-08-08
 
 Initial release.

{tdd_cli-0.1.0 → tdd_cli-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tdd-cli
-Version: 0.1.0
+Version: 0.2.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
@@ -132,6 +132,35 @@ generated   = true                   # excluded from authorship accounting
 A generator that is never hand-edited (`codegen`) is an artifact regeneration command, not a
 project. It has no tests and no cycles.
 
+Some tests intentionally live outside the project's default runner config — contract tests
+that need a live backend being the common case, where CI runs the default suite with no
+backend up. Widening the default config to make such a test collectable is the wrong fix:
+the plain suite starts making real network calls, and the other suite's tests pollute
+target adoption. Instead, declare an override per pattern:
+
+```toml
+[project.frontend]
+root         = "frontend"
+adapter      = "vitest"
+test_paths   = ["**/*.test.ts"]
+test_command = "npx vitest run"
+
+[[project.frontend.override]]
+pattern         = "src/__contract__/"
+test_command    = "npx vitest run --config vitest.contract.config.ts"
+collect_command = "npx vitest list --config vitest.contract.config.ts"
+env             = { API_URL = "http://localhost:${API_PORT}" }
+```
+
+Collection and suite runs union the default suite with every override suite, so a cycle can
+target a test only the alternate config reaches. Patterns match paths relative to the
+project root with `test_paths` semantics, and override files classify as tests without
+being repeated in `test_paths`. `env` values may reference `${VAR}`, expanded from the
+environment at invocation. For pytest, `collect_command` is optional (`--collect-only`
+composes with the run command); a vitest override must declare one — `vitest list` knows
+nothing of the override config, and the mismatch is refused at `tdd run start`, not
+mid-cycle.
+
 ## Sharing cores between concurrent agents
 
 Several agents running tdd-cli on one machine (each in its own worktree) face a bad

{tdd_cli-0.1.0 → tdd_cli-0.2.1}/README.md

@@ -104,6 +104,35 @@ generated   = true                   # excluded from authorship accounting
 A generator that is never hand-edited (`codegen`) is an artifact regeneration command, not a
 project. It has no tests and no cycles.
 
+Some tests intentionally live outside the project's default runner config — contract tests
+that need a live backend being the common case, where CI runs the default suite with no
+backend up. Widening the default config to make such a test collectable is the wrong fix:
+the plain suite starts making real network calls, and the other suite's tests pollute
+target adoption. Instead, declare an override per pattern:
+
+```toml
+[project.frontend]
+root         = "frontend"
+adapter      = "vitest"
+test_paths   = ["**/*.test.ts"]
+test_command = "npx vitest run"
+
+[[project.frontend.override]]
+pattern         = "src/__contract__/"
+test_command    = "npx vitest run --config vitest.contract.config.ts"
+collect_command = "npx vitest list --config vitest.contract.config.ts"
+env             = { API_URL = "http://localhost:${API_PORT}" }
+```
+
+Collection and suite runs union the default suite with every override suite, so a cycle can
+target a test only the alternate config reaches. Patterns match paths relative to the
+project root with `test_paths` semantics, and override files classify as tests without
+being repeated in `test_paths`. `env` values may reference `${VAR}`, expanded from the
+environment at invocation. For pytest, `collect_command` is optional (`--collect-only`
+composes with the run command); a vitest override must declare one — `vitest list` knows
+nothing of the override config, and the mismatch is refused at `tdd run start`, not
+mid-cycle.
+
 ## Sharing cores between concurrent agents
 
 Several agents running tdd-cli on one machine (each in its own worktree) face a bad

{tdd_cli-0.1.0 → tdd_cli-0.2.1}/src/tddcli/__init__.py

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

{tdd_cli-0.1.0 → tdd_cli-0.2.1}/src/tddcli/adapters/base.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import os
 import subprocess
+from collections import Counter
 from dataclasses import dataclass, field
 from pathlib import Path
 
@@ -42,6 +43,27 @@ class Collection:
     failed_files: dict[str, str] = field(default_factory=dict)
 
 
+def _suite_overlap(suite_ids: list[set[str]]) -> list[str]:
+    """Test ids observed by more than one suite invocation of the union (R7.13).
+    Overlap means the default command's discovery reaches files an override
+    owns, so those tests also ran without the override's command/env — and
+    target matching would judge the target by whichever run came first."""
+    counts = Counter(i for ids in suite_ids for i in ids)
+    return sorted(i for i, n in counts.items() if n > 1)
+
+
+def _overlap_error(overlap: list[str]) -> str:
+    shown = ", ".join(overlap[:5])
+    more = f" (and {len(overlap) - 5} more)" if len(overlap) > 5 else ""
+    return (
+        f"observed by more than one suite invocation: {shown}{more}."
+        " The default suite's discovery reaches files an override owns, so"
+        " these tests also ran without the override's command/env. Scope the"
+        " default test_command so it cannot reach them (e.g. pass the default"
+        " test directories explicitly)."
+    )
+
+
 def run_command(
     command: str, cwd: Path, timeout: int = 1800,
     extra_env: dict[str, str] | None = None,
@@ -77,7 +99,9 @@ class Adapter:
     def run(self, target: str | None = None) -> Verdict:
         raise NotImplementedError
 
-    def _run_suite(self, command: str) -> tuple[int, str, str]:
+    def _run_suite(
+        self, command: str, extra_env: dict[str, str] | None = None
+    ) -> tuple[int, str, str]:
         """Run the suite under a machine-wide worker lease.
 
         Substituting `{workers}` is opt-in per project; a command without the
@@ -91,9 +115,31 @@ class Adapter:
             return run_command(
                 command.replace("{workers}", str(workers)),
                 self.root,
-                extra_env={"TDD_WORKERS": str(workers)},
+                extra_env={"TDD_WORKERS": str(workers), **(extra_env or {})},
             )
 
+    def _test_cmd(self) -> str:
+        raise NotImplementedError
+
+    def _suite_invocations(self) -> list[tuple[str, dict[str, str] | None]]:
+        """The default suite plus one invocation per declared override (R7.13).
+
+        Runs and collection union these results, so a test reachable only under an
+        alternate runner config is still observed — without widening the default
+        config, which is exactly the workaround that breaks CI.
+        """
+        return [(self._test_cmd(), None)] + [
+            (ov.test_command, self._override_env(ov)) for ov in self.project.overrides
+        ]
+
+    @staticmethod
+    def _override_env(override) -> dict[str, str] | None:
+        """`${VAR}` references resolve from the environment at invocation time, so a
+        port assigned by the harness need not be hard-coded in the reviewed file."""
+        if override is None or not override.env:
+            return None
+        return {k: os.path.expandvars(v) for k, v in override.env.items()}
+
     def stub_hint(self) -> str:
         """The language idiom for a stub body, quoted into the create_stub directive."""
         return "a body that fails loudly, never working logic"
@@ -104,6 +150,15 @@ class Adapter:
     def collectable(self) -> GateResult:
         raise NotImplementedError
 
+    def override_isolation(self) -> GateResult:
+        """Whether the default suite's discovery stays out of files an override
+        owns (R7.13's premise). Overlap means runs observe those tests without
+        the override's command/env — and the union then holds the same test
+        twice with conflicting outcomes. Adapters with a way to probe discovery
+        override this; the base answer is ok so third-party adapters without a
+        probe don't fail doctor."""
+        return GateResult(ok=True)
+
     def lint(self) -> GateResult:
         return self._gate(self.project.lint)
 

{tdd_cli-0.1.0 → tdd_cli-0.2.1}/src/tddcli/adapters/pytest_adapter.py

@@ -25,6 +25,8 @@ from .base import (
     Collection,
     GateResult,
     Verdict,
+    _overlap_error,
+    _suite_overlap,
     run_command,
 )
 
@@ -71,8 +73,9 @@ class PytestAdapter(Adapter):
     def _collect_cmd(self) -> str:
         return self.project.collect_command or self._base_cmd()
 
-    def run(self, target: str | None = None) -> Verdict:
-        verdict = Verdict(project=self.project.name, adapter=self.name, target=target)
+    def _suite_report(
+        self, base_cmd: str, extra_env: dict[str, str] | None
+    ) -> tuple[dict | None, str]:
         with tempfile.TemporaryDirectory(prefix="tdd-pytest-") as tmp:
             report_path = Path(tmp) / "report.json"
             # Only reporting flags are appended — parallelism, markers and plugins
@@ -80,26 +83,47 @@ class PytestAdapter(Adapter):
             # `collectors` is omitted when nothing fails to collect, and present with
             # the failing entry when something does, which is when it is consulted.
             cmd = (
-                f"{self._test_cmd()} --json-report"
+                f"{base_cmd} --json-report"
                 f" --json-report-file={shlex.quote(str(report_path))}"
             )
-            code, out, err = self._run_suite(cmd)
+            code, out, err = self._run_suite(cmd, extra_env)
             if not report_path.is_file():
-                verdict.error = (
-                    "pytest produced no JSON report (is pytest-json-report installed?): "
-                    + (err or out)[:500]
+                return None, (
+                    f"`{base_cmd}` produced no JSON report"
+                    " (is pytest-json-report installed?): " + (err or out)[:500]
                 )
-                return verdict
-            report = json.loads(report_path.read_text())
+            return json.loads(report_path.read_text()), ""
 
-        verdict.duration_ms = int(report.get("duration", 0) * 1000)
+    def run(self, target: str | None = None) -> Verdict:
+        verdict = Verdict(project=self.project.name, adapter=self.name, target=target)
+        # Union across the default suite and every override suite (R7.13). A suite
+        # that produces no report is a loud error, not a silent gap: swallowing it
+        # would report a target that lives in that suite as `not_found`, sending the
+        # agent to rewrite a test that is fine.
+        tests: list[dict] = []
+        collectors: list[dict] = []
+        suite_ids: list[set[str]] = []
+        for base_cmd, extra_env in self._suite_invocations():
+            report, error = self._suite_report(base_cmd, extra_env)
+            if report is None:
+                verdict.error = error
+                return verdict
+            verdict.duration_ms += int(report.get("duration", 0) * 1000)
+            tests.extend(report.get("tests", []))
+            collectors.extend(report.get("collectors", []))
+            suite_ids.append({t["nodeid"] for t in report.get("tests", [])})
+
+        overlap = _suite_overlap(suite_ids)
+        if overlap:
+            verdict.error = _overlap_error(overlap)
+            return verdict
 
         uncollectable: set[str] = set()
-        for collector in report.get("collectors", []):
+        for collector in collectors:
             if collector.get("outcome") not in (None, "passed"):
                 uncollectable.add(collector.get("nodeid", ""))
 
-        for test in report.get("tests", []):
+        for test in tests:
             qualified = self.qualify(test["nodeid"])
             if test["outcome"] == "passed":
                 verdict.passed.append(qualified)
@@ -111,9 +135,7 @@ class PytestAdapter(Adapter):
             return verdict
 
         native = self.strip(target)
-        hit = next(
-            (t for t in report.get("tests", []) if t["nodeid"] == native), None
-        )
+        hit = next((t for t in tests if t["nodeid"] == native), None)
         if hit is not None:
             verdict.target_outcome = PASSED if hit["outcome"] == "passed" else FAILED
             call = hit.get("call") or hit.get("setup") or {}
@@ -122,21 +144,30 @@ class PytestAdapter(Adapter):
             target_file = native.split("::", 1)[0]
             if any(c == target_file or c.startswith(target_file) for c in uncollectable):
                 verdict.target_outcome = NOT_COLLECTED
-                verdict.target_failure = self._collector_error(report, target_file)[:1500]
+                verdict.target_failure = self._collector_error(collectors, target_file)[:1500]
             else:
                 verdict.target_outcome = NOT_FOUND
         return verdict
 
     @staticmethod
-    def _collector_error(report: dict, target_file: str) -> str:
-        for collector in report.get("collectors", []):
+    def _collector_error(collectors: list[dict], target_file: str) -> str:
+        for collector in collectors:
             if collector.get("nodeid", "").startswith(target_file):
                 return str(collector.get("longrepr", ""))
         return ""
 
+    def _collect_cmd_for(self, rel: str) -> tuple[str, dict[str, str] | None]:
+        """The collection command for one file: the owning override's, else the
+        project default. An override without a `collect_command` collects with its
+        `test_command` — pytest's `--collect-only` composes with any run command."""
+        ov = self.project.override_for(rel)
+        if ov is None:
+            return self._collect_cmd(), None
+        return ov.collect_command or ov.test_command, self._override_env(ov)
+
     def _test_files(self) -> list[Path]:
         found: list[Path] = []
-        for pattern in self.project.test_paths or ["tests/"]:
+        for pattern in self.project.test_patterns or ["tests/"]:
             if pattern.endswith("/"):
                 base = self.root / pattern
                 if base.is_dir():
@@ -147,27 +178,68 @@ class PytestAdapter(Adapter):
         return sorted({p for p in found if p.is_file()})
 
     def collectable(self) -> GateResult:
-        """A single whole-suite `--collect-only` (§10), not the per-file
-        `collect()` loop below — that loop is R10.3/R10.4's per-file collection,
-        the slow path (the whole-suite probe costs 0.04s on a broken project vs.
-        minutes for the per-file sweep on a real one).
+        """One whole-suite `--collect-only` per declared suite (§10) — the default
+        command plus each override's — not the per-file `collect()` loop below.
+        That loop is R10.3/R10.4's per-file collection, the slow path (the
+        whole-suite probe costs 0.04s on a broken project vs. minutes for the
+        per-file sweep on a real one).
 
         Reads **stdout**, not stderr: `uv` writes environment warnings
         (`VIRTUAL_ENV=... does not match ...`) to stderr while pytest writes the
         actual `ModuleNotFoundError` to stdout. A doctor check that reads stderr
         loses the real error and the failure surfaces unattributed.
         """
-        code, out, err = run_command(f"{self._collect_cmd()} --collect-only -q", self.root)
-        return GateResult(ok=code == 0, output="" if code == 0 else out.strip()[:2000])
+        chunks = []
+        probes = [(self._collect_cmd(), None)] + [
+            (ov.collect_command or ov.test_command, self._override_env(ov))
+            for ov in self.project.overrides
+        ]
+        for cmd, env in probes:
+            code, out, err = run_command(
+                f"{cmd} --collect-only -q", self.root, extra_env=env
+            )
+            if code != 0:
+                chunks.append(out.strip())
+        return GateResult(ok=not chunks, output="\n\n".join(chunks)[:2000])
+
+    def override_isolation(self) -> GateResult:
+        """Probes the *test* command's discovery, not `collect_command`'s: the
+        test command is what runs at suite time, and a scoped `test_command`
+        with a bare per-file `collect_command` is a legitimate registry (the
+        per-file command always gets an explicit path). `{workers}` becomes 0 —
+        xdist's "no workers" — since discovery needs no parallelism. A probe
+        that fails to collect at all is `collectable`'s finding, not this one's."""
+        if not self.project.overrides:
+            return GateResult(ok=True)
+        probe = f"{self._test_cmd().replace('{workers}', '0')} --collect-only -q"
+        code, out, err = run_command(probe, self.root)
+        reached = sorted({
+            f for f in (
+                line.split("::", 1)[0]
+                for line in out.splitlines()
+                if "::" in line
+            )
+            if self.project.override_for(f)
+        })
+        if not reached:
+            return GateResult(ok=True)
+        return GateResult(ok=False, output=(
+            "the default suite's discovery reaches files an override owns, so"
+            " suite runs would observe them without the override's command/env:"
+            f" {', '.join(reached[:5])}. Scope the default test_command so it"
+            " cannot reach them (e.g. `pytest tests/`)."
+        ))
 
     def collect(self) -> Collection:
         """Per file (R10.3) — one uncollectable module must not destroy the whole set."""
         result = Collection()
         for path in self._test_files():
             rel = path.relative_to(self.root)
+            base, env = self._collect_cmd_for(str(rel))
             code, out, err = run_command(
-                f"{self._collect_cmd()} --collect-only -q {shlex.quote(str(rel))}",
+                f"{base} --collect-only -q {shlex.quote(str(rel))}",
                 self.root,
+                extra_env=env,
             )
             if code != 0:
                 result.failed_files[str(rel)] = (err or out).strip()[:800]

{tdd_cli-0.1.0 → tdd_cli-0.2.1}/src/tddcli/adapters/vitest_adapter.py

@@ -21,6 +21,8 @@ from .base import (
     Collection,
     GateResult,
     Verdict,
+    _overlap_error,
+    _suite_overlap,
     run_command,
 )
 
@@ -49,19 +51,44 @@ class VitestAdapter(Adapter):
             rel = suite_path
         return self.qualify(f"{rel} > {full_name}")
 
+    def _test_cmd(self) -> str:
+        return self.project.test_command or "npx vitest run"
+
+    def _collect_cmd(self) -> str:
+        return self.project.collect_command or "npx vitest list"
+
     def run(self, target: str | None = None) -> Verdict:
         verdict = Verdict(project=self.project.name, adapter=self.name, target=target)
-        base = self.project.test_command or "npx vitest run"
-        code, out, err = self._run_suite(f"{base} --reporter=json")
-        report = _extract_json(out)
-        if report is None:
-            verdict.error = f"vitest produced no JSON output: {(err or out)[:500]}"
+        # Union across the default suite and every override suite (R7.13). A suite
+        # producing no JSON is a loud error, not a silent gap: swallowing it would
+        # report a target living in that suite as `not_found`.
+        suites: list[dict] = []
+        suite_ids: list[set[str]] = []
+        for base, extra_env in self._suite_invocations():
+            code, out, err = self._run_suite(f"{base} --reporter=json", extra_env)
+            report = _extract_json(out)
+            if report is None:
+                verdict.error = (
+                    f"`{base}` produced no JSON output: {(err or out)[:500]}"
+                )
+                return verdict
+            verdict.duration_ms += int(report.get("duration") or 0)
+            results = report.get("testResults", [])
+            suites.extend(results)
+            suite_ids.append({
+                self._id_for(s.get("name", ""), t["fullName"])
+                for s in results
+                for t in s.get("assertionResults", [])
+            })
+
+        overlap = _suite_overlap(suite_ids)
+        if overlap:
+            verdict.error = _overlap_error(overlap)
             return verdict
 
-        verdict.duration_ms = int(report.get("duration") or 0)
         failed_suites: dict[str, str] = {}
 
-        for suite in report.get("testResults", []):
+        for suite in suites:
             suite_path = suite.get("name", "")
             assertions = suite.get("assertionResults", [])
             if not assertions and suite.get("status") == "failed":
@@ -82,7 +109,7 @@ class VitestAdapter(Adapter):
             return verdict
         if target in verdict.failed:
             verdict.target_outcome = FAILED
-            for suite in report.get("testResults", []):
+            for suite in suites:
                 for t in suite.get("assertionResults", []):
                     if self._id_for(suite.get("name", ""), t["fullName"]) == target:
                         verdict.target_failure = "\n".join(
@@ -101,7 +128,7 @@ class VitestAdapter(Adapter):
 
     def _test_files(self) -> list[Path]:
         found: set[Path] = set()
-        for pattern in self.project.test_paths or ["**/*.test.ts"]:
+        for pattern in self.project.test_patterns or ["**/*.test.ts"]:
             pat = pattern.rstrip("/") + "/**/*" if pattern.endswith("/") else pattern
             for path in self.root.glob(pat):
                 if path.is_file() and path.suffix in (".ts", ".tsx", ".js", ".jsx"):
@@ -134,19 +161,75 @@ class VitestAdapter(Adapter):
         return found
 
     def collectable(self) -> GateResult:
-        """A single whole-suite probe, mirroring the pytest adapter's `--collect-only`
-        (§10): `npx vitest list` at the project root rather than the
-        per-file `collect()` loop below."""
-        base = self.project.collect_command or "npx vitest list"
-        code, out, err = run_command(base, self.root)
-        return GateResult(ok=code == 0, output="" if code == 0 else (err or out).strip()[:2000])
+        """One whole-suite probe per declared suite, mirroring the pytest adapter's
+        `--collect-only` (§10): `npx vitest list` at the project root rather than
+        the per-file `collect()` loop below.
+
+        An override without a `collect_command` fails here, at run start, not
+        per-file during a cycle: `vitest list` knows nothing of the override's
+        config, and falling back to the override's *run* command would execute the
+        suite — against a live backend — just to enumerate it.
+        """
+        chunks = []
+        code, out, err = run_command(self._collect_cmd(), self.root)
+        if code != 0:
+            chunks.append((err or out).strip())
+        for ov in self.project.overrides:
+            if not ov.collect_command:
+                chunks.append(
+                    f"override {ov.pattern!r}: a vitest override needs an explicit"
+                    ' collect_command (e.g. "npx vitest list --config'
+                    ' vitest.other.config.ts")'
+                )
+                continue
+            code, out, err = run_command(
+                ov.collect_command, self.root, extra_env=self._override_env(ov)
+            )
+            if code != 0:
+                chunks.append((err or out).strip())
+        return GateResult(ok=not chunks, output="\n\n".join(chunks)[:2000])
+
+    def override_isolation(self) -> GateResult:
+        """Probes with the default `vitest list` — the same stand-in for the
+        default run config that `collectable()` already relies on (`vitest run`
+        has no listing mode, and running the suite just to enumerate it would
+        execute against whatever the tests need live)."""
+        if not self.project.overrides:
+            return GateResult(ok=True)
+        code, out, err = run_command(self._collect_cmd(), self.root)
+        reached = sorted({
+            f for f in (
+                line.strip().partition(" > ")[0]
+                for line in out.splitlines()
+                if " > " in line
+            )
+            if self.project.override_for(f)
+        })
+        if not reached:
+            return GateResult(ok=True)
+        return GateResult(ok=False, output=(
+            "the default config's discovery reaches files an override owns, so"
+            " suite runs would observe them without the override's command/env:"
+            f" {', '.join(reached[:5])}. Exclude them from the default vitest"
+            " config (test.exclude) or scope its include globs."
+        ))
 
     def collect(self) -> Collection:
         result = Collection()
         for path in self._test_files():
             rel = path.relative_to(self.root)
-            base = self.project.collect_command or "npx vitest list"
-            code, out, err = run_command(f"{base} {shlex.quote(str(rel))}", self.root)
+            ov = self.project.override_for(str(rel))
+            if ov is not None and not ov.collect_command:
+                result.failed_files[str(rel)] = (
+                    f"override {ov.pattern!r} declares no collect_command; vitest"
+                    " cannot list these tests under the default config"
+                )
+                continue
+            base = ov.collect_command if ov else self._collect_cmd()
+            env = self._override_env(ov)
+            code, out, err = run_command(
+                f"{base} {shlex.quote(str(rel))}", self.root, extra_env=env
+            )
 
             payload = _extract_json(out)
             if payload is not None:

{tdd_cli-0.1.0 → tdd_cli-0.2.1}/src/tddcli/cli.py

@@ -275,6 +275,16 @@ def cmd_doctor(args) -> Envelope:
         gate = adapter.collectable()
         check("collectable", gate.ok, gate.output, project=name)
 
+        # R7.13's premise — "files the default runner config cannot reach" — is
+        # a config property nothing else enforces. Probe it at preflight so the
+        # overlap is named here, not discovered as an opaque mid-cycle failure.
+        if project.overrides:
+            gate = adapter.override_isolation()
+            check(
+                "default suite cannot reach override files",
+                gate.ok, gate.output, project=name,
+            )
+
         projects[name] = {"ok": all(c["ok"] for c in checks[before:])}
 
     for art in cfg.artifacts.values():