specfuse-loop 0.3.12__tar.gz → 0.3.14__tar.gz

{specfuse_loop-0.3.12/specfuse_loop.egg-info → specfuse_loop-0.3.14}/PKG-INFO

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

{specfuse_loop-0.3.12 → specfuse_loop-0.3.14}/pyproject.toml

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

specfuse_loop-0.3.14/specfuse/loop/data/VERSION

@@ -0,0 +1 @@
+0.3.14

{specfuse_loop-0.3.12 → specfuse_loop-0.3.14}/specfuse/loop/gh_backend.py

@@ -13,9 +13,14 @@ from typing import Callable, Optional
 from . import loop as _loop
 
 
-def _default_runner(args: list) -> None:
-    """Shell out to gh with the given argument list. Not called in tests."""
-    subprocess.run(args, check=True, capture_output=True, text=True)
+def _default_runner(args: list, check: bool = True):
+    """Shell out to gh with the given argument list. Not called in tests.
+
+    Returns the completed process so probing callers (e.g. the `gh pr view`
+    idempotency check) can inspect `.returncode` without raising; side-effecting
+    callers pass no `check` override and get the prior raise-on-failure behavior.
+    """
+    return subprocess.run(args, check=check, capture_output=True, text=True)
 
 
 class GitHubBackend(_loop.Backend):
@@ -55,9 +60,9 @@ class GitHubBackend(_loop.Backend):
         title = feat_fm.get("title", feature_id)
 
         # Idempotent: skip PR creation if one already exists for this branch.
-        check = subprocess.run(
+        check = self._runner(
             ["gh", "pr", "view", branch, "--repo", self.repo, "--json", "number"],
-            capture_output=True, text=True,
+            check=False,
         )
         if check.returncode != 0:
             body = (
@@ -70,7 +75,7 @@ class GitHubBackend(_loop.Backend):
                 "gh", "pr", "create",
                 "--title", f"[{feature_id}] {title}",
                 "--body", body,
-                "--base", "main",
+                "--base", _loop.resolve_base(feat_fm),
                 "--head", branch,
             ])
 

{specfuse_loop-0.3.12 → specfuse_loop-0.3.14}/specfuse/loop/lint_plan.py

@@ -249,6 +249,15 @@ def lint(feature_dir: Path) -> list[str]:
     if missing:
         errs.append(f"PLAN.md frontmatter missing keys: {sorted(missing)}")
 
+    if "base" in fm:
+        base_val = fm["base"]
+        feature_id_val = fm.get("feature_id", feature_dir.name)
+        if not isinstance(base_val, str) or not base_val.strip():
+            errs.append(
+                f"{feature_id_val}: PLAN.md frontmatter 'base' key is present but "
+                f"empty/whitespace-only/non-string: {base_val!r}"
+            )
+
     graph = _find_task_graph_block(body)
     if graph is None:
         return errs + ["PLAN.md has no ```yaml graph block"]

{specfuse_loop-0.3.12 → specfuse_loop-0.3.14}/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.12"
+DRIVER_VERSION = "0.3.14"
 # 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
@@ -719,14 +719,34 @@ class FeatureBranchError(RuntimeError):
     """
 
 
+def untracked_paths() -> set[str]:
+    """Repo-relative paths git reports as untracked, honoring .gitignore.
+
+    Snapshotted per-WU immediately before dispatch so `squash_commit` can tell
+    "the operator already had this file" from "this run created it" — only the
+    latter belongs in the WU's commit. See issue #150 and `squash_commit`.
+    """
+    out = subprocess.run(
+        ["git", "ls-files", "--others", "--exclude-standard"],
+        capture_output=True, text=True, check=True,
+    ).stdout
+    return {line.strip() for line in out.splitlines() if line.strip()}
+
+
 def _tracked_dirty_paths() -> set[str]:
     """Paths with TRACKED, uncommitted changes (staged or unstaged), repo-relative.
 
     Untracked files (porcelain `??`) are excluded: they never block a create
