specfuse-loop 0.3.15__tar.gz → 0.3.16__tar.gz

{specfuse_loop-0.3.15/specfuse_loop.egg-info → specfuse_loop-0.3.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specfuse-loop
-Version: 0.3.15
+Version: 0.3.16
 Summary: Local-first executor for the Specfuse Plan + Work Unit gate-cycle methodology.
 Author: Specfuse contributors
 License: Apache-2.0

{specfuse_loop-0.3.15 → specfuse_loop-0.3.16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "specfuse-loop"
-version = "0.3.15"
+version = "0.3.16"
 description = "Local-first executor for the Specfuse Plan + Work Unit gate-cycle methodology."
 readme = "README.md"
 requires-python = ">=3.10"

specfuse_loop-0.3.16/specfuse/loop/data/VERSION

@@ -0,0 +1 @@
+0.3.16

{specfuse_loop-0.3.15 → specfuse_loop-0.3.16}/specfuse/loop/loop.py

@@ -63,7 +63,7 @@ SPECFUSE_DIR = Path(".specfuse")
 REPO_ROOT = SPECFUSE_DIR.parent
 FEATURES_DIR = SPECFUSE_DIR / "features"
 VERIFICATION_PATH = SPECFUSE_DIR / "verification.yml"
-DRIVER_VERSION = "0.3.15"
+DRIVER_VERSION = "0.3.16"
 # Oldest scaffold layout this driver can drive. init.sh stamps the scaffold's own
 # version into `.specfuse/VERSION`; check_scaffold_version() fails loud at startup if
 # the consumer's scaffold is older than this, pointing at `specfuse upgrade`. Bump
@@ -1410,7 +1410,49 @@ def commit_bookkeeping(paths: list, message: str) -> str | None:
     return git("rev-parse", "HEAD")
 
 
-def reset_preserving_events(head_before: str, events_path: Path) -> None:
+def _clean_attempt_untracked(
+    untracked_before: "set[str] | frozenset[str]", events_path: Path,
+) -> None:
+    """Delete untracked files that appeared since the *untracked_before* snapshot.
+
+    Helper for `reset_preserving_events`; see its docstring for why. Deletes
+    FILES only — empty directories are left behind, which is harmless (git
+    does not track directories) and avoids racing the driver's own mid-run
+    scratch dirs.
+
+    Never deletes: paths in *untracked_before* (the operator's, per #150),
+    *events_path* (driver-managed, and untracked on a fresh branch), or
+    gitignored paths (`untracked_paths` honors .gitignore, so a feature's
+    `work/` scratch dir never enters the delete set).
+
+    Best-effort: any git or filesystem error is swallowed. A failure to clean
+    reverts to the old leftover behavior, which must not crash the run.
+    """
+    try:
+        root = Path(git("rev-parse", "--show-toplevel"))
+        candidates = untracked_paths() - set(untracked_before)
+    except (subprocess.CalledProcessError, OSError):
+        return
+    try:
+        keep = events_path.resolve()
+    except OSError:
+        keep = None
+    for rel in sorted(candidates):
+        target = root / rel
+        try:
+            if keep is not None and target.resolve() == keep:
+                continue
+            if target.is_file() or target.is_symlink():
+                target.unlink()
+        except OSError:
+            continue
+
+
+def reset_preserving_events(
+    head_before: str,
+    events_path: Path,
+    untracked_before: "set[str] | frozenset[str] | None" = None,
+) -> None:
     """`git reset --hard <head_before>` without losing events.jsonl content.
 
     The hard-reset is the methodology's "wipe agent's edits before we write our
@@ -1433,11 +1475,27 @@ def reset_preserving_events(head_before: str, events_path: Path) -> None:
 
     Subsequent `flush_events` calls then append to the preserved content;
     `commit_bookkeeping` captures the full history.
+
+    `untracked_before` (#162) is the per-WU untracked snapshot taken at
+    dispatch. When supplied, untracked files that appeared SINCE it are
+    deleted after the reset. A hard reset rolls back tracked content but
+    leaves untracked files on disk, and the snapshot is taken once per WU
+    (outside the attempt loop) — so without this, attempt 1's new files
+    survive into attempt 2, where they are indistinguishable from attempt 2's
+    own work: `verify_files_changed` passes them and `squash_commit` commits
+    them, letting an attempt pass on its predecessor's leftovers.
+
+    Absence is inert BY DESIGN. An empty set would read as "the operator had
+    nothing untracked" and delete the entire untracked working tree; `None`
+    means "no snapshot available, do not clean" and preserves the pre-#162
+    behavior for callers that cannot supply one.
     """
     saved = events_path.read_text() if events_path.is_file() else None
     git("reset", "--hard", head_before)
     if saved is not None:
         events_path.write_text(saved)
+    if untracked_before is not None:
+        _clean_attempt_untracked(untracked_before, events_path)
 
 
 class SquashCommitError(RuntimeError):
@@ -3801,7 +3859,8 @@ def run(
                             wu, attempt, "zero_token_skip",
                             attempts_usage[-1],
                         ))
-                        reset_preserving_events(head_before, events_path)
+                        reset_preserving_events(head_before, events_path,
+                                                untracked_before=untracked_before)
                         print(f"   ZERO-TOKEN attempt {attempt}/{MAX_ATTEMPTS} "
                               f"— no agent output, skipping")
                         continue
@@ -3812,7 +3871,8 @@ def run(
                         # reset wipe the flip — the silent-state-loss bug.
                         # Use reset_preserving_events to keep prior WU's
                         # flushed-but-uncommitted events.jsonl entries.
-                        reset_preserving_events(head_before, events_path)
+                        reset_preserving_events(head_before, events_path,
+                                                untracked_before=untracked_before)
                         backend.set_wu(wu, "status", "blocked_human")
                         write_cost_to_wu(backend, wu, cum_usage)
                         wu_events.append(emit_attempt_outcome(
@@ -3856,7 +3916,8 @@ def run(
                             # written just above — record the failure with git's
                             # stderr, and retry within budget (MAX_ATTEMPTS
                             # exhaustion escalates to blocked_human).
-                            reset_preserving_events(head_before, events_path)
+                            reset_preserving_events(head_before, events_path,
+                                                    untracked_before=untracked_before)
                             # Redact any quoted leak-scan match before it lands
                             # in events.jsonl / the attempt note, so the captured
                             # FINDINGS text can't re-trip the next bookkeeping
@@ -3887,7 +3948,8 @@ def run(
                                 smoke_cmds, Path("."),
                             )
                             if not smoke_ok:
-                                reset_preserving_events(head_before, events_path)
+                                reset_preserving_events(head_before, events_path,
+                                                        untracked_before=untracked_before)
                                 wu_events.append(emit_attempt_outcome(
                                     wu, attempt, "smoke_import_failed",
                                     attempts_usage[-1],
@@ -3904,7 +3966,8 @@ def run(
                             wu, feature_dir, REPO_ROOT, head_before,
                         )
                         if not closing_ok:
-                            reset_preserving_events(head_before, events_path)
+                            reset_preserving_events(head_before, events_path,
+                                                    untracked_before=untracked_before)
                             # `assertion` names the primary (first) failing
                             # assertion. With aggregation (#72) closing_summary
                             # may list several; the first `assert_*` token is the
@@ -3940,7 +4003,8 @@ def run(
                         # every current WU is unchanged.
                         deliv_ok, deliv_summary = assert_declared_deliverables(wu)
                         if not deliv_ok:
-                            reset_preserving_events(head_before, events_path)
+                            reset_preserving_events(head_before, events_path,
+                                                    untracked_before=untracked_before)
                             missing = deliv_summary.split(": ", 1)[-1]
                             wu_events.append(emit_attempt_outcome(
                                 wu, attempt, "deliverable_missing",
@@ -3966,7 +4030,8 @@ def run(
                             wu, touched,
                         )
                         if not impl_ok:
-                            reset_preserving_events(head_before, events_path)
+                            reset_preserving_events(head_before, events_path,
+                                                    untracked_before=untracked_before)
                             wu_events.append(emit_attempt_outcome(
                                 wu, attempt, "no_deliverable_files",
                                 attempts_usage[-1],
@@ -4068,7 +4133,8 @@ def run(
                         ))
                         attempt_notes.append((attempt, note))
                         failure_note = note
-                        reset_preserving_events(head_before, events_path)
+                        reset_preserving_events(head_before, events_path,
+                                                untracked_before=untracked_before)
                         print(f"   FILES_CHANGED MISMATCH attempt "
                               f"{attempt}/{MAX_ATTEMPTS} — {len(payload)} path(s) "
                               f"unchanged")
@@ -4101,7 +4167,8 @@ def run(
                             "attempts": attempt,
                             "attempts_usage": attempts_usage,
                         }))
-                        reset_preserving_events(head_before, events_path)
+                        reset_preserving_events(head_before, events_path,
+                                                untracked_before=untracked_before)
                         backend.set_wu(wu, "status", "blocked_human")
                         write_cost_to_wu(backend, wu, cum_usage)
                         flush_events(events_path, wu_events)
@@ -4119,7 +4186,8 @@ def run(
                         prior_failure_signature = (_fc, _fs)
                     flush_events(events_path, wu_events)
                     wu_events.clear()
-                    reset_preserving_events(head_before, events_path)
+                    reset_preserving_events(head_before, events_path,
+                                            untracked_before=untracked_before)
                     print(f"   FAIL attempt {attempt}/{MAX_ATTEMPTS}")
                 else:
                     # for-else: ran out of attempts without break = spinning.

{specfuse_loop-0.3.15 → specfuse_loop-0.3.16/specfuse_loop.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specfuse-loop
-Version: 0.3.15
+Version: 0.3.16
 Summary: Local-first executor for the Specfuse Plan + Work Unit gate-cycle methodology.
 Author: Specfuse contributors
 License: Apache-2.0

specfuse_loop-0.3.16/tests/test_loop_reset_preserving_events.py

@@ -0,0 +1,294 @@
+#
+# Copyright 2026 Specfuse contributors
+# Licensed under the Apache License, Version 2.0. See LICENSE.
+#
+"""Unit tests for `reset_preserving_events` — FEAT-2026-0015 bug fix.
+
+Bug context: `git reset --hard head_before` between WUs rolled events.jsonl
+back to its last-committed state, silently dropping the prior WU's lifecycle
+events that had been flushed-but-not-yet-committed. Surfaced
+FEAT-2026-0015/T02: ran clean, events flushed post-squash, then T03 blocked
+→ bare hard-reset wiped T02's events.
+
+Fix: helper captures events.jsonl content, performs hard-reset, restores
+content. Subsequent flush_events appends; subsequent commit_bookkeeping
+captures the full history.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import tempfile
+import unittest
+from contextlib import contextmanager
+from pathlib import Path
+
+from tests._loop_loader import load_loop
+
+loop = load_loop()
+
+
+@contextmanager
+def _git_repo_no_sign():
+    """Minimal git repo with signing disabled (operator config-independent)."""
+    with tempfile.TemporaryDirectory(ignore_cleanup_errors=True) as tmp:
+        root = Path(tmp)
+        run = lambda *a: subprocess.run(  # noqa: E731
+            ["git", "-C", str(root), *a], check=True, capture_output=True,
+        )
+        run("init", "-q", "-b", "main")
+        run("config", "commit.gpgSign", "false")
+        run("config", "gc.auto", "0")
+        run("config", "user.email", "test@example.com")
+        run("config", "user.name", "Test")
+        (root / "README.md").write_text("# fixture\n")
+        run("add", ".")
+        run("commit", "-q", "-m", "init")
+        # Sync barrier
+        run("rev-parse", "HEAD")
+        # cwd swap so loop's git() helper (which runs without -C) operates
+        # on this tree
+        prev_cwd = os.getcwd()
+        try:
+            os.chdir(root)
+            yield root
+        finally:
+            os.chdir(prev_cwd)
+
+
+class TestResetPreservingEventsHelper(unittest.TestCase):
+    """Direct unit-level tests on reset_preserving_events()."""
+
+    def test_preserves_flushed_but_uncommitted_events_content(self):
+        """events.jsonl modifications since head_before survive the reset."""
+        with _git_repo_no_sign() as root:
+            # Setup: commit a baseline events.jsonl + README
+            events_path = root / "events.jsonl"
+            events_path.write_text("# committed baseline\n")
+            subprocess.run(
+                ["git", "-C", str(root), "add", "events.jsonl"],
+                check=True, capture_output=True,
+            )
+            subprocess.run(
+                ["git", "-C", str(root), "commit", "-q", "-m", "baseline"],
+                check=True, capture_output=True,
+            )
+            head_before = loop.git("rev-parse", "HEAD")
+
+            # Simulate prior-WU events flushed post-squash, not yet committed:
+            # events.jsonl on disk has new content vs head_before's commit.
+            events_path.write_text(
+                "# committed baseline\n"
+                '{"correlation_id":"FEAT-PRIOR/T01","event_type":"task_completed"}\n'
+            )
+            # Simulate an agent's tracked-file edit that reset SHOULD wipe.
+            readme = root / "README.md"
+            readme.write_text("# AGENT-VANDALIZED\n")
+
+            loop.reset_preserving_events(head_before, events_path)
+
+            # Reset reverted the agent's tracked-file edit
+            self.assertEqual(readme.read_text(), "# fixture\n")
+            # But events.jsonl content survived (NOT rolled back to baseline)
+            self.assertIn("FEAT-PRIOR/T01", events_path.read_text())
+
+    def test_missing_events_file_does_not_crash(self):
+        """If events.jsonl doesn't exist, helper still resets cleanly."""
+        with _git_repo_no_sign() as root:
+            head_before = loop.git("rev-parse", "HEAD")
+            readme = root / "README.md"
+            readme.write_text("# agent garbage\n")
+            events_path = root / "events.jsonl"
+            self.assertFalse(events_path.is_file())
+
+            loop.reset_preserving_events(head_before, events_path)
+
+            self.assertEqual(readme.read_text(), "# fixture\n")
+            # events.jsonl still absent — nothing to preserve
+            self.assertFalse(events_path.is_file())
+
+    def test_preserves_multi_line_events_content(self):
+        """Multi-line events.jsonl content fully preserved."""
+        with _git_repo_no_sign() as root:
+            events_path = root / "events.jsonl"
+            events_path.write_text("# baseline\n")
+            subprocess.run(
+                ["git", "-C", str(root), "add", "events.jsonl"],
+                check=True, capture_output=True,
+            )
+            subprocess.run(
+                ["git", "-C", str(root), "commit", "-q", "-m", "baseline"],
+                check=True, capture_output=True,
+            )
+            head_before = loop.git("rev-parse", "HEAD")
+
+            events_content = (
+                "# baseline\n"
+                '{"correlation_id":"X/T01","event_type":"task_started"}\n'
+                '{"correlation_id":"X/T01","event_type":"task_completed"}\n'
+                '{"correlation_id":"X/T02","event_type":"task_started"}\n'
+            )
+            events_path.write_text(events_content)
+            (root / "README.md").write_text("# vandalized\n")
+
+            loop.reset_preserving_events(head_before, events_path)
+
+            self.assertEqual((root / "README.md").read_text(), "# fixture\n")
+            self.assertEqual(events_path.read_text(), events_content)
+
+
+class TestResetClearsAttemptUntracked(unittest.TestCase):
+    """Issue #162: the reset must clear the failed attempt's untracked output.
+
+    `git reset --hard` rolls back tracked content but leaves untracked files
+    on disk. Because `untracked_before` is snapshotted once per WU (loop.py
+    :3709) and the attempt loop runs beneath it (:3769), attempt 1's new
+    files survive into attempt 2 and are indistinguishable from attempt 2's
+    own work — `verify_files_changed` passes them and `squash_commit` commits
+    them, so an attempt can pass on its predecessor's leftovers.
+
+    The snapshot is the exclusion set: untracked paths present at dispatch
+    are the operator's and must survive; anything else appeared during the
+    attempt and must go.
+    """
+
+    def _snapshot(self):
+        return loop.untracked_paths()
+
+    def test_untracked_file_created_during_attempt_is_removed(self):
+        with _git_repo_no_sign() as root:
+            head_before = loop.git("rev-parse", "HEAD")
+            before = self._snapshot()
+
+            # The attempt creates a new deliverable, then fails.
+            (root / "new.sh").write_text("#!/bin/sh\necho hi\n")
+
+            loop.reset_preserving_events(
+                head_before, root / "events.jsonl", untracked_before=before,
+            )
+
+            self.assertFalse(
+                (root / "new.sh").exists(),
+                "attempt's untracked output must not survive into the next "
+                "attempt — it is what lets a later attempt hollow-pass",
+            )
+
+    def test_operator_untracked_file_survives(self):
+        with _git_repo_no_sign() as root:
+            # Operator WIP predates dispatch (#150's concern).
+            (root / "scratch.md").write_text("my notes\n")
+            head_before = loop.git("rev-parse", "HEAD")
+            before = self._snapshot()
+            self.assertIn("scratch.md", before)
+
+            (root / "new.sh").write_text("#!/bin/sh\n")
+
+            loop.reset_preserving_events(
+                head_before, root / "events.jsonl", untracked_before=before,
+            )
+
+            self.assertTrue((root / "scratch.md").exists())
+            self.assertEqual((root / "scratch.md").read_text(), "my notes\n")
+            self.assertFalse((root / "new.sh").exists())
+
+    def test_untracked_file_in_subdir_is_removed(self):
+        with _git_repo_no_sign() as root:
+            head_before = loop.git("rev-parse", "HEAD")
+            before = self._snapshot()
+
+            (root / "scripts").mkdir()
+            (root / "scripts" / "check.sh").write_text("#!/bin/sh\n")
+
+            loop.reset_preserving_events(
+                head_before, root / "events.jsonl", untracked_before=before,
+            )
+
+            self.assertFalse((root / "scripts" / "check.sh").exists())
+
+    def test_events_file_survives_even_when_untracked(self):
+        """events.jsonl is driver-managed; the cleanup must never eat it.
+
+        It can be untracked (first run on a fresh branch) and is by
+        definition not in the pre-dispatch snapshot when the driver just
+        created it — exactly the shape the cleanup deletes.
+        """
+        with _git_repo_no_sign() as root:
+            head_before = loop.git("rev-parse", "HEAD")
+            before = self._snapshot()
+
+            events_path = root / "events.jsonl"
+            events_path.write_text(
+                '{"correlation_id":"X/T01","event_type":"task_started"}\n'
+            )
+
+            loop.reset_preserving_events(
+                head_before, events_path, untracked_before=before,
+            )
+
+            self.assertTrue(events_path.is_file())
+            self.assertIn("X/T01", events_path.read_text())
+
+    def test_gitignored_file_survives(self):
+        """Gitignored paths (e.g. the feature's `work/` dir) are out of scope.
+
+        `untracked_paths` honors .gitignore, so ignored files never enter the
+        delete set. Asserted explicitly because deleting them would destroy
+        agent scratch space mid-run.
+        """
+        with _git_repo_no_sign() as root:
+            (root / ".gitignore").write_text("work/\n")
+            subprocess.run(
+                ["git", "-C", str(root), "add", ".gitignore"],
+                check=True, capture_output=True,
+            )
+            subprocess.run(
+                ["git", "-C", str(root), "commit", "-q", "-m", "ignore"],
+                check=True, capture_output=True,
+            )
+            head_before = loop.git("rev-parse", "HEAD")
+            before = self._snapshot()
+
+            (root / "work").mkdir()
+            (root / "work" / "scratch.txt").write_text("agent scratch\n")
+
+            loop.reset_preserving_events(
+                head_before, root / "events.jsonl", untracked_before=before,
+            )
+
+            self.assertTrue((root / "work" / "scratch.txt").exists())
+
+    def test_omitting_snapshot_preserves_untracked(self):
+        """Back-compat: no snapshot means no cleanup.
+
+        An empty set is NOT the right default — it reads as "the operator had
+        nothing untracked", which would make every existing call site delete
+        the whole untracked working tree. Absence must stay inert.
+        """
+        with _git_repo_no_sign() as root:
+            head_before = loop.git("rev-parse", "HEAD")
+            (root / "new.sh").write_text("#!/bin/sh\n")
+
+            loop.reset_preserving_events(head_before, root / "events.jsonl")
+
+            self.assertTrue((root / "new.sh").exists())
+
+    def test_tracked_rollback_still_happens_with_cleanup(self):
+        """The cleanup must not displace the reset's original job."""
+        with _git_repo_no_sign() as root:
+            head_before = loop.git("rev-parse", "HEAD")
+            before = self._snapshot()
+
+            (root / "README.md").write_text("# AGENT-VANDALIZED\n")
+            (root / "new.sh").write_text("#!/bin/sh\n")
+
+            loop.reset_preserving_events(
+                head_before, root / "events.jsonl", untracked_before=before,
+            )
+
+            self.assertEqual((root / "README.md").read_text(), "# fixture\n")
+            self.assertFalse((root / "new.sh").exists())
+
+
+if __name__ == "__main__":
+    unittest.main()

specfuse_loop-0.3.15/specfuse/loop/data/VERSION

@@ -1 +0,0 @@
-0.3.15

specfuse_loop-0.3.15/tests/test_loop_reset_preserving_events.py

@@ -1,142 +0,0 @@
-#
-# Copyright 2026 Specfuse contributors
-# Licensed under the Apache License, Version 2.0. See LICENSE.
-#
-"""Unit tests for `reset_preserving_events` — FEAT-2026-0015 bug fix.
-
-Bug context: `git reset --hard head_before` between WUs rolled events.jsonl
-back to its last-committed state, silently dropping the prior WU's lifecycle
-events that had been flushed-but-not-yet-committed. Surfaced
-FEAT-2026-0015/T02: ran clean, events flushed post-squash, then T03 blocked
-→ bare hard-reset wiped T02's events.
-
-Fix: helper captures events.jsonl content, performs hard-reset, restores
-content. Subsequent flush_events appends; subsequent commit_bookkeeping
-captures the full history.
-"""
-
-from __future__ import annotations
-
-import os
-import subprocess
-import tempfile
-import unittest
-from contextlib import contextmanager
-from pathlib import Path
-
-from tests._loop_loader import load_loop
-
-loop = load_loop()
-
-
-@contextmanager
-def _git_repo_no_sign():
-    """Minimal git repo with signing disabled (operator config-independent)."""
-    with tempfile.TemporaryDirectory(ignore_cleanup_errors=True) as tmp:
-        root = Path(tmp)
-        run = lambda *a: subprocess.run(  # noqa: E731
-            ["git", "-C", str(root), *a], check=True, capture_output=True,
-        )
-        run("init", "-q", "-b", "main")
-        run("config", "commit.gpgSign", "false")
-        run("config", "gc.auto", "0")
-        run("config", "user.email", "test@example.com")
-        run("config", "user.name", "Test")
-        (root / "README.md").write_text("# fixture\n")
-        run("add", ".")
-        run("commit", "-q", "-m", "init")
-        # Sync barrier
-        run("rev-parse", "HEAD")
-        # cwd swap so loop's git() helper (which runs without -C) operates
-        # on this tree
-        prev_cwd = os.getcwd()
-        try:
-            os.chdir(root)
-            yield root
-        finally:
-            os.chdir(prev_cwd)
-
-
-class TestResetPreservingEventsHelper(unittest.TestCase):
-    """Direct unit-level tests on reset_preserving_events()."""
-
-    def test_preserves_flushed_but_uncommitted_events_content(self):
-        """events.jsonl modifications since head_before survive the reset."""
-        with _git_repo_no_sign() as root:
-            # Setup: commit a baseline events.jsonl + README
-            events_path = root / "events.jsonl"
-            events_path.write_text("# committed baseline\n")
-            subprocess.run(
-                ["git", "-C", str(root), "add", "events.jsonl"],
-                check=True, capture_output=True,
-            )
-            subprocess.run(
-                ["git", "-C", str(root), "commit", "-q", "-m", "baseline"],
-                check=True, capture_output=True,
-            )
-            head_before = loop.git("rev-parse", "HEAD")
-
-            # Simulate prior-WU events flushed post-squash, not yet committed:
-            # events.jsonl on disk has new content vs head_before's commit.
-            events_path.write_text(
-                "# committed baseline\n"
-                '{"correlation_id":"FEAT-PRIOR/T01","event_type":"task_completed"}\n'
-            )
-            # Simulate an agent's tracked-file edit that reset SHOULD wipe.
-            readme = root / "README.md"
-            readme.write_text("# AGENT-VANDALIZED\n")
-
-            loop.reset_preserving_events(head_before, events_path)
-
-            # Reset reverted the agent's tracked-file edit
-            self.assertEqual(readme.read_text(), "# fixture\n")
-            # But events.jsonl content survived (NOT rolled back to baseline)
-            self.assertIn("FEAT-PRIOR/T01", events_path.read_text())
-
-    def test_missing_events_file_does_not_crash(self):
-        """If events.jsonl doesn't exist, helper still resets cleanly."""
-        with _git_repo_no_sign() as root:
-            head_before = loop.git("rev-parse", "HEAD")
-            readme = root / "README.md"
-            readme.write_text("# agent garbage\n")
-            events_path = root / "events.jsonl"
-            self.assertFalse(events_path.is_file())
-
-            loop.reset_preserving_events(head_before, events_path)
-
-            self.assertEqual(readme.read_text(), "# fixture\n")
-            # events.jsonl still absent — nothing to preserve
-            self.assertFalse(events_path.is_file())
-
-    def test_preserves_multi_line_events_content(self):
-        """Multi-line events.jsonl content fully preserved."""
-        with _git_repo_no_sign() as root:
-            events_path = root / "events.jsonl"
-            events_path.write_text("# baseline\n")
-            subprocess.run(
-                ["git", "-C", str(root), "add", "events.jsonl"],
-                check=True, capture_output=True,
-            )
-            subprocess.run(
-                ["git", "-C", str(root), "commit", "-q", "-m", "baseline"],
-                check=True, capture_output=True,
-            )
-            head_before = loop.git("rev-parse", "HEAD")
-
-            events_content = (
-                "# baseline\n"
-                '{"correlation_id":"X/T01","event_type":"task_started"}\n'
-                '{"correlation_id":"X/T01","event_type":"task_completed"}\n'
-                '{"correlation_id":"X/T02","event_type":"task_started"}\n'
-            )
-            events_path.write_text(events_content)
-            (root / "README.md").write_text("# vandalized\n")
-
-            loop.reset_preserving_events(head_before, events_path)
-
-            self.assertEqual((root / "README.md").read_text(), "# fixture\n")
-            self.assertEqual(events_path.read_text(), events_content)
-
-
-if __name__ == "__main__":
-    unittest.main()