tdd-cli 0.14.0__tar.gz → 0.14.1__tar.gz

{tdd_cli-0.14.0 → tdd_cli-0.14.1}/CHANGELOG.md

@@ -6,6 +6,33 @@ and the project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.14.1] - 2026-09-25
+
+### Fixed
+
+- **vitest ids from named vitest projects** (#163). Whole-suite collection read `vitest list`
+  text, which prefixes `[<project>] ` to every line of a named vitest project and prints paths
+  relative to that project's `root`, so it collected ids no run ever reports (and, via the
+  per-file loop, a second spelling of every test). It now reads `vitest list --json` and roots
+  each id at the test's own file. tdd appends `--json` itself; a collect command must not.
+- **The vitest override-isolation check sees named vitest projects** (#163). `tdd doctor`'s
+  check that the default config does not reach an override's files read the same text
+  listing, so a `[<project>] ` prefix meant it could never match. It now reads
+  `vitest list --json`, and a listing that is not JSON fails the check, naming the command.
+- **Adoption never picks another cycle's test** (#163). When a cycle's declared test was
+  missing, `tdd advance` adopted any test new since the run started, including an earlier
+  cycle's target, so a premature advance handed cycle 1's test to cycle 2. Every target in
+  the run is now excluded, compared by normalised id.
+- **`tdd target` accepts the plan's spelling of a test** (#163). It matched only the exact
+  collected id, so it could not name the declared vitest id (`src/a.test.ts > math > adds`
+  for a collected `frontend::src/a.test.ts > math adds`). It now qualifies and normalises
+  its argument as a plan declaration is, and stores the collected id.
+- **An adopted target the run cannot find is refused** (#163). A test that collection
+  listed but no run reported was recorded as the target and came back `not_found` on every
+  advance, re-adopting a different test each time. The adoption is now evaluated first; on
+  `not_found` the declared target is kept, `adopted_target_not_found` is recorded, and
+  `tdd advance` answers `resolve_blocker`.
+
 ## [0.14.0] - 2026-09-24
 
 ### Added

{tdd_cli-0.14.0 → tdd_cli-0.14.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tdd-cli
-Version: 0.14.0
+Version: 0.14.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
@@ -170,7 +170,11 @@ being repeated in `test_paths`. `env` values may reference `${VAR}`, expanded fr
 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.
+mid-cycle. For the whole-suite listing tdd appends `--json` to each vitest collect command
+(the default and every override's) and reads each test's file from vitest's JSON, so a
+collect command must not carry `--json` itself: `vitest list --json --json` prints nothing.
+The override-isolation check in `tdd doctor` reads the same JSON listing, and a listing it
+cannot read fails the check, naming the command it ran.
 
 ## Sharing cores between concurrent agents
 

{tdd_cli-0.14.0 → tdd_cli-0.14.1}/README.md

@@ -142,7 +142,11 @@ being repeated in `test_paths`. `env` values may reference `${VAR}`, expanded fr
 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.
+mid-cycle. For the whole-suite listing tdd appends `--json` to each vitest collect command
+(the default and every override's) and reads each test's file from vitest's JSON, so a
+collect command must not carry `--json` itself: `vitest list --json --json` prints nothing.
+The override-isolation check in `tdd doctor` reads the same JSON listing, and a listing it
+cannot read fails the check, naming the command it ran.
 
 ## Sharing cores between concurrent agents
 

{tdd_cli-0.14.0 → tdd_cli-0.14.1}/docs/PRD.md

@@ -533,8 +533,11 @@ one has no move left but to re-run doctor and read the same output again.
 - **R8.7** A blocked run is not live. H1 must permit the agent to stop, or a blocker traps it.
 - **R8.8** `human_intervention` events are the input to interventions-per-run, the primary
   autonomy metric.
-- **R8.9** In `AWAITING_TEST`, `advance` resolves the target by diffing `collect()` against cycle
-  open. When the declared target is `not_found`, the adoption flow runs:
+- **R8.9** In `AWAITING_TEST`, `advance` resolves the target by diffing `collect()` against the
+  run's start, and never offers a test that another cycle of the run targets: an earlier cycle's
+  test is new since the start too, and adopting it would hand one test to two cycles (#163). The
+  exclusion compares `normalise_id` forms (R10.8), because a target may be stored in its declared
+  spelling. When the declared target is `not_found`, the adoption flow runs:
   - **Single new test:** adopted as the target; `declared_test_mismatch` is recorded. The verdict
     from the run that already happened is evaluated immediately in the same `advance` call — no
     extra suite run. If the adopted test failed, the RED commit is made and the cycle moves to
@@ -544,6 +547,14 @@ one has no move left but to re-run doctor and read the same output again.
     above; `declared_test_mismatch` is recorded with the full candidate list.
   - **Multiple new tests — ambiguous:** recorded as `multiple_new_tests`; `next_action` requires
     the agent to name the intended target with `tdd target <id>` rather than guessing.
+    `tdd target` qualifies its argument the way a plan declaration is qualified and matches it by
+    `normalise_id` (R10.8), so the plan's own spelling names the test; it stores the collected id,
+    and refuses an id that matches no collected test in any spelling (#163).
+  - **Adopted target the run cannot find:** the adoption is evaluated before it is recorded. If
+    the run reports the adopted test `not_found`, collection and execution disagree about its id,
+    and no test the agent writes can fix that: the declared target is kept, no
+    `declared_test_mismatch` is recorded, `adopted_target_not_found` is (`{declared, adopted}`),
+    and `next_action` is `resolve_blocker`, asking for a `tooling` blocker (#163).
   The run that produced `not_found` already executed the new test; its verdict is retrieved from
   the in-hand `Verdict` objects without an extra suite run.
 
@@ -861,7 +872,14 @@ Adapter.typecheck(project)               -> GateResult
   file it came from. `tdd doctor` reads the subprocess's **stdout**: `uv` writes
   environment warnings (e.g. `VIRTUAL_ENV=... does not match ...`) to stderr, while pytest writes
   the actual collection error (e.g. `ModuleNotFoundError`) to stdout. A check that reads stderr
-  reports the wrapper's noise and loses the real error underneath it.
+  reports the wrapper's noise and loses the real error underneath it. Collection's whole-suite
+  vitest listing is `vitest list --json`, not the text listing `collectable()` probes: the text
+  prefixes `[<project>] ` to every line of a named vitest project and prints paths relative to
+  that project's own `root`, while the JSON carries each test's absolute `file`, which the
+  adapter makes root-relative exactly as `run()` does (#163). The vitest override-isolation probe
+  reads the same `vitest list --json` and decides reach from each entry's root-relative `file`; a
+  listing that is not a JSON array fails the probe and names the command, since passing it would
+  disable the check without a signal.
 
 ---
 

{tdd_cli-0.14.0 → tdd_cli-0.14.1}/docs/harness-integration.md

@@ -74,11 +74,11 @@ skill that duplicates any of it will fight the ledger.
 | `write_implementation` | RED is confirmed and committed, or the target still fails at GREEN (only the target ran) | write the minimum code to pass the target, then `tdd advance` |
 | `fix_regression` | tests outside the cycle are failing at GREEN, or the close sweep / lint / typecheck gates failed | fix them without breaking the target, then `tdd advance` |
 | `run_sensitivity_check` | a test passed where proof it *can* fail is required | `tdd sensitivity begin`, mutate the behaviour under test, `tdd sensitivity check`, then `tdd sensitivity end` |
-| `name_target_test` | several new tests appeared; a cycle covers one behaviour | pick the intended one: `tdd target <id>` |
+| `name_target_test` | several new tests appeared; a cycle covers one behaviour | pick the intended one: `tdd target <id>`, in the collected spelling or the plan's own (`src/a.test.ts > math > adds`); the collected id is stored |
 | `refactor_or_advance` | GREEN is committed, or the tool simply wants `tdd advance` next | refactor only if the plan calls for it, then `tdd advance` |
 | `confirm_cycle_applicable` | a judgement point outside the cycle loop: config scaffolded, no active run, doctor passed | review / register / start as the `detail` names; if a cycle no longer applies, `tdd cycle skip --reason "..."` |
 | `annotate_cycle` | the plan requires judgement annotations before the cycle closes | `tdd annotate --key <k> --value "..."` for each missing key, then `tdd advance` |
-| `resolve_blocker` | wedged: three unchanged retries, or failing environment checks | fix the cause, or record it: `tdd blocker --kind <kind> --detail "..."` |
+| `resolve_blocker` | wedged: three unchanged retries, failing environment checks, or an adopted target the run cannot find | fix the cause, or record it: `tdd blocker --kind <kind> --detail "..."` |
 | `await_baseline` | baseline collection is in flight (collector pid alive) | poll `tdd progress`; **never** re-run `tdd run start` for a live claim |
 | `complete` *(terminal)* | the run (or command) is finished | render the friction log if the `detail` asks, then stop |
 | `blocked` *(terminal)* | a typed blocker was recorded | surface the blocker to the human and stop |

{tdd_cli-0.14.0 → tdd_cli-0.14.1}/src/tddcli/__init__.py

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

{tdd_cli-0.14.0 → tdd_cli-0.14.1}/src/tddcli/adapters/vitest_adapter.py

@@ -41,6 +41,18 @@ def _extract_json(raw: str) -> dict | None:
     return None
 
 
+def _json_listing(raw: str) -> list[dict] | None:
+    """`vitest list --json`'s array of `{name, file, projectName}`, or None when the
+    output is not one."""
+    try:
+        payload = json.loads(raw)
+    except json.JSONDecodeError:
+        return None
+    if not isinstance(payload, list):
+        return None
+    return [entry for entry in payload if isinstance(entry, dict)]
+
+
 #: The characters a JavaScript regex treats as syntax. Only these are escaped: vitest
 #: may compile `-t` with the `u` flag, which rejects the identity escapes (`\ `, `\-`)
 #: that Python's `re.escape` emits.
@@ -86,13 +98,14 @@ class VitestAdapter(Adapter):
         name = " ".join(part.strip() for part in remainder.split(" > "))
         return self.qualify(f"{file_part} > {name}")
 
-    def _id_for(self, suite_path: str, full_name: str) -> str:
-        abs_path = Path(suite_path)
+    def _rel(self, suite_path: str) -> str:
         try:
-            rel = os.path.relpath(abs_path, self.root)
+            return os.path.relpath(Path(suite_path), self.root)
         except ValueError:
-            rel = suite_path
-        return self.qualify(f"{rel} > {full_name}")
+            return suite_path
+
+    def _id_for(self, suite_path: str, full_name: str) -> str:
+        return self.qualify(f"{self._rel(suite_path)} > {full_name}")
 
     def _test_cmd(self) -> str:
         return self.project.test_command or "npx vitest run"
@@ -267,24 +280,31 @@ class VitestAdapter(Adapter):
         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
+        """Probes with the default `vitest list --json` — 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)."""
+        execute against whatever the tests need live). Reach is decided from each
+        entry's root-relative `file`; a listing that is not JSON fails the gate
+        rather than passing it by reaching nothing."""
         if not self.project.overrides:
             return GateResult(ok=True)
+        command = f"{self._collect_cmd()} --json"
         code, out, err = run_command(
-            self._collect_cmd(), self.root, extra_env=self._suite_env(None), label="doctor"
-        )
-        reached = sorted(
-            {
-                f
-                for f in (
-                    line.strip().partition(" > ")[0] for line in out.splitlines() if " > " in line
-                )
-                if self.project.override_for(f)
-            }
+            command, self.root, extra_env=self._suite_env(None), label="doctor"
         )
+        listing = _json_listing(out)
+        if listing is None:
+            return GateResult(
+                ok=False,
+                output=(
+                    f"`{command}` did not print a JSON array (exit {code}); tdd reads"
+                    " vitest's JSON listing to check which files the default config"
+                    " reaches, so a collect command must not already carry --json: "
+                    + (err or out).strip()[:600]
+                ),
+            )
+        listed = {self._rel(entry["file"]) for entry in listing if entry.get("file")}
+        reached = sorted(f for f in listed if self.project.override_for(f))
         if not reached:
             return GateResult(ok=True)
         return GateResult(
@@ -311,22 +331,26 @@ class VitestAdapter(Adapter):
         self, command: str, env: dict[str, str] | None
     ) -> tuple[set[str], set[str]] | None:
         """Unlike `_parse_list_output`, which pins every id to the one file it was
-        given, a whole-suite listing must read the file from each line — the same
-        `file > describe > name` shape, one file per line rather than one per run."""
-        code, out, err = run_command(command, self.root, extra_env=env, label="collect")
+        given, a whole-suite listing must read each test's file. The text listing
+        cannot supply it: a named vitest project prefixes `[<name>] ` to every line,
+        and a project with its own `root` prints paths relative to that root. The
+        JSON listing carries the absolute `file`, rooted here exactly as `run()`
+        roots its report. Anything that is not a JSON array is left to the loop."""
+        code, out, err = run_command(f"{command} --json", self.root, extra_env=env, label="collect")
         if code != 0:
             return None
+        listing = _json_listing(out)
+        if listing is None:
+            return None
         tests: set[str] = set()
         files: set[str] = set()
-        for line in out.splitlines():
-            line = line.strip()
-            if " > " not in line:
+        for entry in listing:
+            file, name = entry.get("file"), entry.get("name")
+            if not (file and name):
                 continue
-            rel, _, remainder = line.partition(" > ")
-            full_name = " ".join(part.strip() for part in remainder.split(" > "))
-            if rel and full_name:
-                tests.add(self.qualify(f"{rel.strip()} > {full_name}"))
-                files.add(rel.strip())
+            full_name = " ".join(part.strip() for part in name.split(" > "))
+            tests.add(self._id_for(file, full_name))
+            files.add(self._rel(file))
         # An empty result needs no special case: it accounts for no files, so every
         # file falls to the loop exactly as a failure would.
         return tests, files

{tdd_cli-0.14.0 → tdd_cli-0.14.1}/src/tddcli/advance.py

@@ -58,17 +58,30 @@ def _last_invocation_hash(engine: Engine, cycle) -> str | None:
 
 
 def _adopt_target(engine: Engine, cycle, missing: list[str]) -> tuple[list[str], list[str]]:
-    """R8.9 — resolve the target from newly collected tests when the declared id misses."""
+    """R8.9 — resolve the target from newly collected tests when the declared id misses.
+
+    A test another cycle of the run already targets is never a candidate: it is new
+    since the run started too. Targets may be stored in the declared spelling, so the
+    exclusion compares normalised ids (#163)."""
     projects = json.loads(cycle["projects"])
     at_start = engine.ledger.collection(engine.run["id"])
     known = {t for tests in at_start.values() for t in tests}
-    existing_targets = set(json.loads(cycle["target_tests"]))
+    run_targets = {
+        t
+        for row in engine.ledger.all(
+            "SELECT target_tests FROM cycle WHERE run_id = ?", (engine.run["id"],)
+        )
+        for t in json.loads(row["target_tests"])
+    }
 
     new_tests: list[str] = []
     for name in projects:
         adapter = adapters.build(engine.config.project(name), engine.worktree)
+        claimed = {adapter.normalise_id(t) for t in run_targets}
         current = adapter.collect()
-        new_tests.extend(sorted(current.tests - known - existing_targets))
+        new_tests.extend(
+            sorted(t for t in current.tests - known if adapter.normalise_id(t) not in claimed)
+        )
     return new_tests, missing
 
 
@@ -200,6 +213,60 @@ def _evaluate_adopted(
     return outcomes.get(adopted), failure
 
 
+def _adopt(
+    engine: Engine,
+    cycle,
+    projects: list[str],
+    targets: list[str],
+    missing: list[str],
+    adopted: str,
+    detail: dict,
+    verdicts,
+    retried: bool,
+):
+    """R8.9's one adoption path, whichever branch chose `adopted`: evaluate the new
+    target, then record the mismatch and retarget the cycle. Returns the reply when
+    the target is refused or has no outcome yet, else `(cycle, targets, outcome,
+    failure)`.
+
+    The evaluation comes first because a test that collection lists but the run
+    cannot find would otherwise become the target and come back `not_found` on every
+    advance (#163): collection and execution disagree about its id, which no test
+    the agent writes can fix."""
+    kept = [t for t in targets if t not in missing]
+    outcome, failure = _evaluate_adopted(engine, cycle, projects, kept, adopted, verdicts, retried)
+    if outcome == NOT_FOUND:
+        engine.ledger.event(
+            engine.run["id"],
+            cycle["id"],
+            "adopted_target_not_found",
+            json.dumps({"declared": missing, "adopted": [adopted]}),
+        )
+        return _reply(
+            engine,
+            cycle,
+            Verb.RESOLVE_BLOCKER,
+            f"{adopted} is collected but the run cannot find it: collection and execution"
+            " disagree about its id. The declared target is unchanged. Record it:"
+            " `tdd blocker --kind tooling --detail '...'`.",
+            adopted=[adopted],
+            declared=missing,
+        )
+    engine.ledger.event(engine.run["id"], cycle["id"], "declared_test_mismatch", json.dumps(detail))
+    engine.ledger.update("cycle", cycle["id"], target_tests=json.dumps(kept + [adopted]))
+    cycle = engine.ledger.one("SELECT * FROM cycle WHERE id = ?", (cycle["id"],))
+    if outcome is None:
+        return _reply(
+            engine,
+            cycle,
+            Verb.REFACTOR_OR_ADVANCE,
+            f"Adopted {adopted} as the target (declared {missing[0]} was not"
+            " collected). Run `tdd advance` again to evaluate it.",
+            adopted=[adopted],
+        )
+    return cycle, kept + [adopted], outcome, failure
+
+
 # -- handlers ------------------------------------------------------------
 
 
@@ -219,67 +286,23 @@ def _handle_test_phase(engine: Engine, cycle, retried: bool, expect_pass: bool)
     missing = [t for t, o in outcomes.items() if o == NOT_FOUND]
     if missing:
         candidates, _ = _adopt_target(engine, cycle, missing)
-        if len(candidates) == 1:
-            engine.ledger.event(
-                engine.run["id"],
-                cycle["id"],
-                "declared_test_mismatch",
-                json.dumps({"declared": missing, "adopted": candidates}),
-            )
-            kept = [t for t in targets if t not in missing]
-            engine.ledger.update("cycle", cycle["id"], target_tests=json.dumps(kept + candidates))
-            cycle = engine.ledger.one("SELECT * FROM cycle WHERE id = ?", (cycle["id"],))
-            adopted_outcome, adopted_failure = _evaluate_adopted(
-                engine, cycle, projects, kept, candidates[0], verdicts, retried
+        if not candidates:
+            return _reply(
+                engine,
+                cycle,
+                Verb.WRITE_TEST,
+                f"Target {missing[0]} was not collected and no new test was found."
+                " Write the failing test.",
+                missing=missing,
             )
-            if adopted_outcome is None:
-                return _reply(
-                    engine,
-                    cycle,
-                    Verb.REFACTOR_OR_ADVANCE,
-                    f"Adopted {candidates[0]} as the target (declared {missing[0]} was not"
-                    " collected). Run `tdd advance` again to evaluate it.",
-                    adopted=candidates,
-                )
-            targets = kept + candidates
-            outcomes = {candidates[0]: adopted_outcome}
-            failure = adopted_failure or failure
-            others = [t for t in others if t != candidates[0]]
-        elif len(candidates) > 1:
+        if len(candidates) == 1:
+            adopted = candidates[0]
+            detail = {"declared": missing, "adopted": candidates}
+        else:
             owner = missing[0].split("::", 1)[0]
             adapter = adapters.build(engine.config.project(owner), engine.worktree)
             resolved = _disambiguate(candidates, missing[0], adapter)
-            if resolved is not None:
-                engine.ledger.event(
-                    engine.run["id"],
-                    cycle["id"],
-                    "declared_test_mismatch",
-                    json.dumps(
-                        {"declared": missing, "adopted": [resolved], "all_candidates": candidates}
-                    ),
-                )
-                kept = [t for t in targets if t not in missing]
-                engine.ledger.update(
-                    "cycle", cycle["id"], target_tests=json.dumps(kept + [resolved])
-                )
-                cycle = engine.ledger.one("SELECT * FROM cycle WHERE id = ?", (cycle["id"],))
-                adopted_outcome, adopted_failure = _evaluate_adopted(
-                    engine, cycle, projects, kept, resolved, verdicts, retried
-                )
-                if adopted_outcome is None:
-                    return _reply(
-                        engine,
-                        cycle,
-                        Verb.REFACTOR_OR_ADVANCE,
-                        f"Adopted {resolved} as the target (declared {missing[0]} was not"
-                        " collected). Run `tdd advance` again to evaluate it.",
-                        adopted=[resolved],
-                    )
-                targets = kept + [resolved]
-                outcomes = {resolved: adopted_outcome}
-                failure = adopted_failure or failure
-                others = [t for t in others if t != resolved]
-            else:
+            if resolved is None:
                 engine.ledger.event(
                     engine.run["id"],
                     cycle["id"],
@@ -294,15 +317,17 @@ def _handle_test_phase(engine: Engine, cycle, retried: bool, expect_pass: bool)
                     " intended target with `tdd target <id>`.",
                     candidates=candidates,
                 )
-        else:
-            return _reply(
-                engine,
-                cycle,
-                Verb.WRITE_TEST,
-                f"Target {missing[0]} was not collected and no new test was found."
-                " Write the failing test.",
-                missing=missing,
-            )
+            adopted = resolved
+            detail = {"declared": missing, "adopted": [resolved], "all_candidates": candidates}
+        adoption = _adopt(
+            engine, cycle, projects, targets, missing, adopted, detail, verdicts, retried
+        )
+        if isinstance(adoption, Envelope):
+            return adoption
+        cycle, targets, adopted_outcome, adopted_failure = adoption
+        outcomes = {adopted: adopted_outcome}
+        failure = adopted_failure or failure
+        others = [t for t in others if t != adopted]
 
     not_collected = [t for t, o in outcomes.items() if o == NOT_COLLECTED]
     if not_collected:

{tdd_cli-0.14.0 → tdd_cli-0.14.1}/src/tddcli/cli.py

@@ -1493,11 +1493,23 @@ def cmd_target(args) -> Envelope:
     # grounded in observed execution (#15): recording free text deferred a typo —
     # or a speculative `tdd target env` — to the next suite run, where it
     # surfaced as `not_found` against a test that never existed.
+    #
+    # The argument is qualified and matched the way a plan declaration is (#163), so
+    # the plan's own spelling names the test it collected as; the collected id is what
+    # is stored, because outcome lookups compare against verdicts verbatim.
+    declared = _engine(worktree, cfg, ledger, run).declared_for(cycle["ordinal"])
+    wanted = Engine._qualify(declared, args.test) if declared else args.test
     known: set[str] = set()
+    target: str | None = None
     for name in json.loads(cycle["projects"]):
         adapter = adapters.build(cfg.project(name), worktree)
-        known |= adapter.collect().tests
-    if args.test not in known:
+        collected = adapter.collect().tests
+        known |= collected
+        norm = adapter.normalise_id(wanted)
+        target = target or next(
+            (t for t in sorted(collected) if adapter.normalise_id(t) == norm), None
+        )
+    if target is None:
         close = difflib.get_close_matches(args.test, sorted(known), n=3, cutoff=0.6)
         hint = f" Closest collected ids: {', '.join(close)}." if close else ""
         return failure(
@@ -1505,11 +1517,11 @@ def cmd_target(args) -> Envelope:
             f" the target was not changed.{hint}"
         )
 
-    ledger.update("cycle", cycle["id"], target_tests=json.dumps([args.test]))
-    ledger.event(run["id"], cycle["id"], "target_named_by_agent", args.test)
+    ledger.update("cycle", cycle["id"], target_tests=json.dumps([target]))
+    ledger.event(run["id"], cycle["id"], "target_named_by_agent", target)
     return Envelope(
         run={"id": run["id"], "cycle": cycle["ordinal"]},
-        result={"target": args.test},
+        result={"target": target},
         next_action=NextAction(Verb.REFACTOR_OR_ADVANCE, "Target set. `tdd advance`."),
     )
 

{tdd_cli-0.14.0 → tdd_cli-0.14.1}/tests/conftest.py

@@ -1,8 +1,11 @@
 from __future__ import annotations
 
+import json
 import os
 import pwd
+import shlex
 import subprocess
+import sys
 from pathlib import Path
 from types import SimpleNamespace
 
@@ -162,6 +165,36 @@ def repo(tmp_path, ledger_home):
     return root
 
 
+FAKE_VITEST = Path(__file__).parent / "fake_vitest.py"
+
+
+@pytest.fixture
+def repo_vitest(tmp_path, ledger_home):
+    """A git repo with one vitest project, `frontend`, driven by `fake_vitest.py`:
+    a named vitest project (`[core]`) whose runner is a Python script."""
+    root = tmp_path / "workspace"
+    (root / "frontend" / "src").mkdir(parents=True)
+    fake = f"{shlex.quote(sys.executable)} {shlex.quote(str(FAKE_VITEST))}"
+    (root / "tdd.toml").write_text(
+        "[project.frontend]\n"
+        'root            = "frontend"\n'
+        'adapter         = "vitest"\n'
+        'test_paths      = ["**/*.test.ts"]\n'
+        f"test_command    = {json.dumps(fake + ' run')}\n"
+        f"collect_command = {json.dumps(fake + ' list')}\n"
+        "lint            = []\n"
+        "typecheck       = []\n"
+    )
+    (root / "frontend" / "src" / "smoke.test.ts").write_text("case: smoke > works = pass\n")
+
+    subprocess.run(["git", "init", "-q", str(root)], check=True)
+    git(root, "config", "user.email", "test@example.com")
+    git(root, "config", "user.name", "Test")
+    git(root, "add", "-A")
+    git(root, "commit", "-q", "-m", "initial")
+    return root
+
+
 @pytest.fixture
 def repo_multi(repo, ledger_home):
     """`repo` plus an empty vitest `frontend` (a `package.json`, no test files).