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

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

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

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

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

{specfuse_loop-0.3.17 → specfuse_loop-0.3.19}/specfuse/loop/_miniyaml.py

@@ -53,7 +53,9 @@ on a missing gate set — silent misparses are worse than crashes.
         fields that the driver writes to WU frontmatter.
       - **booleans** — exact lowercase `true` / `false` only. `True`, `yes`,
         `on`, etc. are errors.
-      - **empty value** — a key followed by `:` with nothing after is `None`.
+      - **empty value / explicit null** — a key followed by `:` with nothing
+        after is `None`; so are the explicit YAML null spellings `null`,
+        `Null`, `NULL`, and `~` (matching yaml.safe_load).
   * **Inline (flow) lists** — `[]`, `[a]`, `[a, b]`. Items are scalars only;
     nested brackets are an error. Real usage is correlation-ID lists.
   * **Comments** — `#` starting a line (after optional whitespace), or
@@ -73,8 +75,9 @@ on a missing gate set — silent misparses are worse than crashes.
   * Mixed / inconsistent indentation.
   * Nested brackets inside a flow list.
   * Escape sequences other than `\\` and `\"` in double-quoted strings.
-  * Boolean spellings other than exact lowercase `true` / `false`.
-  * Explicit null markers (`null`, `Null`, `NULL`, `~`).
+  * Boolean spellings other than exact lowercase `true` / `false` (the YAML
+    1.1 "Norway problem" — `yes`/`no`/`on`/`off`/`True` — stays rejected on
+    purpose; only `null` is accepted as a non-lowercase-keyword idiom).
   * Integers with sign, leading zeros, floats, hex, or underscores.
 
 A file using any of those raises `MiniYAMLError` with a line number and a
@@ -108,7 +111,7 @@ _FORBIDDEN_BOOLS = {
     "yes", "Yes", "YES", "no", "No", "NO",
     "on", "On", "ON", "off", "Off", "OFF",
 }
-_FORBIDDEN_NULLS = {"null", "Null", "NULL", "~"}
+_NULL_SCALARS = {"null", "Null", "NULL", "~"}
 
 
 # --------------------------------------------------------------------------- #
@@ -363,9 +366,13 @@ def _parse_scalar(text: str, lineno: int) -> Any:
         # forgiving result-block parse path on real agent output.
         raise MiniYAMLError(
             f"line {lineno}: flow mappings unsupported — use a block mapping")
