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

{specfuse_loop-0.3.16/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.16
+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.16 → specfuse_loop-0.3.17}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "specfuse-loop"
-version = "0.3.16"
+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.16 → 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.16"
+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
 
 
@@ -1498,6 +1537,51 @@ def reset_preserving_events(
         _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):
     """Raised when squash_commit's `git commit` is rejected (non-zero exit).
 
@@ -4144,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)
@@ -4169,11 +4265,18 @@ def run(
                         }))
                         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}",
@@ -4206,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.16 → 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.16 → 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.16
+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.16 → 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.16 → 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()

{specfuse_loop-0.3.16 → specfuse_loop-0.3.17}/tests/test_scaffold_upgrade.py

@@ -1,6 +1,8 @@
 # Copyright 2026 Specfuse Contributors
 # Licensed under the Apache License, Version 2.0. See LICENSE.
 
+import contextlib
+import io
 import pathlib
 import shutil
 import tempfile
@@ -87,6 +89,70 @@ class TestUpgradeDowngradeRefusal(unittest.TestCase):
             shutil.rmtree(tmpdir)
 
 
+class TestUnmanagedLegacyWarning(unittest.TestCase):
+    """#165: upgrade advances VERSION but never manages scripts/ or skills/.
+
+    Only pre-PyPI (init.sh-era) repos carry full copies; upgrade leaves them
+    stale while VERSION moves on. A warning must surface that drift; a clean
+    (post-migration) project must stay silent.
+    """
+
+    def _upgrade_capturing_stderr(self, target) -> str:
+        err = io.StringIO()
+        with contextlib.redirect_stderr(err):
+            upgrade_specfuse(target)
+        return err.getvalue()
+
+    def test_warns_when_legacy_scripts_and_skills_present(self):
+        target, specfuse, tmpdir = _make_target_with_version("0.0.1")
+        try:
+            (specfuse / "scripts").mkdir()
+            (specfuse / "scripts" / "loop.py").write_text("# legacy 0.2.0\n")
+            (specfuse / "skills" / "draft-feature").mkdir(parents=True)
+            (specfuse / "skills" / "draft-feature" / "SKILL.md").write_text("x")
+            out = self._upgrade_capturing_stderr(target)
+            self.assertIn("scripts/", out)
+            self.assertIn("skills/", out)
+            # Names the version it advanced to, so the drift is legible.
+            self.assertIn(scaffold_version(), out)
+        finally:
+            shutil.rmtree(tmpdir)
+
+    def test_warns_when_only_scripts_present(self):
+        target, specfuse, tmpdir = _make_target_with_version("0.0.1")
+        try:
+            (specfuse / "scripts").mkdir()
+            (specfuse / "scripts" / "loop.py").write_text("# legacy\n")
+            out = self._upgrade_capturing_stderr(target)
+            self.assertIn("scripts/", out)
+            self.assertNotIn("skills/", out)
+        finally:
+            shutil.rmtree(tmpdir)
+
+    def test_silent_on_clean_project(self):
+        # A post-migration project (init_specfuse ships neither dir).
+        tmpdir = tempfile.mkdtemp()
+        target = pathlib.Path(tmpdir)
+        try:
+            init_specfuse(target)
+            self.assertFalse((target / ".specfuse" / "scripts").exists())
+            self.assertFalse((target / ".specfuse" / "skills").exists())
+            out = self._upgrade_capturing_stderr(target)
+            self.assertNotIn("not managed", out.lower())
+        finally:
+            shutil.rmtree(tmpdir)
+
+    def test_empty_legacy_dir_does_not_warn(self):
+        # An empty scripts/ dir (no files) is not drift.
+        target, specfuse, tmpdir = _make_target_with_version("0.0.1")
+        try:
+            (specfuse / "scripts").mkdir()
+            out = self._upgrade_capturing_stderr(target)
+            self.assertNotIn("not managed", out.lower())
+        finally:
+            shutil.rmtree(tmpdir)
+
+
 class TestUpgradeOverlayAndPreserve(unittest.TestCase):
     def setUp(self):
         self._tmpdir = tempfile.TemporaryDirectory()

{specfuse_loop-0.3.16 → specfuse_loop-0.3.17}/tests/test_untracked_file_absorption.py

@@ -186,6 +186,11 @@ class TestUntrackedPathsHelper(unittest.TestCase):
         root = Path(self._tmp.name)
         subprocess.run(["git", "init", "-q", "-b", "main", str(root)],
                        check=True)
+        # Disable commit signing so the fixture is independent of operator
+        # global config: with SSH signing on and no agent socket (e.g. a
+        # sandboxed session) `git commit` fails "Couldn't get agent socket"
+        # (#166). Mirrors the _git_repo_no_sign convention used elsewhere.
+        _git(root, "config", "commit.gpgSign", "false")
         _git(root, "config", "user.email", "test@example.com")
         _git(root, "config", "user.name", "Test")
         (root / "a.py").write_text("a\n")

specfuse_loop-0.3.16/specfuse/loop/data/VERSION

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