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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specfuse-loop
-Version: 0.3.15
+Version: 0.3.17
 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.17}/pyproject.toml

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

specfuse_loop-0.3.17/specfuse/loop/data/VERSION

@@ -0,0 +1 @@
+0.3.17

{specfuse_loop-0.3.15 → specfuse_loop-0.3.17}/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.17"
 # 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
@@ -542,6 +542,36 @@ def detect_degraded_oracle(stdout: str) -> str | None:
     return None
 
 
+# A failure signature carries no distinguishing content when it is a bare
+# code/markdown fence, whitespace-only, or pure ANSI. Non-Python gate output
+# (e.g. a TypeScript `tests` gate) matches none of the Python-specific
+# _SIG_PATTERNS below and used to fall through to the first line after the
+# marker — often a ``` fence — collapsing genuinely different failures to one
+# value and false-firing spinning_signature_repeat (#167).
+_FENCE_RE = re.compile(r"^[`~]{3,}[\w.+-]*$")
+_ANSI_RE = re.compile(r"\x1b\[[0-9;]*[A-Za-z]")
+# Sentinel returned when every line after the FAIL marker is non-informative.
+# Distinct from `no_gate_marker` (a marker WAS found) and treated as
+# non-informative by `_is_noninformative_signature`.
+NO_SIGNATURE = "no_signature"
+
+
+def _is_noninformative_signature(sig: "str | None") -> bool:
+    """True when *sig* cannot distinguish one failure from another.
+
+    Covers None, whitespace-only, bare fences (``` / ~~~, optionally with a
+    language tag), pure-ANSI strings, and the NO_SIGNATURE sentinel. The spin
+    detector and the extraction fallback both consult this so a content-free
+    signature neither becomes a WU's identity nor trips escalation (#167).
+    """
+    if sig is None or sig == NO_SIGNATURE:
+        return True
+    stripped = _ANSI_RE.sub("", sig).strip()
+    if not stripped:
+        return True
+    return bool(_FENCE_RE.match(stripped))
+
+
 def parse_gate_failure_signature(stdout: str) -> tuple[str, str]:
     """Extract (failure_class, failure_signature) from gate runner stdout.
 
@@ -577,9 +607,12 @@ def parse_gate_failure_signature(stdout: str) -> tuple[str, str]:
             return failure_class, sig if sig else "unknown"
     for line in after_lines:
         stripped = line.strip()
-        if stripped:
-            return failure_class, stripped[:100]
-    return failure_class, "unknown"
+        # Skip non-informative lines (bare fences, whitespace, pure ANSI):
+        # keying the signature off one would collapse distinct failures (#167).
+        if _is_noninformative_signature(stripped):
+            continue
+        return failure_class, stripped[:100]
+    return failure_class, NO_SIGNATURE
 
 
 def detect_spinning_signature_repeat(
@@ -592,6 +625,9 @@ def detect_spinning_signature_repeat(
     Returns False when either element of current is None.
     Returns False when current or prior is the no_gate_marker sentinel to
     avoid false-positive halts on parser-opaque failures (AC4).
+    Returns False when either signature is non-informative — a bare fence,
+    whitespace, pure ANSI, or the NO_SIGNATURE sentinel — since such values
+    collapse distinct failures and would false-fire the spin halt (#167).
     """
     _SENTINEL = ("other", "no_gate_marker")
     if prior is None:
