specfuse-loop 0.26.0__tar.gz → 0.26.1__tar.gz

{specfuse_loop-0.26.0/specfuse_loop.egg-info → specfuse_loop-0.26.1}/PKG-INFO

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

{specfuse_loop-0.26.0 → specfuse_loop-0.26.1}/pyproject.toml

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

specfuse_loop-0.26.1/specfuse/loop/data/VERSION

@@ -0,0 +1 @@
+0.26.1

{specfuse_loop-0.26.0 → specfuse_loop-0.26.1}/specfuse/loop/loop.py

@@ -127,7 +127,7 @@ SPECFUSE_DIR = Path(".specfuse")
 REPO_ROOT = SPECFUSE_DIR.parent
 FEATURES_DIR = SPECFUSE_DIR / "features"
 VERIFICATION_PATH = SPECFUSE_DIR / "verification.yml"
-DRIVER_VERSION = "0.26.0"
+DRIVER_VERSION = "0.26.1"
 # 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
@@ -6008,6 +6008,11 @@ def is_zero_token_attempt(usage: dict | None) -> bool:
 
 
 RESULT_BLOCK_RE = re.compile(r"```result\s*\n(.*?)\n```", re.DOTALL)
+# #3442: a near-miss the contract does not name but agents do emit — any fence
+# whose first line is `RESULT` (FEAT-2026-0116/T01). Consulted only when no
+# proper ```result block exists, so a quoted example never overrides one.
+NEAR_MISS_RESULT_BLOCK_RE = re.compile(
+    r"```[^\n`]*\n[ \t]*RESULT:?[ \t]*\n(.*?)\n```", re.DOTALL | re.IGNORECASE)
 
 
 def parse_result_block(stdout: str) -> dict | None:
@@ -6023,11 +6028,21 @@ def parse_result_block(stdout: str) -> dict | None:
     if not stdout:
         return None
     matches = list(RESULT_BLOCK_RE.finditer(stdout))
+    if not matches:
+        matches = list(NEAR_MISS_RESULT_BLOCK_RE.finditer(stdout))
     if not matches:
         return None
     body = matches[-1].group(1)  # LAST result block — agents may discuss before it
     try:
         parsed = _miniyaml.parse(body)
+    except _miniyaml.MiniYAMLError:
+        # #3436: the commonest "malformed" RESULT is a well-formed one using a
+        # YAML block scalar (`blocked_reason: |`), which the strict subset
+        # rejects on purpose for config. Retry with a RESULT-only lenient read
+        # before degrading, so an honest multi-line block is not mistaken for
+        # a silent `complete`. Only the parser's own documented-subset error
+        # takes this path; any other exception still degrades to None below.
+        return _lenient_result_parse(body)
     except Exception:  # noqa: BLE001 - intentional: see comment below
         # Broad catch is deliberate AND scoped to this site only. The agent's
         # stdout is the least-trusted input in the system (free-form LLM text
@@ -6046,6 +6061,55 @@ def parse_result_block(stdout: str) -> dict | None:
     return parsed if isinstance(parsed, dict) else None
 
 
+_LENIENT_KEY_RE = re.compile(r"^([A-Za-z_][A-Za-z0-9_]*):(?:\s+(.*))?$")
+
+
+def _lenient_result_parse(body: str) -> dict | None:
+    """Best-effort read of a RESULT block the strict mini-YAML parser refused (#3436).
+
+    Understands only what agents actually emit at the top level: `key: value`
+    scalars (quotes stripped), `key: |` / `key: >` block scalars (literal keeps
+    line breaks, folded joins with spaces), and `key:` followed by indented
+    `- item` scalar lines. Anything nested deeper is skipped rather than
+    guessed. Returns None unless a `status` field was read, so a block that is
+    genuinely unreadable still degrades to verify() as before. Used only for
+    agent stdout, never for operator-authored config.
+    """
+    lines = body.splitlines()
+    out: dict = {}
+    i = 0
+    while i < len(lines):
+        m = _LENIENT_KEY_RE.match(lines[i])
+        if not m:
+            i += 1
+            continue
+        key, rhs = m.group(1), (m.group(2) or "").strip()
+        i += 1
+        child: list[str] = []
+        while i < len(lines) and (not lines[i].strip() or lines[i][:1] in (" ", "\t")):
+            child.append(lines[i])
+            i += 1
+        while child and not child[-1].strip():
+            child.pop()
+        if rhs[:1] in ("|", ">"):
+            indents = [len(c) - len(c.lstrip()) for c in child if c.strip()]
+            cut = min(indents) if indents else 0
+            text = [c[cut:] if c.strip() else "" for c in child]
+            out[key] = ("\n".join(text) if rhs[0] == "|"
+                        else " ".join(s.strip() for s in text if s.strip()))
+        elif rhs:
+            out[key] = rhs.strip("\"'")
+        elif child and all(c.lstrip().startswith("- ") for c in child if c.strip()
+                           and len(c) - len(c.lstrip()) == min(
+                               len(x) - len(x.lstrip()) for x in child if x.strip())):
+            base = min(len(x) - len(x.lstrip()) for x in child if x.strip())
+            items = [c.strip()[2:].strip().strip("\"'") for c in child
+                     if c.strip() and len(c) - len(c.lstrip()) == base]
+            if all(":" not in it for it in items):
+                out[key] = items
+    return out if "status" in out else None
+
+
 PROGRESS_FILENAME = "PROGRESS.md"
 
 
