@tencent-rtc/trtc-agent-skills 0.1.0

package/skills/trtc-topic/tests/test_session_resolver.py

@@ -0,0 +1,260 @@
+"""Regression tests for the session-path resolver shared by all topic CLIs.
+
+Background:
+    Before commit 1981bac, init_slice_queue.py / next_slice.py / apply.py
+    each computed their default `--session` path as `HERE.parents[4] /
+    ".trtc-session.yaml"` — i.e. the skill repo root. That's wrong:
+    `.trtc-session.yaml` lives in the *user project* (e.g. `demo-0518/`),
+    not in the skill repo. When AI ran the script from the user project
+    without passing `--session`, it errored with:
+
+        error: session file not found at <skill-repo>/.trtc-session.yaml
+
+    Fix: each CLI now resolves the session path the same way the
+    PreToolUse hooks already did:
+
+        1. --session flag, if given (explicit override)
+        2. $TRTC_SESSION_PATH env var
+        3. $CLAUDE_PROJECT_DIR/.trtc-session.yaml
+        4. ./.trtc-session.yaml (cwd fallback)
+
+These tests pin the chain so a future refactor can't silently break it
+again. We exercise the actual subprocess (not the import-level resolver)
+because the bug surfaced at the subprocess boundary — the shipped script
+is what AI invokes.
+"""
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+import yaml
+
+ROOT = Path(__file__).resolve().parents[1]
+INIT = ROOT / "scripts" / "init_slice_queue.py"
+NEXT = ROOT / "scripts" / "next_slice.py"
+APPLY = ROOT / "scripts" / "apply.py"
+
+
+def _seed_session(project_root: Path, confirmed_plan=None) -> Path:
+    """Drop a minimal .trtc-session.yaml into project_root and return its path."""
+    project_root.mkdir(parents=True, exist_ok=True)
+    session = project_root / ".trtc-session.yaml"
+    session.write_text(
+        yaml.safe_dump(
+            {
+                "schema_version": 1,
+                "status": "active",
+                "product": "conference",
+                "platform": "web",
+                "intent": "integrate-scenario",
+                "scenario": "general-conference",
+                "confirmed_plan": confirmed_plan or ["conference/login-auth"],
+                "project_state": {"project_root": str(project_root)},
+            },
+            sort_keys=False,
+            allow_unicode=True,
+        )
+    )
+    return session
+
+
+def _run(script: Path, *cli_args, cwd: Path, env: dict | None = None) -> subprocess.CompletedProcess:
+    """Run a topic CLI with a clean env (so parent-process env vars don't leak in)."""
+    base_env = {"PATH": "/usr/bin:/bin"}
+    if env:
+        base_env.update(env)
+    return subprocess.run(
+        [sys.executable, str(script), *map(str, cli_args)],
+        cwd=str(cwd),
+        text=True,
+        capture_output=True,
+        env=base_env,
+    )
+
+
+# ---------- Resolver chain --------------------------------------------------
+
+
+class TestSessionResolverChain:
+    """The four resolution paths, in priority order."""
+
+    def test_cwd_fallback_finds_session_in_user_project(self, tmp_path):
+        """AI's typical setup: cd to user project, no flag, no env vars.
+
+        This is the exact bug the user hit on demo-0518. Without the
+        cwd fallback, the script looked at the skill repo root and
+        errored.
+        """
+        project = tmp_path / "demo-0518"
+        _seed_session(project)
+
+        # No --session, no env vars, cwd = user project.
+        r = _run(INIT, cwd=project)
+        assert r.returncode == 0, (
+            f"cwd fallback should let init find ./trtc-session.yaml; "
+            f"stderr={r.stderr}"
+        )
+        assert "queue initialised" in r.stdout
+
+    def test_claude_project_dir_env_resolves_when_cwd_is_elsewhere(self, tmp_path):
+        """Claude Code sets $CLAUDE_PROJECT_DIR to the user project root.
+
+        The CLI must honour that even when AI's cwd is somewhere else
+        (e.g. the skill repo, or `/tmp`). We use init_slice_queue here
+        because its output is deterministic ("queue initialised — N slices");
+        next_slice.py status would also work but emits "queue not
+        initialised" — which would still prove session resolution worked,
+        but the assertion is fuzzier.
+        """
+        project = tmp_path / "user-proj"
+        _seed_session(project)
+
+        r = _run(
+            INIT,
+            cwd=tmp_path,  # not the project
+            env={"CLAUDE_PROJECT_DIR": str(project)},
+        )
+        assert r.returncode == 0, r.stderr
+        assert "queue initialised" in r.stdout
+        assert "conference/login-auth" in r.stdout
+
+    def test_trtc_session_path_env_wins_over_claude_project_dir(self, tmp_path):
+        """Explicit env var beats $CLAUDE_PROJECT_DIR.
+
+        Useful for tests, custom setups, multi-project workflows.
+        Strategy: point $TRTC_SESSION_PATH at a real session and
+        $CLAUDE_PROJECT_DIR at a project that *has no session file at all*.
+        If $CLAUDE_PROJECT_DIR is consulted first the script will error
+        with "session file not found"; if $TRTC_SESSION_PATH wins, init
+        succeeds.
+        """
+        real_project = tmp_path / "real"
+        _seed_session(real_project)
+        bogus_project = tmp_path / "bogus"
+        bogus_project.mkdir()  # exists but contains no .trtc-session.yaml
+
+        r = _run(
+            INIT,
+            cwd=tmp_path,
+            env={
+                "TRTC_SESSION_PATH": str(real_project / ".trtc-session.yaml"),
+                "CLAUDE_PROJECT_DIR": str(bogus_project),
+            },
+        )
+        assert r.returncode == 0, (
+            f"$TRTC_SESSION_PATH should take precedence; stderr={r.stderr}"
+        )
+        assert "queue initialised" in r.stdout
+
+    def test_explicit_session_flag_wins_over_envs(self, tmp_path):
+        """--session is the highest-priority override."""
+        real_project = tmp_path / "real"
+        _seed_session(real_project)
+
+        r = _run(
+            NEXT,
+            "--session",
+            str(real_project / ".trtc-session.yaml"),
+            "status",
+            cwd=tmp_path,
+            env={
+                "TRTC_SESSION_PATH": str(tmp_path / "nonexistent.yaml"),
+                "CLAUDE_PROJECT_DIR": str(tmp_path / "also-nonexistent"),
+            },
+        )
+        assert r.returncode == 0, (
+            f"--session flag should override env vars; stderr={r.stderr}"
+        )
+
+    def test_no_session_anywhere_errors_with_actionable_hint(self, tmp_path):
+        """When nothing resolves, the error must tell the user what to fix.
+
+        This replaces the silent skill-repo lookup that AI had no way to
+        diagnose.
+        """
+        empty_dir = tmp_path / "empty"
+        empty_dir.mkdir()
+
+        r = _run(NEXT, "status", cwd=empty_dir)
+        assert r.returncode == 1
+        # The error must point at the resolved path AND tell the user how
+        # to fix it. We check both halves so paraphrasing the message
+        # later doesn't drop the actionable bit.
+        assert "session file not found" in r.stderr
+        assert (
+            "CLAUDE_PROJECT_DIR" in r.stderr
+            or "TRTC_SESSION_PATH" in r.stderr
+            or "cd to the user project" in r.stderr
+        ), (
+            f"stderr should hint how to point the script at the session; "
+            f"got: {r.stderr}"
+        )
+
+
+# ---------- All three CLIs honour the chain ---------------------------------
+
+
+class TestAllCLIsUseSameResolver:
+    """Sanity check: init_slice_queue / next_slice / apply all behave the same.
+
+    They each reimplement `_resolve_session_path` (no shared module yet)
+    so we test all three to catch the case where one drifts.
+    """
+
+    @pytest.mark.parametrize("script,subcmd", [
+        (INIT, []),
+        (NEXT, ["status"]),
+    ])
+    def test_cli_finds_session_via_cwd(self, script, subcmd, tmp_path):
+        project = tmp_path / "user-proj"
+        _seed_session(project)
+        r = _run(script, *subcmd, cwd=project)
+        assert r.returncode == 0, f"{script.name}: {r.stderr}"
+
+    @pytest.mark.parametrize("script,subcmd", [
+        (INIT, []),
+        (NEXT, ["status"]),
+    ])
+    def test_cli_finds_session_via_claude_project_dir(self, script, subcmd, tmp_path):
+        project = tmp_path / "user-proj"
+        _seed_session(project)
+        r = _run(
+            script,
+            *subcmd,
+            cwd=tmp_path,
+            env={"CLAUDE_PROJECT_DIR": str(project)},
+        )
+        assert r.returncode == 0, f"{script.name}: {r.stderr}"
+
+    def test_apply_finds_session_via_cwd(self, tmp_path):
+        """apply.py needs more setup (state machine seeded to code_written)
+        before it'll do anything useful, so it gets its own test rather
+        than the parametrised pair above."""
+        project = tmp_path / "user-proj"
+        session = _seed_session(project)
+        # Seed state to code_written so apply.py reaches the project scan.
+        sys.path.insert(0, str(ROOT / "scripts" / "lib"))
+        try:
+            import state_machine
+            state_machine.init_queue(session)
+            state_machine.advance(session, "mark_slice_read")
+            state_machine.advance(session, "mark_code_written")
+        finally:
+            sys.path.pop(0)
+
+        # apply.py: no --session, no env, cwd = project. Should resolve
+        # session via cwd fallback. The actual apply result will be fail
+        # (no src/) — but rc != 2 (usage error), and importantly it does
+        # NOT error with "session file not found".
+        r = _run(APPLY, "--slice", "conference/login-auth", cwd=project)
+        assert "session file not found" not in r.stderr, (
+            f"apply.py should resolve session via cwd; got: {r.stderr}"
+        )
+        # rc 1 = apply fail (expected — no src/), rc 0 = apply pass
+        # (unexpected here), rc 2 = usage error (regression).
+        assert r.returncode in (0, 1), (
+            f"unexpected rc={r.returncode}; stderr={r.stderr}"
+        )

