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

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

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

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

specfuse_loop-0.3.24/specfuse/loop/data/VERSION

@@ -0,0 +1 @@
+0.3.24

{specfuse_loop-0.3.22 → specfuse_loop-0.3.24}/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.22 → specfuse_loop-0.3.24}/specfuse/loop/data/docs/skills.md

@@ -48,6 +48,11 @@ roadmap ──/pick-feature──▶ active ──/draft-feature──▶ gate 1
   `/draft-feature`.
 - **`/roadmap-add`** — add a new feature row to the roadmap before it's ready to
   pick.
+- **`/block-feature`** — flip a roadmap feature to `blocked` (or clear it) with a
+  linked `**Blocked by.**` blocker — an ADR awaiting approval or an upstream
+  FEAT-ID that must complete first. Writes the row status, the detail block, and
+  PLAN frontmatter, keeping intra-page feature links resolvable.
+  `/block-feature FEAT-ID --unblock` clears the block and restores the status.
 
 ### 2. Draft — turn a picked feature into a runnable gate
 

{specfuse_loop-0.3.22 → specfuse_loop-0.3.24}/specfuse/loop/data/roadmap.template.md

@@ -23,8 +23,24 @@ the canonical column order below.
 |----------------|-------|--------|--------|--------|
 
 Status: `planned` → `active` → `done` (or `abandoned`). `deferred` = parked
-pending an external decision/dependency; resumable (a human flips it back to
-`active` when the blocker clears), distinct from `abandoned` (dead).
+by choice pending an external decision/dependency; resumable (a human flips it
+back to `active` when the blocker clears), distinct from `abandoned` (dead).
+`blocked` = cannot proceed because a *named* dependency is unmet — an ADR
+awaiting approval, or an upstream feature that must complete first. Resumable
+like `deferred`, but where `deferred` is a voluntary park with no named blocker,
+`blocked` always names its blocker so the roadmap shows what it waits on and
+links to it.
+
+A `blocked` feature's detail section carries a `**Blocked by.**` block — blank
+line above it, one linked blocker per clause:
+
+**Blocked by.** [ADR-0007: event-schema versioning](../docs/adr/0007-event-schema-versioning.md) — awaiting approval; [FEAT-2026-0011](#feat-2026-0011) — scoring data must land first.
+
+Each blocker is a Markdown link: an ADR points at its `.md` file (kept under
+`docs/adr/` by convention, so from `.specfuse/roadmap.md` the link is
+`../docs/adr/…`); a feature dependency points at the blocking
+feature's roadmap anchor (`#feat-yyyy-nnnn`). When every blocker clears, a human
+flips `blocked` → `active` (or `planned`) and removes the `**Blocked by.**` block.
 
 ## Notes
 

specfuse_loop-0.3.24/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.24}/specfuse/loop/data/templates/PLAN.template.md

@@ -7,7 +7,7 @@ roadmap_goal: <one line copied from the roadmap — the north star this feature
   plan-next anchors every drafted gate to this and flags if a retrospective implies
   it should change>
 autonomy_default: review        # auto | review | supervised
-status: active                  # active | deferred | done | abandoned
+status: active                  # active | blocked | deferred | done | abandoned
                                 # deferred = parked pending an external decision/dependency; resumable, non-dispatchable
 # planned_cost_usd: 0.00        # OPTIONAL — sum of WU planned costs; lint warns when missing or when delta from WU sum > 10%
 ---

{specfuse_loop-0.3.22 → specfuse_loop-0.3.24}/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.24}/specfuse/loop/lint_plan.py

@@ -46,7 +46,7 @@ VALID_STATUS = {"draft", "pending", "ready", "in_progress", "in_review", "done",
 # unrecognized status that passes lint and then behaves differently at dispatch
 # is the class #183 (deferred) and #185 exist to close. Keep in sync with
 # find_feature / the gate-status transitions in loop.py.
-VALID_FEATURE_STATUS = {"planned", "active", "deferred", "done", "abandoned"}
+VALID_FEATURE_STATUS = {"planned", "active", "blocked", "deferred", "done", "abandoned"}
 VALID_GATE_STATUS = {"open", "awaiting_review", "passed"}
 CLOSING_SEQUENCE = ["retrospective", "lessons", "docs", "plan-next"]
 # New compact closing shapes (FEAT-2026-0015):
@@ -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.24}/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.24"
 # 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
