specfuse-loop 0.3.11__tar.gz → 0.3.13__tar.gz

{specfuse_loop-0.3.11/specfuse_loop.egg-info → specfuse_loop-0.3.13}/PKG-INFO

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

{specfuse_loop-0.3.11 → specfuse_loop-0.3.13}/pyproject.toml

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

specfuse_loop-0.3.13/specfuse/loop/data/VERSION

@@ -0,0 +1 @@
+0.3.13

{specfuse_loop-0.3.11 → specfuse_loop-0.3.13}/specfuse/loop/loop.py

@@ -62,7 +62,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.11"
+DRIVER_VERSION = "0.3.13"
 # 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
@@ -766,6 +766,84 @@ def _current_branch() -> str:
     return git("branch", "--show-current")
 
 
+def _default_branch() -> "str | None":
+    """The repo's default branch, or None if undeterminable.
+
+    Prefers origin's HEAD symref (`origin/main` -> `main`); falls back to a
+    local `main`/`master` when there is no remote. None when neither resolves —
+    callers then treat the current branch as non-default (auto_sync commits its
+    scaffold sync rather than leaving it dangling).
+    """
+    ref = subprocess.run(
+        ["git", "symbolic-ref", "--short", "refs/remotes/origin/HEAD"],
+        capture_output=True, text=True,
+    )
+    if ref.returncode == 0 and ref.stdout.strip():
+        name = ref.stdout.strip()
+        return name[len("origin/"):] if name.startswith("origin/") else name
+    for cand in ("main", "master"):
+        if subprocess.run(
+            ["git", "rev-parse", "--verify", "--quiet", cand],
+            capture_output=True, text=True,
+        ).returncode == 0:
+            return cand
+    return None
+
+
+# Paths the scaffold overlay owns — auto_sync writes these on upgrade. They are
+# the driver's, not the user's edits: they may carry onto a feature branch and
+# are folded into the --prepare scaffold commit. Mirrors scaffold.py's versioned
+# overlay set (templates/, rules/, docs/, schemas/) plus the meta files.
+_SCAFFOLD_MANAGED_PREFIXES: tuple[str, ...] = (
+    ".specfuse/templates/", ".specfuse/rules/",
+    ".specfuse/docs/", ".specfuse/schemas/",
+)
+_SCAFFOLD_MANAGED_EXACT: frozenset[str] = frozenset({
+    ".specfuse/VERSION", ".specfuse/.scaffold-manifest",
+    ".specfuse/verification.yml.example",
+})
+
+
+def _is_scaffold_managed(path: str) -> bool:
+    return (path in _SCAFFOLD_MANAGED_EXACT
+            or any(path.startswith(p) for p in _SCAFFOLD_MANAGED_PREFIXES))
+
+
+def _scaffold_managed_dirty() -> set[str]:
+    """Tracked-dirty paths the scaffold overlay owns (subset of the dirty set)."""
+    return {p for p in _tracked_dirty_paths() if _is_scaffold_managed(p)}
+
+
+def _persist_scaffold_sync(installed: str) -> None:
+    """After auto_sync overlays a newer scaffold, keep the tree clean for the
+    rest of the run. On a non-default branch, commit the scaffold-managed
+    changes (`chore(loop): sync scaffold to X.Y.Z`). On the DEFAULT branch, leave
+    them and print guidance — committing scaffold churn onto the default branch
+    is undesirable; --prepare (or the next ensure_feature_branch) carries them
+    onto the feature branch and folds them into its scaffold commit instead.
+    """
+    dirty = _scaffold_managed_dirty()
+    if not dirty:
+        return
+    branch = _current_branch()
+    on_default = (not branch) or branch == _default_branch()
+    if on_default:
+        print(
+            f"auto_sync: scaffold upgraded to {installed}; leaving "
+            f"{len(dirty)} scaffold file(s) uncommitted on default branch "
+            f"'{branch or '(detached)'}'. --prepare will carry them onto the "
+            f"feature branch, or commit them yourself.",
+            file=sys.stderr,
+        )
+        return
+    commit_bookkeeping(sorted(dirty), f"chore(loop): sync scaffold to {installed}")
+    print(
+        f"auto_sync: scaffold upgraded to {installed}; committed "
+        f"{len(dirty)} scaffold file(s) on '{branch}'.",
+        file=sys.stderr,
+    )
+
+
 def _branch_prep_hint(feature_dir: "Path", feat_fm: dict, feature_id: str) -> str:
     """Actionable next-step block for the two pre-flight guards.
 
@@ -920,6 +998,11 @@ def prepare_feature(feat_fm: dict, feature_dir: "Path", feature_id: str) -> None
     for rel in (".specfuse/roadmap.md", ".specfuse/roadmap-archive.md"):
         if (repo_root / rel).exists():
             add_paths.append(str(repo_root / rel))
+    # Fold auto_sync's scaffold overlay into this commit too. On the default
+    # branch auto_sync leaves those uncommitted (see _persist_scaffold_sync);
+    # committing them here lands the upgrade on the feature branch, clean.
+    for rel in sorted(_scaffold_managed_dirty()):
+        add_paths.append(str(repo_root / rel))
     git("add", "--", *add_paths)
     staged = git("status", "--porcelain", "--", *add_paths)
     if staged:
@@ -1006,7 +1089,11 @@ def ensure_feature_branch(feat_fm: dict, feature_dir: "Path | None" = None) -> N
         # Create-from-HEAD carries the working tree onto the new branch. Only
         # the expected /pick-feature flips may ride along; anything else stops.
         dirty = _tracked_dirty_paths()
-        unexpected = dirty - _expected_flip_paths(feature_dir)
+        # Scaffold-overlay files (auto_sync's own upgrade writes) ride along too:
+        # they are driver-owned, and prepare_feature folds them into the scaffold
+        # commit. Only genuinely-unrelated edits remain "unexpected" (#prepare).
+        allowed = _expected_flip_paths(feature_dir) | _scaffold_managed_dirty()
+        unexpected = dirty - allowed
         if unexpected:
             raise FeatureBranchError(
                 "working tree has uncommitted changes to unexpected paths: "
@@ -2564,13 +2651,17 @@ _NO_FAILURES_SENTINEL = "### Failure-class breakdown\n\n(no non-passing attempts
 def summarize_attempt_failure_classes(
     feature_dir: Path,
     gate_n: int | None = None,
+    exclude_correlation_id: str | None = None,
 ) -> str:
     """Render a '### Failure-class breakdown' markdown table from events.jsonl.
 
     Reads attempt_outcome events whose outcome != 'passed'.  When gate_n is
     provided, restricts to events whose correlation_id belongs to that gate
