specfuse-loop 0.3.5__tar.gz → 0.3.7__tar.gz

{specfuse_loop-0.3.5/specfuse_loop.egg-info → specfuse_loop-0.3.7}/PKG-INFO

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

{specfuse_loop-0.3.5 → specfuse_loop-0.3.7}/pyproject.toml

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

specfuse_loop-0.3.7/specfuse/loop/data/VERSION

@@ -0,0 +1 @@
+0.3.7

{specfuse_loop-0.3.5 → specfuse_loop-0.3.7}/specfuse/loop/data/docs/methodology.md

@@ -18,7 +18,11 @@ on both surfaces.
 ## 1. The unit hierarchy
 
 - **Roadmap** — the master index of features for a repository/project, with each
-  feature's status (`planned → active → done`/`abandoned`).
+  feature's status (`planned → active → done`/`abandoned`). A feature may also be
+  `deferred` — parked pending an external decision or dependency: nothing is
+  loop-dispatchable, so the driver skips it (like `abandoned`), but it stays
+  resumable — a human flips it back to `active` when the blocker clears. `deferred`
+  is distinct from `abandoned` (dead) and `done` (complete).
 - **Feature** — a spec-driven *or directly-authored* unit of value, identified by
   a correlation ID `FEAT-YYYY-NNNN`. A feature owns an ordered list of gates.
 - **Gate** — a milestone partition of a feature: an ordered batch of substantive

{specfuse_loop-0.3.5 → specfuse_loop-0.3.7}/specfuse/loop/data/docs/skills.md

@@ -110,6 +110,9 @@ either auto-closes a clean gate or halts at the gate boundary for review.
 - **`/feature-conversion`** — bring an existing feature folder into conformance
   with the current scaffold's structural contract. Runs after `specfuse upgrade`
   flags a feature as `FAIL`. Interactive, lint-driven.
+- **`/scaffold-upgrade`** — dry-run-reports or end-to-end upgrades a target
+  project's Specfuse scaffold via `specfuse upgrade [--dry-run] <target>`,
+  wrapping the git choreography (branch/commit/push/PR/CI/merge-gate) around it.
 - **`/learnings-suggest`** — scan `attempt_outcome` events across features,
   cluster non-passing attempts, and surface recurring patterns as candidate
   `LEARNINGS.md` entries. Read-only — you promote. The *additive* half.

{specfuse_loop-0.3.5 → specfuse_loop-0.3.7}/specfuse/loop/data/roadmap.template.md

@@ -22,7 +22,9 @@ the canonical column order below.
 | Feature ID     | Title | Status | Folder | Detail |
 |----------------|-------|--------|--------|--------|
 
-Status: `planned` → `active` → `done` (or `abandoned`).
+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).
 
 ## Notes
 

{specfuse_loop-0.3.5 → specfuse_loop-0.3.7}/specfuse/loop/data/templates/PLAN.template.md

@@ -7,7 +7,8 @@ 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 | done | abandoned
+status: active                  # active | 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.5 → specfuse_loop-0.3.7}/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.5"
+DRIVER_VERSION = "0.3.7"
 # 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
@@ -470,13 +470,36 @@ def build_event(event_type: str, correlation_id: str, payload: dict) -> dict:
     }
 
 
+# Matches macOS ("/Users/" + "<name>/") and Linux ("/home/" + "<name>/") home
+# prefixes at runtime without containing a literal "/Users/" substring in
+# source, so this file's own staged diff never re-trips the structural leak-scan.
+_HOME_PATH_RE = re.compile(r"/(?:Users|home)/[^/\s]+/")
+_HOME_PATH_PLACEHOLDER = "<redacted-home>/"
+
+
+def _redact_home_paths(value):
+    """Recursively redact absolute home-directory prefixes from a JSON-ish value.
+
+    Walks dict/list/str/scalar and replaces every "/Users/" + "<name>/" or
+    "/home/" + "<name>/" match in string leaves with a stable placeholder.
+    Other text is preserved verbatim; idempotent (a second pass is a no-op).
+    """
+    if isinstance(value, str):
+        return _HOME_PATH_RE.sub(_HOME_PATH_PLACEHOLDER, value)
+    if isinstance(value, dict):
+        return {k: _redact_home_paths(v) for k, v in value.items()}
+    if isinstance(value, list):
+        return [_redact_home_paths(v) for v in value]
+    return value
+
+
 def flush_events(events_path: Path, events: list) -> None:
     """Append a batch of buffered events to the JSONL log."""
     if not events:
         return
     with events_path.open("a") as fh:
         for evt in events:
-            fh.write(json.dumps(evt) + "\n")
+            fh.write(json.dumps(_redact_home_paths(evt)) + "\n")
 
 
 # --------------------------------------------------------------------------- #
@@ -2900,17 +2923,13 @@ def assert_terminal_flips_fired(
             False,
             f"roadmap_row_not_done: roadmap.md absent at {roadmap_path}",
         )
-    row_re = re.compile(
-        r"^\|\s*" + re.escape(feature_id) + r"\s*\|([^|]*)\|([^|]*)\|",
-        re.MULTILINE,
-    )
-    rm = row_re.search(roadmap_path.read_text())
-    if not rm:
+    parsed = _parse_roadmap_row(roadmap_path.read_text(), feature_id)
+    if not parsed:
         return (
             False,
             f"roadmap_row_not_done: row for {feature_id} not found",
         )
-    row_status = rm.group(2).strip()
+    row_status = parsed["columns"].get("Status", "").strip()
     if row_status != "done":
         return False, f"roadmap_row_not_done: status={row_status!r}"
 

{specfuse_loop-0.3.5 → specfuse_loop-0.3.7/specfuse_loop.egg-info}/PKG-INFO

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

{specfuse_loop-0.3.5 → specfuse_loop-0.3.7}/specfuse_loop.egg-info/SOURCES.txt

@@ -54,6 +54,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_events_redaction.py
 tests/test_extra_gates.py
 tests/test_force_full_close.py
 tests/test_gate_eval.py
@@ -69,6 +70,7 @@ tests/test_init_integration.py
 tests/test_leak_findings_redaction.py
 tests/test_leak_scan.py
 tests/test_leak_scan_content.py
+tests/test_learnings_query.py
 tests/test_legacy_4wu_terminal_flips.py
 tests/test_lifecycle_integration.py
 tests/test_lint_bare_produces_path.py
@@ -122,6 +124,7 @@ tests/test_terminal_flip_ownership.py
 tests/test_terminal_flips.py
 tests/test_untracked_feature_folder.py
 tests/test_upgrade_integration.py
+tests/test_upgrade_merge_gate.py
 tests/test_validate_event.py
 tests/test_verdict_coupling.py
 tests/test_verify_empty_gate_set.py

specfuse_loop-0.3.7/tests/test_events_redaction.py

@@ -0,0 +1,105 @@
+#
+# Copyright 2026 Specfuse Contributors
+# Licensed under the Apache License, Version 2.0. See LICENSE.
+#
+"""Tests for the events.jsonl home-path redaction chokepoint (FEAT-2026-0030/T01).
+
+Fixture home paths are built by concatenation, never as a contiguous
+"/Users/" + "<seg>/" literal, so this file's own staged diff does not re-trip
+the repo's structural leak-scan (which this test itself exercises in AC4).
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from specfuse.loop.loop import _redact_home_paths, _HOME_PATH_RE, build_event, flush_events
+
+# Concatenated so no contiguous "/Users/" + "<seg>/" literal appears in source.
+MAC_HOME = "/Users/" + "alice/checkout/repo"
+LINUX_HOME = "/home/" + "bob/checkout/repo"
+
+
+class RedactHomePathsTests(unittest.TestCase):
+    def test_home_path_redacted_before_flush(self):
+        """Red on HEAD: flush_events must strip a macOS home path from payload."""
+        events_path = Path(self._tmp_events_path())
+        evt = build_event(
+            "attempt_outcome",
+            "FEAT-2026-0030/T01",
+            {"agent_blocked_reason": f"grepped {MAC_HOME}/events.jsonl for context"},
+        )
+        flush_events(events_path, [evt])
+        written = events_path.read_text()
+        self.assertIsNone(_HOME_PATH_RE.search(written))
+
+    def _tmp_events_path(self):
+        import tempfile
+        fd, path = tempfile.mkstemp(suffix=".jsonl")
+        import os
+        os.close(fd)
+        os.remove(path)
+        return path
+
+    def test_linux_home_path_redacted(self):
+        out = _redact_home_paths(f"note: {LINUX_HOME}/x.py")
+        self.assertIsNone(_HOME_PATH_RE.search(out))
+
+    def test_nested_dict_redacted_at_depth(self):
+        payload = {"outer": {"inner": f"path {MAC_HOME}/x.py"}}
+        out = _redact_home_paths(payload)
+        self.assertIsNone(_HOME_PATH_RE.search(json.dumps(out)))
+
+    def test_list_of_strings_redacted_elementwise(self):
+        payload = [f"a {MAC_HOME}/one.py", "clean text", f"b {LINUX_HOME}/two.py"]
+        out = _redact_home_paths(payload)
+        self.assertIsNone(_HOME_PATH_RE.search(json.dumps(out)))
+
+    def test_no_home_path_unchanged(self):
+        payload = {"correlation_id": "FEAT-2026-0030/T01", "notes": "no path here at all"}
+        out = _redact_home_paths(payload)
+        self.assertEqual(out, payload)
+
+    def test_audit_fields_survive_unchanged(self):
+        evt = build_event(
+            "attempt_outcome",
+            "FEAT-2026-0030/T01",
+            {"failure_class": "tests", "notes": f"see {MAC_HOME}/log.txt"},
+        )
+        out = _redact_home_paths(evt)
+        self.assertEqual(out["correlation_id"], "FEAT-2026-0030/T01")
+        self.assertEqual(out["event_type"], "attempt_outcome")
+        self.assertEqual(out["source"], "driver")
+        self.assertEqual(out["payload"]["failure_class"], "tests")
+
+    def test_idempotent(self):
+        once = _redact_home_paths(f"path {MAC_HOME}/x.py")
+        twice = _redact_home_paths(once)
+        self.assertEqual(once, twice)
+
+    def test_dogfood_leak_scan_clean(self):
+        """Redacted output would pass this repo's structural leak-scan (user-path)."""
+        sys.path.insert(
+            0, str(Path(__file__).resolve().parent.parent / ".specfuse" / "scripts")
+        )
+        from leak_scan import scan_text  # noqa: E402  (repo-internal, test-only)
+
+        events_path = Path(self._tmp_events_path())
+        evt = build_event(
+            "attempt_outcome",
+            "FEAT-2026-0030/T01",
+            {"agent_blocked_reason": f"grepped {MAC_HOME}/events.jsonl for context"},
+        )
+        flush_events(events_path, [evt])
+        written = events_path.read_text()
+        findings = [f for f in scan_text(written) if f.startswith("user-path")]
+        self.assertEqual(findings, [])
+
+
+if __name__ == "__main__":
+    unittest.main()

specfuse_loop-0.3.7/tests/test_learnings_query.py

@@ -0,0 +1,246 @@
+#
+# Copyright 2026 Specfuse Contributors
+# Licensed under the Apache License, Version 2.0. See LICENSE.
+#
+"""Tests for .specfuse/scripts/learnings_query.py (FEAT-2026-0025/T01).
+
+`parse_entries` splits LEARNINGS.md's `- [tag] text` bullets (which may wrap
+across lines) into entries, excluding header/Format/heading prose. `rank`
+scores those entries against a query with a stdlib BM25 implementation. Loaded
+by file path, matching the pattern other `.specfuse/scripts` helpers use in
+this test suite (see test_leak_scan_content.py) since this module is not part
+of the `specfuse` package.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+SCRIPTS_DIR = REPO_ROOT / ".specfuse" / "scripts"
+LEARNINGS_QUERY_PATH = SCRIPTS_DIR / "learnings_query.py"
+
+
+def _load(name: str):
+    if str(SCRIPTS_DIR) not in sys.path:
+        sys.path.insert(0, str(SCRIPTS_DIR))
+    path = SCRIPTS_DIR / f"{name}.py"
+    spec = importlib.util.spec_from_file_location(name, path)
+    mod = importlib.util.module_from_spec(spec)
+    sys.modules[name] = mod
+    spec.loader.exec_module(mod)
+    return mod
+
+
+lq = _load("learnings_query")
+
+
+class TestRank(unittest.TestCase):
+    def test_ranks_relevant_entry_first(self):
+        entries = [
+            {"tag": "meta/a", "text": "Coverage gates must run before commit."},
+            {"tag": "meta/b", "text": "BM25 ranking helps retrieve relevant learnings entries fast."},
+            {"tag": "meta/c", "text": "Never touch the driver internals directly."},
+        ]
+        ranked = lq.rank("BM25 ranking learnings retrieval", entries)
+        self.assertEqual(ranked[0]["tag"], "meta/b")
+
+    def test_empty_query_returns_all_entries_deterministically(self):
+        entries = [
+            {"tag": "meta/a", "text": "alpha rule"},
+            {"tag": "meta/b", "text": "beta rule"},
+        ]
+        ranked = lq.rank("", entries)
+        self.assertEqual([e["tag"] for e in ranked], ["meta/a", "meta/b"])
+
+    def test_no_match_returns_all_entries_in_stable_order(self):
+        entries = [
+            {"tag": "meta/a", "text": "alpha rule about routers"},
+            {"tag": "meta/b", "text": "beta rule about gates"},
+            {"tag": "meta/c", "text": "gamma rule about secrets"},
+        ]
+        ranked = lq.rank("zzznomatchzzz", entries)
+        self.assertEqual([e["tag"] for e in ranked], ["meta/a", "meta/b", "meta/c"])
+
+    def test_top_n_truncates(self):
+        entries = [
+            {"tag": "meta/a", "text": "alpha rule about routers"},
+            {"tag": "meta/b", "text": "beta rule about gates"},
+            {"tag": "meta/c", "text": "gamma rule about secrets"},
+        ]
+        ranked = lq.rank("rule", entries, top_n=2)
+        self.assertEqual(len(ranked), 2)
+
+    def test_rank_handles_empty_entries_list(self):
+        self.assertEqual(lq.rank("anything", []), [])
+
+
+class TestParseEntries(unittest.TestCase):
+    def test_parses_simple_bullet(self):
+        text = (
+            "# LEARNINGS\n\n"
+            "## Format\n\n"
+            "```\n"
+            "- [FEAT-2026-0001/G1] Example bullet that must be excluded.\n"
+            "```\n\n"
+            "## Entries\n\n"
+            "<!-- lessons work units append below this line -->\n\n"
+            "- [meta/foo] This is a rule.\n"
+        )
+        entries = lq.parse_entries(text)
+        self.assertEqual(len(entries), 1)
+        self.assertEqual(entries[0]["tag"], "meta/foo")
+        self.assertEqual(entries[0]["text"], "This is a rule.")
+
+    def test_joins_wrapped_multiline_bullet(self):
+        text = (
+            "## Entries\n\n"
+            "<!-- lessons work units append below this line -->\n\n"
+            "- [meta/foo] This rule wraps across\n"
+            "  several lines of prose\n"
+            "  before it ends.\n"
+        )
+        entries = lq.parse_entries(text)
+        self.assertEqual(len(entries), 1)
+        self.assertEqual(
+            entries[0]["text"],
+            "This rule wraps across several lines of prose before it ends.",
+        )
+
+    def test_section_heading_ends_entry_and_is_excluded(self):
+        text = (
+            "## Entries\n\n"
+            "<!-- lessons work units append below this line -->\n\n"
+            "- [meta/foo] First rule.\n\n"
+            "## FEAT-2026-0001/G1-CLOSE — some retro title\n\n"
+            "- [FEAT-2026-0001/G1-CLOSE] Second rule.\n"
+        )
+        entries = lq.parse_entries(text)
+        self.assertEqual(len(entries), 2)
+        self.assertEqual(entries[0]["text"], "First rule.")
+        self.assertEqual(entries[1]["text"], "Second rule.")
+
+    def test_blank_line_separates_entries(self):
+        text = (
+            "## Entries\n\n"
+            "<!-- lessons work units append below this line -->\n\n"
+            "- [meta/a] Rule one.\n\n"
+            "- [meta/b] Rule two.\n"
+        )
+        entries = lq.parse_entries(text)
+        self.assertEqual(len(entries), 2)
+        self.assertEqual(entries[0]["tag"], "meta/a")
+        self.assertEqual(entries[1]["tag"], "meta/b")
+
+    def test_real_learnings_file_round_trip(self):
+        learnings_path = REPO_ROOT / ".specfuse" / "LEARNINGS.md"
+        text = learnings_path.read_text(encoding="utf-8")
+        entries = lq.parse_entries(text)
+        self.assertGreater(len(entries), 1)
+        for entry in entries:
+            self.assertTrue(entry["text"])
+            self.assertTrue(entry["tag"])
+
+
+def _small_fixture(n_entries: int) -> str:
+    lines = ["## Entries", "", "<!-- lessons work units append below this line -->", ""]
+    for i in range(n_entries):
+        lines.append(f"- [meta/e{i}] Entry number {i} about routers and gates.")
+    return "\n".join(lines) + "\n"
+
+
+class TestShouldLoadWhole(unittest.TestCase):
+    def test_below_threshold_is_true(self):
+        entries = [{"tag": "a", "text": "x"}] * 5
+        self.assertTrue(lq.should_load_whole(entries, threshold=40))
+
+    def test_at_or_above_threshold_is_false(self):
+        entries = [{"tag": "a", "text": "x"}] * 40
+        self.assertFalse(lq.should_load_whole(entries, threshold=40))
+        entries = [{"tag": "a", "text": "x"}] * 41
+        self.assertFalse(lq.should_load_whole(entries, threshold=40))
+
+
+class TestCli(unittest.TestCase):
+    def _run_cli(self, *args: str) -> subprocess.CompletedProcess:
+        return subprocess.run(
+            [sys.executable, str(LEARNINGS_QUERY_PATH), *args],
+            capture_output=True,
+            text=True,
+        )
+
+    def test_cli_below_threshold_signals_load_whole(self):
+        with tempfile.NamedTemporaryFile(
+            mode="w", suffix=".md", delete=False
+        ) as fixture:
+            fixture.write(_small_fixture(5))
+            fixture_path = fixture.name
+        try:
+            result = self._run_cli(
+                "routers", "--file", fixture_path, "--threshold", "40"
+            )
+        finally:
+            Path(fixture_path).unlink()
+        self.assertEqual(result.returncode, 0)
+        self.assertEqual(result.stdout.strip(), lq.LOAD_WHOLE_SENTINEL)
+
+    def test_cli_at_threshold_returns_ranked_slice(self):
+        with tempfile.NamedTemporaryFile(
+            mode="w", suffix=".md", delete=False
+        ) as fixture:
+            fixture.write(_small_fixture(45))
+            fixture_path = fixture.name
+        try:
+            result = self._run_cli(
+                "routers", "--file", fixture_path, "--threshold", "40", "--top", "3"
+            )
+        finally:
+            Path(fixture_path).unlink()
+        self.assertEqual(result.returncode, 0)
+        lines = [line for line in result.stdout.splitlines() if line.strip()]
+        self.assertNotIn(lq.LOAD_WHOLE_SENTINEL, lines)
+        self.assertEqual(len(lines), 3)
+
+    def test_cli_threshold_zero_forces_slice_on_tiny_file(self):
+        with tempfile.NamedTemporaryFile(
+            mode="w", suffix=".md", delete=False
+        ) as fixture:
+            fixture.write(_small_fixture(2))
+            fixture_path = fixture.name
+        try:
+            result = self._run_cli(
+                "routers", "--file", fixture_path, "--threshold", "0"
+            )
+        finally:
+            Path(fixture_path).unlink()
+        self.assertEqual(result.returncode, 0)
+        self.assertNotEqual(result.stdout.strip(), lq.LOAD_WHOLE_SENTINEL)
+        self.assertEqual(len(result.stdout.strip().splitlines()), 2)
+
+    def test_cli_missing_file_exits_nonzero_with_message(self):
+        result = self._run_cli("routers", "--file", "/nonexistent/path/LEARNINGS.md")
+        self.assertNotEqual(result.returncode, 0)
+        self.assertIn("cannot read", result.stderr)
+
+    def test_cli_top_bounds_count(self):
+        with tempfile.NamedTemporaryFile(
+            mode="w", suffix=".md", delete=False
+        ) as fixture:
+            fixture.write(_small_fixture(45))
+            fixture_path = fixture.name
+        try:
+            result = self._run_cli(
+                "routers", "--file", fixture_path, "--threshold", "40", "--top", "1"
+            )
+        finally:
+            Path(fixture_path).unlink()
+        self.assertEqual(len(result.stdout.strip().splitlines()), 1)
+
+
+if __name__ == "__main__":
+    unittest.main()

{specfuse_loop-0.3.5 → specfuse_loop-0.3.7}/tests/test_loop_orchestration.py

@@ -319,6 +319,27 @@ class TestFindFeatureSelection(unittest.TestCase):
         result = loop.find_feature("FEAT-2026-9502-explicit")
         self.assertEqual(result, fdir)
 
+    def test_deferred_feature_is_not_auto_selected(self):
+        """Issue #106: a `deferred` foldered feature is non-dispatchable — the
+        driver skips it exactly like a non-active feature (parked, resumable)."""
+        self._write_plan("FEAT-2026-9502-deferred", "deferred")
+        with self.assertRaises(SystemExit) as ctx:
+            loop.find_feature(None)
+        self.assertIn("active", str(ctx.exception.code).lower())
+
+    def test_deferred_does_not_count_as_a_second_active(self):
+        """A `deferred` feature alongside one `active` does not trigger the
+        multiple-active disambiguation — deferred is not dispatchable."""
+        active_dir = self._write_plan("FEAT-2026-9502-live", "active")
+        self._write_plan("FEAT-2026-9502-parked", "deferred")
+        self.assertEqual(loop.find_feature(None), active_dir)
+
+    def test_deferred_still_selectable_by_explicit_arg(self):
+        """A human can still target a `deferred` feature explicitly (e.g. to
+        inspect it); only auto-selection skips it."""
+        fdir = self._write_plan("FEAT-2026-9502-parked", "deferred")
+        self.assertEqual(loop.find_feature("FEAT-2026-9502-parked"), fdir)
+
     def test_explicit_arg_without_plan_exits(self):
         """Lines 188-190: explicit dir name with no PLAN.md → sys.exit."""
         orphan = self._features_dir / "FEAT-2026-9502-orphan"

{specfuse_loop-0.3.5 → specfuse_loop-0.3.7}/tests/test_loop_post_pass_invariant.py

@@ -69,6 +69,7 @@ def _write_feature_scaffold(
     roadmap_row_status: str = "done",
     archive_anchor_present: bool = True,
     wu_verdict: str = "met",
+    roadmap_priority_column: bool = False,
 ) -> Path:
     """Write a .specfuse scaffold matching the requested post-flip state.
 
@@ -98,11 +99,23 @@ def _write_feature_scaffold(
         f"status: done\nattempts: 1\nverdict: {wu_verdict}\n---\n\n# Close{_WU_BODY}"
     )
 
+    if roadmap_priority_column:
+        # Non-canonical shape: a Priority column sits BEFORE Status, shifting
+        # Status from column 3 to column 4. Exercises header-name parsing.
+        roadmap_table = (
+            f"| Feature ID | Title | Priority | Status | Folder |\n"
+            f"|------------|-------|----------|--------|--------|\n"
+            f"| {feature_id} | Test feature | P2 | {roadmap_row_status} | — |\n\n"
+        )
+    else:
+        roadmap_table = (
+            f"| Feature ID | Title | Status | Folder | Detail |\n"
+            f"|------------|-------|--------|--------|--------|\n"
+            f"| {feature_id} | Test feature | {roadmap_row_status} | — | — |\n\n"
+        )
     (specfuse / "roadmap.md").write_text(
         f"---\nproject: test\n---\n\n# Roadmap\n\n"
-        f"| Feature ID | Title | Status | Folder | Detail |\n"
-        f"|------------|-------|--------|--------|--------|\n"
-        f"| {feature_id} | Test feature | {roadmap_row_status} | — | — |\n\n"
+        f"{roadmap_table}"
         f"## {feature_id} — Test feature\n\nContent.\n"
     )
 
@@ -175,6 +188,46 @@ class TestAssertTerminalFlipsFired(unittest.TestCase):
             )
             self.assertIn("active", reason)
 
+    def test_close_passes_with_priority_column_roadmap(self):
+        """Issue #104: roadmap with a Priority column before Status.
+
+        Positional parsing read the Priority cell ('P2') as the status and
+        false-escalated roadmap_row_not_done. Header-name parsing must find
+        the real Status column and pass.
+        """
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            feature_dir = _write_feature_scaffold(
+                root, roadmap_priority_column=True,
+            )
+            wu = _make_close_wu(feature_dir)
+            ok, reason = loop.assert_terminal_flips_fired(
+                wu, feature_dir, root, DUMMY_HEAD,
+            )
+            self.assertTrue(ok, msg=f"unexpected fail: {reason!r}")
+            self.assertEqual(reason, "")
+
+    def test_close_fails_with_priority_column_when_row_active(self):
+        """Priority-column table, row genuinely active → still flagged, and the
+        reason reports the real Status cell, not the Priority token."""
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            feature_dir = _write_feature_scaffold(
+                root, roadmap_priority_column=True,
+                roadmap_row_status="active",
+            )
+            wu = _make_close_wu(feature_dir)
+            ok, reason = loop.assert_terminal_flips_fired(
+                wu, feature_dir, root, DUMMY_HEAD,
+            )
+            self.assertFalse(ok)
+            self.assertTrue(
+                reason.startswith("roadmap_row_not_done:"),
+                msg=f"unexpected reason: {reason!r}",
+            )
+            self.assertIn("active", reason)
+            self.assertNotIn("P2", reason)
+
     def test_close_with_verdict_met_fails_when_archive_anchor_absent(self):
         """Gate + row done but archive missing the lower-cased anchor."""
         with tempfile.TemporaryDirectory() as tmp: