specfuse-loop 0.3.9__tar.gz → 0.3.11__tar.gz

{specfuse_loop-0.3.9/specfuse_loop.egg-info → specfuse_loop-0.3.11}/PKG-INFO

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

{specfuse_loop-0.3.9 → specfuse_loop-0.3.11}/pyproject.toml

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

specfuse_loop-0.3.11/specfuse/loop/data/VERSION

@@ -0,0 +1 @@
+0.3.11

{specfuse_loop-0.3.9 → specfuse_loop-0.3.11}/specfuse/loop/data/docs/concepts/architecture-addendum-gates-and-iterative-planning.md

@@ -24,7 +24,7 @@ implementation feature == a loop feature**: the receiving component's loop decom
 So gates are **internal to the loop**, not orchestrator state. The orchestrator owns
 `initiative → feature` decomposition, cross-repo dependency ordering, and the spec/generated
 interface contracts between features; it does **not** identify gates, run `plan-next`, or hold a
-per-gate `plan_review`. The loop owns all of that, per [`methodology.md`](methodology.md).
+per-gate `plan_review`. The loop owns all of that, per [`methodology.md`](../methodology.md).
 
 **Why Model B (summary).** The loop is single-repo + edit-and-commit; codegen freezes the
 cross-repo interface (generated `emit-*`/`on-*` contracts are immutable `_generated/`), so
@@ -60,7 +60,7 @@ gates were placed in the loop instead.
 
 ## 3. What the loop owns (the gate layer)
 
-Per [`methodology.md`](methodology.md): the gate cycle (plan → execute → close → review&arm), the
+Per [`methodology.md`](../methodology.md): the gate cycle (plan → execute → close → review&arm), the
 four-type closing sequence (`retrospective → lessons → docs → plan-next`), `plan-next` drafting
 the next gate (never arming it), `LEARNINGS.md`, and per-gate autonomy. These are **loop-internal**
 to each dispatched feature; the orchestrator sees only the feature's overall state (via issue

{specfuse_loop-0.3.9 → specfuse_loop-0.3.11}/specfuse/loop/data/docs/concepts/ralph-lineage.md

@@ -50,7 +50,7 @@ independently-adoptable projects live under it:
   for multi-repo, spec-first feature delivery.
 
 The loop and the orchestrator are two execution surfaces of **one** methodology
-(see [`methodology.md`](methodology.md)); they share the gate cycle, the
+(see [`methodology.md`](../methodology.md)); they share the gate cycle, the
 work-unit contract, the correlation-ID scheme, and the verification discipline.
 The loop is the right home for work that lives in one repo or has no formal
 spec; the orchestrator is the right home when the work genuinely spans repos and

{specfuse_loop-0.3.9 → specfuse_loop-0.3.11}/specfuse/loop/data/templates/WU.template.md

@@ -38,7 +38,7 @@ AUTHOR-SET FIELDS — fill or override these at draft/arm time:
 - `produces` — OPTIONAL. File path(s) this WU must produce; machine-enforced by the driver's
   presence gate (FEAT-2026-0022). Lint WARN when absent on `implementation` WUs.
 
-DRIVER-OWNED FIELDS — the driver writes these at outcome time; authors leave them absent:
+DRIVER-OWNED FIELDS - the driver writes these at outcome time; authors leave them absent:
 <!-- driver-owned: attempts, cost_usd, input_tokens, output_tokens, duration_seconds,
      cumulative_cost_usd, cumulative_duration_seconds, cumulative_input_tokens,
      cumulative_output_tokens, re_arm_count, re_arm_history -->

{specfuse_loop-0.3.9 → specfuse_loop-0.3.11}/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.9"
+DRIVER_VERSION = "0.3.11"
 # 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.9 → specfuse_loop-0.3.11/specfuse_loop.egg-info}/PKG-INFO

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

{specfuse_loop-0.3.9 → specfuse_loop-0.3.11}/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
@@ -117,6 +118,7 @@ tests/test_roadmap_add_skill.py
 tests/test_roadmap_archive_skill.py
 tests/test_roadmap_row_parser.py
 tests/test_scaffold_data_in_sync.py
