specfuse-loop 0.3.22__tar.gz → 0.3.23__tar.gz

{specfuse_loop-0.3.22/specfuse_loop.egg-info → specfuse_loop-0.3.23}/PKG-INFO

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

{specfuse_loop-0.3.22 → specfuse_loop-0.3.23}/pyproject.toml

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

specfuse_loop-0.3.23/specfuse/loop/data/VERSION

@@ -0,0 +1 @@
+0.3.23

{specfuse_loop-0.3.22 → specfuse_loop-0.3.23}/specfuse/loop/data/docs/methodology.md

@@ -147,6 +147,18 @@ WU's** frontmatter. The predicate keys on the implementation WUs' cost and
 plan-conformance and cannot see what a close verifies, so a substantive close
 must be marked must-run or its verification is silently skipped (#189).
 
+**Hedged verdicts leave a trail** — a close that ends `met_locally` (everything
+locally verifiable passed; something structurally could not be verified here)
+leaves every terminal surface un-flipped (driver >= 0.3.21: gate
+`awaiting_review`, roadmap row `active`, PLAN.md `active`) AND must produce a
+follow-up record — in the gate review or `RETROSPECTIVE.md` — naming each
+unmet criterion, why it was unverifiable in this environment, and the exact
+re-run condition that would upgrade the verdict to `met`. Without the record,
+`met_locally` is a dead end; with it, the feature is resumable by anyone. See
+`.specfuse/rules/close-discipline.md` §2 for the record's shape and the other
+close-time obligations (fresh oracle re-runs, consumer-visible-change
+enumeration).
+
 **Predicate-version transparency** — every `auto_close_decision` event in
 `events.jsonl` carries a `predicate_version` field (e.g., `predicate_version:
 v1`). Future revisions to the predicate constants increment this version, so

specfuse_loop-0.3.23/specfuse/loop/data/rules/close-discipline.md

@@ -0,0 +1,74 @@
+<!--
+Copyright 2026 Specfuse Contributors
+Licensed under the Apache License, Version 2.0. See LICENSE.
+-->
+
+# Rule: close discipline
+
+Three obligations for `close` and `close-intermediate` WUs, binding at close
+time. Sibling of [`planning-discipline.md`](planning-discipline.md) (plan/arm
+time) and of the per-WU closing obligations in
+[`result-contract.md`](result-contract.md). Provenance: FEAT-2026-0049
+(the specfuse-generator dogfood), where three gates auto-closed at
+`attempts: 0` and the one close forced to run caught two false-`done` WUs and
+an unsatisfiable predicate — 48% of the feature's spend landed after the
+terminal gate had already "auto-closed". A close that only writes prose
+verifies nothing.
+
+A close whose acceptance criteria include ANY obligation below is
+**load-bearing**: the plan author sets `auto_close_disabled: true` in that
+WU's frontmatter so the auto-close predicate cannot optimize it away (#189).
+
+## 1. Oracles re-run fresh
+
+The close re-runs every oracle the feature's acceptance criteria name — the
+full test command(s), plus any compile/execution gates — fresh, in this
+session, exit codes read directly. Never inherit a producing WU's
+self-report: `done` is a claim, the re-run is the verification. When the
+feature's criteria assert on generated artifacts, regenerate into a clean
+output directory before asserting — stale output satisfies any assertion.
+
+> **Provenance.** A WU reported `done` while its source was untouched and its
+> oracle never ran; the driver-side produces-vs-diff guard now refuses that
+> pass (specfuse-loop >= 0.3.21), but only the close's own fresh re-run
+> catches the composite: all WUs individually green while the feature-level
+> oracle fails.
+
+## 2. Hedged-verdict follow-up record
+
+On `met_locally`, the close must produce a named record — in the gate review
+or `RETROSPECTIVE.md` — with one entry per unmet criterion:
+
+- the criterion, verbatim;
+- why it is unverifiable in this environment;
+- the exact re-run condition that would upgrade the verdict to `met`.
+
+The driver (>= 0.3.21) already guarantees the surfaces stay un-flipped on a
+hedged verdict (gate `awaiting_review`, roadmap `active`, PLAN `active`);
+this record is the other half: without it, `met_locally` is a dead end —
+no artifact says what would make it `met`, and the honest hedged verdict
+degrades into a polite synonym for "unknown".
+
+## 3. Consumer-visible contract changes enumerated, human-acknowledged
+
+The close enumerates every consumer-visible addition, removal, or rename the
+feature makes across ALL its producing WUs — API surface, generated models,
+published schemas, CLI flags, whatever contract consumers depend on — and
+blocks on explicit human acknowledgment of the list. A feature with no such
+changes writes exactly: `n/a — no consumer-visible contract change` (do not
+fabricate an empty enumeration; the n/a line is the reviewed claim).
+
+A close carrying this obligation is always load-bearing
+(`auto_close_disabled: true`).
+
+> **Provenance.** A breaking removal from a generated model survived four
+> gates unreviewed because no close surface owned the breaking-change list.
+> A silent breaking change is the most expensive false-done, and it is not
+> language-specific — any generated or published contract has this surface.
+
+## Split with project-local rules
+
+These are the generic obligations. The concrete grounding — which command is
+the oracle, which surface is "the API", project-specific regeneration
+hazards — is per-project and belongs in that project's
+`.specfuse/rules-local/` (never touched by upgrade), referencing this rule.

{specfuse_loop-0.3.22 → specfuse_loop-0.3.23}/specfuse/loop/data/templates/WU.template.md

@@ -92,6 +92,26 @@ defect gates later.
 |---|---|---|
 | `<path/method>` | yes / no | <one line> |
 
+**Close obligations** (REQUIRED only for `close` / `close-intermediate` WUs; omit
+otherwise — see `.specfuse/rules/close-discipline.md`). The close's acceptance
+criteria must cover:
+
+1. **Oracles re-run fresh** (§1): every oracle the feature's criteria name,
+   full command(s), exit codes read directly — never a producing WU's
+   self-report; regenerate into a clean dir before asserting on generated
+   artifacts.
+2. **Hedged follow-up record** (§2): on `met_locally`, a named record per
+   unmet criterion — criterion, why unverifiable here, exact re-run condition
+   that upgrades it to `met`.
+3. **Consumer-visible contract changes** (§3): enumerate every addition /
+   removal / rename across the feature's producing WUs and block on human
+   acknowledgment, or write exactly `n/a — no consumer-visible contract
+   change`.
+
+A close whose criteria include any of these is load-bearing — set
+`auto_close_disabled: true` in this WU's frontmatter so the auto-close
+predicate cannot skip it.
+
 **Do not touch.** Generated directories (`_generated/`, `gen-src/`, or the repo's
 declared equivalent), files owned by other work units in this gate, secrets,
 `.git/`. The driver owns all git operations — you edit files only. See

{specfuse_loop-0.3.22 → specfuse_loop-0.3.23}/specfuse/loop/lint_plan.py

@@ -335,6 +335,56 @@ def check_planned_cost(feature_dir: Path, plan_fm: dict, gates: list) -> None:
             )
 
 