-    if text in _FORBIDDEN_NULLS:
-        raise MiniYAMLError(
-            f"line {lineno}: explicit null marker unsupported — leave value empty")
+    if text in _NULL_SCALARS:
+        # Explicit YAML null spellings map to None, same as an empty value.
+        # Accepting them (rather than failing loud) removes a foot-gun for
+        # hand-authored frontmatter and for anything generated by a real YAML
+        # library, which emits `null` for None — and matches yaml.safe_load,
+        # tightening the equivalence guarantee (#177).
+        return None
     if text in _FORBIDDEN_BOOLS:
         raise MiniYAMLError(
             f"line {lineno}: only lowercase `true`/`false` accepted as "

specfuse_loop-0.3.19/specfuse/loop/data/VERSION

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

{specfuse_loop-0.3.17 → specfuse_loop-0.3.19}/specfuse/loop/data/verification.yml.example

@@ -28,6 +28,15 @@
 #
 # cost_tracking: true
 
+# PER-GATE `wu_must_reference: true` (optional, default false). Flag a gate
+# whose fix is MECHANICAL over a work unit's own output — a formatter, an
+# auto-fixable linter (`spotless:check`, `black --check`, `gofmt -l`,
+# `prettier --check`). The plan linter (specfuse-lint) then WARNs when an
+# implementation WU's Verification section names none of that gate's command —
+# catching, at authoring time and zero model cost, the case where a WU forgets
+# a mechanical gate and the driver spins retries on the identical failure until
+# the attempt budget is exhausted. Leave it off for project-global gates
+# (leak-scan, hygiene checks) that an individual WU has no reason to name.
 code:
   - name: tests
     command: "pytest -q"
@@ -37,6 +46,9 @@ code:
     command: "python3 -W error -c 'pass'"    # replace with your build's -Werror equivalent
   - name: lint
     command: "ruff check ."
+  - name: format
+    command: "black --check ."               # deterministic formatter: fix with `black .`
+    wu_must_reference: true                   # WUs must name it (see note above)
   - name: security
     command: "bandit -r src -ll"             # or your OWASP-aligned scanner
 

{specfuse_loop-0.3.17 → specfuse_loop-0.3.19}/specfuse/loop/lint_plan.py

@@ -40,6 +40,14 @@ VALID_TYPES = {"implementation", "retrospective", "lessons", "docs", "plan-next"
                "close-intermediate"}
 VALID_STATUS = {"draft", "pending", "ready", "in_progress", "in_review", "done",
                 "blocked_human", "abandoned"}
+# Feature (PLAN.md) and gate status vocabularies the DRIVER branches on. Kept
+# here (duplicated from loop.py's status literals, like VALID_TYPES/VALID_STATUS
+# above) so the linter validates the same set the driver acts on — an
+# unrecognized status that passes lint and then behaves differently at dispatch
+# is the class #183 (deferred) and #185 exist to close. Keep in sync with
+# find_feature / the gate-status transitions in loop.py.
+VALID_FEATURE_STATUS = {"planned", "active", "deferred", "done", "abandoned"}
+VALID_GATE_STATUS = {"open", "awaiting_review", "passed"}
 CLOSING_SEQUENCE = ["retrospective", "lessons", "docs", "plan-next"]
 # New compact closing shapes (FEAT-2026-0015):
 #   non-terminal gate: close-intermediate → plan-next
@@ -138,6 +146,69 @@ def _slice_section(body: str, section_name: str) -> str:
     return after[:em.start()] if em else after
 
 
+# Interpreters / super-generic words that don't distinguish one gate command
+# from another — excluded from a command's signature tokens (#176).
+_GATE_TOKEN_STOP = {
+    "python", "python3", "bash", "sh", "run", "exec", "discover",
+    "report", "source", "true", "false",
+}
+_GATE_TOKEN_RE = re.compile(r"[A-Za-z][A-Za-z0-9_.:+-]{2,}")
+# Verification prose that delegates to the whole gate set — treat as
+# referencing every gate so a legitimate "all gates pass" phrasing is not
+# flagged.
+_UMBRELLA_GATES_RE = re.compile(r"(?i)\b(all|every|entire|full|the)\b[^.\n]{0,24}\bgate")
+
+
+def _must_reference_gate_signatures(feature_dir: Path) -> list[tuple[str, set[str]]]:
+    """Return [(gate_name, signature_tokens)] for OPT-IN must-reference gates (#176).
+
+    Reads ``<project>/.specfuse/verification.yml`` (``feature_dir`` is
+    ``.../.specfuse/features/<name>``) and includes only `code` gates that set
+    ``wu_must_reference: true``. This is deliberately opt-in: warning on every
+    declared gate is noise on real multi-gate projects (leak-scan, hygiene
+    bats, etc. that an individual WU has no business naming). A project flags
+    the gates whose fix is mechanical over a WU's own output — formatters,
+    auto-fixable linters — the class #175 shows can burn the whole attempt
+    budget when a WU forgets them. Empty list (the check no-ops) when the file
+    is absent, unparseable, or no gate opts in. Each gate's token set is the
+    distinctive words of its command plus the gate name, lowercased.
+    """
+    vpath = feature_dir.parent.parent / "verification.yml"
+    if not vpath.is_file():
+        return []
+    try:
+        cfg = _miniyaml.parse(vpath.read_text()) or {}
+    except _miniyaml.MiniYAMLError:
+        return []
+    out: list[tuple[str, set[str]]] = []
+    for gate in cfg.get("code") or []:
+        if not isinstance(gate, dict) or gate.get("wu_must_reference") is not True:
+            continue
+        name = str(gate.get("name") or "").strip()
+        command = str(gate.get("command") or "")
+        tokens = {t.lower() for t in _GATE_TOKEN_RE.findall(command)
+                  if t.lower() not in _GATE_TOKEN_STOP}
+        if name:
+            tokens.add(name.lower())
+        if tokens:
+            out.append((name or command[:40], tokens))
+    return out
+
+
+def _unreferenced_code_gates(
+    verification_text: str, signatures: list[tuple[str, set[str]]],
+) -> list[str]:
+    """Names of code gates whose tokens *verification_text* references none of.
+
+    An umbrella "all gates" phrasing short-circuits to [] (author delegated).
+    """
+    if _UMBRELLA_GATES_RE.search(verification_text):
+        return []
+    low = verification_text.lower()
+    return [name for name, tokens in signatures
+            if not any(tok in low for tok in tokens)]
+
+
 def detect_oracle_verbs(ac_section_text: str) -> list[str]:
     """Return matched oracle-verb strings found in the AC section text."""
     found = []
@@ -249,6 +320,22 @@ def lint(feature_dir: Path) -> list[str]:
     if missing:
         errs.append(f"PLAN.md frontmatter missing keys: {sorted(missing)}")
 
+    # Feature status must be a value the driver recognizes (#185). An
+    # unrecognized status passes every other check and then behaves
+    # differently at dispatch — the shape #183 (deferred passed lint,
+    # dispatched anyway) exposed. Only validate when present; the missing-key
+    # check above already covers absence.
+    if "status" in fm and fm["status"] not in VALID_FEATURE_STATUS:
+        errs.append(
+            f"PLAN.md frontmatter status {fm['status']!r} is not a recognized "
+            f"feature status {sorted(VALID_FEATURE_STATUS)}"
+        )
+
+    # Opt-in must-reference gate signatures, loaded once for the
+    # Verification-reference WARN below (#176). Empty unless the project flags
+    # gates with `wu_must_reference: true`.
+    must_ref_gate_sigs = _must_reference_gate_signatures(feature_dir)
+
     if "base" in fm:
         base_val = fm["base"]
         feature_id_val = fm.get("feature_id", feature_dir.name)
@@ -283,6 +370,12 @@ def lint(feature_dir: Path) -> list[str]:
             gate_path = feature_dir / gate_file_rel
             if gate_path.exists():
                 gfm, _ = read_frontmatter(gate_path)
+                # Gate status must be a value the driver recognizes (#185).
+                if "status" in gfm and gfm["status"] not in VALID_GATE_STATUS:
+                    errs.append(
+                        f"{gate_file_rel}: gate status {gfm['status']!r} is not "
+                        f"a recognized gate status {sorted(VALID_GATE_STATUS)}"
+                    )
                 if "cost_budget_usd" in gfm:
                     val = gfm["cost_budget_usd"]
                     if isinstance(val, bool) or not isinstance(val, (int, float)):
@@ -400,6 +493,25 @@ def lint(feature_dir: Path) -> list[str]:
                         f"driver. See authoring-work-units §9 + FEAT-2026-0017."
                     )
 