+tests/test_scaffold_doc_hygiene.py
 tests/test_scaffold_docs.py
 tests/test_scaffold_init.py
 tests/test_scaffold_manifest.py

specfuse_loop-0.3.11/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.11/tests/test_scaffold_doc_hygiene.py

@@ -0,0 +1,79 @@
+#
+# Copyright 2026 Specfuse Contributors
+# Licensed under the Apache License, Version 2.0. See LICENSE.
+#
+"""Issue #140 — vendored scaffold docs/templates must not carry defects that
+trip Markdown inspections downstream.
+
+Two genuine defects were observed in a freshly-initialized project:
+
+1. Broken relative links to `methodology.md` from `docs/concepts/*.md`: the
+   link uses a same-directory path but `methodology.md` lives one level up in
+   `docs/`. Correct target is `../methodology.md`.
+2. A "Bad character" parse error on the em-dash (U+2014) leading the inline
+   text of the `DRIVER-OWNED FIELDS` paragraph in `WU.template.md`.
+
+These guards run against the CANONICAL sources (`docs/`, `.specfuse/`); the
+byte-match drift guard in test_scaffold_data_in_sync.py keeps the vendored
+`specfuse/loop/data/` copies in lockstep, so fixing the canonicals + re-vendoring
+propagates the fix everywhere.
+"""
+
+from __future__ import annotations
+
+import pathlib
+import re
+import unittest
+
+REPO_ROOT = pathlib.Path(__file__).parent.parent
+DOCS = REPO_ROOT / "docs"
+WU_TEMPLATE = REPO_ROOT / ".specfuse" / "templates" / "WU.template.md"
+
+# Markdown inline link with a relative path target (skips absolute URLs and
+# pure-anchor links). Captures the path portion, dropping any `#anchor`.
+_LINK_RE = re.compile(r"\]\((?!https?://)([^)#][^)]*?)(?:#[^)]*)?\)")
+EM_DASH = "—"
+
+
+class TestScaffoldDocHygiene(unittest.TestCase):
+
+    def test_docs_relative_md_links_resolve(self):
+        """Every relative .md link in docs/ must resolve to an existing file
+        from the linking file's own directory (issue #140 defect 1)."""
+        broken: list[str] = []
+        for md in sorted(DOCS.rglob("*.md")):
+            for lineno, line in enumerate(
+                md.read_text(encoding="utf-8").splitlines(), start=1
+            ):
+                for target in _LINK_RE.findall(line):
+                    if not target.endswith(".md"):
+                        continue
+                    resolved = (md.parent / target).resolve()
+                    if not resolved.is_file():
+                        rel = md.relative_to(REPO_ROOT)
+                        broken.append(f"{rel}:{lineno} -> {target}")
+        self.assertEqual(
+            [], broken,
+            "broken relative .md links in docs/ (fix the path):\n"
+            + "\n".join(broken),
+        )
+
+    def test_wu_template_driver_owned_line_has_no_em_dash(self):
+        """The DRIVER-OWNED FIELDS paragraph must not carry the U+2014 em-dash
+        that IntelliJ flags as a Bad character (issue #140 defect 2)."""
+        matches = [
+            line
+            for line in WU_TEMPLATE.read_text(encoding="utf-8").splitlines()
+            if line.startswith("DRIVER-OWNED FIELDS")
+        ]
+        self.assertTrue(matches, "DRIVER-OWNED FIELDS line not found in template")
+        for line in matches:
+            self.assertNotIn(
+                EM_DASH, line,
+                "DRIVER-OWNED FIELDS line still contains the U+2014 em-dash "
+                "that trips the Markdown parser — use ' - ' instead",
+            )
+
+
+if __name__ == "__main__":
+    unittest.main()

specfuse_loop-0.3.9/specfuse/loop/data/VERSION

@@ -1 +0,0 @@
-0.3.9