package/skills/trtc-topic/tests/test_state_machine.py

@@ -0,0 +1,414 @@
+"""Tests for the slice-loop state machine.
+
+Contract:
+    init_queue(session_path) -> None
+        Reads `confirmed_plan` from session, writes:
+            execution_queue: [{id, type, slices, status}, ...]
+            current_execution_index: 0
+            current_execution_state: not_started
+        Raises RuntimeError if confirmed_plan missing/empty.
+        Idempotent: repeat calls with same plan are no-ops; calls with a
+        different plan raise RuntimeError (the queue is frozen once set).
+
+    current_slice(session_path) -> (index, slice_id, state)
+        Returns the cursor. (None, None, None) if queue not initialised
+        (PreToolUse hooks rely on this to detect "not in topic flow").
+
+    advance(session_path, transition) -> new_state
+        Allowed transitions:
+            not_started   --mark_slice_read-->     slice_read
+            slice_read    --mark_code_written-->   code_written
+            code_written  --mark_apply_passed-->   apply_passed
+            code_written  --mark_apply_failed-->   apply_failed
+            apply_failed  --mark_code_written-->   code_written
+            apply_passed  --mark_user_confirmed--> not_started (index += 1)
+
+        At the end of the queue, advancing user_confirmed sets state to
+        all_done. Further transitions raise RuntimeError.
+
+        Any other (state, transition) pair raises RuntimeError.
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import pytest
+import yaml
+
+# state_machine lives in topic/scripts/lib/
+STATE_MACHINE_DIR = Path(__file__).resolve().parents[1] / "scripts" / "lib"
+sys.path.insert(0, str(STATE_MACHINE_DIR))
+import state_machine  # noqa: E402
+sys.path.pop(0)
+
+
+# ---------- init_queue ----------
+
+class TestInitQueue:
+    def test_writes_queue_index_and_state(self, session_factory):
+        path = session_factory()
+        state_machine.init_queue(path)
+        data = yaml.safe_load(path.read_text())
+        assert data["execution_queue"] == [
+            {"id": "conference/login-auth", "type": "slice", "title": "conference/login-auth", "status": "pending", "slices": ["conference/login-auth"]},
+            {"id": "conference/room-lifecycle", "type": "slice", "title": "conference/room-lifecycle", "status": "pending", "slices": ["conference/room-lifecycle"]},
+            {"id": "conference/participant-list", "type": "slice", "title": "conference/participant-list", "status": "pending", "slices": ["conference/participant-list"]},
+            {"id": "conference/video-layout", "type": "slice", "title": "conference/video-layout", "status": "pending", "slices": ["conference/video-layout"]},
+            {"id": "conference/device-control", "type": "slice", "title": "conference/device-control", "status": "pending", "slices": ["conference/device-control"]},
+            {"id": "conference/network-quality", "type": "slice", "title": "conference/network-quality", "status": "pending", "slices": ["conference/network-quality"]},
+        ]
+        assert data["current_execution_index"] == 0
+        assert data["current_execution_state"] == "not_started"
+
+    def test_raises_when_confirmed_plan_missing(self, session_factory):
+        path = session_factory(confirmed_plan=None)
+        with pytest.raises(RuntimeError, match="confirmed_plan"):
+            state_machine.init_queue(path)
+
+    def test_raises_when_confirmed_plan_empty(self, session_factory):
+        path = session_factory(confirmed_plan=[])
+        with pytest.raises(RuntimeError, match="confirmed_plan"):
+            state_machine.init_queue(path)
+
+    def test_idempotent_when_plan_unchanged(self, session_factory):
+        path = session_factory()
+        state_machine.init_queue(path)
+        # Advance once, so the cursor moves
+        state_machine.advance(path, "mark_slice_read")
+        # Calling init_queue again should NOT reset the cursor —
+        # the same plan is already installed.
+        state_machine.init_queue(path)
+        data = yaml.safe_load(path.read_text())
+        assert data["current_execution_state"] == "slice_read"
+        assert data["current_execution_index"] == 0
+
+    def test_raises_when_replan_differs(self, session_factory):
+        path = session_factory()
+        state_machine.init_queue(path)
+        # Mutate confirmed_plan and try to re-init — must refuse.
+        data = yaml.safe_load(path.read_text())
+        data["confirmed_plan"] = ["conference/login-auth"]
+        path.write_text(yaml.safe_dump(data, sort_keys=False))
+        with pytest.raises(RuntimeError, match="frozen|differs"):
+            state_machine.init_queue(path)
+
+
+class TestInitDeliveryUnitQueue:
+    def test_unit_mode_groups_confirmed_plan_without_adding_slices(self, session_factory):
+        path = session_factory(
+            execution_granularity="unit",
+            confirmed_plan=[
+                "conference/login-auth",
+                "conference/room-lifecycle",
+                "conference/video-layout",
+                "conference/device-control",
+                "conference/room-chat",
+            ],
+        )
+        state_machine.init_queue(path)
+        data = yaml.safe_load(path.read_text())
+
+        assert [step["slices"] for step in data["execution_queue"]] == [
+            ["conference/login-auth", "conference/room-lifecycle"],
+            ["conference/video-layout"],
+            ["conference/device-control"],
+            ["conference/room-chat"],
+        ]
+        flattened = [
+            sid
+            for step in data["execution_queue"]
+            for sid in step["slices"]
+        ]
+        assert flattened == data["confirmed_plan"]
+        assert data["current_execution_index"] == 0
+        assert data["current_execution_state"] == "not_started"
+
+    def test_unit_mode_respects_declared_units_and_fills_missing_singletons(self, session_factory):
+        path = session_factory(
+            execution_granularity="unit",
+            confirmed_plan=[
+                "conference/login-auth",
+                "conference/room-lifecycle",
+                "conference/screen-share",
+            ],
+            delivery_units=[
+                {
+                    "id": "foundation",
+                    "title": "基础链路",
+                    "slices": ["conference/login-auth", "conference/room-lifecycle"],
+                }
+            ],
+        )
+        state_machine.init_queue(path)
+        data = yaml.safe_load(path.read_text())
+        assert [step["id"] for step in data["execution_queue"]] == [
+            "foundation",
+            "conference/screen-share",
+        ]
+        assert data["execution_queue"][1]["slices"] == ["conference/screen-share"]
+
+    def test_unit_mode_without_scenario_config_uses_singletons(self, session_factory):
+        path = session_factory(
+            scenario="custom-scenario-without-unit-config",
+            execution_granularity="unit",
+            confirmed_plan=[
+                "conference/login-auth",
+                "conference/room-lifecycle",
+            ],
+        )
+        state_machine.init_queue(path)
+        data = yaml.safe_load(path.read_text())
+        assert [step["type"] for step in data["execution_queue"]] == ["slice", "slice"]
+        assert [step["slices"] for step in data["execution_queue"]] == [
+            ["conference/login-auth"],
+            ["conference/room-lifecycle"],
+        ]
+
+
+# ---------- current_slice ----------
+
+class TestCurrentSlice:
+    def test_returns_none_tuple_before_init(self, session_factory):
+        path = session_factory()
+        assert state_machine.current_slice(path) == (None, None, None)
+
+    def test_returns_first_slice_after_init(self, session_factory):
+        path = session_factory()
+        state_machine.init_queue(path)
+        assert state_machine.current_slice(path) == (
+            0,
+            "conference/login-auth",
+            "not_started",
+        )
+
+    def test_returns_none_when_session_missing(self, tmp_path):
+        path = tmp_path / "missing.yaml"
+        assert state_machine.current_slice(path) == (None, None, None)
+
+    def test_current_scope_reports_unit_slice_ids(self, session_factory):
+        path = session_factory(
+            execution_granularity="unit",
+            confirmed_plan=["conference/login-auth", "conference/room-lifecycle"],
+        )
+        state_machine.init_queue(path)
+        scope = state_machine.current_scope(path)
+        assert scope["kind"] == "unit"
+        assert scope["id"] == "foundation"
+        assert scope["slice_ids"] == [
+            "conference/login-auth",
+            "conference/room-lifecycle",
+        ]
+
+
+# ---------- advance ----------
+
+class TestAdvanceHappyPath:
+    def test_full_cycle_advances_index(self, session_factory):
+        path = session_factory()
+        state_machine.init_queue(path)
+
+        assert state_machine.advance(path, "mark_slice_read") == "slice_read"
+        assert state_machine.advance(path, "mark_code_written") == "code_written"
+        assert state_machine.advance(path, "mark_apply_passed") == "apply_passed"
+        assert state_machine.advance(path, "mark_user_confirmed") == "not_started"
+
+        idx, sid, st = state_machine.current_slice(path)
+        assert idx == 1
+        assert sid == "conference/room-lifecycle"
+        assert st == "not_started"
+
+    def test_apply_failed_then_retry(self, session_factory):
+        path = session_factory()
+        state_machine.init_queue(path)
+        state_machine.advance(path, "mark_slice_read")
+        state_machine.advance(path, "mark_code_written")
+        assert state_machine.advance(path, "mark_apply_failed") == "apply_failed"
+        # Retry: regenerate code, mark code_written again
+        assert state_machine.advance(path, "mark_code_written") == "code_written"
+        assert state_machine.advance(path, "mark_apply_passed") == "apply_passed"
+
+    def test_reaches_all_done_on_last_confirm(self, session_factory):
+        path = session_factory(confirmed_plan=["conference/login-auth"])
+        state_machine.init_queue(path)
+        state_machine.advance(path, "mark_slice_read")
+        state_machine.advance(path, "mark_code_written")
+        state_machine.advance(path, "mark_apply_passed")
+        # Last slice — confirming should reach all_done, not advance index.
+        assert state_machine.advance(path, "mark_user_confirmed") == "all_done"
+
+    def test_marks_completed_slices_in_queue(self, session_factory):
+        """execution_queue[i].status flips pending → done as we confirm each."""
+        path = session_factory()
+        state_machine.init_queue(path)
+        state_machine.advance(path, "mark_slice_read")
+        state_machine.advance(path, "mark_code_written")
+        state_machine.advance(path, "mark_apply_passed")
+        state_machine.advance(path, "mark_user_confirmed")
+        data = yaml.safe_load(path.read_text())
+        assert data["execution_queue"][0]["status"] == "done"
+        assert data["execution_queue"][1]["status"] == "pending"
+
+    def test_unit_cycle_marks_all_slices_in_unit_done(self, session_factory):
+        path = session_factory(
+            execution_granularity="unit",
+            confirmed_plan=[
+                "conference/login-auth",
+                "conference/room-lifecycle",
+                "conference/room-chat",
+            ],
+        )
+        state_machine.init_queue(path)
+        state_machine.advance(path, "mark_slice_read")
+        state_machine.advance(path, "mark_code_written")
+        state_machine.advance(path, "mark_apply_passed")
+        assert state_machine.advance(path, "mark_user_confirmed") == "not_started"
+
+        data = yaml.safe_load(path.read_text())
+        assert data["execution_queue"][0]["status"] == "done"
+        assert data["execution_queue"][1]["status"] == "pending"
+
+
+class TestAdvanceIllegalTransitions:
+    @pytest.mark.parametrize("bad_transition", [
+        # From not_started: only mark_slice_read is legal.
+        "mark_code_written",
+        "mark_apply_passed",
+        "mark_apply_failed",
+        "mark_user_confirmed",
+    ])
+    def test_not_started_rejects(self, session_factory, bad_transition):
+        path = session_factory()
+        state_machine.init_queue(path)
+        with pytest.raises(RuntimeError):
+            state_machine.advance(path, bad_transition)
+
+    def test_slice_read_rejects_apply(self, session_factory):
+        path = session_factory()
+        state_machine.init_queue(path)
+        state_machine.advance(path, "mark_slice_read")
+        with pytest.raises(RuntimeError):
+            state_machine.advance(path, "mark_apply_passed")
+
+    def test_apply_passed_rejects_repeat_apply(self, session_factory):
+        path = session_factory()
+        state_machine.init_queue(path)
+        state_machine.advance(path, "mark_slice_read")
+        state_machine.advance(path, "mark_code_written")
+        state_machine.advance(path, "mark_apply_passed")
+        with pytest.raises(RuntimeError):
+            state_machine.advance(path, "mark_apply_passed")
+
+    def test_unknown_transition_name(self, session_factory):
+        path = session_factory()
+        state_machine.init_queue(path)
+        with pytest.raises(RuntimeError, match="unknown"):
+            state_machine.advance(path, "mark_lunch_break")
+
+    def test_advance_before_init_raises(self, session_factory):
+        path = session_factory()
+        with pytest.raises(RuntimeError, match="not initialised|init_queue"):
+            state_machine.advance(path, "mark_slice_read")
+
+    def test_advance_after_all_done_raises(self, session_factory):
+        path = session_factory(confirmed_plan=["conference/login-auth"])
+        state_machine.init_queue(path)
+        state_machine.advance(path, "mark_slice_read")
+        state_machine.advance(path, "mark_code_written")
+        state_machine.advance(path, "mark_apply_passed")
+        state_machine.advance(path, "mark_user_confirmed")  # all_done
+        with pytest.raises(RuntimeError, match="all_done|finished|complete"):
+            state_machine.advance(path, "mark_slice_read")
+
+
+# ---------- Evidence auto-delete on user confirm ----------
+#
+# Successful slices' evidence JSON is deleted by mark_user_confirmed so the
+# .trtc-apply-evidence/ directory ends a clean integration empty. Failed
+# evidence is preserved (the slice still needs work; the next apply.py call
+# will overwrite it).
+
+import json
+
+
+class TestEvidenceCleanup:
+    def _evidence_path(self, session_path, slice_id):
+        return session_path.parent / ".trtc-apply-evidence" / (
+            slice_id.replace("/", "__") + ".json"
+        )
+
+    def _seed_evidence(self, session_path, slice_id, status="pass"):
+        ev = self._evidence_path(session_path, slice_id)
+        ev.parent.mkdir(parents=True, exist_ok=True)
+        ev.write_text(json.dumps({"slice_id": slice_id, "status": status}))
+        return ev
+
+    def test_mark_user_confirmed_deletes_evidence(self, session_factory):
+        path = session_factory()
+        state_machine.init_queue(path)
+        state_machine.advance(path, "mark_slice_read")
+        state_machine.advance(path, "mark_code_written")
+        state_machine.advance(path, "mark_apply_passed")
+
+        ev = self._seed_evidence(path, "conference/login-auth")
+        assert ev.exists()
+
+        state_machine.advance(path, "mark_user_confirmed")
+        assert not ev.exists(), "evidence should be deleted on confirm"
+
+    def test_mark_user_confirmed_handles_missing_evidence(self, session_factory):
+        """No evidence file → confirm still succeeds (no exception)."""
+        path = session_factory()
+        state_machine.init_queue(path)
+        state_machine.advance(path, "mark_slice_read")
+        state_machine.advance(path, "mark_code_written")
+        state_machine.advance(path, "mark_apply_passed")
+
+        # Don't seed an evidence file.
+        ev = self._evidence_path(path, "conference/login-auth")
+        assert not ev.exists()
+
+        new_state = state_machine.advance(path, "mark_user_confirmed")
+        assert new_state == "not_started"
+
+    def test_apply_failed_evidence_not_deleted(self, session_factory):
+        """apply_failed → mark_code_written retry → next apply overwrites.
+
+        We don't get to mark_user_confirmed in this path, so evidence stays.
+        Confirms the cleanup is bound to confirm, not to advance-in-general.
+        """
+        path = session_factory()
+        state_machine.init_queue(path)
+        state_machine.advance(path, "mark_slice_read")
+        state_machine.advance(path, "mark_code_written")
+        state_machine.advance(path, "mark_apply_failed")
+
+        ev = self._seed_evidence(path, "conference/login-auth", status="fail")
+        assert ev.exists()
+
+        # Retry: regenerate code → mark_code_written. Evidence still there.
+        state_machine.advance(path, "mark_code_written")
+        assert ev.exists(), "fail-evidence must persist across retries"
+
+    def test_evidence_deleted_for_each_slice_in_sequence(self, session_factory):
+        """Two slices, both confirmed → both evidence files gone."""
+        path = session_factory(
+            confirmed_plan=["conference/login-auth", "conference/room-lifecycle"]
+        )
+        state_machine.init_queue(path)
+
+        # Slice 0
+        state_machine.advance(path, "mark_slice_read")
+        state_machine.advance(path, "mark_code_written")
+        state_machine.advance(path, "mark_apply_passed")
+        ev0 = self._seed_evidence(path, "conference/login-auth")
+        state_machine.advance(path, "mark_user_confirmed")
+        assert not ev0.exists()
+
+        # Slice 1
+        state_machine.advance(path, "mark_slice_read")
+        state_machine.advance(path, "mark_code_written")
+        state_machine.advance(path, "mark_apply_passed")
+        ev1 = self._seed_evidence(path, "conference/room-lifecycle")
+        state_machine.advance(path, "mark_user_confirmed")
+        assert not ev1.exists()