-    (`checkout -B`) and carry harmlessly, so counting them would spuriously
-    flag a leftover events.jsonl as an "unexpected" change. The dirty-tree
-    failure in #48 is tracked local modifications ("your local changes would
-    be overwritten by checkout"), which is exactly what this set captures.
+    (`checkout -B`), so counting them would spuriously flag a leftover
+    events.jsonl as an "unexpected" change. The dirty-tree failure in #48 is
+    tracked local modifications ("your local changes would be overwritten by
+    checkout"), which is exactly what this set captures.
+
+    This exclusion means untracked files DO carry onto a freshly created feature
+    branch. That is safe only because `squash_commit` refuses to stage untracked
+    paths that pre-date the WU's dispatch (#150) — before that fix, its
+    `git add -A` committed them, so this guard was strictly narrower than the
+    commit that followed it.
     """
     out = subprocess.run(
         ["git", "status", "--porcelain"],
@@ -790,6 +810,78 @@ def _default_branch() -> "str | None":
     return None
 
 
+def resolve_base(feat_fm: dict) -> "str | None":
+    """The ref a feature's branch/PR should sit on top of.
+
+    Frontmatter `base` wins when set and non-empty (after stripping
+    whitespace). Absent, empty, or whitespace-only falls back to
+    `_default_branch()`; if that too is undeterminable, falls back to the
+    current branch. Callers (T02, T03) are responsible for wiring this in —
+    this function only resolves the name, it does not touch git state.
+    """
+    base = feat_fm.get("base")
+    if isinstance(base, str) and base.strip():
+        return base.strip()
+    default = _default_branch()
+    if default:
+        return default
+    return _current_branch()
+
+
+class BaseBranchError(RuntimeError):
+    """Raised when a feature's declared `base` ref cannot be made available.
+
+    Carries an actionable, human-readable message distinguishing a probable
+    typo (remote confirms the ref does not exist) from an unreachable remote
+    (network/auth failure — the ref's existence is simply unknown), so the two
+    cases are never mistaken for each other.
+    """
+
+
+def ensure_base_ref(base: str) -> None:
+    """Make sure git ref *base* is resolvable locally, fetching it if needed.
+
+    No-ops (no network call) when `git rev-parse --verify base` already
+    succeeds locally. Otherwise asks origin via `git ls-remote --exit-code`:
+    if origin has it, fetches it and prints one line naming what and why; if
+    origin explicitly does not have it, raises BaseBranchError naming likely
+    local-branch candidates (probable typo); if ls-remote itself fails
+    (offline/auth), raises a distinctly-worded BaseBranchError instead of
+    conflating "does not exist" with "could not check".
+    """
+    local = subprocess.run(
+        ["git", "rev-parse", "--verify", base],
+        capture_output=True, text=True,
+    )
+    if local.returncode == 0:
+        return
+    remote = subprocess.run(
+        ["git", "ls-remote", "--exit-code", "origin", base],
+        capture_output=True, text=True,
+    )
+    if remote.returncode == 0:
+        subprocess.run(["git", "fetch", "origin", base], capture_output=True, text=True, check=True)
+        print(f"ensure_base_ref: fetched '{base}' from origin (declared feature base, not present locally).")
+        return
+    if remote.returncode == 2:
+        # ls-remote's documented exit code for "ref not found on that remote".
+        branches = subprocess.run(
+            ["git", "branch", "--list", "--format=%(refname:short)"],
+            capture_output=True, text=True,
+        ).stdout.splitlines()
+        candidates = [b.strip() for b in branches if b.strip()]
+        listed = ", ".join(sorted(candidates)) if candidates else "(no local branches)"
+        raise BaseBranchError(
+            f"base '{base}' does not exist locally or on origin — probable typo. "
+            f"Local branches: {listed}"
+        )
+    stderr = remote.stderr.strip() or remote.stdout.strip() or "(no git output)"
+    raise BaseBranchError(
+        f"base '{base}' could not be verified against origin — remote unreachable "
+        f"(offline or auth failure), not confirmed missing: {stderr}"
+    )
+
+
 # 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
@@ -1059,34 +1151,41 @@ def ensure_feature_branch(feat_fm: dict, feature_dir: "Path | None" = None) -> N
     ).stdout.strip()
     if current == branch:
         return
+    # A declared `base` (T01's resolve_base/ensure_base_ref) is the branch's
+    # true starting point, not wherever HEAD happens to be standing. Resolving
+    # and fetching it here — before any checkout — lets both branch creation
+    # and the staleness check below anchor on the base instead of HEAD.
+    # BaseBranchError is intentionally left to propagate uncaught: the base
+    # cause must reach the operator, not be reshaped into a FeatureBranchError.
+    base = resolve_base(feat_fm)
+    if base:
+        ensure_base_ref(base)
+    else:
+        base = current
     exists = subprocess.run(
         ["git", "rev-parse", "--verify", branch],
         capture_output=True, text=True,
     ).returncode == 0
     if exists:
-        # Surface a stale branch that diverged from the current base instead of
-        # silently reusing it. `merge-base --is-ancestor B HEAD` exits 0 iff B
-        # is an ancestor of HEAD (i.e. HEAD already contains B — safe to reuse).
+        # Surface a stale branch that diverged from the declared base instead
+        # of silently reusing it. `merge-base --is-ancestor B <base>` exits 0
+        # iff B is an ancestor of base (i.e. base already contains B — safe).
         is_ancestor = subprocess.run(
-            ["git", "merge-base", "--is-ancestor", branch, "HEAD"],
+            ["git", "merge-base", "--is-ancestor", branch, base],
             capture_output=True, text=True,
         ).returncode == 0
         if not is_ancestor:
             raise FeatureBranchError(
-                f"branch '{branch}' already exists and has diverged from your "
-                f"current branch '{current}' (it carries commits HEAD does not). "
-                f"Refusing to silently check it out — that could build on a stale "
-                f"base or lose work. Pick one, then re-run:\n"
-                f"  - resume that branch's work:    git checkout {branch}\n"
-                f"  - rebase it onto here:          git checkout {branch} && "
-                f"git rebase {current}\n"
-                f"  - discard it (work not needed): git branch -D {branch}   "
-                f"(the loop recreates it from HEAD)"
+                f"branch '{branch}' has diverged from '{base}' — it carries "
+                f"commits '{base}' does not, likely because it was created "
+                f"from a different starting point or '{base}' has since moved "
+                f"on. The safe action is to bring it up to date with the base:\n"
+                f"  git checkout {branch} && git rebase {base}"
             )
         _checked_checkout(["checkout", branch], f"checkout of existing branch '{branch}'")
         print(f"Switched to feature branch '{branch}' (was on '{current}').")
     else:
-        # Create-from-HEAD carries the working tree onto the new branch. Only
+        # Create-from-base carries the working tree onto the new branch. Only
         # the expected /pick-feature flips may ride along; anything else stops.
         dirty = _tracked_dirty_paths()
         # Scaffold-overlay files (auto_sync's own upgrade writes) ride along too:
@@ -1101,8 +1200,8 @@ def ensure_feature_branch(feat_fm: dict, feature_dir: "Path | None" = None) -> N
                 + f". Refusing to carry them onto new branch '{branch}'. "
                 "Commit or stash them first, then re-run."
             )
-        _checked_checkout(["checkout", "-B", branch], f"create of branch '{branch}'")
-        print(f"Created feature branch '{branch}' from '{current}'.")
+        _checked_checkout(["checkout", "-B", branch, base], f"create of branch '{branch}'")
+        print(f"Created feature branch '{branch}' from '{base}'.")
 
 
 def acquire_tree_lock(specfuse_dir: Path):
@@ -1344,12 +1443,38 @@ class SquashCommitError(RuntimeError):
     """
 
 
-def squash_commit(wu: WorkUnit, head_before: str) -> str | None:
+def squash_commit(
+    wu: WorkUnit,
+    head_before: str,
+    untracked_before: "set[str] | frozenset[str]" = frozenset(),
+) -> str | None:
+    """Squash the WU's work into one commit; return its sha, or None if nothing.
+
+    `untracked_before` is the set of untracked paths captured immediately before
+    this WU was dispatched (see `untracked_paths`). Those are the operator's —
+    scratch notes, another harness's config, a local script — and are unstaged
+    after `add -A` so they are not absorbed into the WU's commit (#150). Files
+    the run itself created are still committed: the distinction is "did this
+    dispatch create it", not "is it tracked".
+
+    Callers that omit the snapshot keep the legacy stage-everything behavior.
+    """
     if git("rev-parse", "HEAD") != head_before:
         git("reset", "--soft", head_before)  # fold away any commits the agent made
     if not git("status", "--porcelain"):
         return None
     git("add", "-A")
+    if untracked_before:
+        # Unstage the operator's pre-existing untracked files. Paths the agent
+        # deleted during dispatch are skipped — `git reset -- <missing>` is fine,
+        # but pathspec-matching nothing errors on some git versions.
+        stale = sorted(p for p in untracked_before if Path(p).exists())
+        if stale:
+            git("reset", "-q", "--", *stale)
+        # `add -A` may have had nothing else to stage: a WU whose only tree
+        # change was the operator's WIP must not manufacture a commit from it.
+        if not git("diff", "--cached", "--name-only"):
+            return None
     msg = f"feat: {wu.title}\n\nFeature: {wu.wu_id}"
     res = subprocess.run(
         ["git", "commit", "-m", msg], capture_output=True, text=True,
@@ -2651,13 +2776,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).
@@ -2680,8 +2809,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)
@@ -2745,7 +2876,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, ""
@@ -2753,7 +2891,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():
@@ -2770,18 +2908,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}",
     )
 
 
