specfuse-loop 0.7.0__tar.gz → 0.7.1__tar.gz

{specfuse_loop-0.7.0/specfuse_loop.egg-info → specfuse_loop-0.7.1}/PKG-INFO

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

{specfuse_loop-0.7.0 → specfuse_loop-0.7.1}/pyproject.toml

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

specfuse_loop-0.7.1/specfuse/loop/_wu_sections.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+#
+# Copyright 2026 Specfuse contributors
+# Licensed under the Apache License, Version 2.0. See LICENSE.
+#
+"""
+Dependency-free slicers for work-unit body sections.
+
+Shared by `loop.py` and `lint_plan.py`, which cannot import each other
+(`lint_plan.py` imports `VERDICT_VALUES` from `loop.py`, so the reverse
+import would be a cycle). This module imports nothing from either.
+"""
+
+from __future__ import annotations
+
+import re
+
+_AC_END_RE = re.compile(r"(?m)^(?:\*\*|#{1,6}\s)")
+
+
+def slice_wu_section(body: str, section_name: str) -> str:
+    """Return content between a named section heading and the next heading.
+
+    Handles both section-heading shapes a WU body uses: the canonical
+    bold-preamble form (`**Section name.** content starting on the same
+    line`, what `.specfuse/templates/WU.template.md` prescribes and what
+    327/327 real WU bodies in this repo use) and the ATX form (`## Section
+    name`, content starting on the next line). For the bold form, content
+    immediately following the closing `**` — on the label line itself — is
+    part of the section; discarding it (as a next-line-only slice would)
+    silently drops whatever a WU author wrote inline after the label.
+    """
+    escaped = re.escape(section_name)
+    heading_re = re.compile(
+        rf"(?mi)^#{{1,6}}\s*{escaped}\b|^\*\*{escaped}[^\n*]*\*\*\.?"
+    )
+    m = heading_re.search(body)
+    if not m:
+        return ""
+    if m.group(0).startswith("#"):
+        nl = body.find("\n", m.end())
+        after = body[nl + 1:] if nl != -1 else ""
+    else:
+        after = body[m.end():]
+    em = _AC_END_RE.search(after)
+    return after[:em.start()] if em else after
+
+
+def slice_acceptance_criteria(body: str) -> str:
+    """Return the text of the Acceptance criteria section only (bold-preamble or ATX)."""
+    return slice_wu_section(body, "Acceptance criteria")

specfuse_loop-0.7.1/specfuse/loop/data/VERSION

@@ -0,0 +1 @@
+0.7.1

{specfuse_loop-0.7.0 → specfuse_loop-0.7.1}/specfuse/loop/data/templates/WU.template.md