+# Planning-discipline section names (#201, second half). Canonical since the
+# FEAT-2026-0049 planning-discipline drop (PR #211): PLAN.md carries the two
+# ADR sections; each gate file carries the arming-discipline section. Names
+# are shared vocabulary with downstream planning tooling — do not rename here
+# without a template/coordination change.
+PLAN_DISCIPLINE_SECTIONS = (
+    "Existing-mechanism search",
+    "Escalation-predicate satisfiability",
+)
+GATE_ARMING_SECTION = "Arming discipline"
+
+
+def check_planning_sections(
+    feature_dir: Path, plan_fm: dict, plan_body: str, gates: list,
+) -> None:
+    """WARN when the planning-discipline sections are absent (#201).
+
+    Presence-only: the PLAN template's sections allow an explicit n/a line, so
+    content is the arming reviewer's job — this check only catches the section
+    never being written at all (pre-0.3.22 drafts, or a plan-next that dropped
+    it). Sealed features (plan status done/abandoned) are history and skipped.
+    WARN-only, exit code 0, like the rest of the planning-lint family.
+    """
+    if plan_fm.get("status") in ("done", "abandoned"):
+        return
+    for section in PLAN_DISCIPLINE_SECTIONS:
+        if not _slice_section(plan_body, section).strip():
+            print(
+                f"WARN: {feature_dir}/PLAN.md: missing '{section}' section "
+                f"(planning-discipline; write it or an explicit 'n/a' line). "
+                f"See .specfuse/rules/planning-discipline.md."
+            )
+    for g in gates:
+        gate_file = g.get("file")
+        if not gate_file:
+            continue
+        gate_path = feature_dir / gate_file
+        if not gate_path.exists():
+            continue
+        gfm, gbody = read_frontmatter(gate_path)
+        if gfm.get("status") == "passed":
+            continue
+        if not _slice_section(gbody, GATE_ARMING_SECTION).strip():
+            print(
+                f"WARN: {gate_file}: missing '{GATE_ARMING_SECTION}' section "
+                f"(runtime-probe / flag-scope / predicate checks before "
+                f"arming). See .specfuse/rules/planning-discipline.md."
+            )
+
+
 def lint(feature_dir: Path) -> list[str]:
     errs: list[str] = []
     plan = feature_dir / "PLAN.md"
