specfuse-loop 0.17.0__tar.gz → 0.18.0__tar.gz

{specfuse_loop-0.17.0/specfuse_loop.egg-info → specfuse_loop-0.18.0}/PKG-INFO

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

{specfuse_loop-0.17.0 → specfuse_loop-0.18.0}/pyproject.toml

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

specfuse_loop-0.18.0/specfuse/loop/data/VERSION

@@ -0,0 +1 @@
+0.18.0

{specfuse_loop-0.17.0 → specfuse_loop-0.18.0}/specfuse/loop/data/rules/operator-escalation.md

@@ -6,7 +6,7 @@ Licensed under the Apache License, Version 2.0. See LICENSE.
 # Rule: operator escalation framing
 
 Binding whenever work **stops and needs a human decision** — a `blocked` work
-unit, a gate at `awaiting_review`, a hedged verdict, a scope question, a refusal,
+unit, a gate at `awaiting_review`, a `not_met` verdict, a scope question, a refusal,
 or any skill that asks before writing.
 
 The audience is someone **deciding**, not someone executing. They may not have
@@ -60,7 +60,7 @@ so in that line rather than dropping it silently.
 ## The feature briefing — required when the halt is at feature scope
 
 The six parts frame a **decision**. When the halt is at feature or gate scope —
-a hedged terminal verdict, a feature that stopped partway and needs a human —
+a `not_met` terminal verdict, a feature that stopped partway and needs a human —
 the decision is not the whole question. The operator also needs to know whether
 the work *achieved what it was funded to achieve*, and that is a separate
 question from whether the tasks passed.
@@ -124,11 +124,11 @@ success is the failure this section prevents.
 
 - **Options without a recommendation.** Surfacing choices and stopping pushes the
   analysis back onto the person who asked. Always make the call; they can override.
-- **A refusal reported as a malfunction.** A withheld terminal flip on a hedged
+- **A refusal reported as a malfunction.** A withheld terminal flip on a `not_met`
   verdict is the contract working. Reporting it in the same tone as a crash makes
   a correct system look broken and invites someone to "fix" the safety catch.
 - **Writing the human's own justification for them.** Where a field records *why a
-  human accepted something* — `/accept-hedged-close`'s reason line, `/unblock-wu`'s
+  human decided something* — a `type: human` unit's `evidence:` line, `/unblock-wu`'s
   rationale, a contract-change acknowledgment — that text must come from the human.
   An agent that drafts it has removed the signature it was collecting. Ask; do not
   supply.

{specfuse_loop-0.17.0 → specfuse_loop-0.18.0}/specfuse/loop/loop.py

@@ -123,7 +123,7 @@ SPECFUSE_DIR = Path(".specfuse")
 REPO_ROOT = SPECFUSE_DIR.parent
 FEATURES_DIR = SPECFUSE_DIR / "features"
 VERIFICATION_PATH = SPECFUSE_DIR / "verification.yml"
-DRIVER_VERSION = "0.17.0"
+DRIVER_VERSION = "0.18.0"
 # 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
@@ -2964,14 +2964,68 @@ def apply_diff(diff_text: str) -> bool:
     return proc.returncode == 0
 
 