@@ -600,6 +636,9 @@ def detect_spinning_signature_repeat(
         return False
     if current == _SENTINEL or prior == _SENTINEL:
         return False
+    if (_is_noninformative_signature(current[1])
+            or _is_noninformative_signature(prior[1])):
+        return False
     return current == prior
 
 
@@ -1410,7 +1449,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 +1514,72 @@ 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)
+
+
+def capture_working_tree_diff(head_before: str, max_chars: int = 20000) -> str:
+    """Return `git diff <head_before>` (working tree vs pre-attempt base), capped.
+
+    Folded into a failing attempt's evidence note BEFORE the per-attempt
+    `git reset --hard` discards the rejected work, so a blocked WU stays
+    diagnosable — a human (or /gate-status) can see the diff that was rolled
+    back, not just a truncated failure excerpt (#168).
+
+    Best-effort: returns "" on any git error or a clean tree. Truncated to
+    max_chars so a large refactor's diff cannot bloat the committed note.
+    """
+    try:
+        out = subprocess.run(
+            ["git", "diff", head_before],
+            capture_output=True, text=True, check=True,
+        ).stdout
+    except (subprocess.CalledProcessError, OSError):
+        return ""
+    if len(out) > max_chars:
+        out = out[:max_chars] + "\n… (diff truncated)\n"
+    return out
+
+
+def persist_attempt_notes(
+    work_dir: Path, wu_id: str, attempt_notes: "list[tuple[int, str]]",
+) -> "list[Path]":
+    """Write buffered per-attempt evidence to work/<wu>/attempt-N.md.
+
+    Extracted so both escalation paths persist evidence the same way: the
+    exhausted-attempts `for-else` and the early `spinning_signature_repeat`
+    halt. Previously only the former wrote notes, so a signature-repeat block
+    left nothing on disk to diagnose (#168). Returns the written paths for
+    inclusion in the escalation commit. `work/` is gitignored, so the explicit
+    `git add` in commit_bookkeeping is what tracks these.
+    """
+    wu_key = wu_id.replace("/", "_")
+    paths: list[Path] = []
+    for atmpt, evidence in attempt_notes:
+        p = work_dir / wu_key / f"attempt-{atmpt}.md"
+        p.parent.mkdir(parents=True, exist_ok=True)
+        p.write_text(evidence)
+        paths.append(p)
+    return paths
 
 
 class SquashCommitError(RuntimeError):
