specfuse-loop 0.3.8__tar.gz → 0.3.10__tar.gz

{specfuse_loop-0.3.8/specfuse_loop.egg-info → specfuse_loop-0.3.10}/PKG-INFO

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

{specfuse_loop-0.3.8 → specfuse_loop-0.3.10}/pyproject.toml

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

specfuse_loop-0.3.10/specfuse/loop/data/VERSION

@@ -0,0 +1 @@
+0.3.10

{specfuse_loop-0.3.8 → specfuse_loop-0.3.10}/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.8"
+DRIVER_VERSION = "0.3.10"
 # 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
@@ -507,6 +507,35 @@ def flush_events(events_path: Path, events: list) -> None:
 # --------------------------------------------------------------------------- #
 
 
+# Known signatures of a gate whose oracle SILENTLY DEGRADED — the command
+# exits 0 while its analyzer measured a strict subset of the real check, so a
+# green gate is a hollow pass (issue #134). Each entry is (compiled pattern,
+# human reason). A gate whose output matches while exiting 0 is forced to FAIL
+# so the driver blocks honestly instead of certifying `met` on a subset oracle.
+# These are language/tool-specific data, not detection logic — extend the list
+# as new silent-degradation modes surface; the matching in verify() is generic.
+DEGRADED_ORACLE_MARKERS: list[tuple["re.Pattern[str]", str]] = [
+    # Flutter/Dart custom_lint: the analyzer plugin can't resolve/build (e.g.
+    # network to pub.dev blocked in the sandbox), so `flutter analyze` drops to
+    # core lints only and still exits 0 — every custom_lint/riverpod_lint rule
+    # is invisible. Observed on FEAT-2026-0005 (28 warnings CI caught, loop 0).
+    (re.compile(r"error occurred while setting up the analyzer plugin",
+                re.IGNORECASE),
+     "custom_lint analyzer plugin did not load — 'flutter analyze' degraded to "
+     "core lints only; the warnings oracle measured a subset of the real check "
+     "and cannot certify zero warnings in this environment"),
+]
+
+
+def detect_degraded_oracle(stdout: str) -> str | None:
+    """Return an honest reason string if gate output shows a silently degraded
+    oracle, else None. Matches against DEGRADED_ORACLE_MARKERS (issue #134)."""
+    for pattern, reason in DEGRADED_ORACLE_MARKERS:
+        if pattern.search(stdout):
+            return reason
+    return None
+
+
 def parse_gate_failure_signature(stdout: str) -> tuple[str, str]:
     """Extract (failure_class, failure_signature) from gate runner stdout.
 
@@ -1654,6 +1683,14 @@ def verify(wu: WorkUnit, feature_dir: Path,
             out, _ = proc.communicate(timeout=GATE_TIMEOUT_SECONDS)
             ok = proc.returncode == 0
             tail = (out or "").strip().splitlines()[-15:]
+            # A green gate whose oracle silently degraded is a hollow pass
+            # (issue #134): force FAIL and name the degradation honestly so the
+            # log reads as "oracle couldn't measure it," not "code is clean."
+            if ok:
+                degraded = detect_degraded_oracle(out or "")
+                if degraded:
+                    ok = False
+                    tail = tail + [f"DEGRADED ORACLE: {degraded}"]
         except subprocess.TimeoutExpired:
             try:
                 os.killpg(os.getpgid(proc.pid), signal.SIGKILL)
@@ -3174,6 +3211,11 @@ def run(
 
                 print(f"\n[{time.strftime('%H:%M:%S')}] -- {wu.wu_id} "
                       f"[{wu.type}] model={wu.model} effort={wu.effort}")
+                # Summary line: the WU's title, so the log says WHAT is being
+                # worked, not just its id. Skipped when title just echoes the id
+                # (the parse default when a WU has no `# Title` heading).
+                if wu.title and wu.title != wu.wu_id:
+                    print(f"   ↳ {wu.title}")
                 if dry_run:
                     print("   (dry run — would dispatch)")
                     wu.status = DONE

{specfuse_loop-0.3.8 → specfuse_loop-0.3.10/specfuse_loop.egg-info}/PKG-INFO

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

{specfuse_loop-0.3.8 → specfuse_loop-0.3.10}/specfuse_loop.egg-info/SOURCES.txt

@@ -53,6 +53,7 @@ tests/test_bookkeeping_commit_crash_run.py
 tests/test_bookkeeping_commit_hook_crash.py
 tests/test_closing_deliverable_guard.py
 tests/test_cost_tracking.py
+tests/test_degraded_oracle.py
 tests/test_deliverable_presence_gate.py
 tests/test_doctor.py
 tests/test_driver_integration.py

specfuse_loop-0.3.10/tests/test_degraded_oracle.py

@@ -0,0 +1,90 @@
+#
+# Copyright 2026 Specfuse contributors
+# Licensed under the Apache License, Version 2.0. See LICENSE.
+#
+"""Issue #134 — verify() must FAIL when a gate's oracle silently degraded.
+
+A gate command can exit 0 while its analyzer degraded to a strict subset of the
+real check. The observed case: `flutter analyze --fatal-warnings` cannot build a
+`custom_lint` plugin in the loop sandbox (network to pub.dev blocked), prints
+"An error occurred while setting up the analyzer plugin ...", then continues with
+core lints only and exits 0 — "No issues found!". The gate passes; the real CI
+(plugin loads there) fails on warnings the in-loop oracle never saw. A hollow
+pass.
+
+verify() must treat a known silent-degradation signature in gate output as a
+gate FAILURE even on exit 0, with an honest message naming the degraded oracle,
+so the driver blocks instead of certifying `met` on a subset check.
+"""
+
+from __future__ import annotations
+
+import unittest
+from pathlib import Path
+
+from tests._loop_loader import load_loop
+
+loop = load_loop()
+
+
+def make_wu(wu_type: str = "implementation"):
+    return loop.WorkUnit(
+        wu_id="FEAT-2026-9999/T01",
+        file=Path("/tmp/does-not-matter.md"),
+        depends_on=[],
+        type=wu_type,
+        model="claude-haiku-4-5-20251001",
+        status="pending",
+        attempts=0,
+        title="test fixture",
+        body="(body unused)",
+    )
+
+
+# A shell command that reproduces the degraded-oracle shape: emit the analyzer
+# plugin-setup error to stdout, report "No issues found!", then exit 0.
+_DEGRADED_CMD = (
+    "printf '%s\\n' "
+    "'An error occurred while setting up the analyzer plugin custom_lint' "
+    "'No issues found!'; true"
+)
+
+
+class TestDegradedOracle(unittest.TestCase):
+
+    def test_plugin_setup_error_fails_gate_despite_exit_zero(self):
+        cfg = {"code": [{"name": "warnings", "command": _DEGRADED_CMD}]}
+        ok, msg = loop.verify(make_wu(), Path("/tmp/feat"), cfg=cfg)
+        self.assertFalse(
+            ok, "exit 0 with a plugin-setup error must FAIL — oracle degraded"
+        )
+        self.assertIn("### warnings: FAIL", msg)
+        self.assertIn("DEGRADED ORACLE", msg)
+
+    def test_message_is_honest_about_the_cause(self):
+        cfg = {"code": [{"name": "warnings", "command": _DEGRADED_CMD}]}
+        _, msg = loop.verify(make_wu(), Path("/tmp/feat"), cfg=cfg)
+        # The honest reason (not just the echoed marker) reaches the log: names
+        # the degradation and that the oracle measured a subset, not a warning.
+        self.assertIn("did not load", msg)
+        self.assertIn("subset", msg)
+
+    def test_clean_pass_still_passes(self):
+        # Same "No issues found!" success WITHOUT the degradation marker: passes.
+        cfg = {"code": [{"name": "warnings",
+                         "command": "printf '%s\\n' 'No issues found!'; true"}]}
+        ok, msg = loop.verify(make_wu(), Path("/tmp/feat"), cfg=cfg)
+        self.assertTrue(ok, "clean exit 0 with no degradation marker must pass")
+        self.assertIn("### warnings: PASS", msg)
+
+    def test_marker_does_not_override_a_real_failure(self):
+        # Command exits non-zero AND has the marker: still a FAIL (not masked).
+        cfg = {"code": [{"name": "warnings",
+                         "command": _DEGRADED_CMD.replace("; true", "; false")}]}
+        ok, msg = loop.verify(make_wu(), Path("/tmp/feat"), cfg=cfg)
+        self.assertFalse(ok)
+        self.assertIn("### warnings: FAIL", msg)
+
+
+if __name__ == "__main__":
+    unittest.main()

{specfuse_loop-0.3.8 → specfuse_loop-0.3.10}/tests/test_roadmap_add_skill.py

@@ -5,7 +5,8 @@
 """Reference implementation and tests for the roadmap-add skill algorithm.
 
 The skill appends a new planned feature's table row and detail section to