+def _untracked_file_blocks(max_chars: int) -> str:
+    """Render files the attempt CREATED as diff-shaped blocks, capped (#3249).
+
+    `git diff` only reports tracked content, so a file that did not exist at
+    `head_before` has nothing to diff against and never reached the attempt
+    note. FEAT-2026-0100/T03 spun twice against six failures in a new test
+    module that the note did not contain — the operator had to guess.
+
+    `--exclude-standard` honours .gitignore, which keeps `work/` out: folding
+    the notes directory into a note would nest each attempt's evidence inside
+    the next one's. Binary files are named but not inlined.
+
+    Best-effort like its caller: any git error yields "".
+    """
+    try:
+        raw = subprocess.run(
+            ["git", "ls-files", "--others", "--exclude-standard", "-z"],
+            capture_output=True, text=True, check=True,
+        ).stdout
+    except (subprocess.CalledProcessError, OSError):
+        return ""
+    blocks: list[str] = []
+    used = 0
+    for path in filter(None, raw.split("\0")):
+        if used >= max_chars:
+            blocks.append("… (further created files omitted)\n")
+            break
+        header = f"--- /dev/null\n+++ b/{path}\n"
+        try:
+            data = Path(path).read_bytes()
+        except OSError:
+            continue
+        if b"\x00" in data:
+            body = f"(binary file, {len(data)} bytes - content omitted)\n"
+        else:
+            text = data.decode("utf-8", errors="replace")
+            # `+` prefix so the block reads as the new-file hunk it stands for.
+            body = "".join(f"+{line}\n" for line in text.splitlines())
+            room = max_chars - used - len(header)
+            if len(body) > room:
+                body = body[:max(room, 0)] + "\n… (file truncated)\n"
+        block = header + body
+        blocks.append(block)
+        used += len(block)
+    return "".join(blocks)
+
+
 def capture_working_tree_diff(head_before: str, max_chars: int = 20000) -> str:
-    """Return `git diff <head_before>` (working tree vs pre-attempt base), capped.
+    """Return the working tree's departure from `head_before`, capped.
 
     Folded into a failing attempt's evidence note BEFORE the per-attempt
     `git reset --hard` discards the rejected work, so a blocked WU stays
     diagnosable — a human (or /gate-status) can see the diff that was rolled
     back, not just a truncated failure excerpt (#168).
 
+    Covers tracked changes via `git diff` AND files the attempt created, which
+    `git diff` cannot see (#3249). Created files get a reserved share of the
+    budget rather than whatever a concatenation leaves over: truncating the
+    combined text would let a large tracked diff consume everything and drop
+    the new file again, on exactly the large attempts where diagnosis is
+    hardest.
+
     Best-effort: returns "" on any git error or a clean tree. Truncated to
     max_chars so a large refactor's diff cannot bloat the committed note.
     """
@@ -2982,9 +3036,11 @@ def capture_working_tree_diff(head_before: str, max_chars: int = 20000) -> str:
         ).stdout
     except (subprocess.CalledProcessError, OSError):
         return ""
-    if len(out) > max_chars:
-        out = out[:max_chars] + "\n… (diff truncated)\n"
-    return out
+    created = _untracked_file_blocks(max_chars // 2)
+    budget = max_chars - len(created)
+    if len(out) > budget:
+        out = out[:max(budget, 0)] + "\n… (diff truncated)\n"
+    return out + created
 
 
 def persist_attempt_notes(

{specfuse_loop-0.17.0 → specfuse_loop-0.18.0/specfuse_loop.egg-info}/PKG-INFO

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

{specfuse_loop-0.17.0 → specfuse_loop-0.18.0}/specfuse_loop.egg-info/SOURCES.txt

@@ -186,6 +186,7 @@ tests/test_arm_sweep_gate.py
 tests/test_arm_txn.py
 tests/test_arm_wiring.py
 tests/test_artifact_redaction.py
+tests/test_attempt_note_untracked_files.py
 tests/test_attempt_outcome_contract.py
 tests/test_attempt_outcome_emission.py
 tests/test_attention_nonwriting_guard.py

specfuse_loop-0.18.0/tests/test_attempt_note_untracked_files.py

@@ -0,0 +1,126 @@
+#
+# Copyright 2026 Specfuse contributors
+# Licensed under the Apache License, Version 2.0. See LICENSE.
+#
+"""An attempt note records files the attempt CREATED, not only ones it changed (#3249).
+
+`capture_working_tree_diff` folds `git diff <head_before>` into a failing
+attempt's evidence note before the per-attempt `git reset --hard` discards the
+work. `git diff` only sees tracked content, so a file that did not exist at
+`head_before` has nothing to diff against and never reaches the note.
+
+That is not a theoretical gap. FEAT-2026-0100/T03 spun twice on 2026-09-06
+against six failures in `tests/test_verify_empty_gate_set.py`; the note carried
+diffs for the WU file, `events.jsonl` and `loop.py`, and the one file that
+explained the failure — the new test module, patching `loop.verify` without
+restoring it — was absent. The operator had to guess, which is what
+`/gate-status` ended up doing.
+
+Same lesson `verify_files_changed` already learned for its own purpose (#3119):
+`git diff` is not a complete account of what an attempt did.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import tempfile
+import unittest
+from pathlib import Path
+
+from tests._loop_loader import load_loop
+
+loop = load_loop()
+
+
+def _git(*args: str, cwd: Path) -> str:
+    return subprocess.run(
+        ["git", *args], cwd=cwd, capture_output=True, text=True, check=True,
+    ).stdout
+
+
+class TestAttemptNoteRecordsUntrackedFiles(unittest.TestCase):
+
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory()
+        self.repo = Path(self._tmp.name)
+        _git("init", "-q", cwd=self.repo)
+        _git("config", "user.email", "t@example.com", cwd=self.repo)
+        _git("config", "user.name", "t", cwd=self.repo)
+        (self.repo / "tracked.py").write_text("original\n")
+        (self.repo / ".gitignore").write_text("work/\n")
+        _git("add", "-A", cwd=self.repo)
+        _git("commit", "-qm", "base", cwd=self.repo)
+        self.head_before = _git("rev-parse", "HEAD", cwd=self.repo).strip()
+        self._cwd = os.getcwd()
+        os.chdir(self.repo)
+
+    def tearDown(self):
+        os.chdir(self._cwd)
+        self._tmp.cleanup()
+
+    def test_a_created_file_reaches_the_note(self):
+        # The FEAT-2026-0100/T03 shape: the attempt edits one tracked file and
+        # creates the test module that actually breaks the suite.
+        (self.repo / "tracked.py").write_text("edited\n")
+        (self.repo / "new_test.py").write_text("SENTINEL_CREATED_CONTENT = 1\n")
+
+        out = loop.capture_working_tree_diff(self.head_before)
+
+        self.assertIn("tracked.py", out, "the tracked diff must still be there")
+        self.assertIn(
+            "new_test.py", out,
+            "a file the attempt CREATED is exactly what the note was missing "
+            "when FEAT-2026-0100/T03 spun twice (#3249)")
+        self.assertIn(
+            "SENTINEL_CREATED_CONTENT", out,
+            "naming the file is not enough — the note has to carry what the "
+            "file says, or it still cannot be diagnosed from the artifacts")
+
+    def test_gitignored_paths_stay_out(self):
+        # work/ holds the notes themselves; folding them into a note would
+        # nest each attempt's evidence inside the next one's.
+        (self.repo / "work").mkdir()
+        (self.repo / "work" / "attempt-1.md").write_text("SHOULD_NOT_APPEAR\n")
+        (self.repo / "new_test.py").write_text("kept\n")
+
+        out = loop.capture_working_tree_diff(self.head_before)
+
+        self.assertNotIn("SHOULD_NOT_APPEAR", out)
+        self.assertIn("new_test.py", out)
+
+    def test_a_clean_tree_still_returns_empty(self):
+        self.assertEqual("", loop.capture_working_tree_diff(self.head_before))
+
+    def test_the_cap_still_bounds_the_note(self):
+        (self.repo / "big_new.py").write_text("x" * 50_000)
+        out = loop.capture_working_tree_diff(self.head_before, max_chars=2_000)
+        self.assertLess(
+            len(out), 4_000,
+            "an untracked file must not escape the cap that keeps a committed "
+            "note from bloating")
+
+    def test_a_large_tracked_diff_does_not_squeeze_out_the_created_file(self):
+        """The regression that would reintroduce the bug at a different size.
+
+        Truncating a concatenation would let a big tracked diff consume the
+        whole budget, and the created file — the thing this fix exists to
+        surface — would vanish again on exactly the large attempts where
+        diagnosis matters most.
+        """
+        (self.repo / "tracked.py").write_text("y" * 40_000)
+        (self.repo / "new_test.py").write_text("SENTINEL_CREATED_CONTENT = 1\n")
+
+        out = loop.capture_working_tree_diff(self.head_before, max_chars=4_000)
+
+        self.assertIn("SENTINEL_CREATED_CONTENT", out)
+
+    def test_a_binary_file_is_named_but_not_inlined(self):
+        (self.repo / "blob.bin").write_bytes(b"\x00\x01\x02BINARY\x00")
+        out = loop.capture_working_tree_diff(self.head_before)
+        self.assertIn("blob.bin", out)
+        self.assertNotIn("BINARY", out)
+
+
+if __name__ == "__main__":
+    unittest.main()

{specfuse_loop-0.17.0 → specfuse_loop-0.18.0}/tests/test_scaffold_doc_hygiene.py

@@ -28,6 +28,15 @@ import unittest
 REPO_ROOT = pathlib.Path(__file__).parent.parent
 DOCS = REPO_ROOT / "docs"
 WU_TEMPLATE = REPO_ROOT / ".specfuse" / "templates" / "WU.template.md"
+RULES = REPO_ROOT / ".specfuse" / "rules"
+SKILLS = REPO_ROOT / ".specfuse" / "skills"
+
+# Slash commands the methodology has removed. A retired command may still be
+# named in a provenance blockquote — that is history — but never in a live
+# instruction. Add a line here when a command is retired (#3241).
+RETIRED_COMMANDS = (
+    "/accept-hedged-close",   # removed by FEAT-2026-0085, shipped in 0.15.0
+)
 
 # Markdown inline link with a relative path target (skips absolute URLs and
 # pure-anchor links). Captures the path portion, dropping any `#anchor`.
@@ -74,6 +83,41 @@ class TestScaffoldDocHygiene(unittest.TestCase):
                 "that trips the Markdown parser — use ' - ' instead",
             )
 
+    def test_no_live_instruction_cites_a_retired_command(self):
+        """A retired slash command may be named in HISTORY, never in an
+        instruction an agent is expected to follow (#3241).
+
+        `operator-escalation.md` told the reader that a field recording why a
+        human accepted something is "`/accept-hedged-close`'s reason line" —
+        for a command FEAT-2026-0085 removed in 0.15.0. An agent following
+        that looks for a reason line it can never find. The rule shipped in
+        the packaged scaffold, so every consumer read it.
+
+        Provenance blocks are exempt by design: they record what a past
+        feature actually did, and rewriting them to erase a command that did
+        once exist would be its own defect. The discriminator is the
+        blockquote — a `>`-prefixed line is history, anything else is a live
+        instruction. Same reasoning `closing_requirements.py` applies to the
+        deliberately-unused requirement ID between `close-i` and `close-k`.
+        """
+        offenders: list[str] = []
+        for md in sorted(RULES.rglob("*.md")) + sorted(SKILLS.rglob("SKILL.md")):
+            for lineno, line in enumerate(
+                    md.read_text(encoding="utf-8").splitlines(), start=1):
+                if line.lstrip().startswith(">"):
+                    continue                      # provenance, not instruction
+                for retired in RETIRED_COMMANDS:
+                    if retired in line:
+                        rel = md.relative_to(REPO_ROOT)
+                        offenders.append(f"{rel}:{lineno}: {retired} — {line.strip()}")
+        self.assertEqual(
+            [], offenders,
+            "these live instructions cite a command that no longer exists;\n"
+            "name a surface that still exists, or move the mention into a\n"
+            "provenance blockquote if it is recording history:\n  "
+            + "\n  ".join(offenders),
+        )
+
 
 if __name__ == "__main__":
     unittest.main()

specfuse_loop-0.17.0/specfuse/loop/data/VERSION

@@ -1 +0,0 @@
-0.17.0