@@ -3801,7 +3943,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 +3955,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 +4000,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 +4032,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 +4050,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 +4087,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 +4114,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 +4217,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")
@@ -4078,7 +4228,19 @@ def run(
                     # Per-attempt notes are buffered (not written to disk) so they
                     # ride with the spinning-escalation commit if we exhaust
                     # attempts; on eventual PASS they're discarded as scratch.
-                    attempt_notes.append((attempt, payload))
+                    # Fold the rejected working-tree diff into the buffered
+                    # evidence NOW, before the reset below discards it (#168).
+                    # Signature/excerpt parsing stays on the raw payload.
+                    _diff = capture_working_tree_diff(head_before)
+                    _evidence = payload
+                    if _diff:
+                        _evidence = (
+                            payload
+                            + "\n\n## Rejected working-tree diff "
+                              "(discarded by git reset on block)\n\n"
+                            + "```diff\n" + _diff + "\n```\n"
+                        )
+                    attempt_notes.append((attempt, _evidence))
                     failure_note = payload
                     _fc, _fs = parse_gate_failure_signature(payload)
                     _ex = extract_failure_excerpt(payload)
@@ -4101,12 +4263,20 @@ 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)
+                        # Persist buffered evidence (verify output + rejected
+                        # diff) AFTER the reset — work/ is gitignored so the
+                        # reset leaves it untouched, and this makes a
+                        # signature-repeat block diagnosable like the
+                        # exhausted-attempts path (#168).
+                        note_paths = persist_attempt_notes(
+                            work_dir, wu.wu_id, attempt_notes)
                         backend.set_wu(wu, "status", "blocked_human")
                         write_cost_to_wu(backend, wu, cum_usage)
                         flush_events(events_path, wu_events)
                         commit_bookkeeping(
-                            [wu.file, events_path],
+                            [wu.file, events_path, *note_paths],
                             f"chore(loop): {wu.wu_id} blocked_human "
                             f"(spinning_signature_repeat, attempt {attempt})"
                             f"\n\nFeature: {wu.wu_id}",
@@ -4119,7 +4289,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.
@@ -4138,13 +4309,8 @@ def run(
                         o == "zero_token" for o in attempt_outcomes)
                     reason = ("all_attempts_zero_token" if all_zero
                               else "spinning_detected")
-                    wu_key = wu.wu_id.replace("/", "_")
-                    note_paths = []
-                    for atmpt, evidence in attempt_notes:
-                        p = work_dir / wu_key / f"attempt-{atmpt}.md"
-                        p.parent.mkdir(parents=True, exist_ok=True)
-                        p.write_text(evidence)
-                        note_paths.append(p)
+                    note_paths = persist_attempt_notes(
+                        work_dir, wu.wu_id, attempt_notes)
                     backend.set_wu(wu, "status", "blocked_human")
                     write_cost_to_wu(backend, wu, cum_usage)
                     wu_events.append(build_event("human_escalation", wu.wu_id, {

{specfuse_loop-0.3.15 → specfuse_loop-0.3.17}/specfuse/loop/scaffold.py

@@ -8,6 +8,7 @@ import importlib.resources
 import json
 import os
 import re
+import sys
 from pathlib import Path
 
 from . import _miniyaml
@@ -389,9 +390,45 @@ def upgrade_specfuse(
     wire_claude(target_path)
     _write_manifest(specfuse_dir, manifest_entries)
 
+    _warn_unmanaged_legacy_dirs(specfuse_dir)
+
     return sorted(written)
 
 
+def _warn_unmanaged_legacy_dirs(specfuse_dir: Path) -> None:
+    """Warn (stderr) when legacy scripts/ or skills/ copies exist post-upgrade.
+
+    Current scaffold data ships neither directory: scripts come from the
+    specfuse-loop package, skills from the specfuse@specfuse plugin. Only
+    pre-PyPI (init.sh-era) repos carry full copies, and `upgrade` overlays
+    none of them while still advancing VERSION — so a VERSION that outpaces
+    the vendored scripts/skills is silent drift (#165). New projects have
+    neither dir, so this is a no-op for them.
+
+    A warning, not a prune: reconciling those copies (see `migrate_legacy`)
+    is destructive and left to an explicit operator step.
+    """
+    drift: list[str] = []
+    for name in ("scripts", "skills"):
+        d = specfuse_dir / name
+        if d.is_dir():
+            n = sum(1 for p in d.rglob("*") if p.is_file())
+            if n:
+                drift.append(f"  .specfuse/{name}/ ({n} file(s))")
+    if not drift:
+        return
+    print(
+        f"specfuse upgrade: WARNING — VERSION advanced to {scaffold_version()}, "
+        "but these directories are NOT managed by upgrade and may be stale:\n"
+        + "\n".join(drift)
+        + "\n  Scripts are provided by the specfuse-loop package and skills by "
+        "the specfuse@specfuse plugin; these are leftover full copies from an "
+        "older (pre-package) install. Remove them once nothing local depends "
+        "on them.",
+        file=sys.stderr,
+    )
+
+
 def init(target: str | Path, *, ci_check: str | None = None) -> list[str]:
     """Bootstrap a Specfuse-enabled repo: write .specfuse/ then wire .claude/.
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specfuse-loop
-Version: 0.3.15
+Version: 0.3.17
 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.17}/specfuse_loop.egg-info/SOURCES.txt

@@ -102,6 +102,7 @@ tests/test_lint_plan_relative_import.py
 tests/test_lint_produces_driver_helper.py
 tests/test_lint_sections.py
 tests/test_lint_task_graph_yaml_selection.py
+tests/test_loop_attempt_evidence.py
 tests/test_loop_auto_archive.py
 tests/test_loop_caveman_preamble.py
 tests/test_loop_close_intermediate.py

{specfuse_loop-0.3.15 → specfuse_loop-0.3.17}/tests/test_attempt_outcome_emission.py

@@ -231,6 +231,45 @@ class TestParseGateFailureSignature(unittest.TestCase):
         self.assertEqual(fc, "other")
         self.assertEqual(sig, "no_gate_marker")
 
+    # -- #167: non-Python gate output must not collapse to a bare fence -- #
+
+    def test_fallback_skips_bare_code_fence(self):
+        # A non-Python tests gate (e.g. TypeScript) matches none of the
+        # Python _SIG_PATTERNS and falls through. The first line after the
+        # marker is a Markdown fence; the signature must key off the real
+        # failure line beneath it, not the fence.
+        stdout = (
+            "### tests: FAIL\n"
+            "```\n"
+            "  ✕ company builds a valid config (expected 3, got 4)\n"
+            "```\n"
+        )
+        fc, sig = loop.parse_gate_failure_signature(stdout)
+        self.assertEqual(fc, "tests")
+        self.assertNotEqual(sig, "```")
+        self.assertIn("company builds a valid config", sig)
+
+    def test_fallback_skips_whitespace_and_tilde_fence(self):
+        stdout = "### tests: FAIL\n   \n~~~\n\nReal failure: assertion X\n"
+        fc, sig = loop.parse_gate_failure_signature(stdout)
+        self.assertEqual(fc, "tests")
+        self.assertIn("Real failure", sig)
+
+    def test_all_noninformative_returns_no_signature(self):
+        stdout = "### tests: FAIL\n```\n   \n~~~\n"
+        fc, sig = loop.parse_gate_failure_signature(stdout)
+        self.assertEqual(fc, "tests")
+        self.assertEqual(sig, "no_signature")
+
+    def test_two_distinct_ts_failures_yield_distinct_signatures(self):
+        # The #167 false-spin: two genuinely different failures must NOT
+        # reduce to the same signature (both previously became "```").
+        a = "### tests: FAIL\n```\n  ✕ builds config (expected 3, got 4)\n```\n"
+        b = "### tests: FAIL\n```\n  ✕ parses tokens (unexpected EOF)\n```\n"
+        _, sig_a = loop.parse_gate_failure_signature(a)
+        _, sig_b = loop.parse_gate_failure_signature(b)
+        self.assertNotEqual(sig_a, sig_b)
+
 
 # --------------------------------------------------------------------------- #
 # TestExtractFailureExcerpt                                                    #
@@ -443,6 +482,49 @@ class TestDetectSpinningSignatureRepeat(unittest.TestCase):
         )
         self.assertFalse(result)
 
+    # -- #167: non-informative signatures must not trip the spin detector -- #
+
+    def test_false_on_bare_fence_signature(self):
+        # The exact #167 shape: both attempts reduced to "```". Even though
+        # current == prior, a bare fence carries no failure-distinguishing
+        # content and must not escalate.
+        self.assertFalse(
+            loop.detect_spinning_signature_repeat(
+                ("tests", "```"), ("tests", "```"),
+            )
+        )
+
+    def test_false_on_whitespace_signature(self):
+        self.assertFalse(
+            loop.detect_spinning_signature_repeat(
+                ("tests", "   "), ("tests", "   "),
+            )
+        )
+
+    def test_false_on_pure_ansi_signature(self):
+        ansi = "\x1b[31m\x1b[0m"
+        self.assertFalse(
+            loop.detect_spinning_signature_repeat(
+                ("tests", ansi), ("tests", ansi),
+            )
+        )
+
+    def test_false_on_no_signature_sentinel(self):
+        self.assertFalse(
+            loop.detect_spinning_signature_repeat(
+                ("tests", "no_signature"), ("tests", "no_signature"),
+            )
+        )
+
+    def test_still_true_on_real_repeated_signature(self):
+        # Guard against over-correction: a genuine repeat still escalates.
+        self.assertTrue(
+            loop.detect_spinning_signature_repeat(
+                ("tests", "builds config (expected 3, got 4)"),
+                ("tests", "builds config (expected 3, got 4)"),
+            )
+        )
+
 
 # --------------------------------------------------------------------------- #
 # TestSummarizeAttemptFailureClasses                                           #

specfuse_loop-0.3.17/tests/test_loop_attempt_evidence.py

@@ -0,0 +1,116 @@
+#
+# Copyright 2026 Specfuse contributors
+# Licensed under the Apache License, Version 2.0. See LICENSE.
+#
+"""Unit tests for #168 — persist rejected-attempt evidence before git reset.
+
+Two helpers keep a blocked WU diagnosable:
+
+- `capture_working_tree_diff(head_before)` folds the rejected diff into a
+  failing attempt's note BEFORE the per-attempt `git reset` discards it.
+- `persist_attempt_notes(work_dir, wu_id, notes)` writes the buffered
+  evidence to `work/<wu>/attempt-N.md`. It is now called on BOTH escalation
+  paths (early spinning_signature_repeat and exhausted-attempts); previously
+  only the latter wrote notes, so a signature-repeat block lost all evidence.
+"""
+
+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")
+        run("rev-parse", "HEAD")
+        prev_cwd = os.getcwd()
+        try:
+            os.chdir(root)
+            yield root
+        finally:
+            os.chdir(prev_cwd)
+
+
+class TestCaptureWorkingTreeDiff(unittest.TestCase):
+
+    def test_captures_tracked_modification(self):
+        with _git_repo_no_sign() as root:
+            head = loop.git("rev-parse", "HEAD")
+            (root / "README.md").write_text("# fixture\nnew line\n")
+            diff = loop.capture_working_tree_diff(head)
+            self.assertIn("new line", diff)
+            self.assertIn("README.md", diff)
+
+    def test_empty_on_clean_tree(self):
+        with _git_repo_no_sign():
+            head = loop.git("rev-parse", "HEAD")
+            self.assertEqual(loop.capture_working_tree_diff(head), "")
+
+    def test_truncates_large_diff(self):
+        with _git_repo_no_sign() as root:
+            head = loop.git("rev-parse", "HEAD")
+            (root / "big.txt").write_text("x\n" * 100000)
+            subprocess.run(["git", "-C", str(root), "add", "big.txt"],
+                           check=True, capture_output=True)
+            diff = loop.capture_working_tree_diff(head, max_chars=2000)
+            self.assertLessEqual(len(diff), 2000 + 64)
+            self.assertIn("truncated", diff)
+
+    def test_empty_on_bad_ref(self):
+        with _git_repo_no_sign():
+            # A non-existent ref makes git diff exit non-zero → "" (best-effort).
+            self.assertEqual(
+                loop.capture_working_tree_diff("deadbeefdeadbeef"), "")
+
+
+class TestPersistAttemptNotes(unittest.TestCase):
+
+    def test_writes_one_file_per_attempt(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            work = Path(tmp) / "work"
+            notes = [(1, "first failure"), (2, "second failure")]
+            paths = loop.persist_attempt_notes(work, "FEAT-2026-0016/T03", notes)
+            self.assertEqual(len(paths), 2)
+            self.assertTrue((work / "FEAT-2026-0016_T03" / "attempt-1.md").exists())
+            self.assertEqual(
+                (work / "FEAT-2026-0016_T03" / "attempt-2.md").read_text(),
+                "second failure")
+
+    def test_wu_id_slashes_flattened(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            work = Path(tmp) / "work"
+            paths = loop.persist_attempt_notes(work, "A/B/C", [(1, "x")])
+            self.assertIn("A_B_C", str(paths[0]))
+
+    def test_empty_notes_writes_nothing(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            work = Path(tmp) / "work"
+            paths = loop.persist_attempt_notes(work, "X/T01", [])
+            self.assertEqual(paths, [])
+            self.assertFalse(work.exists())
+
+
+if __name__ == "__main__":
+    unittest.main()