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

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

@@ -6,6 +6,25 @@ and the project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [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.0}/PKG-INFO

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

{tdd_cli-0.11.0 → tdd_cli-0.12.0}/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.0}/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.0"

{tdd_cli-0.11.0 → tdd_cli-0.12.0}/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.0}/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.0}/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.0}/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.12.0/tests/test_close_sweep_gates.py

@@ -0,0 +1,361 @@
+"""Close-sweep gate ordering and short-circuit (issue #129)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from conftest import git, run_cli, write_plan
+from tddcli import gitutil
+from tddcli.ledger import Ledger
+
+# ── inner plan used by every test to reach the close sweep ────────────────────
+
+SIMPLE_PLAN = """---
+cycles:
+  - n: 1
+    project: backend
+    title: "basic pass"
+    test: "tests/test_gate_probe.py::test_gate_probe"
+    stub_expected: ["app/probe.py"]
+    commit_red: "test: gate probe"
+    commit_green: "feat: gate probe"
+---
+"""
+
+_TEST = """\
+from app.probe import probe
+
+
+def test_gate_probe():
+    assert probe() == 42
+"""
+
+_STUB = "def probe():\n    raise NotImplementedError\n"
+_IMPL = "def probe():\n    return 42\n"
+
+
+def _toml(lint_cmds: list[str], typecheck_cmds: list[str] | None = None) -> str:
+    tc = typecheck_cmds if typecheck_cmds is not None else []
+    return (
+        "[project.backend]\n"
+        'root       = "backend"\n'
+        'adapter    = "pytest"\n'
+        'test_paths = ["tests/"]\n'
+        f"lint       = {lint_cmds!r}\n"
+        f"typecheck  = {tc!r}\n"
+    )
+
+
+def _drive_to_close(
+    repo: Path,
+    lint_cmds: list[str] | None = None,
+    typecheck_cmds: list[str] | None = None,
+    project: str = "backend",
+) -> dict:
+    """Drive a single-cycle inner plan through RED → GREEN and return the
+    close-sweep envelope (the advance at AWAITING_REFACTOR)."""
+    lint = lint_cmds if lint_cmds is not None else []
+    (repo / "tdd.toml").write_text(_toml(lint, typecheck_cmds))
+    git(repo, "add", "-A")
+    git(repo, "commit", "-q", "-m", "configure gates")
+
+    plan = write_plan(repo, SIMPLE_PLAN)
+    assert run_cli(repo, "plan", "register", plan)["ok"]
+    assert run_cli(repo, "run", "start", "--plan", plan)["ok"]
+
+    # RED: write test + stub so the test collects but fails
+    (repo / project / "tests" / "test_gate_probe.py").write_text(_TEST)
+    (repo / project / "app" / "probe.py").write_text(_STUB)
+    adv = run_cli(repo, "advance")
+    assert adv["next_action"]["verb"] == "write_implementation", adv
+
+    # GREEN: write real implementation
+    (repo / project / "app" / "probe.py").write_text(_IMPL)
+    adv = run_cli(repo, "advance")
+    assert adv["next_action"]["verb"] == "refactor_or_advance", adv
+
+    # Advance at AWAITING_REFACTOR → triggers the close sweep
+    return run_cli(repo, "advance")
+
+
+# ── cycle 1 ── pin: a failing gate replies fix_regression with that gate's entry
+
+
+def test_failing_lint_replies_fix_regression_with_the_lint_gate(repo):
+    out = _drive_to_close(repo, lint_cmds=["sh -c 'exit 1'"])
+    verb = out["next_action"]["verb"]
+    gates = out.get("result", {}).get("gates", [])
+    assert (verb, [(g["project"], g["kind"]) for g in gates]) == (
+        "fix_regression",
+        [("backend", "lint")],
+    )
+
+
+# ── cycle 2 ── pin: a gate that ran records a gate_result row
+
+
+def test_a_failing_lint_records_its_gate_result_row(repo):
+    out = _drive_to_close(repo, lint_cmds=["sh -c 'exit 1'"])
+    run_id = out["run"]["id"]
+    led = Ledger(gitutil.repo_identity(repo))
+    rows = led.all(
+        "SELECT * FROM gate_result WHERE run_id = ? AND project = 'backend' AND kind = 'lint'",
+        (run_id,),
+    )
+    assert any(r["ok"] == 0 for r in rows)
+
+
+# ── cycle 3 ── _gate stops at the first failing command
+
+
+def test_gate_stops_at_the_first_failing_command(repo):
+    lint_cmds = [
+        "sh -c 'echo LINT-BOOM; exit 1'",
+        "sh -c 'echo SECOND-RAN; exit 1'",
+    ]
+    out = _drive_to_close(repo, lint_cmds=lint_cmds)
+    gates = out.get("result", {}).get("gates", [])
+    lint_gate = next((g for g in gates if g["kind"] == "lint"), None)
+    assert lint_gate is not None
+    assert "SECOND-RAN" not in lint_gate["output"]
+
+
+# ── cycle 4 ── a failing lint means typecheck is never run
+
+
+def test_a_failing_lint_stops_the_gate_pass_before_typecheck(repo, tmp_path):
+    counter = tmp_path / "typecheck-ran"
+    typecheck_cmds = [f"sh -c 'echo ran >> {counter}; exit 1'"]
+    _drive_to_close(repo, lint_cmds=["sh -c 'exit 1'"], typecheck_cmds=typecheck_cmds)
+    assert not counter.exists()
+
+
+# ── cycle 5 ── a failing gate short-circuits the sweep before any suite runs
+
+
+def test_a_failing_gate_runs_no_suite(repo):
+    out = _drive_to_close(repo, lint_cmds=["sh -c 'exit 1'"])
+    run_id = out["run"]["id"]
+    led = Ledger(gitutil.repo_identity(repo))
+    rows = led.all(
+        "SELECT * FROM invocation WHERE run_id = ? AND phase_at = 'CLOSE_SWEEP'",
+        (run_id,),
+    )
+    assert len(rows) == 0
+
+
+# ── cycle 6 ── every sweep project's gates run before any project's suite
+
+_THREE_PLAN = """\
+---
+cycles:
+  - n: 1
+    project: backend
+    title: "basic pass"
+    test: "tests/test_gate_probe.py::test_gate_probe"
+    stub_expected: ["app/probe.py"]
+    commit_red: "test: gate probe"
+    commit_green: "feat: gate probe"
+---
+"""
+
+
+def test_a_later_projects_failing_gate_runs_no_earlier_suite(repo_three):
+    # Rewrite tdd.toml: backend has no lint, svc has a failing lint.
+    (repo_three / "tdd.toml").write_text(
+        "[project.backend]\n"
+        'root       = "backend"\n'
+        'adapter    = "pytest"\n'
+        'test_paths = ["tests/"]\n'
+        "\n"
+        "[project.svc]\n"
+        'root       = "svc"\n'
+        'adapter    = "pytest"\n'
+        'test_paths = ["tests/"]\n'
+        "lint       = [\"sh -c 'exit 1'\"]\n"
+        "typecheck  = []\n"
+        "\n"
+        "[project.other]\n"
+        'root       = "other"\n'
+        'adapter    = "pytest"\n'
+        'test_paths = ["tests/"]\n'
+        "\n"
+        "[artifact.schema]\n"
+        'path        = "backend/schema.json"\n'
+        'produced_by = "backend"\n'
+        'consumed_by = ["svc"]\n'
+        'regenerate  = "true"\n'
+    )
+    git(repo_three, "add", "-A")
+    git(repo_three, "commit", "-q", "-m", "configure svc lint")
+
+    plan = write_plan(repo_three, _THREE_PLAN)
+    assert run_cli(repo_three, "plan", "register", plan)["ok"]
+    assert run_cli(repo_three, "run", "start", "--plan", plan)["ok"]
+
+    # RED: test + stub
+    (repo_three / "backend" / "tests" / "test_gate_probe.py").write_text(_TEST)
+    (repo_three / "backend" / "app" / "probe.py").write_text(_STUB)
+    adv = run_cli(repo_three, "advance")
+    assert adv["next_action"]["verb"] == "write_implementation", adv
+
+    # GREEN: real implementation
+    (repo_three / "backend" / "app" / "probe.py").write_text(_IMPL)
+    adv = run_cli(repo_three, "advance")
+    assert adv["next_action"]["verb"] == "refactor_or_advance", adv
+
+    # Modify backend/schema.json (dirty) → pulls svc into the close sweep
+    (repo_three / "backend" / "schema.json").write_text('{"version": 2}\n')
+
+    # Advance at AWAITING_REFACTOR → svc's lint fails → no suite runs
+    out = run_cli(repo_three, "advance")
+
+    run_id = out["run"]["id"]
+    led = Ledger(gitutil.repo_identity(repo_three))
+    rows = led.all(
+        "SELECT * FROM invocation WHERE run_id = ? AND phase_at = 'CLOSE_SWEEP' AND project = 'backend'",
+        (run_id,),
+    )
+    assert len(rows) == 0
+
+
+# ── cycle 7 ── the gate-failure reply does not claim the sweep is green
+
+
+def test_the_gate_failure_reply_does_not_claim_the_sweep_is_green(repo):
+    out = _drive_to_close(repo, lint_cmds=["sh -c 'exit 1'"])
+    assert out["next_action"]["detail"] == (
+        "Close sweep stopped before the suite: lint/typecheck gates failed."
+    )
+
+
+# ── cycle 8 ── pin: a gate that failed is re-run at the same tree
+
+
+def test_a_failed_gate_is_rerun_at_the_same_tree(repo, tmp_path):
+    counter = tmp_path / "lint-count"
+    lint_cmds = [f"sh -c 'echo x >> {counter}; exit 1'"]
+    _drive_to_close(repo, lint_cmds=lint_cmds)
+    # Advance again at AWAITING_REFACTOR with nothing edited (same tree) → gate re-runs
+    run_cli(repo, "advance")
+    assert counter.read_text().count("\n") == 2
+
+
+# ── cycle 9 ── pin: a gate is re-run when its project tree changed
+
+
+def test_a_gate_is_rerun_when_the_tree_changed(repo, tmp_path):
+    """Lint passes but suite fails first time; tree changes; lint runs again second time."""
+    counter = tmp_path / "lint-count"
+    lint_cmds = [f"sh -c 'echo x >> {counter}'"]  # exits 0 (passes)
+
+    # Set up a failing test that will be in the close sweep
+    (repo / "tdd.toml").write_text(_toml(lint_cmds))
+    git(repo, "add", "-A")
+    git(repo, "commit", "-q", "-m", "configure gates")
+
+    plan = write_plan(repo, SIMPLE_PLAN)
+    assert run_cli(repo, "plan", "register", plan)["ok"]
+    assert run_cli(repo, "run", "start", "--plan", plan)["ok"]
+
+    # RED
+    (repo / "backend" / "tests" / "test_gate_probe.py").write_text(_TEST)
+    (repo / "backend" / "app" / "probe.py").write_text(_STUB)
+    adv = run_cli(repo, "advance")
+    assert adv["next_action"]["verb"] == "write_implementation", adv
+
+    # GREEN
+    (repo / "backend" / "app" / "probe.py").write_text(_IMPL)
+    adv = run_cli(repo, "advance")
+    assert adv["next_action"]["verb"] == "refactor_or_advance", adv
+
+    # First close: add a failing test → lint passes but suite fails
+    (repo / "backend" / "tests" / "test_fail.py").write_text("def test_fail():\n    assert False\n")
+    out1 = run_cli(repo, "advance")
+    assert out1["next_action"]["verb"] == "fix_regression", out1
+
+    # Fix the failing test → tree changes → second close: lint re-runs
+    (repo / "backend" / "tests" / "test_fail.py").write_text("def test_fail():\n    assert True\n")
+    out2 = run_cli(repo, "advance")
+    assert out2["next_action"]["verb"] != "fix_regression" or out2.get("result", {}).get("gates"), (
+        out2
+    )
+
+    assert counter.read_text().count("\n") == 2
+
+
+# ── cycle 11 ── a gate that passed at this tree hash is not re-executed
+
+
+def test_a_passing_gate_is_not_reexecuted_at_an_unchanged_tree(repo, tmp_path):
+    """Lint passes first close; suite fails first close; tree unchanged for second close →
+    lint should be skipped the second time."""
+    counter = tmp_path / "lint-count"
+    lint_cmds = [f"sh -c 'echo x >> {counter}'"]  # exits 0 (passes)
+
+    (repo / "tdd.toml").write_text(_toml(lint_cmds))
+    git(repo, "add", "-A")
+    git(repo, "commit", "-q", "-m", "configure gates")
+
+    plan = write_plan(repo, SIMPLE_PLAN)
+    assert run_cli(repo, "plan", "register", plan)["ok"]
+    assert run_cli(repo, "run", "start", "--plan", plan)["ok"]
+
+    # RED/GREEN
+    (repo / "backend" / "tests" / "test_gate_probe.py").write_text(_TEST)
+    (repo / "backend" / "app" / "probe.py").write_text(_STUB)
+    assert run_cli(repo, "advance")["next_action"]["verb"] == "write_implementation"
+    (repo / "backend" / "app" / "probe.py").write_text(_IMPL)
+    assert run_cli(repo, "advance")["next_action"]["verb"] == "refactor_or_advance"
+
+    # First close: add failing test (dirty) → lint passes, suite fails
+    (repo / "backend" / "tests" / "test_fail.py").write_text("def test_fail():\n    assert False\n")
+    out1 = run_cli(repo, "advance")
+    assert out1["next_action"]["verb"] == "fix_regression", out1
+
+    # Second close: no change to tree → lint should be skipped
+    run_cli(repo, "advance")
+    # (could be fix_regression again due to suite failure, but lint must NOT re-run)
+
+    assert counter.read_text().count("\n") == 1
+
+
+# ── cycle 12 ── a skipped gate still records a gate_result row, marked skipped
+
+
+def test_a_skipped_gate_records_a_skipped_row(repo, tmp_path):
+    """Same scenario as cycle 11: lint passes first close, skipped second close.
+    The second gate_result row must have skipped=1."""
+    counter = tmp_path / "lint-count"
+    lint_cmds = [f"sh -c 'echo x >> {counter}'"]
+
+    (repo / "tdd.toml").write_text(_toml(lint_cmds))
+    git(repo, "add", "-A")
+    git(repo, "commit", "-q", "-m", "configure gates")
+
+    plan = write_plan(repo, SIMPLE_PLAN)
+    assert run_cli(repo, "plan", "register", plan)["ok"]
+    assert run_cli(repo, "run", "start", "--plan", plan)["ok"]
+
+    # RED/GREEN
+    (repo / "backend" / "tests" / "test_gate_probe.py").write_text(_TEST)
+    (repo / "backend" / "app" / "probe.py").write_text(_STUB)
+    assert run_cli(repo, "advance")["next_action"]["verb"] == "write_implementation"
+    (repo / "backend" / "app" / "probe.py").write_text(_IMPL)
+    assert run_cli(repo, "advance")["next_action"]["verb"] == "refactor_or_advance"
+
+    # First close: failing test (dirty) → lint passes
+    (repo / "backend" / "tests" / "test_fail.py").write_text("def test_fail():\n    assert False\n")
+    out1 = run_cli(repo, "advance")
+    run_id = out1["run"]["id"]
+    assert out1["next_action"]["verb"] == "fix_regression", out1
+
+    # Second close: no tree change → lint skipped
+    run_cli(repo, "advance")
+
+    led = Ledger(gitutil.repo_identity(repo))
+    rows = led.all(
+        "SELECT skipped FROM gate_result WHERE run_id = ? AND project = 'backend' AND kind = 'lint' ORDER BY id",
+        (run_id,),
+    )
+    assert [r["skipped"] for r in rows] == [0, 1]

{tdd_cli-0.11.0 → tdd_cli-0.12.0}/tests/test_release_surface.py

@@ -197,3 +197,22 @@ def test_run_gains_start_sha_column(tmp_path, ledger_home):
     reopened = Ledger(tmp_path / "somerepo")
     cols2 = {r[1] for r in reopened.db.execute("PRAGMA table_info(run)").fetchall()}
     assert "start_sha" in cols2
+
+
+def test_gate_result_gains_tree_hash_and_skipped_columns(tmp_path, ledger_home):
+    # Fresh ledger: both columns must exist in CREATE TABLE
+    ledger = Ledger(tmp_path / "somerepo")
+    cols = {r[1] for r in ledger.db.execute("PRAGMA table_info(gate_result)").fetchall()}
+    assert "tree_hash" in cols
+    assert "skipped" in cols
+
+    # Migration path: force back to v10 (before these columns), drop them, reopen
+    ledger._write("UPDATE meta SET value = '10' WHERE key = 'schema_version'", ())
+    ledger.db.execute("ALTER TABLE gate_result DROP COLUMN tree_hash")
+    ledger.db.execute("ALTER TABLE gate_result DROP COLUMN skipped")
+    ledger.db.close()
+
+    reopened = Ledger(tmp_path / "somerepo")
+    cols2 = {r[1] for r in reopened.db.execute("PRAGMA table_info(gate_result)").fetchall()}
+    assert "tree_hash" in cols2
+    assert "skipped" in cols2