-roadmap.md, auto-picking the next FEAT-YYYY-NNNN by scanning three sources.
+roadmap.md, auto-picking the next FEAT-YYYY-NNNN by scanning four sources
+(the fourth — GitHub issue/PR-reserved IDs — added for specfuse#16).
 
 Exercises:
   (a) headless mode appends a row and detail section in the right places
@@ -33,19 +34,29 @@ FEAT_ROW_RE = re.compile(r"^\| (FEAT-\d{4}-\d{4})")
 PLAN_FEAT_RE = re.compile(r"^feature_id:\s*(FEAT-\d{4}-\d{4})")
 
 
-def scan_feat_ids(roadmap_path: Path, features_dir: Path, extra_paths: list[Path]) -> dict:
-    """Scan FEAT-YYYY-NNNN IDs from three sources.
+def scan_feat_ids(
+    roadmap_path: Path,
+    features_dir: Path,
+    extra_paths: list[Path],
+    github_reserved: dict[str, str] | None = None,
+) -> dict:
+    """Scan FEAT-YYYY-NNNN IDs from four sources.
 
     Source (a): table rows in roadmap_path (lines matching ``^| FEAT-``).
     Source (b): ``feature_id:`` lines in features_dir/*/PLAN.md.
     Source (c): any occurrence in extra_paths (LEARNINGS.md, RETROSPECTIVE.md).
+    Source (d): GitHub issue/PR titles+bodies — modelled here as an injected
+        ``github_reserved`` map ``{feat_id: "GitHub issue/PR #<n>"}`` so the
+        fold-into-max + collision logic is exercised hermetically (no network).
+        ``None`` models GitHub being unreachable: the skill degrades gracefully
+        and simply omits source (d).
 
-    Returns dict mapping feat_id (str) -> (filepath_str, line_no) for the
+    Returns dict mapping feat_id (str) -> (location_str, line_no) for the
     first occurrence of each ID seen.
     """
     sources: dict[str, tuple[str, int]] = {}
 
-    def record(feat_id: str, filepath: Path, lineno: int) -> None:
+    def record(feat_id: str, filepath, lineno: int) -> None:
         if feat_id not in sources:
             sources[feat_id] = (str(filepath), lineno)
 
@@ -71,6 +82,13 @@ def scan_feat_ids(roadmap_path: Path, features_dir: Path, extra_paths: list[Path
                 for m in FEAT_RE.finditer(line):
                     record(m.group(0), path, lineno)
 
+    # (d) GitHub issue/PR-reserved IDs (None = GitHub unreachable, skip source).
+    if github_reserved:
+        for feat_id, ref in github_reserved.items():
+            # location is the issue/PR ref; lineno 0 (not a file line)
+            if feat_id not in sources:
+                sources[feat_id] = (ref, 0)
+
     return sources
 
 
@@ -449,6 +467,40 @@ class TestNextFeatId(unittest.TestCase):
         self.assertIn("gap", str(ctx.exception).lower())
         self.assertIn("0002", str(ctx.exception))
 
+    # ── Source (d): GitHub issue/PR-reserved IDs (specfuse#16) ──────────────
+
+    def test_github_reserved_id_raises_max(self):
+        """A FEAT ID reserved only on a GitHub issue (no roadmap row) must be
+        folded into the max so the next ID does not collide with it."""
+        # roadmap/plan/learnings top out at 0010; GitHub reserves 0011.
+        gh = {"FEAT-2026-0011": "GitHub issue #345"}
+        sources = scan_feat_ids(
+            self.roadmap, self.features_dir, [self.learnings], github_reserved=gh
+        )
+        feat_id, ordinal = next_feat_id(2026, sources)
+        self.assertEqual(feat_id, "FEAT-2026-0012")
+        self.assertEqual(ordinal, 12)
+
+    def test_github_unreachable_degrades_gracefully(self):
+        """github_reserved=None models GitHub being unreachable: the scan omits
+        source (d) and proceeds on the three local sources — no hard failure."""
+        sources = scan_feat_ids(
+            self.roadmap, self.features_dir, [self.learnings], github_reserved=None
+        )
+        feat_id, _ = next_feat_id(2026, sources)
+        self.assertEqual(feat_id, "FEAT-2026-0011")  # local-only max=0010
+
+    def test_github_reserved_beyond_local_max_surfaces_gap(self):
+        """A reserved ID beyond the local max exposes the intervening ordinals
+        as genuine gaps (roadmap→0010, issue reserves 0016 → 0011–0015 gap)."""
+        gh = {"FEAT-2026-0016": "GitHub issue #345"}
+        sources = scan_feat_ids(
+            self.roadmap, self.features_dir, [self.learnings], github_reserved=gh
+        )
+        with self.assertRaises(ValueError) as ctx:
+            next_feat_id(2026, sources)
+        self.assertIn("gap", str(ctx.exception).lower())
+
 
 class TestCollisionRejection(unittest.TestCase):
     """(c) ID collision is rejected with a message naming the conflicting source."""
@@ -530,6 +582,42 @@ class TestCollisionRejection(unittest.TestCase):
         # Caller would not invoke add_feature on collision; verify snapshot unchanged
         self.assertEqual(self.roadmap.read_text(), snapshot)
 
+    def test_collision_detected_for_github_reserved_id(self):
+        """specfuse#16: an ID reserved only on a GitHub issue/PR (no local
+        source) must be caught by the collision check and name the GitHub ref."""
+        gh = {"FEAT-2026-0016": "GitHub issue #345"}
+        sources = scan_feat_ids(
+            self.roadmap, self.features_dir, [self.learnings], github_reserved=gh
+        )
+        collides, filepath, lineno = check_collision("FEAT-2026-0016", sources)
+        self.assertTrue(collides, "GitHub-reserved ID must collide")
+        self.assertIn("GitHub", filepath)
+
+
+class TestSkillDocumentsGitHubSource(unittest.TestCase):
+    """The skill prose must document source (d) + graceful offline degradation
+    (specfuse#16). Guards against the four-source scan silently regressing to
+    three in the authored SKILL.md."""
+
+    def setUp(self):
+        repo_root = Path(__file__).resolve().parent.parent
+        self.skill = (
+            repo_root / "plugins" / "specfuse" / "skills"
+            / "roadmap-add" / "SKILL.md"
+        ).read_text()
+
+    def test_declares_four_sources(self):
+        self.assertIn("four sources", self.skill)
+
+    def test_documents_github_source(self):
+        self.assertIn("Source (d)", self.skill)
+        self.assertIn("gh search issues", self.skill)
+
+    def test_documents_graceful_degradation(self):
+        # A WARN path so offline runs continue rather than hard-failing.
+        self.assertIn("WARN", self.skill)
+        self.assertIn("offline", self.skill.lower())
+
 
 if __name__ == "__main__":
     unittest.main()

specfuse_loop-0.3.8/specfuse/loop/data/VERSION

@@ -1 +0,0 @@
-0.3.8