@@ -623,6 +673,8 @@ def lint(feature_dir: Path) -> list[str]:
 
     # Planned-cost capture: WARN on missing/divergent planned_cost_usd fields.
     check_planned_cost(feature_dir, fm, gates)
+    # Planning-discipline section presence (#201): WARN-only.
+    check_planning_sections(feature_dir, fm, body, gates)
 
     # Cross-gate mixed-shape check. Two directions of mix:
     #

{specfuse_loop-0.3.22 → specfuse_loop-0.3.23}/specfuse/loop/loop.py

@@ -64,7 +64,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.22"
+DRIVER_VERSION = "0.3.23"
 # 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
@@ -1537,15 +1537,20 @@ def gate_budget_usd(gate_file: Path) -> float | None:
 
 
 def gate_spent_usd(plan: dict, gate: dict, feature_dir: Path) -> float:
-    """Sum lifetime cost across the gate's done WUs (closing-sequence included).
+    """Sum lifetime recorded cost across ALL of the gate's WUs.
 
     Reads each WU file's frontmatter from `gate["work_units"]` and adds
     `cost_usd` PLUS `cumulative_cost_usd` (prior re-arm cycles' spend, folded
-    by fold_cumulative_on_rearm — #199) when the WU's status is "done". WUs
-    whose frontmatter omits both — cost tracking off, or the attempt didn't
-    record a cost — contribute 0.0. `plan` is the feature frontmatter dict and
-    is accepted for signature symmetry with the broader gate-budget helpers;
-    the spent total is derived from WU files alone.
+    by fold_cumulative_on_rearm — #199) regardless of WU status (#219):
+    write_cost_to_wu records cost on every outcome — pass, blocked, spinning —
+    so cost on a non-done WU is real spend, not an estimate. The pre-#219
+    done-only filter left a blocked WU's re-arm burn invisible to the budget
+    brake until the WU finally passed (FEAT-2026-0049/WU-06: $30.29 across 9
+    attempts, contributing $0 while blocked). WUs whose frontmatter omits both
+    fields — cost tracking off, never dispatched, or the attempt didn't record
+    a cost — contribute 0.0. `plan` is the feature frontmatter dict and is
+    accepted for signature symmetry with the broader gate-budget helpers; the
+    spent total is derived from WU files alone.
     """
     del plan  # signature symmetry — sum is derived from WU files only
     total = 0.0
@@ -1557,8 +1562,6 @@ def gate_spent_usd(plan: dict, gate: dict, feature_dir: Path) -> float:
         if not wu_path.exists():
             continue
         fm, _ = read_frontmatter(wu_path)
-        if fm.get("status") != "done":
-            continue
         # Lifetime spend, not per-cycle (#199): fold_cumulative_on_rearm
         # moves each prior dispatch cycle's cost into cumulative_cost_usd and
         # zeroes cost_usd, so summing cost_usd alone undercounts every

{specfuse_loop-0.3.22 → specfuse_loop-0.3.23}/specfuse/loop/scaffold.py

@@ -70,6 +70,27 @@ def _write_manifest(specfuse_dir: Path, entries: dict[str, str]) -> None:
     )
 
 
+def _read_manifest(specfuse_dir: Path) -> dict[str, str]:
+    """Return the on-disk .scaffold-manifest entries, {} when absent/unreadable.
+
+    The manifest is the ownership record: a versioned-dir file is provably
+    specfuse-written iff its relpath appears here (#214). Malformed content
+    degrades to {} — the callers then act as if ownership is unprovable,
+    which errs on the side of not deleting.
+    """
+    manifest_path = specfuse_dir / _MANIFEST_FILE
+    if not manifest_path.exists():
+        return {}
+    try:
+        data = json.loads(manifest_path.read_text(encoding="utf-8"))
+    except (ValueError, OSError):
+        return {}
+    if not isinstance(data, dict):
+        return {}
+    return {k: v for k, v in data.items()
+            if isinstance(k, str) and isinstance(v, str)}
+
+
 def detect_modified(target: str | Path) -> list[str]:
     """Return sorted relpaths of versioned .specfuse/ files whose sha256 differs from the manifest.
 
@@ -322,10 +343,12 @@ def upgrade_specfuse(
     """Overlay versioned seed onto an existing .specfuse/ tree.
 
     Overwrites versioned files (templates/, rules/, verification.yml.example, VERSION),
-    prunes versioned files the seed no longer ships (scoped to templates/ and rules/),
-    seeds missing user-authored files from templates, and refreshes .claude wiring.
-    rules-local/ is project-owned: never overlaid, never pruned; only its README
-    is seeded when absent.
+    prunes versioned files the seed no longer ships — but only those the prior
+    .scaffold-manifest proves specfuse wrote; unknown files are kept with a
+    warning (#214) — seeds missing user-authored files from templates, and
+    refreshes .claude wiring. Overwriting a file whose content is not what the
+    prior upgrade wrote warns to stderr. rules-local/ is project-owned: never
+    overlaid, never pruned; only its README is seeded when absent.
 
     Returns the sorted list of .specfuse/ relpaths written.
     Raises ScaffoldDowngradeError if the target VERSION is newer than the installed seed.
@@ -350,6 +373,11 @@ def upgrade_specfuse(
     written: list[str] = []
     versioned_relpaths: set[str] = set()
     manifest_entries: dict[str, str] = {}
+    # Ownership record from the PRIOR init/upgrade (#214): a file in a
+    # versioned dir is provably specfuse-written iff it appears here. Read
+    # before the overlay overwrites anything and before _write_manifest
+    # replaces it below.
+    old_manifest = _read_manifest(specfuse_dir)
 
     for relpath, content in iter_scaffold_files():
         if not (
@@ -358,6 +386,32 @@ def upgrade_specfuse(
         ):
             continue
         dest = specfuse_dir / relpath
+        # Clobber warning (#214): overwriting is the versioned-dir contract,
+        # but do it loudly when the on-disk content is not what the prior
+        # upgrade wrote — either a project-authored file whose name now
+        # collides with a shipped one, or a locally-modified shipped file.
+        # A missing manifest (legacy pre-manifest tree) stays silent: every
+        # file would warn and the signal would drown.
+        if old_manifest and dest.exists():
+            on_disk_sha = _sha256_hex(dest.read_bytes())
+            if on_disk_sha != _sha256_hex(content):
+                owned_sha = old_manifest.get(relpath)
+                if owned_sha is None:
+                    print(
+                        f"specfuse upgrade: WARNING — overwriting {relpath}: "
+                        "not written by a prior init/upgrade (project-"
+                        "authored?). Project-owned rules belong in "
+                        ".specfuse/rules-local/, which upgrade never touches.",
+                        file=sys.stderr,
+                    )
+                elif on_disk_sha != owned_sha:
+                    print(
+                        f"specfuse upgrade: WARNING — overwriting locally-"
+                        f"modified versioned file {relpath}. Upstream edits "
+                        "belong in a scaffold PR; project-specific rules in "
+                        ".specfuse/rules-local/.",
+                        file=sys.stderr,
+                    )
         dest.parent.mkdir(parents=True, exist_ok=True)
         dest.write_bytes(content)
         written.append(relpath)
@@ -370,8 +424,24 @@ def upgrade_specfuse(
             for existing in dir_path.rglob("*"):
                 if existing.is_file():
                     rel = existing.relative_to(specfuse_dir).as_posix()
-                    if rel not in versioned_relpaths:
+                    if rel in versioned_relpaths:
+                        continue
+                    # Manifest-scoped prune (#214): delete only files the
+                    # prior manifest proves specfuse wrote (shipped once,
+                    # since removed from the seed). Anything else — a
+                    # project-authored file, or any file on a legacy
+                    # pre-manifest tree — is kept, loudly.
+                    if rel in old_manifest:
                         existing.unlink()
+                    else:
+                        print(
+                            f"specfuse upgrade: WARNING — keeping {rel}: not "
+                            "in the shipped scaffold and not written by a "
+                            "prior init/upgrade. If it is project-authored, "
+                            "move it to .specfuse/rules-local/ (never touched "
+                            "by upgrade); if it is stale, delete it manually.",
+                            file=sys.stderr,
+                        )
 
     user_seeds = [
         ("LEARNINGS.md", "LEARNINGS.template.md"),

{specfuse_loop-0.3.22 → specfuse_loop-0.3.23/specfuse_loop.egg-info}/PKG-INFO

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

{specfuse_loop-0.3.22 → specfuse_loop-0.3.23}/specfuse_loop.egg-info/SOURCES.txt

@@ -23,6 +23,7 @@ specfuse/loop/data/docs/methodology.md
 specfuse/loop/data/docs/skills.md
 specfuse/loop/data/docs/concepts/architecture-addendum-gates-and-iterative-planning.md
 specfuse/loop/data/docs/concepts/ralph-lineage.md
+specfuse/loop/data/rules/close-discipline.md
 specfuse/loop/data/rules/correlation-ids.md
 specfuse/loop/data/rules/never-touch.md
 specfuse/loop/data/rules/planning-discipline.md
@@ -102,6 +103,7 @@ tests/test_lint_oracle_env.py
 tests/test_lint_plan_errors.py
 tests/test_lint_plan_next_draft.py
 tests/test_lint_plan_relative_import.py
+tests/test_lint_planning_sections.py
 tests/test_lint_produces_driver_helper.py
 tests/test_lint_sections.py
 tests/test_lint_task_graph_yaml_selection.py

{specfuse_loop-0.3.22 → specfuse_loop-0.3.23}/tests/test_init_integration.py

@@ -34,6 +34,7 @@ _EXPECTED_SPECFUSE_TREE = {
     "templates/GATE.template.md",
     "templates/PLAN.template.md",
     "templates/WU.template.md",
+    "rules/close-discipline.md",
     "rules/correlation-ids.md",
     "rules/never-touch.md",
     "rules/planning-discipline.md",
@@ -117,6 +118,7 @@ class TestInitFullLayout(unittest.TestCase):
 
     def test_rules_byte_faithful(self):
         for rel in (
+            "rules/close-discipline.md",
             "rules/correlation-ids.md",
             "rules/never-touch.md",
             "rules/planning-discipline.md",

{specfuse_loop-0.3.22 → specfuse_loop-0.3.23}/tests/test_lint_close_intermediate.py

@@ -42,6 +42,14 @@ def _write_plan(feature_dir: Path, gates_yaml: str) -> None:
         "```yaml\n"
         f"{gates_yaml}\n"
         "```\n"
+        "\n"
+        "## Existing-mechanism search\n"
+        "\n"
+        "n/a — no enforcement or measurement designed\n"
+        "\n"
+        "## Escalation-predicate satisfiability\n"
+        "\n"
+        "n/a — no severity flip\n"
     )
 
 

specfuse_loop-0.3.23/tests/test_lint_planning_sections.py

@@ -0,0 +1,117 @@
+#
+# Copyright 2026 Specfuse contributors
+# Licensed under the Apache License, Version 2.0. See LICENSE.
+#
+"""Planning-discipline section-presence lint (#201, second half).
+
+WARN-only checks that the sections introduced by the FEAT-2026-0049
+planning-discipline drop (PR #211) are present: PLAN.md carries
+'Existing-mechanism search' and 'Escalation-predicate satisfiability'
+(an explicit n/a line satisfies them — presence, not content), and each
+non-passed gate file carries 'Arming discipline'. Sealed features
+(plan status done/abandoned) are history and never warn.
+"""
+
+from __future__ import annotations
+
+import io
+import tempfile
+import unittest
+from contextlib import redirect_stdout
+from pathlib import Path
+
+from tests._loop_loader import load_lint
+
+lint_plan = load_lint()
+
+_SECTIONS = (
+    "\n## Existing-mechanism search\n\nn/a — no enforcement designed\n"
+    "\n## Escalation-predicate satisfiability\n\nn/a — no severity flip\n"
+)
+
+
+def _write_feature(tmpdir: str, *, plan_status: str = "active",
+                   plan_sections: str = _SECTIONS,
+                   gate_status: str = "open",
+                   gate_body: str = "\n## Arming discipline\n\nprobe notes\n",
+                   ) -> Path:
+    feature = Path(tmpdir) / "feature"
+    feature.mkdir(exist_ok=True)
+    (feature / "PLAN.md").write_text(
+        "---\nfeature_id: FEAT-2026-9998\ntitle: T\nbranch: feat/t\n"
+        f"roadmap_goal: g\nstatus: {plan_status}\n"
+        "planned_cost_usd: 10.00\n---\n\n# Plan\n\n"
+        "```yaml\ngates:\n  - gate: 1\n    file: GATE-01.md\n"
+        "    work_units:\n      - id: FEAT-2026-9998/T01\n"
+        "        file: WU-01-impl.md\n        depends_on: []\n"
+        "      - id: FEAT-2026-9998/G1-CLOSE\n        file: WU-90-close.md\n"
+        "        depends_on: [FEAT-2026-9998/T01]\n```\n"
+        f"{plan_sections}"
+    )
+    (feature / "GATE-01.md").write_text(
+        f"---\ngate: 1\nstatus: {gate_status}\n---\n\n# Gate 1\n{gate_body}"
+    )
+    for fname, wid, wtype in (("WU-01-impl.md", "T01", "implementation"),
+                              ("WU-90-close.md", "G1-CLOSE", "close")):
+        (feature / fname).write_text(
+            f"---\nid: FEAT-2026-9998/{wid}\ntype: {wtype}\nstatus: done\n"
+            f"attempts: 1\nplanned_cost_usd: 5.0\n---\n\n# {wid}\n"
+        )
+    return feature
+
+
+def _run_lint(feature: Path) -> tuple[list[str], str]:
+    buf = io.StringIO()
+    with redirect_stdout(buf):
+        errs = lint_plan.lint(feature)
+    return errs, buf.getvalue()
+
+
+class TestPlanningSectionLint(unittest.TestCase):
+
+    def test_silent_when_sections_present(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            errs, out = _run_lint(_write_feature(tmp))
+            self.assertEqual(errs, [])
+            self.assertNotIn("Existing-mechanism", out)
+            self.assertNotIn("Arming discipline", out)
+
+    def test_warns_on_missing_plan_sections(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            errs, out = _run_lint(_write_feature(tmp, plan_sections=""))
+            self.assertEqual(errs, [], "section presence is WARN-only")
+            self.assertIn("missing 'Existing-mechanism search'", out)
+            self.assertIn("missing 'Escalation-predicate satisfiability'", out)
+
+    def test_na_line_satisfies_presence(self):
+        """Presence, not content: the template's explicit n/a escape passes."""
+        with tempfile.TemporaryDirectory() as tmp:
+            _, out = _run_lint(_write_feature(tmp, plan_sections=_SECTIONS))
+            self.assertNotIn("missing 'Existing-mechanism search'", out)
+
+    def test_warns_on_gate_missing_arming_section(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            errs, out = _run_lint(_write_feature(tmp, gate_body=""))
+            self.assertEqual(errs, [])
+            self.assertIn("missing 'Arming discipline'", out)
+            self.assertIn("GATE-01.md", out)
+
+    def test_passed_gate_never_warns(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            _, out = _run_lint(_write_feature(tmp, gate_status="passed",
+                                              gate_body=""))
+            self.assertNotIn("missing 'Arming discipline'", out)
+
+    def test_sealed_feature_never_warns(self):
+        for status in ("done", "abandoned"):
+            with self.subTest(status=status):
+                with tempfile.TemporaryDirectory() as tmp:
+                    _, out = _run_lint(_write_feature(
+                        tmp, plan_status=status, plan_sections="",
+                        gate_body=""))
+                    self.assertNotIn("missing 'Existing-mechanism search'", out)
+                    self.assertNotIn("missing 'Arming discipline'", out)
+
+
+if __name__ == "__main__":
+    unittest.main()

{specfuse_loop-0.3.22 → specfuse_loop-0.3.23}/tests/test_loop_gate_budget.py

@@ -134,15 +134,20 @@ class TestGateBudgetUsd(unittest.TestCase):
 
 class TestGateSpentUsd(unittest.TestCase):
 
-    def test_sums_done_wus_only(self):
+    def test_sums_recorded_cost_regardless_of_status(self):
+        """#219: recorded cost is real spend on every status — a blocked WU's
+        re-arm burn must count toward the brake, not wait for done. A WU that
+        never dispatched carries no cost fields and contributes 0."""
         with tempfile.TemporaryDirectory() as tmp:
             feature = Path(tmp)
             _write_wu(feature / "WU-T01.md", wu_id="FEAT-2026-9701/T01",
                       status="done", cost_usd=0.5)
+            # Blocked mid-gate: write_cost_to_wu recorded its spend.
             _write_wu(feature / "WU-T02.md", wu_id="FEAT-2026-9701/T02",
-                      status="pending", cost_usd=1.25)
+                      status="blocked_human", cost_usd=1.25)
+            # Never dispatched: no cost fields at all.
             _write_wu(feature / "WU-T03.md", wu_id="FEAT-2026-9701/T03",
-                      status="done", cost_usd=0.75)
+                      status="pending", cost_usd=None)
             gate = {
                 "file": "GATE-01.md",
                 "work_units": [
@@ -152,7 +157,26 @@ class TestGateSpentUsd(unittest.TestCase):
                 ],
             }
             spent = loop.gate_spent_usd({}, gate, feature)
-            self.assertAlmostEqual(spent, 1.25, places=6)
+            self.assertAlmostEqual(spent, 1.75, places=6)
+
+    def test_blocked_wu_cumulative_counts_toward_brake(self):
+        """The WU-06 shape: blocked with folded prior-cycle spend — the brake
+        must see the full lifetime burn while the WU is still blocked."""
+        with tempfile.TemporaryDirectory() as tmp:
+            feature = Path(tmp)
+            (feature / "WU-T01.md").write_text(
+                "---\nid: FEAT-2026-9701/T01\ntype: implementation\n"
+                "model: sonnet\nstatus: blocked_human\nattempts: 3\n"
+                "cost_usd: 2.75\ncumulative_cost_usd: 27.54\n---\n\n# T01\n"
+            )
+            gate = {
+                "file": "GATE-01.md",
+                "work_units": [
+                    {"id": "FEAT-2026-9701/T01", "file": "WU-T01.md"},
+                ],
+            }
+            self.assertAlmostEqual(
+                loop.gate_spent_usd({}, gate, feature), 30.29, places=6)
 
     def test_missing_cost_contributes_zero(self):
         with tempfile.TemporaryDirectory() as tmp:

{specfuse_loop-0.3.22 → specfuse_loop-0.3.23}/tests/test_scaffold_data_in_sync.py

@@ -23,6 +23,7 @@ TRACKED = {
     "templates/GATE.template.md",
     "templates/PLAN.template.md",
     "templates/WU.template.md",
+    "rules/close-discipline.md",
     "rules/correlation-ids.md",
     "rules/never-touch.md",
     "rules/planning-discipline.md",

{specfuse_loop-0.3.22 → specfuse_loop-0.3.23}/tests/test_scaffold_docs.py

@@ -91,8 +91,15 @@ class TestUpgradeOverlaysDocs(unittest.TestCase):
         )
 
     def test_upgrade_prunes_removed_docs(self):
+        """A docs file the seed once shipped (manifest-owned) but no longer
+        carries is pruned; manifest membership is the ownership proof (#214)."""
+        import json as _json
         stray = self.specfuse / "docs" / "obsolete-doc.md"
         stray.write_bytes(b"old doc")
+        manifest = self.specfuse / ".scaffold-manifest"
+        entries = _json.loads(manifest.read_text())
+        entries["docs/obsolete-doc.md"] = "0" * 64
+        manifest.write_text(_json.dumps(entries))
         upgrade_specfuse(self.target)
         self.assertFalse(stray.exists(), "stray docs file must be pruned on upgrade")
 

{specfuse_loop-0.3.22 → specfuse_loop-0.3.23}/tests/test_scaffold_init.py

@@ -16,6 +16,7 @@ _EXPECTED_TREE = {
     "templates/GATE.template.md",
     "templates/PLAN.template.md",
     "templates/WU.template.md",
+    "rules/close-discipline.md",
     "rules/correlation-ids.md",
     "rules/never-touch.md",
     "rules/planning-discipline.md",
@@ -45,6 +46,7 @@ _VERSIONED_SEED_TO_TARGET = {
     "templates/GATE.template.md": "templates/GATE.template.md",
     "templates/PLAN.template.md": "templates/PLAN.template.md",
     "templates/WU.template.md": "templates/WU.template.md",
+    "rules/close-discipline.md": "rules/close-discipline.md",
     "rules/correlation-ids.md": "rules/correlation-ids.md",
     "rules/never-touch.md": "rules/never-touch.md",
     "rules/planning-discipline.md": "rules/planning-discipline.md",

{specfuse_loop-0.3.22 → specfuse_loop-0.3.23}/tests/test_scaffold_resources.py

@@ -18,6 +18,7 @@ _EXPECTED_RELPATHS = {
     "templates/GATE.template.md",
     "templates/PLAN.template.md",
     "templates/WU.template.md",
+    "rules/close-discipline.md",
     "rules/correlation-ids.md",
     "rules/never-touch.md",
     "rules/planning-discipline.md",