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

{specfuse_loop-0.3.6/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.6
+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.6 → specfuse_loop-0.3.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "specfuse-loop"
-version = "0.3.6"
+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.6 → 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.6 → 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.6"
+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")
 
 
 # --------------------------------------------------------------------------- #

{specfuse_loop-0.3.6 → 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.6
+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.6 → 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.7/tests/test_upgrade_merge_gate.py

@@ -0,0 +1,181 @@
+#
+# Copyright 2026 Specfuse Contributors
+# Licensed under the Apache License, Version 2.0. See LICENSE.
+#
+"""Tests for .specfuse/scripts/upgrade_merge_gate.py (FEAT-2026-0029/T01).
+
+`decide` turns (CI status, per-feature lint_plan.py results) into a merge/halt
+verdict; `collect_reports` produces those per-feature results by shelling out
+to lint_plan.py once per `.specfuse/features/*/` folder. 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 sys
+import tempfile
+import unittest
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+SCRIPTS_DIR = REPO_ROOT / ".specfuse" / "scripts"
+
+
+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
+
+
+umg = _load("upgrade_merge_gate")
+
+_VALID_FM = """\
+---
+feature_id: FEAT-2026-0099
+title: Test Feature
+branch: feat/test
+roadmap_goal: Test goal
+status: active
+---
+"""
+
+_CLOSING_WUS = [
+    ("FEAT-2026-0099/G1-RETRO", "WU-90-retro.md", "retrospective"),
+    ("FEAT-2026-0099/G1-LESSONS", "WU-91-lessons.md", "lessons"),
+    ("FEAT-2026-0099/G1-DOCS", "WU-92-docs.md", "docs"),
+    ("FEAT-2026-0099/G1-PLAN", "WU-93-plan-next.md", "plan-next"),
+]
+
+
+def _wu_fm(wid: str, wu_type: str, status: str = "done") -> str:
+    return "\n".join(["---", f"id: {wid}", f"type: {wu_type}", f"status: {status}", "---"]) + "\n"
+
+
+def _make_graph(work_units: list[dict]) -> str:
+    parts = ["```yaml", "gates:", "  - gate: 1", "    work_units:"]
+    for wu in work_units:
+        parts.append(f"      - id: {wu['id']}")
+        parts.append(f"        file: {wu['file']}")
+        parts.append("        depends_on: []")
+    parts.append("```")
+    return "\n".join(parts)
+
+
+def _build_valid_feature(features_dir: Path, name: str) -> Path:
+    """A feature folder that passes lint_plan.py cleanly."""
+    feat = features_dir / name
+    feat.mkdir()
+    impl_id = "FEAT-2026-0099/T01"
+    impl_file = "WU-01-impl.md"
+    all_wus = [{"id": impl_id, "file": impl_file}] + [
+        {"id": wid, "file": wfile} for wid, wfile, _ in _CLOSING_WUS
+    ]
+    (feat / "PLAN.md").write_text(_VALID_FM + "\n" + _make_graph(all_wus) + "\n")
+    (feat / impl_file).write_text(_wu_fm(impl_id, "implementation"))
+    for wid, wfile, wtype in _CLOSING_WUS:
+        (feat / wfile).write_text(_wu_fm(wid, wtype))
+    return feat
+
+
+def _build_invalid_feature(features_dir: Path, name: str) -> Path:
+    """A feature folder with no PLAN.md — fails lint_plan.py."""
+    feat = features_dir / name
+    feat.mkdir()
+    return feat
+
+
+class TestDecide(unittest.TestCase):
+
+    def test_halts_when_a_feature_fails_conformance(self):
+        verdict, reason = umg.decide(
+            True,
+            [
+                {"feature": "FEAT-2026-0001-a", "ok": True, "detail": ""},
+                {"feature": "FEAT-2026-0002-b", "ok": False, "detail": "missing PLAN.md"},
+            ],
+        )
+        self.assertEqual(verdict, "halt")
+        self.assertIn("FEAT-2026-0002-b", reason)
+
+    def test_merge_when_all_ok_and_ci_green(self):
+        verdict, reason = umg.decide(
+            True,
+            [
+                {"feature": "a", "ok": True, "detail": ""},
+                {"feature": "b", "ok": True, "detail": ""},
+            ],
+        )
+        self.assertEqual(verdict, "merge")
+        self.assertEqual(reason, "")
+
+    def test_halt_when_ci_not_green_even_if_all_ok(self):
+        verdict, reason = umg.decide(
+            False,
+            [{"feature": "a", "ok": True, "detail": ""}],
+        )
+        self.assertEqual(verdict, "halt")
+        self.assertIn("CI not green", reason)
+
+    def test_halt_when_ci_green_but_a_report_not_ok(self):
+        verdict, reason = umg.decide(
+            True,
+            [{"feature": "a", "ok": True, "detail": ""}, {"feature": "b", "ok": False, "detail": "x"}],
+        )
+        self.assertEqual(verdict, "halt")
+        self.assertIn("b", reason)
+
+    def test_empty_reports_fails_safe_to_halt(self):
+        verdict, reason = umg.decide(True, [])
+        self.assertEqual(verdict, "halt")
+        self.assertIn("no feature folders", reason)
+
+
+class TestCollectReports(unittest.TestCase):
+
+    def test_no_feature_folders_returns_empty_list(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            repo_root = Path(tmp)
+            reports = umg.collect_reports(repo_root)
+        self.assertEqual(reports, [])
+
+    def test_marks_valid_and_invalid_feature_folders(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            repo_root = Path(tmp)
+            features_dir = repo_root / ".specfuse" / "features"
+            features_dir.mkdir(parents=True)
+            _build_valid_feature(features_dir, "FEAT-2026-0001-good")
+            _build_invalid_feature(features_dir, "FEAT-2026-0002-bad")
+
+            scripts_dir = repo_root / ".specfuse" / "scripts"
+            scripts_dir.mkdir(parents=True)
+            # A minimal shim (not a copy of the repo's own lint_plan.py shim,
+            # whose path-insert logic assumes it lives 2 levels under the real
+            # repo root) that runs the real specfuse.loop.lint_plan CLI against
+            # this tmp repo's feature folders.
+            (scripts_dir / "lint_plan.py").write_text(
+                "import sys\n"
+                f"sys.path.insert(0, {str(REPO_ROOT)!r})\n"
+                "from specfuse.loop.lint_plan import main\n"
+                "if __name__ == '__main__':\n"
+                "    raise SystemExit(main())\n"
+            )
+
+            reports = umg.collect_reports(repo_root)
+
+        by_name = {r["feature"]: r for r in reports}
+        self.assertEqual(len(reports), 2)
+        self.assertTrue(by_name["FEAT-2026-0001-good"]["ok"])
+        self.assertFalse(by_name["FEAT-2026-0002-bad"]["ok"])
+        self.assertTrue(by_name["FEAT-2026-0002-bad"]["detail"])
+
+
+if __name__ == "__main__":
+    unittest.main()

specfuse_loop-0.3.6/specfuse/loop/data/VERSION

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