@@ -285,10 +285,22 @@ def find_feature(arg: str | None) -> Path:
                 f"deferred features. Flip its PLAN.md status back to `active` "
                 f"when the blocker clears, then re-run."
             )
+        # A `blocked` feature waits on a named unmet dependency (an ADR or an
+        # upstream feature — see its roadmap `**Blocked by.**` block). Like
+        # `deferred` it is non-dispatchable; refuse an explicit --feature
+        # targeting one rather than dispatching it anyway.
+        if _fm.get("status") == "blocked":
+            sys.exit(
+                f"{d.name} is blocked — the loop does not dispatch blocked "
+                f"features. Clear its blocker(s), then run "
+                f"`/block-feature {_fm.get('feature_id', d.name)} --unblock` "
+                f"(or flip its PLAN.md status back to `active`) and re-run."
+            )
         return d
     actives = []
     done_pending_wrap = []
     deferred = []
+    blocked = []
     for d in sorted(FEATURES_DIR.glob("*/")):
         plan = d / "PLAN.md"
         if plan.exists():
@@ -316,6 +328,11 @@ def find_feature(arg: str | None) -> Path:
                 # a bare invocation won't pick it up; surfaced below so a lone
                 # deferred feature reads as parked, not silently absent.
                 deferred.append(d)
+            elif fm.get("status") == "blocked":
+                # Waiting on a named unmet dependency — non-dispatchable, same
+                # as deferred. Surfaced below so a lone blocked feature reads as
+                # parked-on-a-blocker, not silently absent.
+                blocked.append(d)
     if len(actives) == 1:
         return actives[0]
     if not actives:
@@ -328,6 +345,13 @@ def find_feature(arg: str | None) -> Path:
                 f"                    Flip one's PLAN.md status to `active` to "
                 f"resume it.\n"
             )
+        if blocked:
+            names = ", ".join(d.name for d in blocked[-3:])
+            msg += (
+                f"  - {len(blocked)} blocked feature(s), skipped: {names}\n"
+                f"                    Clear the blocker, then /block-feature "
+                f"<id> --unblock to resume.\n"
+            )
         if done_pending_wrap:
             names = ", ".join(d.name for d in done_pending_wrap[-3:])
             msg += (
@@ -1537,15 +1561,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 +1586,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
@@ -2666,7 +2693,14 @@ def auto_archive_feature(feature_id: str, repo_root: Path) -> str:
         section_m2 = section_re.search(roadmap_text)
         if section_m2:
             roadmap_text = roadmap_text[:section_m2.start()] + roadmap_text[section_m2.end():]
-            roadmap_text = re.sub(r'\n{3,}', '\n\n', roadmap_text)
+    # A feature that was ever `blocked` via /block-feature carries an explicit
+    # `<a id="feat-…"></a>` line above its heading (so intra-page `#feat-…`
+    # links resolve). The section regex above does not span it, so removing the
+    # section would strand the anchor pointing at a section that has moved to the
+    # archive. Strip the now-orphaned anchor line; Step 3 already re-emitted the
+    # canonical anchor in roadmap-archive.md, so the link target travels with it.
+    roadmap_text = roadmap_text.replace(f"{anchor}\n", "")
+    roadmap_text = re.sub(r'\n{3,}', '\n\n', roadmap_text)
     roadmap_path.write_text(roadmap_text)
 
     return "archived"

{specfuse_loop-0.3.22 → specfuse_loop-0.3.24}/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.24/specfuse_loop.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specfuse-loop
-Version: 0.3.22
+Version: 0.3.24
 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.24}/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.24}/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.24}/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"
     )