@@ -6193,6 +6257,9 @@ def agent_reported_blocked(stdout: str) -> tuple[bool, str | None]:
     if not parsed or parsed.get("status") != "blocked":
         return False, None
     reason = parsed.get("blocked_reason")
+    if reason is None:
+        # #3442: agents also write `reason:`; the contract's key still wins.
+        reason = parsed.get("reason")
     return True, (str(reason) if reason is not None else None)
 
 

{specfuse_loop-0.26.0 → specfuse_loop-0.26.1/specfuse_loop.egg-info}/PKG-INFO

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

{specfuse_loop-0.26.0 → specfuse_loop-0.26.1}/specfuse_loop.egg-info/SOURCES.txt

@@ -548,6 +548,8 @@ tests/test_resolve_base.py
 tests/test_restart_cap_counts_progress.py
 tests/test_result_block.py
 tests/test_result_block_audience.py
+tests/test_result_block_near_miss.py
+tests/test_result_block_scalar.py
 tests/test_resume_command_build.py
 tests/test_retain_on_guard_refusal_docs.py
 tests/test_roadmap_add_skill.py

specfuse_loop-0.26.1/tests/test_result_block_near_miss.py

@@ -0,0 +1,54 @@
+# Copyright 2026 Specfuse Contributors
+# Licensed under the Apache License, Version 2.0. See LICENSE.
+"""A near-miss RESULT block is still read (#3442).
+
+FEAT-2026-0116/T01, attempt 1, ended with a legitimate block in a bare fence
+whose first line was `RESULT`, and named the reason `reason:` rather than
+`blocked_reason:`. RESULT_BLOCK_RE found no ```result block, so the attempt was
+read as complete and verified against a tree the session had left untouched.
+"""
+import unittest
+
+from tests._loop_loader import load_loop
+
+loop = load_loop()
+
+_T01_RESULT = """Confirmed: the pinned test asserts the run-level summary. Escalation trigger fires. Stop, no code edits.
+
+```
+RESULT
+status: blocked
+reason: "Acceptance criterion 4 pins tests.test_surefire_run_level_signature.TestSurefireRunLevelSignature.test_signature_is_the_run_level_error_summary, which asserts a run-level summary line is the signature. Escalation trigger matched verbatim."
+files_touched: []
+tests_run: "python3 -m unittest tests.test_surefire_run_level_signature -v -b"
+tests_result: pass (baseline, unmodified, confirms the conflict, not a fix)
+```
+"""
+
+
+class NearMissResultIsRead(unittest.TestCase):
+    def test_bare_fence_led_by_RESULT_with_reason_alias_reads_as_blocked(self):
+        blocked, reason = loop.agent_reported_blocked(_T01_RESULT)
+        self.assertTrue(blocked)
+        self.assertIn("Acceptance criterion 4 pins", reason)
+
+    def test_reason_alias_inside_a_proper_result_fence(self):
+        out = "```result\nstatus: blocked\nreason: the plan contradicts itself\n```\n"
+        self.assertEqual(loop.agent_reported_blocked(out), (True, "the plan contradicts itself"))
+
+    def test_blocked_reason_wins_over_reason_when_both_are_present(self):
+        out = "```result\nstatus: blocked\nblocked_reason: the real one\nreason: other\n```\n"
+        self.assertEqual(loop.agent_reported_blocked(out), (True, "the real one"))
+
+    def test_a_proper_result_fence_takes_precedence_over_a_near_miss(self):
+        out = ("```result\nstatus: complete\nsummary: done\n```\n\n"
+               "```\nRESULT\nstatus: blocked\nreason: quoted example\n```\n")
+        self.assertEqual(loop.parse_result_block(out)["status"], "complete")
+
+    def test_a_plain_code_fence_is_not_a_result(self):
+        out = "Here is the diff:\n\n```\nstatus: blocked\nreason: not a result\n```\n"
+        self.assertIsNone(loop.parse_result_block(out))
+
+
+if __name__ == "__main__":
+    unittest.main()

