Address remaining review comments: patch-path validation, CI clean-tree check

- Validate each patch path in the interactive TUI stepper before handing it
  to Patch.from_file, mirroring SubProject._apply_patches' own skip checks
  (missing file, or outside the current directory). A rejected patch logs
  a warning and the step still advances, rather than crashing or silently
  applying an unvalidated path. Filtering the patch list up front was
  tried first but rejected: it shrinks the reported total, which threw off
  the fully-patched restore-path decision in combined mode.
- CI: verify dfetch replay-patches actually leaves the working tree
  unchanged (snapshot git status before/after) instead of just checking it
  exits 0, in both the cygwin and the OS/Python matrix jobs. Runs under
  shell: bash explicitly so the check is identical on Windows (Git Bash)
  and Linux/macOS; verified against a real replay-patches run.

Left unfixed with reasoning:
- security/tm_usage.py's "preserve pre-existing staged changes" comment:
  verified against current code -- _can_review_project already calls
  has_local_changes_in_dir before staging, which skips any project with
  staged OR unstaged changes, so there's never a pre-existing staged state
  to lose. False positive; the reviewer's own analysis was scoped to
  replay_patches.py and git.py only, missing this upstream guard.
- The dfetch.terminal import "layer violation": already verified in an
  earlier round -- pyproject.toml's actual enforced import-linter contract
  places dfetch.terminal in the same bottom layer as util/log, and
  lint-imports passes. The reviewer's guideline source (AGENTS.md's prose
  diagram) just omits it from the list.
- Generalizing asciinema's exit-status propagation across all ~19
  generate-casts.sh demo scripts: out of scope for this PR, which only
  fixed it for the two replay-patches demos it adds.

Verified: 734 unit tests, ruff/pylint/mypy/pydocstyle/bandit/lint-imports,
git+SVN replay-patches BDD scenarios, and the new CI check against a real
replay-patches run all pass.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01A7miizBGMoLEXXZxuq6XUJ

Author: claude

.github/workflows/run.yml

@@ -66,7 +66,17 @@ jobs:
       - run: dfetch update
       - run: dfetch update
       - run: dfetch update-patch
-      - run: dfetch replay-patches
+      - name: Verify replay-patches restores a clean working tree
+        shell: bash
+        run: |
+          before="$(git status --porcelain)"
+          dfetch replay-patches
+          after="$(git status --porcelain)"
+          if [ "$before" != "$after" ]; then
+            echo "::error::dfetch replay-patches left the working tree changed"
+            git status
+            exit 1
+          fi
       - run: dfetch format-patch
       - run: dfetch report -t sbom
       - run: dfetch remove test-repo
@@ -212,7 +222,17 @@ jobs:
       - run: dfetch update
       - run: dfetch update
       - run: dfetch update-patch
-      - run: dfetch replay-patches
+      - name: Verify replay-patches restores a clean working tree
+        shell: bash
+        run: |
+          before="$(git status --porcelain)"
+          dfetch replay-patches
+          after="$(git status --porcelain)"
+          if [ "$before" != "$after" ]; then
+            echo "::error::dfetch replay-patches left the working tree changed"
+            git status
+            exit 1
+          fi
       - run: dfetch format-patch
       - run: dfetch report -t sbom
       - run: dfetch remove test-repo

dfetch/commands/replay_patches.py

@@ -284,6 +284,22 @@ def _can_review_project(
     return True
 
 
+def _is_safe_patch_path(patch: str) -> bool:
+    """Return False for a patch that ``SubProject._apply_patches`` would have skipped.
+
+    Mirrors its checks (stays within the current directory, and exists) so
+    the interactive stepper never hands ``Patch.from_file`` a path that the
+    non-interactive apply would have silently skipped instead.
+    """
+    cwd = Path.cwd()
+    patch_path = (cwd / patch).resolve()
+    try:
+        patch_path.relative_to(cwd)
+    except ValueError:
+        return False
+    return patch_path.exists()
+
+
 def _apply_review(
     subproject: SubProject,
     project_name: str,
@@ -509,12 +525,20 @@ def _apply_step(
 ) -> tuple[int, bool]:
     """Handle one keypress; return (new_current, done)."""
     if key == "LEFT" and current > 0:
-        with _silent_patch_ng():
-            Patch.from_file(patches[current - 1]).reverse().apply(root=local_path)
+        patch = patches[current - 1]
+        if _is_safe_patch_path(patch):
+            with _silent_patch_ng():
+                Patch.from_file(patch).reverse().apply(root=local_path)
+        else:
+            logger.warning(f'Skipping patch "{patch}": missing or outside {Path.cwd()}')
         return current - 1, False
     if key == "RIGHT" and current < total:
-        with _silent_patch_ng():
-            Patch.from_file(patches[current]).apply(root=local_path)
+        patch = patches[current]
+        if _is_safe_patch_path(patch):
+            with _silent_patch_ng():
+                Patch.from_file(patch).apply(root=local_path)
+        else:
+            logger.warning(f'Skipping patch "{patch}": missing or outside {Path.cwd()}')
         return current + 1, False
     if key in ("ENTER", "ESC"):
         return current, True

tests/test_replay_patches.py

@@ -431,3 +431,30 @@ def test_stage_one_restores_worktree_on_add_path_failure():
 
     sub_a.update.assert_called_once()
     fake_super.restore_from_head.assert_called_once_with("proj_a")
+
+
+def test_is_safe_patch_path_rejects_missing_and_outside_root():
+    """A missing patch, or one outside cwd, is rejected rather than handed to Patch.from_file."""
+    from dfetch.commands.replay_patches import _is_safe_patch_path
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        with patch("pathlib.Path.cwd", return_value=Path(tmpdir)):
+            (Path(tmpdir) / "patches").mkdir()
+            (Path(tmpdir) / "patches" / "real.patch").write_text("diff")
+
+            assert _is_safe_patch_path("patches/real.patch") is True
+            assert _is_safe_patch_path("patches/missing.patch") is False
+            assert _is_safe_patch_path("../outside.patch") is False
+
+
+def test_apply_step_skips_unsafe_patch_without_crashing():
+    """RIGHT on a missing patch logs a warning, still advances, and does not raise."""
+    from dfetch.commands.replay_patches import _apply_step
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        with patch("pathlib.Path.cwd", return_value=Path(tmpdir)):
+            current, done = _apply_step(
+                "RIGHT", 0, 1, ["patches/missing.patch"], "some/local/path"
+            )
+
+    assert (current, done) == (1, False)