specfuse-loop 0.3.19__tar.gz → 0.3.20__tar.gz

{specfuse_loop-0.3.19/specfuse_loop.egg-info → specfuse_loop-0.3.20}/PKG-INFO

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

{specfuse_loop-0.3.19 → specfuse_loop-0.3.20}/pyproject.toml

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

specfuse_loop-0.3.20/specfuse/loop/data/VERSION

@@ -0,0 +1 @@
+0.3.20

{specfuse_loop-0.3.19 → specfuse_loop-0.3.20}/specfuse/loop/data/docs/methodology.md

@@ -139,7 +139,13 @@ auto-close only eliminates the reflective overhead, not the forward-design step.
 full close ceremony regardless of predicate outcome. Alternatively, set
 `auto_close_disabled: true` in a feature's `PLAN.md` frontmatter to disable
 auto-close permanently for that feature (e.g., for features that are inherently
-exploratory and expect off-plan behavior).
+exploratory and expect off-plan behavior). For a single **substantive close**
+— a `close` (or `close-intermediate`) WU whose acceptance criteria assert on the
+source tree, reconcile prior gates, or observe runtime behaviour rather than
+just writing the retrospective stub — set `auto_close_disabled: true` in **that
+WU's** frontmatter. The predicate keys on the implementation WUs' cost and
+plan-conformance and cannot see what a close verifies, so a substantive close
+must be marked must-run or its verification is silently skipped (#189).
 
 **Predicate-version transparency** — every `auto_close_decision` event in
 `events.jsonl` carries a `predicate_version` field (e.g., `predicate_version:

{specfuse_loop-0.3.19 → specfuse_loop-0.3.20}/specfuse/loop/loop.py

@@ -63,7 +63,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.19"
+DRIVER_VERSION = "0.3.20"
 # 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
@@ -2778,6 +2778,56 @@ def _already_auto_closed(wu_file: Path) -> bool:
     return auto in (True, "true", "True")
 
 
+def _gate_impl_deliverables_present(
+    feature_dir: Path, gate: "GateNode",
+) -> tuple[bool, str]:
+    """Return (True, "") iff every implementation WU in *gate* has its declared
+    ``produces:`` deliverables present and non-empty on disk (#190).
+
+    Auto-close keys on WU cost/plan-conformance and trusts each WU's ``done``
+    status; ``assert_declared_deliverables`` — the dispatch-time presence gate —
+    never runs on an auto-closed gate, so a WU that reported ``done`` with its
+    ``produces:`` paths absent still counts as a clean gate. Running the same
+    check here stops the predicate auto-closing over a ``done`` that did not
+    deliver. Non-implementation WUs and WUs with no ``produces:`` are skipped
+    (the latter is assert_declared_deliverables's own opt-out). A missing or
+    malformed WU file is left to the predicate / dispatch path that already
+    handles it, not crashed on here.
+    """
+    for ref in gate.refs:
+        try:
+            wu = load_wu(feature_dir, ref)
+        except (FileNotFoundError, KeyError, _miniyaml.MiniYAMLError):
+            continue
+        if wu.type != "implementation":
+            continue
+        ok, summary = assert_declared_deliverables(wu)
+        if not ok:
+            return False, f"{ref.get('id', wu.wu_id)}: {summary}"
+    return True, ""
+
+
+def _close_wu_disables_auto_close(close_wu: "WorkUnit | None") -> bool:
+    """True iff the close WU's frontmatter sets ``auto_close_disabled`` truthy.
+
+    Per-WU counterpart to PLAN.md's feature-level ``auto_close_disabled``
+    (#189). The auto-close predicate keys on the implementation WUs' cost and
+    plan-conformance; it has no signal for what the CLOSE WU itself is
+    contracted to verify. A substantive close — one whose acceptance criteria
+    assert on the source tree, reconcile prior gates, or observe runtime
+    behaviour — must be dispatched and run, not optimized away. The plan author
+    marks such a close with ``auto_close_disabled: true`` in its frontmatter;
+    the predicate then always defers to dispatch for that gate.
+
+    Distinct from the ``auto_close`` key, which is the auto-close OUTPUT marker
+    (set to ``true`` by mark_close_wu_auto_closed after a gate auto-closes).
+    """
+    if close_wu is None or not close_wu.file.is_file():
+        return False
+    fm, _ = read_frontmatter(close_wu.file)
+    return fm.get("auto_close_disabled") in (True, "true", "True")
+
+
 def write_stub_retrospective_terminal(
     feature_dir: Path,
     gate_number: int,
@@ -2881,9 +2931,32 @@ def maybe_auto_close_terminal(
             feature_id=feature_id,
             predicate_version="v1",
         )
+    if _close_wu_disables_auto_close(close_wu_for_terminal):
+        # Substantive close marked must-run (#189): dispatch it, don't skip.
+        return False, AutoCloseDecision(
+            auto=False,
+            reasons=["auto_close_disabled_per_wu"],
+            metrics={},
+            gate_id=gate.number,
+            feature_id=feature_id,
+            predicate_version="v1",
+        )
     decision = evaluate_auto_close(feature_dir, gate.number)
     if not decision.auto:
         return False, decision
+    present, reason = _gate_impl_deliverables_present(feature_dir, gate)
+    if not present:
+        # A gate WU reported done without its declared deliverable on disk;
+        # do not auto-close over the discrepancy — dispatch the close, which is
+        # where it surfaces (#190).
+        return False, AutoCloseDecision(
+            auto=False,
+            reasons=[f"declared_deliverable_missing: {reason}"],
+            metrics=decision.metrics,
+            gate_id=gate.number,
+            feature_id=feature_id,
+            predicate_version=decision.predicate_version,
+        )
     write_stub_retrospective_terminal(feature_dir, gate.number, decision)
     mark_close_wu_auto_closed(close_wu_for_terminal, decision)
     metrics = decision.metrics
@@ -2994,9 +3067,31 @@ def maybe_auto_close_intermediate(
             feature_id=feature_id,
             predicate_version="v1",
         )
+    if _close_wu_disables_auto_close(close_intermediate_wu):
+        # Substantive close-intermediate marked must-run (#189): dispatch it.
+        return False, AutoCloseDecision(
+            auto=False,
+            reasons=["auto_close_disabled_per_wu"],
+            metrics={},
+            gate_id=gate.number,
+            feature_id=feature_id,
+            predicate_version="v1",
+        )
     decision = evaluate_auto_close(feature_dir, gate.number)
     if not decision.auto:
         return False, decision
+    present, reason = _gate_impl_deliverables_present(feature_dir, gate)
+    if not present:
+        # See maybe_auto_close_terminal: don't auto-close over a done WU whose
+        # declared deliverable is absent — dispatch the close instead (#190).
+        return False, AutoCloseDecision(
+            auto=False,
+            reasons=[f"declared_deliverable_missing: {reason}"],
+            metrics=decision.metrics,
+            gate_id=gate.number,
+            feature_id=feature_id,
+            predicate_version=decision.predicate_version,
+        )
     append_stub_retrospective_intermediate(feature_dir, gate.number, decision)
     if close_intermediate_wu is not None:
         write_frontmatter_field(close_intermediate_wu.file, "status", "done")

{specfuse_loop-0.3.19 → specfuse_loop-0.3.20/specfuse_loop.egg-info}/PKG-INFO

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

{specfuse_loop-0.3.19 → specfuse_loop-0.3.20}/tests/test_gate_eval_intermediate_wiring.py

@@ -245,6 +245,17 @@ class TestAutoCloseIntermediateFiresOnCleanGate(unittest.TestCase):
             self.events_path, self.root, self.ci_wu, self.plan_next_wu,
         )
 
+    def test_per_wu_opt_out_refuses(self):
+        # #189: close-intermediate marked auto_close_disabled → not auto-closed.
+        self.ci_wu.file.write_text(
+            f"---\nid: {self.feature_id}/G1-CI\ntype: close-intermediate\n"
+            f"model: opus\nstatus: pending\nattempts: 0\n"
+            f"auto_close_disabled: true\n---\n\n# CI\n"
+        )
+        result, decision = self._call()
+        self.assertFalse(result)
+        self.assertIn("auto_close_disabled_per_wu", decision.reasons)
+
     def test_returns_true_and_decision(self):
         result, decision = self._call()
         self.assertTrue(result)

{specfuse_loop-0.3.19 → specfuse_loop-0.3.20}/tests/test_gate_eval_terminal_wiring.py

@@ -256,6 +256,117 @@ class TestMaybeAutoCloseTerminalAutoPath(unittest.TestCase):
 # ---------------------------------------------------------------------------
 
 
+class TestMaybeAutoCloseTerminalPerWuOptOut(unittest.TestCase):
+    """#189: a close WU marked auto_close_disabled must NOT be auto-closed,
+    even on an otherwise clean/on-plan gate — it is dispatched instead."""
+
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory(ignore_cleanup_errors=True)
+        self.root = Path(self._tmp.name)
+        self.feature_id = "FEAT-2026-9981"
+        self.gate_num = 1
+        fdir = self.root
+        self.fdir = fdir
+        _write_plan_md(fdir, self.feature_id, self.gate_num)
+        _write_wu_impl(fdir, f"{self.feature_id}/T01")
+        # Close WU carries the per-WU opt-out.
+        (fdir / "WU-close.md").write_text(
+            f"---\nid: {self.feature_id}/G{self.gate_num}-CLOSE\ntype: close\n"
+            f"model: opus\nstatus: pending\nattempts: 0\n"
+            f"auto_close_disabled: true\n---\n\n# Close\n"
+        )
+        _write_gate_file(fdir, self.gate_num)
+        _write_task_completed_event(fdir, f"{self.feature_id}/T01")
+        self.gate = _make_gate_node(fdir, self.feature_id, self.gate_num)
+        self.close_wu = _make_close_wu(
+            fdir, f"{self.feature_id}/G{self.gate_num}-CLOSE")
+        self.events_path = fdir / "events.jsonl"
+
+    def tearDown(self):
+        self._tmp.cleanup()
+
+    def test_refuses_and_names_reason(self):
+        result, decision = loop.maybe_auto_close_terminal(
+            self.fdir, self.feature_id, self.gate, [self.gate],
+            self.events_path, self.close_wu, repo_root=self.root,
+        )
+        self.assertFalse(result)
+        self.assertFalse(decision.auto)
+        self.assertIn("auto_close_disabled_per_wu", decision.reasons)
+
+    def test_close_wu_not_marked_auto_closed(self):
+        loop.maybe_auto_close_terminal(
+            self.fdir, self.feature_id, self.gate, [self.gate],
+            self.events_path, self.close_wu, repo_root=self.root,
+        )
+        fm, _ = loop.read_frontmatter(self.close_wu.file)
+        # Status untouched (still dispatchable); no auto_close output marker.
+        self.assertEqual(fm.get("status"), "pending")
+        self.assertNotEqual(fm.get("auto_close"), True)
+
+    def test_helper_reads_the_flag(self):
+        self.assertTrue(loop._close_wu_disables_auto_close(self.close_wu))
+
+
+class TestMaybeAutoCloseTerminalDeliverableMissing(unittest.TestCase):
+    """#190: auto-close must refuse when an implementation WU reports done but
+    its declared `produces:` deliverable is absent — dispatch the close."""
+
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory(ignore_cleanup_errors=True)
+        self.root = Path(self._tmp.name)
+        self.feature_id = "FEAT-2026-9982"
+        self.gate_num = 1
+        fdir = self.root
+        self.fdir = fdir
+        _write_plan_md(fdir, self.feature_id, self.gate_num)
+        # Implementation WU claims done + a produces path that does NOT exist.
+        missing = fdir / "src" / "never-created.py"
+        (fdir / "WU-01.md").write_text(
+            f"---\nid: {self.feature_id}/T01\ntype: implementation\n"
+            f"model: sonnet\nstatus: done\nattempts: 1\ncost_usd: 0.5\n"
+            f"planned_cost_usd: 0.5\nproduces: [{missing}]\n---\n\n# T01\n"
+        )
+        _write_wu_close(fdir, f"{self.feature_id}/G{self.gate_num}-CLOSE")
+        _write_gate_file(fdir, self.gate_num)
+        _write_task_completed_event(fdir, f"{self.feature_id}/T01")
+        self.gate = _make_gate_node(fdir, self.feature_id, self.gate_num)
+        self.close_wu = _make_close_wu(
+            fdir, f"{self.feature_id}/G{self.gate_num}-CLOSE")
+        self.events_path = fdir / "events.jsonl"
+
+    def tearDown(self):
+        self._tmp.cleanup()
+
+    def _call(self):
+        return loop.maybe_auto_close_terminal(
+            self.fdir, self.feature_id, self.gate, [self.gate],
+            self.events_path, self.close_wu, repo_root=self.root,
+        )
+
+    def test_refuses_on_missing_deliverable(self):
+        result, decision = self._call()
+        self.assertFalse(result)
+        self.assertFalse(decision.auto)
+        self.assertTrue(any("declared_deliverable_missing" in r
+                            for r in decision.reasons),
+                        f"reasons={decision.reasons}")
+
+    def test_present_deliverable_still_auto_closes(self):
+        # Create the declared deliverable → predicate proceeds to auto-close.
+        missing = self.fdir / "src" / "never-created.py"
+        missing.parent.mkdir(parents=True, exist_ok=True)
+        missing.write_text("x = 1\n")
+        result, decision = self._call()
+        self.assertTrue(result)
+        self.assertTrue(decision.auto)
+
+    def test_helper_reports_the_offender(self):
+        ok, reason = loop._gate_impl_deliverables_present(self.fdir, self.gate)
+        self.assertFalse(ok)
+        self.assertIn("never-created.py", reason)
+
+
 class TestMaybeAutoCloseTerminalNonAutoPath(unittest.TestCase):
 
     def setUp(self):

specfuse_loop-0.3.19/specfuse/loop/data/VERSION

@@ -1 +0,0 @@
-0.3.19