@@ -45,7 +45,9 @@ AUTHOR-SET FIELDS — fill or override these at draft/arm time:
   (`loop.py`, `lint_plan.py`, adjacent scripts). Lint WARN when body mentions driver-wiring
   keywords but field is absent. See FEAT-2026-0017.
 - `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.
+  presence gate (FEAT-2026-0022). Unified contract: a literal path must exist non-empty; a glob
+  needs ≥1 existing non-empty match — either form satisfies both the presence gate and the
+  in-diff gate. Lint WARN when absent on `implementation` WUs.
 
 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,

{specfuse_loop-0.7.0 → specfuse_loop-0.7.1}/specfuse/loop/lint_plan.py

@@ -28,6 +28,7 @@ Usage:  specfuse-lint .specfuse/features/FEAT-XXXX-slug
 
 from __future__ import annotations
 
+import fnmatch
 import re
 from pathlib import Path
 
@@ -441,6 +442,311 @@ def check_closing_guard_literals(feature_dir: Path, gates: list) -> None:
 
 _AUTOCLOSE_DEBT_MARKER_RE = re.compile(r"<!--\s*specfuse:autoclose-debt\s+gate=(\d+)")
 
+_PRODUCES_DISPATCHABLE_STATUSES = {"draft", "pending", "ready"}
+_PRODUCES_EXEMPT_PATHS = {"events.jsonl"}
+
+
+def check_produces_satisfiability(feature_dir: Path, gates: list) -> None:
+    """WARN when a dispatchable WU's `produces:` path was already delivered.
+
+    Exact string match only against a `done` WU's `produces:` entries in the
+    same feature — a glob is compared literally, not expanded (expansion
+    semantics belong to the presence gate, not this lint). Parallel drafts
+    sharing a surface are fine (the earlier WU must be `done`), and a WU's own
+    file / `events.jsonl` never count as a clash. WARN-only; never appends to
+    the errors list. See FEAT-2026-0055/T01, FEAT-2026-0066/T04.
+    """
+    records = []  # (wid, wfile, status, produces_entries)
+    for gate in gates:
+        for entry in gate.get("work_units") or []:
+            wid, wfile = entry.get("id"), entry.get("file")
+            if not wid or not wfile:
+                continue
+            wpath = feature_dir / wfile
+            if not wpath.exists():
+                continue
+            wfm, _ = read_frontmatter(wpath)
+            produces_raw = wfm.get("produces")
+            if not produces_raw:
+                continue
+            raw_entries = produces_raw if isinstance(produces_raw, list) else [produces_raw]
+            cleaned = set()
+            for p in raw_entries:
+                p_s = str(p).strip()
+                if not p_s or p_s in _PRODUCES_EXEMPT_PATHS or p_s == wfile:
+                    continue
+                cleaned.add(p_s)
+            if cleaned:
+                records.append((wid, wfile, wfm.get("status", ""), cleaned))
+
+    done_paths: dict = {}  # path -> (wid, wfile), first done WU declaring it
+    for wid, wfile, status, entries in records:
+        if status != "done":
+            continue
+        for p in entries:
+            done_paths.setdefault(p, (wid, wfile))
+
+    for wid, wfile, status, entries in records:
+        if status not in _PRODUCES_DISPATCHABLE_STATUSES:
+            continue
+        for p in entries:
+            match = done_paths.get(p)
+            if match is None or match[0] == wid:
+                continue
+            done_wid, done_wfile = match
+            print(
+                f"WARN: {wfile}: {wid} declares produces path {p!r}, but "
+                f"done WU {done_wid} ({done_wfile}) already delivered it. "
+                f"Drop the path, or state the incremental edit this WU makes "
+                f"to it in the body."
+            )
+
+
+_DNT_CARVEOUT_RE = re.compile(r"(?i)\bexcept\b")
+_DNT_ALLOW_ENUM_RE = re.compile(
+    r"(?i)\b(?:files?|paths?)(?:\s+that)?\s+change\b|\badds?\b|\bnew\b"
+)
+_DNT_AMBIGUOUS_PHRASE_RE = re.compile(
+    r"(?i)\bexisting\b|\bgenerated (?:by|from)\b|\boutput of\b"
+    r"|\bhand-edit\b|\bdirect edit\b"
+)
+_DNT_CONTAINER_TOKEN_RE = re.compile(r"(?i)\bin\s*`([^`]+)`")
+_BACKTICK_TOKEN_RE = re.compile(r"`([^`]+)`")
+
+
+def _split_dnt_clauses(dnt_text: str) -> list[str]:
+    """Split Do-not-touch prose into clauses on ';' and sentence-ending '.'.
+
+    Physical lines are joined first (a wrapped sentence spans them; the
+    bold-preamble form's canonical body is prose, not one clause per line),
+    and a delimiter inside backticks never splits a clause — a path like
+    `SKILL.md` must not fracture on its own period.
+    """
+    joined = " ".join(
+        line.strip().lstrip("-*").strip()
+        for line in dnt_text.splitlines()
+        if line.strip()
+    )
+    clauses: list[str] = []
+    buf: list[str] = []
+    in_backtick = False
+    for ch in joined:
+        if ch == "`":
+            in_backtick = not in_backtick
+            buf.append(ch)
+            continue
+        if not in_backtick and ch in ";.":
+            clause = "".join(buf).strip()
+            if clause:
+                clauses.append(clause)
+            buf = []
+            continue
+        buf.append(ch)
+    tail = "".join(buf).strip()
+    if tail:
+        clauses.append(tail)
+    return clauses
+
+
+def _extract_do_not_touch_patterns(dnt_text: str) -> tuple[list[str], list[str], set[str]]:
+    """Return (prohibit_patterns, ambiguous_patterns, allowed_literals) from a
+    Do-not-touch body.
+
+    Only backtick-quoted tokens containing '/', '*', or a file extension count
+    as binding path patterns — a plain-prose mention of a path never fires the
+    boundary check (no semantic judgment, no false ERROR on illustrative
+    prose). Extraction is prohibition-scoped, per clause (split on ';' and
+    sentence-ending '.'):
+
+    - A clause carrying an "except" carve-out (the shape FEAT-2026-0066/T04's
+      re-armed body used) contributes no patterns at all.
+    - A clause carrying an allow-enumeration signal ("These/Paths that
+      change:" / "adds" / "new" — the FEAT-2026-0023/T01 shape, where the
+      WU's own deliverables are listed, not forbidden) contributes no
+      patterns to either bucket. Its backtick tokens are instead recorded as
+      `allowed_literals`: exact paths the WU has explicitly declared it is
+      creating or changing. A later clause's *pattern* may still coincide
+      with one of these paths (e.g. "any other `.github/workflows/*` file"
+      after enumerating the one workflow file this WU adds) — the caller
+      treats an exact `allowed_literals` hit as never a match, regardless of
+      which clause the pattern came from, since the enumeration is a
+      definite allow-list for that literal path.
+    - A clause carrying a semantic qualifier cannot be resolved without
+      knowing something about the WU's own edit that the lint has no way to
+      check. Its path-like tokens go in `ambiguous_patterns` — the caller
+      downgrades a match to WARN, never ERROR, per this WU's design rule:
+      ERROR only on certainty. Two qualifier shapes, both drawn from the
+      retrospective's real fixtures:
+      - "existing" (FEAT-2026-0070/T08: "every existing `check_*`
+        function") — is a given produces path pre-existing or newly
+        created by this WU?
+      - "generated by/output of/hand-edit/direct edit" (FEAT-2026-0069/T08,
+        FEAT-2026-0070/T03: "`.../SKILL.md` as a direct edit — it is an
+        output of `scripts/sync-scaffold.sh`") — the prohibition is on
+        *manual* editing; a produces declaration doesn't say whether the
+        WU reaches the path by hand or by running the generator.
+    - A token immediately preceded by "in" (e.g. "`discover_components()`
+      and `_STACK_A_PATTERNS` in `tests/test_x.py`" — FEAT-2026-0069/T03)
+      names a container, not the prohibition itself: the forbidden things
+      are the symbols named before "in", and the file may otherwise be
+      touched freely. Also goes to `ambiguous_patterns` — the lint can spot
+      the grammatical shape but not verify the symbols went untouched.
+    - Everything else is an unqualified prohibition and goes in
+      `prohibit_patterns`.
+    """
+    prohibit: list[str] = []
+    ambiguous: list[str] = []
+    allowed_literals: set[str] = set()
+    for clause in _split_dnt_clauses(dnt_text):
+        if _DNT_CARVEOUT_RE.search(clause):
+            continue
+        if _DNT_ALLOW_ENUM_RE.search(clause):
+            for tok in _BACKTICK_TOKEN_RE.findall(clause):
+                tok = tok.strip()
+                if tok:
+                    allowed_literals.add(tok)
+            continue
+        clause_ambiguous = bool(_DNT_AMBIGUOUS_PHRASE_RE.search(clause))
+        container_tokens = {
+            m.group(1).strip() for m in _DNT_CONTAINER_TOKEN_RE.finditer(clause)
+        }
+        for tok in _BACKTICK_TOKEN_RE.findall(clause):
+            tok = tok.strip()
+            if not tok:
+                continue
+            if "/" in tok or "*" in tok or re.search(r"\.[A-Za-z0-9]+$", tok.rstrip("/")):
+                bucket = (
+                    ambiguous if (clause_ambiguous or tok in container_tokens)
+                    else prohibit
+                )
+                bucket.append(tok)
+    return prohibit, ambiguous, allowed_literals
+
+
+def _match_dnt_boundary(
+    surface: str,
+    prohibit_patterns: list[str],
+    ambiguous_patterns: list[str],
+    allowed_literals: set[str],
+) -> tuple[str, str] | None:
+    """Return (severity, pattern) for the first pattern `surface` matches —
+    ERROR if prohibited, WARN if only ambiguous. A surface the WU has
+    explicitly enumerated as its own new/changed deliverable never matches,
+    even against a pattern found in an unrelated clause."""
+    if surface in allowed_literals:
+        return None
+    for pat in prohibit_patterns:
+        if fnmatch.fnmatch(surface, pat):
+            return ("ERROR", pat)
+    for pat in ambiguous_patterns:
+        if fnmatch.fnmatch(surface, pat):
+            return ("WARN", pat)
+    return None
+
+
+def check_produces_boundary(feature_dir: Path, gates: list) -> list[str]:
+    """ERROR when a WU's own `produces:` path (or `produces_driver_helper`
+    surface) falls inside its own Do-not-touch section's paths.
+
+    A structural deadlock, not a review nit: the WU cannot both deliver the
+    path and honor its own boundary, and `assert_produces_in_diff` only
+    catches this AFTER a full dispatch attempt — the cost FEAT-2026-0066/T04
+    paid (3 attempts + an operator re-arm) for a conjunction this lint makes
+    un-armable up front. See FEAT-2026-0070 (earlier-enforcer-names-the-
+    later-one): the ERROR names the post-attempt guard it preempts so the
+    author isn't left to rediscover the connection.
+    """
+    found: list[str] = []
+    for gate in gates:
+        for entry in gate.get("work_units") or []:
+            wid, wfile = entry.get("id"), entry.get("file")
+            if not wid or not wfile:
+                continue
+            wpath = feature_dir / wfile
+            if not wpath.exists():
+                continue
+            wfm, wbody = read_frontmatter(wpath)
+            dnt_text = _slice_section(wbody, "Do not touch")
+            if not dnt_text.strip():
+                continue
+            prohibit_patterns, ambiguous_patterns, allowed_literals = (
+                _extract_do_not_touch_patterns(dnt_text)
+            )
+            if not prohibit_patterns and not ambiguous_patterns:
+                continue
+
+            produces_raw = wfm.get("produces")
+            produces_entries = (
+                produces_raw if isinstance(produces_raw, list)
+                else [produces_raw] if produces_raw else []
+            )
+            for p in produces_entries:
+                p_s = str(p).strip()
+                if not p_s:
+                    continue
+                hit = _match_dnt_boundary(
+                    p_s, prohibit_patterns, ambiguous_patterns, allowed_literals
+                )
+                if hit is None:
+                    continue
+                severity, pat = hit
+                if severity == "ERROR":
+                    found.append(
+                        f"ERROR: {wfile}: {wid} declares produces path "
+                        f"{p_s!r}, which its own Do-not-touch section "
+                        f"forbids via {pat!r}. This is a structural "
+                        f"deadlock — assert_produces_in_diff would refuse "
+                        f"it after a full dispatch attempt. Drop the path "
+                        f"from produces, narrow the Do-not-touch pattern, "
+                        f"or add an explicit 'except' carve-out. See "
+                        f"FEAT-2026-0066/T04, FEAT-2026-0070."
+                    )
+                else:
+                    print(
+                        f"WARN: {wfile}: {wid} declares produces path "
+                        f"{p_s!r}, which matches Do-not-touch pattern "
+                        f"{pat!r} — the boundary's wording ('existing', "
+                        f"'generated by', 'in <file>', or similar) makes "
+                        f"this pattern's scope ambiguous without semantic "
+                        f"judgment this lint does not have. Confirm by hand "
+                        f"before arming, or reword the boundary to name the "
+                        f"protected surface unambiguously."
+                    )
+
+            pdh_raw = wfm.get("produces_driver_helper")
+            if pdh_raw:
+                pdh_s = str(pdh_raw).strip()
+                surface = pdh_s.split("—")[0].split("--")[0].strip().strip("`\"'")
+                if surface:
+                    hit = _match_dnt_boundary(
+                        surface, prohibit_patterns, ambiguous_patterns, allowed_literals
+                    )
+                    if hit is not None:
+                        severity, pat = hit
+                        if severity == "ERROR":
+                            found.append(
+                                f"ERROR: {wfile}: {wid} declares "
+                                f"produces_driver_helper surface {surface!r}, "
+                                f"which its own Do-not-touch section forbids "
+                                f"via {pat!r}. This is a structural deadlock — "
+                                f"assert_produces_in_diff would refuse it "
+                                f"after a full dispatch attempt. Drop/narrow "
+                                f"the boundary, or add an explicit 'except' "
+                                f"carve-out. See FEAT-2026-0066/T04, "
+                                f"FEAT-2026-0070."
+                            )
+                        else:
+                            print(
+                                f"WARN: {wfile}: {wid} declares "
+                                f"produces_driver_helper surface {surface!r}, "
+                                f"which matches Do-not-touch pattern {pat!r} "
+                                f"— the boundary's wording makes this "
+                                f"pattern's scope ambiguous without semantic "
+                                f"judgment this lint does not have. Confirm "
+                                f"by hand before arming."
+                            )
+    return found
+
 
 def check_autoclose_debt_prediction(feature_dir: Path, gates: list) -> None:
     """WARN when a terminal close WU's body never instructs reconciling a
@@ -890,6 +1196,8 @@ def lint(feature_dir: Path) -> list[str]:
     check_planning_sections(feature_dir, fm, body, gates)
     check_closing_guard_literals(feature_dir, gates)
     check_autoclose_debt_prediction(feature_dir, gates)
+    check_produces_satisfiability(feature_dir, gates)
+    errs.extend(check_produces_boundary(feature_dir, gates))
     errs.extend(check_done_feature_gates(feature_dir, fm))
 
     # Cross-gate mixed-shape check. Two directions of mix:

{specfuse_loop-0.7.0 → specfuse_loop-0.7.1}/specfuse/loop/loop.py

@@ -42,6 +42,7 @@ from __future__ import annotations
 import argparse
 import datetime as dt
 import fnmatch
+import glob
 import hashlib
 import json
 import logging
@@ -88,7 +89,7 @@ SPECFUSE_DIR = Path(".specfuse")
 REPO_ROOT = SPECFUSE_DIR.parent
 FEATURES_DIR = SPECFUSE_DIR / "features"
 VERIFICATION_PATH = SPECFUSE_DIR / "verification.yml"
-DRIVER_VERSION = "0.7.0"
+DRIVER_VERSION = "0.7.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
@@ -4517,27 +4518,55 @@ def assert_implementation_touched_files(
 
 
 def assert_declared_deliverables(wu: WorkUnit) -> tuple[bool, str]:
-    """Deliverable-presence gate (FEAT-2026-0022/T02).
-
-    Verify every path the WU declared in ``produces:`` exists on disk and is
-    non-empty (``test -s`` semantics: ``Path(p).exists()`` and
-    ``Path(p).stat().st_size > 0``). Returns ``(True, "")`` when ``wu.produces``
-    is empty — the opt-out: an undeclared ``produces:`` means no gate, exactly
-    as ``verify_files_changed``'s absence opt-out (loop.py:994) — or when every
-    declared path exists and is non-empty. On the first offending path returns
-    ``(False, summary)`` naming that path and whether it was absent or empty.
-
-    A path that exists but is zero-length is treated as missing: an empty
-    deliverable is a hollow deliverable. This catches the partial-bundle hollow
-    pass (FEAT-2026-0020/T12: SECURITY.md present, bundled CODE_OF_CONDUCT.md
-    absent). The check is file-level only; symbol-level checks are out of scope
-    (PLAN Scope OUT).
+    """Deliverable-presence gate (FEAT-2026-0022/T02), unified with
+    ``assert_produces_in_diff``'s literal/glob contract (FEAT-2026-0055/T03).
+
+    Returns ``(True, "")`` when ``wu.produces`` is empty — the opt-out: an
+    undeclared ``produces:`` means no gate, exactly as ``verify_files_changed``'s
+    absence opt-out (loop.py:994). Otherwise every declared entry must satisfy
+    one of two forms:
+
+    - **Literal path** (no ``fnmatch`` metacharacter — none of ``* ? [``):
+      must exist and be non-empty (``test -s`` semantics). Unchanged from the
+      original presence gate.
+    - **Glob** (contains an ``fnmatch`` metacharacter): at least one existing,
+      non-empty file must match, via ``glob.glob`` (same pattern syntax
+      ``assert_produces_in_diff`` matches against the squash diff with
+      ``fnmatch.fnmatch``, so a pattern that satisfies one satisfies the other).
+
+    A path that is, or resolves to, a directory is refused outright with an
+    ``ERROR``-worthy message naming the unified contract: directories were
+    never valid produces: entries (a directory always passed this presence
+    gate while failing ``assert_produces_in_diff``'s diff match — the
+    literal-vs-glob split this WU exists to close); the refusal now says why
+    instead of silently passing one gate and failing the other.
+
+    On the first offending entry returns ``(False, summary)`` naming it.
     """
     if not wu.produces:
         return True, ""
     for raw in wu.produces:
         path = str(raw)
         p = Path(path)
+        if path.endswith("/") or p.is_dir():
+            return False, (
+                f"declared deliverable is a directory: {path} — directories "
+                "are not valid produces: entries under the unified "
+                "literal/glob contract (a directory always passed presence "
+                "while failing assert_produces_in_diff's diff match); declare "
+                "the specific file(s) or a glob instead"
+            )
+        if any(ch in path for ch in "*?["):
+            matches = [
+                m for m in glob.glob(path)
+                if Path(m).is_file() and Path(m).stat().st_size > 0
+            ]
+            if not matches:
+                return False, (
+                    f"declared deliverable glob matched no existing "
+                    f"non-empty file: {path}"
+                )
+            continue
         if not p.exists():
             return False, f"declared deliverable absent: {path}"
         if p.stat().st_size == 0:

{specfuse_loop-0.7.0 → specfuse_loop-0.7.1/specfuse_loop.egg-info}/PKG-INFO

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

{specfuse_loop-0.7.0 → specfuse_loop-0.7.1}/specfuse_loop.egg-info/SOURCES.txt

@@ -150,6 +150,8 @@ tests/test_legacy_4wu_terminal_flips.py
 tests/test_lifecycle_integration.py
 tests/test_lifetime_accounting.py
 tests/test_lint_bare_produces_path.py
+tests/test_lint_boundary_consistency.py
+tests/test_lint_boundary_extraction.py
 tests/test_lint_close_intermediate.py
 tests/test_lint_close_wu.py
 tests/test_lint_closing.py
@@ -163,6 +165,7 @@ tests/test_lint_plan_relative_import.py
 tests/test_lint_plan_verdict_exempt.py
 tests/test_lint_planning_sections.py
 tests/test_lint_produces_driver_helper.py
+tests/test_lint_produces_satisfiability.py
 tests/test_lint_sections.py
 tests/test_lint_task_graph_yaml_selection.py
 tests/test_lint_verification_reference.py
@@ -200,6 +203,7 @@ tests/test_prepare_feature.py
 tests/test_prepare_scaffold_sync.py
 tests/test_produces_field.py
 tests/test_produces_in_diff.py
+tests/test_produces_semantics_unified.py
 tests/test_provision_labels.py
 tests/test_queue_stalled_adapter.py
 tests/test_redaction_windows_home.py