-    (resolved via _gate_number_from_wu_id).  Returns _NO_FAILURES_SENTINEL when
-    no non-passing attempts match the filter.
+    (resolved via _gate_number_from_wu_id).  When exclude_correlation_id is
+    provided, drops events with that exact correlation_id — used to keep a
+    close WU's OWN non-passing attempts out of the breakdown it authors, so the
+    close's stumble does not arm the guard against itself (issue #145).  Returns
+    _NO_FAILURES_SENTINEL when no non-passing attempts match the filter.
 
     Pure function — reads events.jsonl; no writes, no side effects.
     Malformed JSONL lines are skipped (legacy-event tolerance, AC5).
@@ -2593,8 +2684,10 @@ def summarize_attempt_failure_classes(
         payload = evt.get("payload") or {}
         if payload.get("outcome") == "passed":
             continue
+        cid = evt.get("correlation_id", "")
+        if exclude_correlation_id is not None and cid == exclude_correlation_id:
+            continue
         if gate_n is not None:
-            cid = evt.get("correlation_id", "")
             if _gate_number_from_wu_id(cid) != gate_n:
                 continue
         non_passing.append(payload)
@@ -2658,7 +2751,14 @@ def assert_failure_class_breakdown_when_failures_present(
         return True, ""
 
     gate_n = _gate_number_from_wu_id(wu.wu_id)
-    summary = summarize_attempt_failure_classes(feature_dir, gate_n)
+    # Exclude the close WU's OWN non-passing attempts: the breakdown documents
+    # SUBSTANTIVE-WU failures, not the close's own stumble. Without this, a
+    # failed first close attempt retroactively requires a new subsection in the
+    # RETROSPECTIVE the close itself authors — and the between-attempt
+    # `reset --hard` wipes the partial each retry → spin → blocked_human on
+    # otherwise-done features (issue #145).
+    summary = summarize_attempt_failure_classes(
+        feature_dir, gate_n, exclude_correlation_id=wu.wu_id)
 
     if summary == _NO_FAILURES_SENTINEL:
         return True, ""
@@ -2666,7 +2766,7 @@ def assert_failure_class_breakdown_when_failures_present(
     if re.search(r"^#{3} Failure-class breakdown\b", retro.read_text(), re.MULTILINE):
         return True, ""
 
-    # Count non-passing attempts for the error message.
+    # Count non-passing attempts (excluding the close's own) for the message.
     events_path = feature_dir / "events.jsonl"
     count = 0
     if events_path.exists():
@@ -2683,18 +2783,25 @@ def assert_failure_class_breakdown_when_failures_present(
             payload = evt.get("payload") or {}
             if payload.get("outcome") == "passed":
                 continue
+            cid = evt.get("correlation_id", "")
+            if cid == wu.wu_id:
+                continue
             if gate_n is not None:
-                cid = evt.get("correlation_id", "")
                 if _gate_number_from_wu_id(cid) != gate_n:
                     continue
             count += 1
 
     gate_label = f"gate {gate_n}" if gate_n is not None else "all gates"
+    # Actionable, self-contained retry note (flows into the next attempt's prompt
+    # via failure_note, issue #145 fix #2): name the moved bar AND embed the exact
+    # table to paste, so the agent doesn't rediscover the requirement.
     return (
         False,
         f"assert_failure_class_breakdown_when_failures_present: {count} "
-        f"non-passing attempt(s) in {gate_label} but '### Failure-class breakdown' "
-        f"subsection absent from RETROSPECTIVE.md",
+        f"substantive-WU attempt(s) in {gate_label} did not pass, so "
+        f"RETROSPECTIVE.md MUST include a '### Failure-class breakdown' subsection "
+        f"— it is absent. Add exactly this subsection to RETROSPECTIVE.md:\n\n"
+        f"{summary}",
     )
 
 
@@ -3112,7 +3219,14 @@ def run(
         # draft-feature can't take). --prepare-only stops after, so you can
         # review the commit before the loop dispatches anything.
         if prepare or prepare_only:
-            prepare_feature(feat_fm, feature_dir, feature_id)
+            # Genuinely-unrelated dirty paths (not the /pick-feature flips, not
+            # auto_sync's scaffold overlay) still stop --prepare — but with a
+            # clean, actionable message and a non-zero exit, not a traceback.
+            try:
+                prepare_feature(feat_fm, feature_dir, feature_id)
+            except FeatureBranchError as exc:
+                print(f"--prepare cannot proceed:\n{exc}", file=sys.stderr)
+                return 1
         if prepare_only:
             print("Prepared: feature is on its branch and committed. "
                   "Re-run `specfuse-loop` to start the gate.")
@@ -3998,6 +4112,7 @@ def auto_sync(
                 f"WARNING: auto_sync: plugin config drift corrected: {', '.join(changes)}",
                 file=sys.stderr,
             )
+        _persist_scaffold_sync(installed)
         return
 
     # Older with modified files.
@@ -4056,6 +4171,7 @@ def auto_sync(
                 f"WARNING: auto_sync: plugin config drift corrected: {', '.join(changes)}",
                 file=sys.stderr,
             )
+        _persist_scaffold_sync(installed)
     else:
         # Non-interactive (CI / claude -p): skip modified files + warn; never block.
         print(
@@ -4092,6 +4208,7 @@ def auto_sync(
                 f"WARNING: auto_sync: plugin config drift corrected: {', '.join(changes)}",
                 file=sys.stderr,
             )
+        _persist_scaffold_sync(installed)
 
 
 def main() -> int:

{specfuse_loop-0.3.11 → specfuse_loop-0.3.13/specfuse_loop.egg-info}/PKG-INFO

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

{specfuse_loop-0.3.11 → specfuse_loop-0.3.13}/specfuse_loop.egg-info/SOURCES.txt

@@ -51,6 +51,7 @@ tests/test_autosync_plugin.py
 tests/test_backend.py
 tests/test_bookkeeping_commit_crash_run.py
 tests/test_bookkeeping_commit_hook_crash.py
+tests/test_close_wu_self_reference.py
 tests/test_closing_deliverable_guard.py
 tests/test_cost_tracking.py
 tests/test_degraded_oracle.py
@@ -112,6 +113,7 @@ tests/test_miniyaml_equivalence.py
 tests/test_miniyaml_negative.py
 tests/test_planned_cost_lint.py
 tests/test_prepare_feature.py
+tests/test_prepare_scaffold_sync.py
 tests/test_produces_field.py
 tests/test_result_block.py
 tests/test_roadmap_add_skill.py

specfuse_loop-0.3.13/tests/test_close_wu_self_reference.py

@@ -0,0 +1,115 @@
+#
+# Copyright 2026 Specfuse contributors
+# Licensed under the Apache License, Version 2.0. See LICENSE.
+#
+"""Issue #145 — a close WU's own failed attempt must not arm the
+failure-class-breakdown guard against that same close WU.
+
+`assert_failure_class_breakdown_when_failures_present` requires a
+`### Failure-class breakdown` subsection in RETROSPECTIVE.md once non-passing
+attempts exist in the gate. It counted ALL non-passing attempts — including the
+close WU's OWN. Since the close WU is the one that authors the RETROSPECTIVE the
+guard inspects, its malformed first attempt retroactively added a required
+subsection to its own output, and the between-attempt `reset --hard` wiped the
+partial each retry → spin → blocked_human on otherwise-done features.
+
+Fix #3: exclude the close WU's own attempts (correlation_id == its wu_id) from
+the failure set that arms the guard against it. Substantive-WU failures still
+require the breakdown. Fix #2: when the guard does fire, its message names the
+required subsection and embeds the exact expected table (it flows into the retry
+prompt via failure_note), so the agent doesn't rediscover the moved bar.
+"""
+
+from __future__ import annotations
+
+import json
+import tempfile
+import unittest
+from pathlib import Path
+
+from tests._loop_loader import load_loop
+
+loop = load_loop()
+
+CLOSE_ID = "FEAT-2026-0099/G1-CLOSE"
+SUBSTANTIVE_ID = "FEAT-2026-0099/G1-T01"
+
+
+def _close_wu(wu_file: Path) -> "loop.WorkUnit":
+    return loop.WorkUnit(
+        wu_id=CLOSE_ID, file=wu_file, depends_on=[], type="close",
+        model="opus", effort="high", status="pending", attempts=1,
+        title="Close gate 1", body="body",
+    )
+
+
+def _attempt_event(correlation_id: str, outcome: str = "failed",
+                   failure_class: str = "other", sig: str = "verdict_malformed") -> str:
+    return json.dumps({
+        "event_type": "attempt_outcome",
+        "correlation_id": correlation_id,
+        "timestamp": "2026-07-12T00:00:00Z",
+        "payload": {"outcome": outcome, "failure_class": failure_class,
+                    "failure_signature": sig},
+    })
+
+
+class TestCloseSelfReference(unittest.TestCase):
+    def _feature_dir(self, tmp: str, events: list[str], retro: str = "# Retro\n") -> Path:
+        d = Path(tmp)
+        (d / "events.jsonl").write_text("\n".join(events) + "\n")
+        (d / "RETROSPECTIVE.md").write_text(retro)
+        return d
+
+    def test_close_own_failure_does_not_arm_guard(self):
+        # Only the close WU's OWN attempts are non-passing (the observed run).
+        with tempfile.TemporaryDirectory() as tmp:
+            d = self._feature_dir(tmp, [_attempt_event(CLOSE_ID)])
+            wu = _close_wu(d / "WU.md")
+            ok, msg = loop.assert_failure_class_breakdown_when_failures_present(
+                wu, d, Path(tmp), "HEAD~1")
+        self.assertTrue(ok, f"close's own failure must not require the breakdown: {msg}")
+
+    def test_substantive_failure_still_requires_breakdown(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            d = self._feature_dir(
+                tmp, [_attempt_event(SUBSTANTIVE_ID), _attempt_event(CLOSE_ID)])
+            wu = _close_wu(d / "WU.md")
+            ok, msg = loop.assert_failure_class_breakdown_when_failures_present(
+                wu, d, Path(tmp), "HEAD~1")
+        self.assertFalse(ok, "a substantive-WU failure still requires the breakdown")
+        # Fix #2 — message is actionable and embeds the exact table to include.
+        self.assertIn("### Failure-class breakdown", msg)
+        self.assertIn("| failure_class |", msg)
+
+    def test_breakdown_table_excludes_close_own_attempts(self):
+        # Two substantive failures + one close-own failure; the rendered table
+        # the guard offers must count only the two substantive ones.
+        with tempfile.TemporaryDirectory() as tmp:
+            d = self._feature_dir(
+                tmp,
+                [_attempt_event(SUBSTANTIVE_ID), _attempt_event(SUBSTANTIVE_ID),
+                 _attempt_event(CLOSE_ID)])
+            table = loop.summarize_attempt_failure_classes(
+                d, gate_n=1, exclude_correlation_id=CLOSE_ID)
+        self.assertIn("**total** | **2**", table)
+
+    def test_summarize_all_self_returns_sentinel(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            d = self._feature_dir(tmp, [_attempt_event(CLOSE_ID)])
+            table = loop.summarize_attempt_failure_classes(
+                d, gate_n=1, exclude_correlation_id=CLOSE_ID)
+        self.assertEqual(table, loop._NO_FAILURES_SENTINEL)
+
+    def test_breakdown_present_passes(self):
+        retro = "# Retro\n\n### Failure-class breakdown\n\n| x | 1 | y |\n"
+        with tempfile.TemporaryDirectory() as tmp:
+            d = self._feature_dir(tmp, [_attempt_event(SUBSTANTIVE_ID)], retro=retro)
+            wu = _close_wu(d / "WU.md")
+            ok, _ = loop.assert_failure_class_breakdown_when_failures_present(
+                wu, d, Path(tmp), "HEAD~1")
+        self.assertTrue(ok)
+
+
+if __name__ == "__main__":
+    unittest.main()

specfuse_loop-0.3.13/tests/test_prepare_scaffold_sync.py

@@ -0,0 +1,172 @@
+#
+# Copyright 2026 Specfuse contributors
+# Licensed under the Apache License, Version 2.0. See LICENSE.
+#
+"""auto_sync's scaffold upgrade must not poison the same run's --prepare.
+
+Before this fix, `specfuse-loop --prepare` crashed with a traceback: auto_sync
+overlays the new scaffold (dirtying .specfuse/VERSION, .scaffold-manifest,
+docs/, templates/) and leaves it uncommitted, then ensure_feature_branch
+refuses to carry those "unexpected" paths onto the new feature branch.
+
+The graceful behavior pinned here:
+
+  1. auto_sync COMMITS its own scaffold overlay on a non-default branch
+     (`chore(loop): sync scaffold to X.Y.Z`) so the tree is clean; on the
+     DEFAULT branch it leaves them + prints guidance (--prepare carries them).
+  2. ensure_feature_branch CARRIES scaffold-managed dirty paths onto a new
+     branch instead of refusing — but still blocks genuinely-unrelated edits.
+  3. prepare_feature FOLDS the scaffold-managed paths into its scaffold commit
+     (so the default-branch case lands them committed on the feature branch).
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import unittest
+from contextlib import contextmanager
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+from tests._loop_loader import load_loop
+
+loop = load_loop()
+
+
+def _git(root: Path, *args: str) -> str:
+    return subprocess.run(
+        ["git", "-C", str(root), *args],
+        capture_output=True, text=True, check=True,
+    ).stdout.strip()
+
+
+@contextmanager
+def _chdir(path: Path):
+    prev = Path.cwd()
+    os.chdir(path)
+    try:
+        yield
+    finally:
+        os.chdir(prev)
+
+
+@contextmanager
+def _repo():
+    """Temp git repo on `main`, one commit, a tracked scaffold template."""
+    with TemporaryDirectory(ignore_cleanup_errors=True) as tmp:
+        root = Path(tmp)
+        subprocess.run(["git", "init", "-q", "-b", "main", str(root)], check=True)
+        _git(root, "config", "user.email", "test@example.com")
+        _git(root, "config", "user.name", "Test")
+        _git(root, "config", "commit.gpgSign", "false")
+        tmpl = root / ".specfuse/templates/WU.template.md"
+        tmpl.parent.mkdir(parents=True)
+        tmpl.write_text("old template\n")
+        (root / ".specfuse/VERSION").write_text("0.3.0\n")
+        (root / "README.md").write_text("# fixture\n")
+        _git(root, "add", ".")
+        _git(root, "commit", "-q", "-m", "init")
+        yield root
+
+
+def _dirty_scaffold(root: Path) -> None:
+    """Simulate auto_sync's overlay: modify tracked scaffold files."""
+    (root / ".specfuse/templates/WU.template.md").write_text("new template\n")
+    (root / ".specfuse/VERSION").write_text("0.3.11\n")
+
+
+class TestDefaultBranch(unittest.TestCase):
+    def test_local_main_detected(self):
+        with _repo() as root, _chdir(root):
+            self.assertEqual(loop._default_branch(), "main")
+
+
+class TestScaffoldManagedDirty(unittest.TestCase):
+    def test_classifies_scaffold_vs_user_paths(self):
+        with _repo() as root:
+            _dirty_scaffold(root)
+            (root / "README.md").write_text("# edited\n")  # user edit
+            with _chdir(root):
+                managed = loop._scaffold_managed_dirty()
+        self.assertIn(".specfuse/templates/WU.template.md", managed)
+        self.assertIn(".specfuse/VERSION", managed)
+        self.assertNotIn("README.md", managed)
+
+
+class TestPersistScaffoldSync(unittest.TestCase):
+    def test_commits_on_feature_branch(self):
+        with _repo() as root:
+            _git(root, "checkout", "-q", "-b", "feat/x")
+            _dirty_scaffold(root)
+            with _chdir(root):
+                loop._persist_scaffold_sync("0.3.11")
+                dirty = loop._tracked_dirty_paths()
+            self.assertEqual(dirty, set(), "scaffold sync must be committed")
+            self.assertIn("sync scaffold to 0.3.11",
+                          _git(root, "log", "-1", "--pretty=%s"))
+
+    def test_guides_and_leaves_on_default_branch(self):
+        with _repo() as root:  # on main == default
+            _dirty_scaffold(root)
+            with _chdir(root):
+                loop._persist_scaffold_sync("0.3.11")
+                dirty = loop._tracked_dirty_paths()
+            # left uncommitted (no surprise commit on the default branch)
+            self.assertIn(".specfuse/VERSION", dirty)
+            self.assertEqual("init", _git(root, "log", "-1", "--pretty=%s"))
+
+
+class TestEnsureFeatureBranchCarriesScaffold(unittest.TestCase):
+    def test_scaffold_paths_carry_onto_new_branch(self):
+        with _repo() as root:
+            _dirty_scaffold(root)
+            with _chdir(root):
+                loop.ensure_feature_branch({"branch": "feat/y"})
+                current = _git(root, "branch", "--show-current")
+            self.assertEqual(current, "feat/y")
+            self.assertEqual(
+                (root / ".specfuse/templates/WU.template.md").read_text(),
+                "new template\n",
+            )
+
+    def test_unexpected_edit_still_blocks_even_with_scaffold_dirty(self):
+        with _repo() as root:
+            _commit = root / "src/app.py"
+            _commit.parent.mkdir()
+            _commit.write_text("x = 1\n")
+            _git(root, "add", ".")
+            _git(root, "commit", "-q", "-m", "app")
+            _dirty_scaffold(root)
+            (root / "src/app.py").write_text("x = 2\n")  # unrelated edit
+            with _chdir(root):
+                with self.assertRaises(loop.FeatureBranchError) as ctx:
+                    loop.ensure_feature_branch({"branch": "feat/z"})
+            self.assertIn("src/app.py", str(ctx.exception))
+
+
+class TestPrepareFoldsScaffold(unittest.TestCase):
+    def test_default_branch_scaffold_folds_into_prepare_commit(self):
+        with _repo() as root:  # on main == default
+            feat_dir = root / ".specfuse/features/FEAT-2026-0099-x"
+            feat_dir.mkdir(parents=True)
+            (feat_dir / "PLAN.md").write_text("branch: feat/FEAT-2026-0099-x\n")
+            _dirty_scaffold(root)  # auto_sync left these on default branch
+            with _chdir(root):
+                loop.prepare_feature(
+                    {"branch": "feat/FEAT-2026-0099-x"}, feat_dir,
+                    "FEAT-2026-0099",
+                )
+                dirty = loop._tracked_dirty_paths()
+                current = _git(root, "branch", "--show-current")
+            self.assertEqual(current, "feat/FEAT-2026-0099-x")
+            self.assertEqual(dirty, set(), "scaffold + folder must be committed")
+            # scaffold file is committed on the feature branch
+            self.assertEqual(
+                _git(root, "show", "HEAD:.specfuse/templates/WU.template.md"),
+                "new template",
+            )
+
+
+if __name__ == "__main__":
+    unittest.main()

specfuse_loop-0.3.11/specfuse/loop/data/VERSION

@@ -1 +0,0 @@
-0.3.11