@@ -3394,6 +3539,11 @@ def run(
                     # Fall through to existing close-WU dispatch path
 
                 head_before = git("rev-parse", "HEAD")
+                # Snapshot the operator's untracked files alongside head_before:
+                # squash_commit must not absorb WIP that pre-dates this dispatch
+                # (#150). Captured here, not inside squash_commit, because by
+                # then the agent's own new files are indistinguishable from it.
+                untracked_before = untracked_paths()
                 _is_rearm = detect_rearm_dispatch(wu)
                 if _is_rearm:
                     fold_cumulative_on_rearm(wu, backend)
@@ -3533,7 +3683,8 @@ def run(
                         backend.set_wu(wu, "status", DONE)
                         write_cost_to_wu(backend, wu, cum_usage)
                         try:
-                            sha = squash_commit(wu, head_before)
+                            sha = squash_commit(wu, head_before,
+                                                untracked_before=untracked_before)
                         except SquashCommitError as exc:
                             # The squash commit was rejected (typically a
                             # pre-commit hook). Treat as a failed attempt rather

{specfuse_loop-0.3.12 → specfuse_loop-0.3.14/specfuse_loop.egg-info}/PKG-INFO

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

{specfuse_loop-0.3.12 → specfuse_loop-0.3.14}/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
@@ -61,6 +62,7 @@ tests/test_driver_lock.py
 tests/test_duration_tracking.py
 tests/test_empty_files_escalation.py
 tests/test_ensure_feature_branch.py
+tests/test_ensure_feature_branch_base.py
 tests/test_events_redaction.py
 tests/test_extra_gates.py
 tests/test_force_full_close.py
@@ -114,6 +116,7 @@ tests/test_planned_cost_lint.py
 tests/test_prepare_feature.py
 tests/test_prepare_scaffold_sync.py
 tests/test_produces_field.py
+tests/test_resolve_base.py
 tests/test_result_block.py
 tests/test_roadmap_add_skill.py
 tests/test_roadmap_archive_skill.py
@@ -133,6 +136,7 @@ tests/test_template_closing_shapes.py
 tests/test_terminal_flip_ownership.py
 tests/test_terminal_flips.py
 tests/test_untracked_feature_folder.py
+tests/test_untracked_file_absorption.py
 tests/test_upgrade_integration.py
 tests/test_upgrade_merge_gate.py
 tests/test_validate_event.py

{specfuse_loop-0.3.12 → specfuse_loop-0.3.14}/tests/test_backend.py

@@ -17,7 +17,7 @@ import unittest
 from pathlib import Path
 
 from tests._loop_loader import load_loop
-from tests._workspace import integration_workspace
+from tests._workspace import integration_workspace, with_deliverable
 
 loop = load_loop()
 
@@ -154,6 +154,11 @@ class TestBackendLifecycleIntegration(unittest.TestCase):
 
     def _patch(self, name: str, replacement):
         self._patches.append((name, getattr(loop, name)))
+        # Dispatch stubs must write a deliverable or the presence gate
+        # (FEAT-2026-0022) rejects the WU as hollow. See #150 —
+        # `.specfuse/.loop.lock` used to stand in as the deliverable.
+        if name == "dispatch":
+            replacement = with_deliverable(replacement)
         setattr(loop, name, replacement)
 
     def test_on_feature_start_fires_before_dispatch_on_blocked_run(self):

specfuse_loop-0.3.14/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.12 → specfuse_loop-0.3.14}/tests/test_cost_tracking.py

@@ -22,6 +22,7 @@ import unittest
 from pathlib import Path
 
 from tests._loop_loader import load_loop
+from tests._workspace import with_deliverable
 from tests.test_driver_integration import (
     integration_workspace,
     write_minimal_feature,
@@ -125,6 +126,11 @@ class TestCostTrackingIntegration(unittest.TestCase):
 
     def _patch(self, name: str, replacement):
         self._patches.append((name, getattr(loop, name)))
+        # Dispatch stubs must write a deliverable or the presence gate
+        # (FEAT-2026-0022) rejects the WU as hollow. See #150 —
+        # `.specfuse/.loop.lock` used to stand in as the deliverable.
+        if name == "dispatch":
+            replacement = with_deliverable(replacement)
         setattr(loop, name, replacement)
 
     def test_enabled_writes_cost_to_wu_frontmatter_and_events(self):

{specfuse_loop-0.3.12 → specfuse_loop-0.3.14}/tests/test_driver_integration.py

@@ -26,7 +26,7 @@ import unittest
 from pathlib import Path
 
 from tests._loop_loader import load_loop
-from tests._workspace import integration_workspace
+from tests._workspace import integration_workspace, with_deliverable
 
 loop = load_loop()
 
@@ -90,6 +90,13 @@ gates:
             f"---\nid: {wu_id}\ntype: {wu_type}\nmodel: claude-haiku-4-5-20251001\n"
             f"status: {wu_status}\nattempts: 0\n---\n\n# {tnn}{body}"
         )
+    # Mirror the real repo's .gitignore for driver-owned runtime files. Without
+    # this the fixture repo leaves `.specfuse/.loop.lock` untracked, and before
+    # #150 `squash_commit`'s `git add -A` committed it — where it silently
+    # satisfied the deliverable-presence guard for stub dispatches that write
+    # nothing. The lock file is not a deliverable; the real .gitignore has always
+    # excluded it, so the fixture models reality by doing the same.
+    (root / ".gitignore").write_text(".specfuse/.loop.lock\n")
     # Stage and commit the scaffold so the driver starts from a clean tree.
     subprocess.run(["git", "-C", str(root), "add", "."], check=True)
     subprocess.run(["git", "-C", str(root), "commit", "-q", "-m",
@@ -147,6 +154,11 @@ class TestBug1StatusFlipSurvivesReset(unittest.TestCase):
 
     def _patch(self, name: str, replacement):
         self._patches.append((name, getattr(loop, name)))
+        # Dispatch stubs must write a deliverable or the presence gate
+        # (FEAT-2026-0022) rejects the WU as hollow. See #150 —
+        # `.specfuse/.loop.lock` used to stand in as the deliverable.
+        if name == "dispatch":
+            replacement = with_deliverable(replacement)
         setattr(loop, name, replacement)
 
     def test_passed_then_blocked_flips_persist(self):
@@ -253,6 +265,11 @@ class TestBug2FeatureBranchCheckout(unittest.TestCase):
 
     def _patch(self, name: str, replacement):
         self._patches.append((name, getattr(loop, name)))
+        # Dispatch stubs must write a deliverable or the presence gate
+        # (FEAT-2026-0022) rejects the WU as hollow. See #150 —
+        # `.specfuse/.loop.lock` used to stand in as the deliverable.
+        if name == "dispatch":
+            replacement = with_deliverable(replacement)
         setattr(loop, name, replacement)
 
     def test_driver_switches_to_declared_branch(self):