specfuse_loop-0.26.1/tests/test_result_block_scalar.py

@@ -0,0 +1,72 @@
+# Copyright 2026 Specfuse Contributors
+# Licensed under the Apache License, Version 2.0. See LICENSE.
+"""A RESULT block whose fields use YAML block scalars still parses (#3436).
+
+FEAT-2026-0115/T02 ended two sessions with a legitimate `status: blocked` whose
+`blocked_reason` was a `|` block scalar. The strict mini-YAML parser rejects
+block scalars by design (operator config must fail loudly), so
+`parse_result_block` returned None, `agent_reported_blocked` returned
+(False, None), and the driver ran verify() on an attempt that had written
+nothing and escalated it as a spin.
+"""
+import unittest
+
+from tests._loop_loader import load_loop
+
+loop = load_loop()
+
+_T02_RESULT = """Confirmed genuine escalation match. No edits made.
+
+```result
+status: blocked
+summary: Investigated evaluate_fix_unit_insertion's two required calls; both hit the WU's own named escalation triggers before any code could be written — no edits made.
+blocked_reason: |
+  Both escalation triggers in the WU body are real, verified by reading the
+  called modules, not guessed:
+
+  1. lint_plan_next_draft(feature_dir, just_closed_gate) has no per-unit
+     check separable from its review-file check.
+  2. evaluate_arm_predicate has no parameter for a projected graph.
+```
+"""
+
+
+class BlockScalarResultParses(unittest.TestCase):
+    def test_literal_block_scalar_blocked_reason_reads_as_blocked(self):
+        blocked, reason = loop.agent_reported_blocked(_T02_RESULT)
+        self.assertTrue(blocked)
+        self.assertIn("Both escalation triggers in the WU body are real", reason)
+        self.assertIn("1. lint_plan_next_draft(feature_dir, just_closed_gate)", reason)
+        self.assertIn("\n\n", reason, "the literal scalar keeps its blank line")
+
+    def test_parsed_block_carries_every_top_level_field(self):
+        parsed = loop.parse_result_block(_T02_RESULT)
+        self.assertIsNotNone(parsed)
+        self.assertEqual(parsed["status"], "blocked")
+        self.assertTrue(parsed["summary"].startswith("Investigated evaluate_fix_unit_insertion"))
+
+    def test_folded_block_scalar_joins_lines_with_spaces(self):
+        out = "```result\nstatus: blocked\nblocked_reason: >\n  one line\n  continued here\n```\n"
+        blocked, reason = loop.agent_reported_blocked(out)
+        self.assertTrue(blocked)
+        self.assertEqual(reason.strip(), "one line continued here")
+
+    def test_list_field_beside_a_block_scalar_survives(self):
+        out = ("```result\nstatus: complete\nsummary: |\n  did the thing\n"
+               "files_changed:\n  - src/a.py\n  - tests/test_a.py\n```\n")
+        parsed = loop.parse_result_block(out)
+        self.assertEqual(parsed["status"], "complete")
+        self.assertEqual(parsed["files_changed"], ["src/a.py", "tests/test_a.py"])
+        self.assertEqual(parsed["summary"].strip(), "did the thing")
+
+    def test_a_block_without_a_status_still_degrades_to_none(self):
+        out = "```result\nsummary: |\n  no status here\n```\n"
+        self.assertIsNone(loop.parse_result_block(out))
+
+    def test_a_well_formed_block_parses_exactly_as_before(self):
+        out = "```result\nstatus: blocked\nblocked_reason: one line\n```\n"
+        self.assertEqual(loop.agent_reported_blocked(out), (True, "one line"))
+
+
+if __name__ == "__main__":
+    unittest.main()

specfuse_loop-0.26.0/specfuse/loop/data/VERSION

@@ -1 +0,0 @@
-0.26.0