+            # Verification ↔ must-reference gate WARN (#176). For gates a
+            # project has flagged `wu_must_reference: true` — those whose fix is
+            # mechanical over a WU's own output (formatters, auto-fixable
+            # linters) — the driver enforces them regardless of what a WU's
+            # Verification names. A session not told to run one writes code that
+            # fails it and, per #175, can burn the whole attempt budget on the
+            # mechanical failure. Flag at lint time, at zero model cost. Opt-in,
+            # so no noise on projects that don't flag any gate.
+            if wu_type_val == "implementation" and must_ref_gate_sigs:
+                verif_text = _slice_section(wbody, "Verification")
+                unref = _unreferenced_code_gates(verif_text, must_ref_gate_sigs)
+                if unref:
+                    print(
+                        f"WARN: {wfile}: Verification references none of the "
+                        f"must-reference gate(s): {', '.join(unref)}. The driver "
+                        f"runs them regardless; name each so the session knows to "
+                        f"satisfy it before finishing (#176)."
+                    )
+
             # Deliverable-presence declaration WARN (FEAT-2026-0022/T01).
             # Advisory: an implementation WU should declare the file path(s) it
             # is contracted to yield via `produces:`, which T02's presence gate

{specfuse_loop-0.3.17 → specfuse_loop-0.3.19}/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.17"
+DRIVER_VERSION = "0.3.19"
 # 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
@@ -190,14 +190,27 @@ FM = re.compile(r"^---\s*$")
 
 
 def read_frontmatter(path: Path) -> tuple[dict, str]:
-    """Return (frontmatter_dict, body_text)."""
+    """Return (frontmatter_dict, body_text).
+
+    A parse failure is re-raised with the file path attached and the line
+    clarified as frontmatter-relative (add 1 for the file line, since the
+    opening `---` is line 1). Without this a `_miniyaml.MiniYAMLError` carries
+    only a block-relative line number, so locating the offending file across
+    many feature folders meant grepping by hand (#177).
+    """
     lines = path.read_text().splitlines()
     if not lines or not FM.match(lines[0]):
         return {}, path.read_text()
     j = 1
     while j < len(lines) and not FM.match(lines[j]):
         j += 1
-    fm = _miniyaml.parse("\n".join(lines[1:j])) or {}
+    try:
+        fm = _miniyaml.parse("\n".join(lines[1:j])) or {}
+    except _miniyaml.MiniYAMLError as exc:
+        raise _miniyaml.MiniYAMLError(
+            f"{path}: {exc} (line is relative to the frontmatter block; "
+            f"add 1 for the file line)"
+        ) from exc
     body = "\n".join(lines[j + 1 :])
     return fm, body
 
@@ -253,15 +266,41 @@ def write_frontmatter_field(path: Path, key: str, value) -> None:
 def find_feature(arg: str | None) -> Path:
     if arg:
         d = FEATURES_DIR / arg if not arg.startswith(".") else Path(arg)
-        if not (d / "PLAN.md").exists():
+        plan = d / "PLAN.md"
+        if not plan.exists():
             sys.exit(f"No PLAN.md under {d}")
+        # A `deferred` feature is parked — non-dispatchable by contract (the
+        # gate-status skill documents it as "non-dispatchable but resumable;
+        # the loop does not auto-resume it"). Refuse an explicit --feature
+        # targeting one instead of dispatching it anyway (#183). Malformed
+        # frontmatter is left to fail later where the graph is parsed.
+        try:
+            _fm, _ = read_frontmatter(plan)
+        except _miniyaml.MiniYAMLError:
+            _fm = {}
+        if _fm.get("status") == "deferred":
+            sys.exit(
+                f"{d.name} is deferred (parked) — the loop does not dispatch "
+                f"deferred features. Flip its PLAN.md status back to `active` "
+                f"when the blocker clears, then re-run."
+            )
         return d
     actives = []
     done_pending_wrap = []
+    deferred = []
     for d in sorted(FEATURES_DIR.glob("*/")):
         plan = d / "PLAN.md"
         if plan.exists():
-            fm, _ = read_frontmatter(plan)
+            try:
+                fm, _ = read_frontmatter(plan)
+            except _miniyaml.MiniYAMLError as exc:
+                # One feature's malformed frontmatter must not block dispatch of
+                # every OTHER feature. Feature lookup is the earliest and least
+                # relevant failure point; skip the bad candidate with a warning
+                # rather than aborting the whole scan (#177).
+                print(f"warning: skipping {d.name} — unparseable PLAN.md "
+                      f"frontmatter: {exc}", file=sys.stderr)
+                continue
             if fm.get("status") == "active":
                 actives.append(d)
             elif fm.get("status") == "done":
@@ -271,10 +310,23 @@ def find_feature(arg: str | None) -> Path:
                 # push + PR are pending.
                 if (d / "RETROSPECTIVE.md").is_file():
                     done_pending_wrap.append(d)
+            elif fm.get("status") == "deferred":
+                # Parked — non-dispatchable (#183). Never enters `actives`, so
+                # a bare invocation won't pick it up; surfaced below so a lone
+                # deferred feature reads as parked, not silently absent.
+                deferred.append(d)
     if len(actives) == 1:
         return actives[0]
     if not actives:
         msg = "No active feature. Set a feature's PLAN.md status to 'active'.\n"
+        if deferred:
+            names = ", ".join(d.name for d in deferred[-3:])
+            msg += (
+                f"  - {len(deferred)} deferred (parked) feature(s), skipped: "
+                f"{names}\n"
+                f"                    Flip one's PLAN.md status to `active` to "
+                f"resume it.\n"
+            )
         if done_pending_wrap:
             names = ", ".join(d.name for d in done_pending_wrap[-3:])
             msg += (
@@ -655,7 +707,56 @@ def extract_failure_excerpt(stdout: str, max_chars: int = 500) -> str:
     encoded = text.encode("utf-8")
     if len(encoded) <= max_chars:
         return text
-    return encoded[-max_chars:].decode("utf-8", errors="ignore")
+    # Head+tail, not tail-only (#175): build-tool output puts the actionable
+    # part (the list of offending files) up top and boilerplate (help URLs,
+    # stack-trace hints) at the bottom. A tail-only slice reliably keeps the
+    # noise; splitting the budget preserves both ends.
+    marker = "\n...\n"
+    budget = max_chars - len(marker.encode("utf-8"))
+    if budget <= 0:
+        return encoded[-max_chars:].decode("utf-8", errors="ignore")
+    head_bytes = budget // 2
+    tail_bytes = budget - head_bytes
+    head = encoded[:head_bytes].decode("utf-8", errors="ignore")
+    tail = encoded[-tail_bytes:].decode("utf-8", errors="ignore")
+    return head + marker + tail
+
+
+# Forward-looking retry directives keyed by failure_class (#175 fix 1). The
+# gate output replayed into a retry describes files the per-attempt reset
+# already discarded, and reads as stale advice about a prior attempt. These
+# reframe it as a standing requirement for the fresh attempt and name the
+# mechanical remedy per class — no per-tool knowledge.
+_RETRY_CLASS_HINT: dict[str, str] = {
+    "lint": "This was a lint/format gate — its fix is mechanical: run the "
+            "formatter / linter's fix command over your changes and re-run the "
+            "gate before declaring done, rather than only rewriting the code.",
+    "tests": "Run the failing tests and make them pass before declaring done.",
+    "coverage": "Add tests covering the new or changed code to clear the "
+                "coverage gate before declaring done.",
+    "security": "Resolve the flagged security findings (or add a narrowly "
+                "scoped, justified suppression) before declaring done.",
+}
+
+
+def synthesize_retry_directive(failure_class: "str | None") -> str:
+    """Return a forward-looking retry instruction for *failure_class* (#175).
+
+    Prepended to the failure note fed into the next attempt. The note itself
+    is raw gate output about files the reset discarded; without this lead a
+    fresh session reads it as stale advice and reproduces the same omission
+    (e.g. never running the formatter), failing identically until attempts
+    exhaust. The lead reframes the output as a standing requirement and the
+    per-class hint names the remedy generically.
+    """
+    lead = ("The previous attempt's work was DISCARDED before this retry, so "
+            "the gate output below refers to files that no longer exist. Do "
+            "not read it as stale advice about a past attempt — treat it as a "
+            "standing requirement for THIS fresh attempt. ")
+    hint = _RETRY_CLASS_HINT.get(
+        failure_class or "",
+        "Satisfy every declared gate before declaring done.")
+    return lead + hint
 
 
 def emit_attempt_outcome(
@@ -1846,6 +1947,22 @@ def verify_files_changed(result: dict, head_before: str) -> list[str]:
     return unchanged
 
 
+def _annotate_unchanged_paths(paths: "list[str]") -> str:
+    """Format files_changed-mismatch paths, distinguishing missing from unchanged.
+
+    Each declared-but-non-diffing path is labeled ``(missing)`` when it does
+    not exist on disk or ``(no diff)`` when it exists but is byte-identical to
+    head_before. Prior wording listed paths bare, which conflated the two —
+    an existing, unchanged file could read as a deletion claim and seed a
+    wrong root-cause diagnosis (#182). The labels say exactly what was found.
+    """
+    lines = []
+    for p in paths:
+        label = "no diff" if Path(str(p)).exists() else "missing"
+        lines.append(f"  - ({label}) {p}")
+    return "\n".join(lines)
+
+
 # Smoke-import runner (FEAT-2026-0008/T03). The conservative pattern matches
 # ONLY a `python3 -c "from X import Y"` line. The agent-authored WU body may
 # declare an existence check naming new symbols this WU just minted; the
@@ -4203,17 +4320,33 @@ def run(
                         # against head_before. Treat as a failed attempt: skip
                         # squash, reset the tree, record evidence, retry within
                         # budget. payload is the list of unchanged paths.
+                        _mm_paths = list(payload)
                         note = (
-                            "RESULT block declared `files_changed` paths that "
-                            "show NO diff against HEAD before this attempt:\n"
-                            + "\n".join(f"  - {p}" for p in payload)
-                            + "\nEither actually modify them, or correct the "
-                              "files_changed list to match what you really edited."
+                            "The RESULT block declared these `files_changed` "
+                            "paths, but each shows NO diff against HEAD before "
+                            "this attempt:\n"
+                            + _annotate_unchanged_paths(_mm_paths)
+                            + "\n\nDeclaring an unchanged path is what fails this "
+                              "guard. For each path: if it did NOT need changing, "
+                              "OMIT it from `files_changed` (declare only files you "
+                              "actually edit); if it SHOULD have changed, make the "
+                              "edit this attempt. A `(missing)` path was never "
+                              "created; a `(no diff)` path exists but is unchanged."
                         )
+                        # Populate failure_class/signature/excerpt (#182): a
+                        # driver-side rejection previously emitted all-null, so
+                        # events.jsonl — and gate-status, which reads only it —
+                        # showed empty columns exactly where the diagnosis lives.
+                        _mm_sig = ", ".join(
+                            sorted({Path(str(p)).name for p in _mm_paths})
+                        )[:100] or "unchanged"
                         wu_events.append(emit_attempt_outcome(
                             wu, attempt, "files_changed_mismatch",
                             attempts_usage[-1],
-                            extras={"unchanged_paths": list(payload)},
+                            failure_class="files_changed_mismatch",
+                            failure_signature=_mm_sig,
+                            failure_excerpt=extract_failure_excerpt(note),
+                            extras={"unchanged_paths": _mm_paths},
                         ))
                         attempt_notes.append((attempt, note))
                         failure_note = note
@@ -4241,9 +4374,16 @@ def run(
                             + "```diff\n" + _diff + "\n```\n"
                         )
                     attempt_notes.append((attempt, _evidence))
-                    failure_note = payload
                     _fc, _fs = parse_gate_failure_signature(payload)
                     _ex = extract_failure_excerpt(payload)
+                    # Prepend a forward-looking directive so the retry reads the
+                    # gate output as a standing requirement, not stale advice
+                    # about the discarded attempt (#175 fix 1).
+                    failure_note = (
+                        synthesize_retry_directive(_fc)
+                        + "\n\n## Gate output from the discarded attempt\n\n"
+                        + payload
+                    )
                     wu_events.append(emit_attempt_outcome(
                         wu, attempt, "failed",
                         attempts_usage[-1],

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

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

{specfuse_loop-0.3.17 → specfuse_loop-0.3.19}/specfuse_loop.egg-info/SOURCES.txt

@@ -102,6 +102,7 @@ tests/test_lint_plan_relative_import.py
 tests/test_lint_produces_driver_helper.py
 tests/test_lint_sections.py
 tests/test_lint_task_graph_yaml_selection.py
+tests/test_lint_verification_reference.py
 tests/test_loop_attempt_evidence.py
 tests/test_loop_auto_archive.py
 tests/test_loop_caveman_preamble.py

{specfuse_loop-0.3.17 → specfuse_loop-0.3.19}/tests/test_attempt_outcome_emission.py

@@ -304,6 +304,49 @@ class TestExtractFailureExcerpt(unittest.TestCase):
             self.fail(f"UnicodeDecodeError raised: {e}")
         self.assertIsInstance(excerpt, str)
 
+    def test_keeps_head_and_tail_on_truncation(self):
+        # #175: build-tool output puts the offending-file list up top and
+        # boilerplate (help URLs, stack hints) at the bottom. A tail-only
+        # slice keeps the noise; head+tail must preserve both ends.
+        lines = ["Error: HEAD_MARKER offending file list here"]
+        lines += [f"Error: filler line {i} " + "x" * 40 for i in range(400)]
+        lines += ["Error: TAIL_MARKER re-run with -X for debug"]
+        excerpt = loop.extract_failure_excerpt("\n".join(lines), max_chars=500)
+        self.assertLessEqual(len(excerpt.encode("utf-8")), 500)
+        self.assertIn("HEAD_MARKER", excerpt)
+        self.assertIn("TAIL_MARKER", excerpt)
+
+
+class TestSynthesizeRetryDirective(unittest.TestCase):
+    """#175 fix 1: the retry note must carry a forward-looking lesson, not
+    just replay output about files the reset already discarded."""
+
+    def test_lint_directive_is_forward_looking(self):
+        d = loop.synthesize_retry_directive("lint")
+        self.assertIn("discard", d.lower())
+        # Names the mechanical remedy without per-tool knowledge.
+        self.assertIn("format", d.lower())
+        self.assertIn("before", d.lower())
+
+    def test_tests_directive_mentions_tests(self):
+        d = loop.synthesize_retry_directive("tests")
+        self.assertIn("test", d.lower())
+        self.assertIn("before", d.lower())
+
+    def test_coverage_and_security_have_specific_hints(self):
+        self.assertIn("coverage", loop.synthesize_retry_directive("coverage").lower())
+        self.assertIn(
+            "finding", loop.synthesize_retry_directive("security").lower())
+
+    def test_unknown_class_falls_back_to_generic_non_empty(self):
+        d = loop.synthesize_retry_directive("other")
+        self.assertTrue(d.strip())
+        self.assertIn("discard", d.lower())
+
+    def test_none_class_does_not_crash(self):
+        d = loop.synthesize_retry_directive(None)
+        self.assertTrue(d.strip())
+
 
 # --------------------------------------------------------------------------- #
 # TestCumulativeFoldOnRearm                                                    #

{specfuse_loop-0.3.17 → specfuse_loop-0.3.19}/tests/test_lint_plan_errors.py

@@ -104,6 +104,46 @@ class TestLintErrorArms(unittest.TestCase):
         self.assertTrue(any("frontmatter missing keys" in e for e in errs),
                         f"expected missing-keys error; errs={errs}")
 
+    def test_unknown_feature_status_errors(self):
+        """#185: a feature status outside the driver's enum is a lint error."""
+        with tempfile.TemporaryDirectory() as tmp:
+            feat = _build_minimal_feature(Path(tmp))
+            plan = feat / "PLAN.md"
+            plan.write_text(plan.read_text().replace(
+                "status: active", "status: paused", 1))
+            errs = lint_plan.lint(feat)
+        self.assertTrue(
+            any("'paused'" in e and "feature status" in e for e in errs),
+            f"expected feature-status error; errs={errs}")
+
+    def test_known_feature_statuses_do_not_error(self):
+        """Every documented feature status passes the vocabulary check."""
+        for status in ("planned", "active", "deferred", "done", "abandoned"):
+            with tempfile.TemporaryDirectory() as tmp:
+                feat = _build_minimal_feature(Path(tmp))
+                plan = feat / "PLAN.md"
+                plan.write_text(plan.read_text().replace(
+                    "status: active", f"status: {status}", 1))
+                errs = lint_plan.lint(feat)
+            self.assertFalse(
+                any("feature status" in e for e in errs),
+                f"{status!r} should be a valid feature status; errs={errs}")
+
+    def test_unknown_gate_status_errors(self):
+        """#185: a gate status outside the driver's enum is a lint error."""
+        with tempfile.TemporaryDirectory() as tmp:
+            feat = _build_minimal_feature(Path(tmp))
+            (feat / "GATE-01.md").write_text(
+                "---\nstatus: reviewing\n---\n\n# Gate 1\n")
+            # Point the graph's gate at the file so lint reads it.
+            plan = feat / "PLAN.md"
+            plan.write_text(plan.read_text().replace(
+                "  - gate: 1\n", "  - gate: 1\n    file: GATE-01.md\n", 1))
+            errs = lint_plan.lint(feat)
+        self.assertTrue(
+            any("'reviewing'" in e and "gate status" in e for e in errs),
+            f"expected gate-status error; errs={errs}")
+
     def test_plan_no_yaml_block(self):
         """Line 91: PLAN.md has valid frontmatter but no fenced yaml graph block."""
         with tempfile.TemporaryDirectory() as tmp: