specfuse-loop 0.3.4__tar.gz → 0.3.6__tar.gz

{specfuse_loop-0.3.4/specfuse_loop.egg-info → specfuse_loop-0.3.6}/PKG-INFO

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

{specfuse_loop-0.3.4 → specfuse_loop-0.3.6}/pyproject.toml

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

specfuse_loop-0.3.6/specfuse/loop/data/VERSION

@@ -0,0 +1 @@
+0.3.6

{specfuse_loop-0.3.4 → specfuse_loop-0.3.6}/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.4 → specfuse_loop-0.3.6}/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.4 → specfuse_loop-0.3.6}/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.4 → specfuse_loop-0.3.6}/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.4"
+DRIVER_VERSION = "0.3.6"
 # 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
@@ -2900,17 +2900,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}"
 
@@ -3531,7 +3527,12 @@ def run(
                         # FEAT-2026-0018/T07 — plan-next-draft lint hook (warn-only v1)
                         if wu.type == "plan-next":
                             try:
-                                from lint_plan import lint_plan_next_draft
+                                # Package-relative + function-local: lint_plan
+                                # imports `from .loop import VERDICT_VALUES`, so a
+                                # module-top import would be circular; the old
+                                # flat (top-level) form broke once the driver
+                                # ships as a pip package (#100).
+                                from .lint_plan import lint_plan_next_draft
                                 _warns = lint_plan_next_draft(feature_dir, gate.number)
                             except Exception as _exc:
                                 _warns = [f"lint_plan_next_draft raised: {_exc}"]

{specfuse_loop-0.3.4 → specfuse_loop-0.3.6/specfuse_loop.egg-info}/PKG-INFO

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

{specfuse_loop-0.3.4 → specfuse_loop-0.3.6}/specfuse_loop.egg-info/SOURCES.txt

@@ -79,6 +79,7 @@ tests/test_lint_correlation_id_close_intermediate.py
 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_produces_driver_helper.py
 tests/test_lint_sections.py
 tests/test_lint_task_graph_yaml_selection.py

specfuse_loop-0.3.6/tests/test_lint_plan_relative_import.py

@@ -0,0 +1,57 @@
+#
+# Copyright 2026 Specfuse contributors
+# Licensed under the Apache License, Version 2.0. See LICENSE.
+#
+"""Regression test for #100 — the plan-next-draft lint hook must use a
+package-relative import.
+
+`loop.py`'s plan-next hook imported `from lint_plan import lint_plan_next_draft`
+(flat). That only resolved when the scripts were copied side-by-side (pre-pip);
+in the installed package it raises `No module named 'lint_plan'`, so the
+plan-next gate logs a warning and the draft lint never runs. The import is
+function-local on purpose (lint_plan imports `from .loop import VERDICT_VALUES`,
+so a module-top import would be circular) — the fix is to make the local import
+package-relative, not to hoist it.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+LOOP_SRC = REPO_ROOT / "specfuse" / "loop" / "loop.py"
+
+
+class TestLintPlanRelativeImport(unittest.TestCase):
+
+    def test_loop_uses_package_relative_lint_plan_import(self):
+        src = LOOP_SRC.read_text(encoding="utf-8")
+        self.assertNotIn(
+            "from lint_plan import", src,
+            "flat `from lint_plan import` breaks in the installed package (#100)",
+        )
+        self.assertIn(
+            "from .lint_plan import lint_plan_next_draft", src,
+            "the plan-next hook must import lint_plan_next_draft package-relative",
+        )
+
+    def test_lint_plan_next_draft_importable_outside_repo_root(self):
+        """Resolvable as a package member even when CWD is not the repo root
+        (so a flat `lint_plan.py` on the path can't mask the bug)."""
+        with tempfile.TemporaryDirectory() as tmp:
+            r = subprocess.run(
+                [sys.executable, "-c",
+                 "from specfuse.loop.lint_plan import lint_plan_next_draft; "
+                 "print('ok')"],
+                capture_output=True, text=True, cwd=tmp,
+            )
+        self.assertEqual(r.returncode, 0, r.stderr)
+        self.assertIn("ok", r.stdout)
+
+
+if __name__ == "__main__":
+    unittest.main()

{specfuse_loop-0.3.4 → specfuse_loop-0.3.6}/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.4 → specfuse_loop-0.3.6}/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:

{specfuse_loop-0.3.4 → specfuse_loop-0.3.6}/tests/test_roadmap_archive_skill.py

@@ -104,6 +104,34 @@ def archive_feature(roadmap_path: Path, archive_path: Path, feat_id: str) -> str
     return "archived"
 
 
+def auto_eligible(roadmap_text: str) -> list[str]:
+    """Reference impl of `--auto` eligibility, corrected per #102.
+
+    Eligible = `done`/`abandoned` rows that still have an inline `## FEAT-id — `
+    section and are not already back-linked. NOT gated on the `Detail` cell being
+    `—`: a folder-path Detail (older convention) is orthogonal to whether the
+    inline prose was archived. The buggy rule (`Detail == '—'`) silently skipped
+    folder-path rows, leaving their prose inline forever.
+    """
+    eligible: list[str] = []
+    row_re = re.compile(
+        r"^\| *(FEAT-\d{4}-\d{4}) *\|([^|]+)\|([^|]+)\|([^|]+)\|([^|]+)\|",
+        re.MULTILINE,
+    )
+    for m in row_re.finditer(roadmap_text):
+        feat_id = m.group(1).strip()
+        status = m.group(3).strip()
+        detail = m.group(5).strip()
+        if status not in ("done", "abandoned"):
+            continue
+        if "roadmap-archive.md#" in detail:
+            continue  # already archived
+        if re.search(r"^## " + re.escape(feat_id) + r" — ", roadmap_text,
+                     re.MULTILINE):
+            eligible.append(feat_id)
+    return eligible
+
+
 # ---------------------------------------------------------------------------
 # Test fixtures
 # ---------------------------------------------------------------------------
@@ -240,5 +268,84 @@ class TestArchiveFeature(unittest.TestCase):
         self.assertEqual(self.archive.read_text(), archive_snapshot)
 
 
+_ROADMAP_MIXED = textwrap.dedent("""\
+    ---
+    project: test
+    ---
+
+    # Roadmap
+
+    | Feature ID     | Title         | Status    | Folder | Detail |
+    |----------------|---------------|-----------|--------|--------|
+    | FEAT-2026-0001 | Folder detail | done      | f1     | features/FEAT-2026-0001-x/ |
+    | FEAT-2026-0002 | Dash detail   | done      | —      | —      |
+    | FEAT-2026-0003 | Already arch  | done      | —      | [→ archive](roadmap-archive.md#feat-2026-0003) |
+    | FEAT-2026-0004 | Planned thing | planned   | —      | —      |
+    | FEAT-2026-0005 | Abandoned one | abandoned | f5     | features/FEAT-2026-0005-y/ |
+
+    ## FEAT-2026-0001 — Folder detail
+
+    Prose 1.
+
+    ## FEAT-2026-0002 — Dash detail
+
+    Prose 2.
+
+    ## FEAT-2026-0004 — Planned thing
+
+    Prose 4.
+
+    ## FEAT-2026-0005 — Abandoned one
+
+    Prose 5.
+
+    ## Notes
+
+    Notes.
+""")
+
+
+class TestAutoEligibility(unittest.TestCase):
+    """#102 — --auto must not gate eligibility on Detail == '—'."""
+
+    def test_folder_path_detail_done_feature_is_eligible(self):
+        elig = auto_eligible(_ROADMAP_MIXED)
+        # The #102 regression: folder-path Detail done feature WITH inline prose.
+        self.assertIn("FEAT-2026-0001", elig)
+        self.assertIn("FEAT-2026-0005", elig)  # abandoned + folder-path
+
+    def test_dash_detail_still_eligible(self):
+        self.assertIn("FEAT-2026-0002", auto_eligible(_ROADMAP_MIXED))
+
+    def test_already_archived_excluded(self):
+        self.assertNotIn("FEAT-2026-0003", auto_eligible(_ROADMAP_MIXED))
+
+    def test_planned_excluded(self):
+        self.assertNotIn("FEAT-2026-0004", auto_eligible(_ROADMAP_MIXED))
+
+    def test_full_eligible_set(self):
+        self.assertEqual(
+            sorted(auto_eligible(_ROADMAP_MIXED)),
+            ["FEAT-2026-0001", "FEAT-2026-0002", "FEAT-2026-0005"],
+        )
+
+    def test_old_dash_only_rule_would_skip_folder_paths(self):
+        """Document the bug: gating on Detail == '—' drops the folder-path rows
+        that the corrected rule (auto_eligible) includes."""
+        dash_only = [f for f in auto_eligible(_ROADMAP_MIXED)
+                     if _detail_cell(_ROADMAP_MIXED, f) == "—"]
+        self.assertEqual(dash_only, ["FEAT-2026-0002"])
+        # corrected rule catches 2 more the buggy one missed
+        self.assertEqual(len(auto_eligible(_ROADMAP_MIXED)) - len(dash_only), 2)
+
+
+def _detail_cell(roadmap_text: str, feat_id: str) -> str:
+    m = re.search(
+        r"^\| *" + re.escape(feat_id) + r" *\|[^|]+\|[^|]+\|[^|]+\|([^|]+)\|",
+        roadmap_text, re.MULTILINE,
+    )
+    return m.group(1).strip() if m else ""
+
+
 if __name__ == "__main__":
     unittest.main()

specfuse_loop-0.3.4/specfuse/loop/data/VERSION

@@ -1 +0,0 @@
-0.3.4