specfuse-loop 0.24.0__tar.gz → 0.25.0__tar.gz

{specfuse_loop-0.24.0/specfuse_loop.egg-info → specfuse_loop-0.25.0}/PKG-INFO

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

{specfuse_loop-0.24.0 → specfuse_loop-0.25.0}/pyproject.toml

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

specfuse_loop-0.25.0/specfuse/loop/data/VERSION

@@ -0,0 +1 @@
+0.25.0

{specfuse_loop-0.24.0 → specfuse_loop-0.25.0}/specfuse/loop/data/docs/methodology.md

@@ -454,6 +454,27 @@ separately carry `auto_repaired_files_changed` in `extras`: the list of
 declared-but-unchanged `files_changed` paths the driver dropped on the
 WU's behalf rather than failing the attempt over.
 
+**Dispatch without the skills index (#3423).** A dispatched session runs
+`claude -p --disable-slash-commands` by default: a work unit invokes no
+skill, and the project's skills index (34 skills, 1,534 words of descriptions
+in the loop repository) is fixed context carried in every turn's cache read.
+`defaults.dispatch_skills: true` in `verification.yml` restores the index for
+a project whose units do call `/skill-name` in-session.
+
+**The post-merge checklist travels with the archive (#3424).** A `met`
+terminal close no longer files PLAN.md's `## Post-merge checklist` as a
+`specfuse:post-merge` issue (ten filed across two repositories, eight never
+actioned); `auto_archive_feature` appends it under the feature's archived
+detail section in `roadmap-archive.md`. `defaults.post_merge_issue: true` in
+`verification.yml` restores the issue.
+
+**Closing sessions run on sonnet (#3425).** `close`, `close-intermediate`
+and `plan-next` default to `sonnet` at effort `high`, the same model as the
+judge that checks them (lower-only, about $0.46 per close). Opus was 56% of
+all spend while implementation ran on sonnet. A unit's own
+`model:` still overrides the default, and every `judged` event carries
+`close_model` so judge agreement can be read per close model.
+
 Retention interacts with spinning detection, not around it:
 `detect_deterministic_refusal_repeat` (#1415) escalates a WU to
 `blocked_human` when two consecutive attempts emit an identical refusal
@@ -579,7 +600,7 @@ completion.
 
 Closing ceremony cost should scale with feature size. A feature whose
 **planned substantive** WU count (types `implementation`, `qa_authoring`,
-`qa_execution`, `qa_curation`) is **≤ 8** drafts as a **single gate** with
+`qa_execution`, `qa_curation`) is **≤ 12** drafts as a **single gate** with
 a **single terminal `close` WU** — no `close-intermediate`, no `plan-next`.
 This is the proportional shape: small features do not pay multi-WU closing
 overhead sized for large ones.
@@ -597,6 +618,13 @@ reflective session. Ceremony proportionality trades reflection only on
 features that stay small **and** on-plan. The `gate_eval.py` predicate is
 the safety net; this rule does not replace it.
 
+The line moved from 8 to 12 on 2026-09-26 (#3426): post-review features
+average 10.7 substantive units, every extra gate costs a `plan-next` plus a
+`close-intermediate` and an `awaiting_review` wait, and the arm predicate
+would have armed only 18 of 74 gate boundaries it evaluated — the wait was a
+human redraft, not a review. A feature goes multi-gate when a human decision
+sits between its gates, not because it is large.
+
 **Reflective prose is conditional too (FEAT-2026-0106).** The roadmap once
 asked for a retrospective "only on `not_met` or on request" — superseded,
 for an ordering reason: the close writes `RETROSPECTIVE.md` before the judge

{specfuse_loop-0.24.0 → specfuse_loop-0.25.0}/specfuse/loop/data/verification.yml.example

@@ -118,9 +118,22 @@
 #                               # attempt repairs the retained tree in place
 #                               # instead of re-authoring from scratch. Set to
 #                               # false to restore the pre-0.18 discard behaviour.
+#   dispatch_skills: false      # whether a dispatched session loads the
+#                               # project's skills index. Defaults to false:
+#                               # a work unit invokes no skill, and the index
+#                               # is fixed context paid on every turn (#3423).
+#                               # Set true for a project whose units call
+#                               # `/skill-name` in-session.
+#   post_merge_issue: false     # whether a `met` terminal close files PLAN.md's
+#                               # `## Post-merge checklist` as a tracked issue.
+#                               # Defaults to false (#3424): the checklist is
+#                               # appended under the feature's archived detail
+#                               # section in roadmap-archive.md instead.
 # defaults:
 #   max_attempts: 3
 #   retain_on_guard_refusal: true
+#   dispatch_skills: false
+#   post_merge_issue: false
 #
 # The re-plan-after-two-failures behaviour (FEAT-2026-0104) reads this same
 # `max_attempts` resolution and adds no config key of its own — a unit's

{specfuse_loop-0.24.0 → specfuse_loop-0.25.0}/specfuse/loop/lint_plan.py

@@ -1041,7 +1041,7 @@ def check_produces_satisfiability(feature_dir: Path, gates: list) -> None:
 
 # Ceremony-proportionality threshold (docs/methodology.md §6): one fact, one
 # home. Referenced, not redefined, in the draft-feature skill.
-GATE_PROPORTIONALITY_THRESHOLD = 8
+GATE_PROPORTIONALITY_THRESHOLD = 12  # was 8 until #3426
 GATE_PROPORTIONALITY_SUBSTANTIVE_TYPES = frozenset(
     {"implementation", "qa_authoring", "qa_execution", "qa_curation"}
 )

{specfuse_loop-0.24.0 → specfuse_loop-0.25.0}/specfuse/loop/loop.py

@@ -42,6 +42,7 @@ from __future__ import annotations
 import argparse
 import datetime as dt
 import fnmatch
+import functools
 import glob
 import hashlib
 import inspect
@@ -125,7 +126,7 @@ SPECFUSE_DIR = Path(".specfuse")
 REPO_ROOT = SPECFUSE_DIR.parent
 FEATURES_DIR = SPECFUSE_DIR / "features"
 VERIFICATION_PATH = SPECFUSE_DIR / "verification.yml"
-DRIVER_VERSION = "0.24.0"
+DRIVER_VERSION = "0.25.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
@@ -635,6 +636,66 @@ def resolve_retain_on_guard_refusal(verification_cfg: dict) -> bool:
     """
     project = (verification_cfg or {}).get("defaults") or {}
     return bool(project.get("retain_on_guard_refusal", True))
+
+
+def resolve_dispatch_skills(verification_cfg: dict) -> bool:
+    """Whether a dispatched session gets the project's skills index (#3423).
+
+    Reads `defaults.dispatch_skills` from verification.yml — the same
+    `defaults` block `resolve_max_attempts` reads. Defaults to False: a
+    dispatched work unit invokes no skill (the narrow-tier instructions are in
+    the preamble and unit bodies name skill files by path, for reading), so
+    the index — 34 skills and 1,534 words of descriptions in this repository —
+    is fixed context carried in every turn's cache read for nothing. Set true
+    for a project whose units do invoke `/skill-name` in-session.
+    """
+    project = (verification_cfg or {}).get("defaults") or {}
+    return bool(project.get("dispatch_skills", False))
+
+
+@functools.lru_cache(maxsize=None)
+def claude_supports_flag(flag: str) -> bool:
+    """Whether the installed Claude Code CLI accepts *flag* (#3432).
+
+    Probed once per driver run from `claude --help`. A CLI that cannot be run
+    reads as not supporting anything: the dispatch then omits the flag and
+    fails on its own terms, not on an unknown option.
+    """
+    try:
+        proc = subprocess.run(
+            resolve_claude_cmd(["claude", "--help"]), capture_output=True,
+            text=True, check=False, timeout=30,
+            env=child_env_without_pin_marker(),
+        )
+    except Exception:  # noqa: BLE001 - a missing or broken CLI is "no"
+        return False
+    out = "".join(s for s in (proc.stdout, proc.stderr) if isinstance(s, str))
+    return flag in out
+
+
+_FLAG_WARNED: set[str] = set()
+
+
+def _warn_flag_unsupported(flag: str, consequence: str) -> None:
+    if flag in _FLAG_WARNED:
+        return
+    _FLAG_WARNED.add(flag)
+    print(f"   WARN: this Claude Code CLI does not accept {flag}; {consequence}")
+
+
+def resolve_post_merge_issue(verification_cfg: dict) -> bool:
+    """Whether a `met` terminal close files the post-merge checklist as an issue (#3424).
+
+    Reads `defaults.post_merge_issue` from verification.yml. Defaults to False:
+    across this repository and its heaviest consumer, ten such issues were
+    filed and eight were never actioned — the checklist is a measurement note
+    for the operator, not a work item. The record survives instead under the
+    feature's archived detail section (`auto_archive_feature`).
+    """
+    project = (verification_cfg or {}).get("defaults") or {}
+    return bool(project.get("post_merge_issue", False))
+
+
 # Per-gate-command wall-clock ceiling. A gate that exceeds it is killed and the gate
 # FAILS (not hangs) — so a deadlocked command (e.g. a test blocked on input()) can't
 # stall the whole driver indefinitely. Generous vs real suites (this repo's is ~20s).
@@ -657,9 +718,16 @@ MODEL_BY_TYPE = {
     "retrospective":     "sonnet",
     "lessons":           "sonnet",
     "docs":              "sonnet",
-    "plan-next":         "opus",
-    "close":             "opus",
-    "close-intermediate": "opus",
+    # #3425: closing sessions on sonnet. Opus was 56% of all spend while
+    # implementation ran on sonnet; the judge (JUDGE_MODEL, itself sonnet,
+    # lower-only, ~$0.46 per close) is the independent check on a close's
+    # measurements and lowered 9 of 54 verdicts correctly, so the close does
+    # not need a bigger model than the session that checks it. A unit's own
+    # `model:` still overrides; `judged` events carry `close_model` so
+    # agreement can be split by model.
+    "plan-next":         "sonnet",
+    "close":             "sonnet",
+    "close-intermediate": "sonnet",
 }
 EFFORT_BY_TYPE = {
     "implementation":    "medium",
@@ -4439,8 +4507,9 @@ def squash_commit(
 # --------------------------------------------------------------------------- #
 
 PROMPT_PREAMBLE = """\
-You are executing a single Specfuse work unit. Read .specfuse/rules/ in full before \
-acting; they are binding. Do NOT run any git command — the driver owns all commits \
+You are executing a single Specfuse work unit. The binding rules are already in \
+your context through .claude/CLAUDE.md; read a further file under .specfuse/rules/ \
+only when your unit body names it. Do NOT run any git command — the driver owns all commits \
 and bookkeeping. Edit files only. Verification is tiered: before you report, run \
 only the per-attempt (narrow) tier yourself — your unit type's gate set in \
 .specfuse/verification.yml minus every gate declaring `tier: broad`, with the \
@@ -4790,7 +4859,8 @@ def format_reverification_worklist(wu: WorkUnit, feature_dir: Path) -> str:
 
 
 def dispatch(wu: WorkUnit, failure_note: str | None,
-             cost_tracking: bool = True) -> tuple[str, dict | None]:
+             cost_tracking: bool = True, *,
+             dispatch_skills: bool | None = None) -> tuple[str, dict | None]:
     """Run a fresh agent session for this WU.
 
     When `cost_tracking` is True (default), requests JSON output from
@@ -4810,6 +4880,24 @@ def dispatch(wu: WorkUnit, failure_note: str | None,
     cmd = [p.replace("{model}", wu.model).replace("{effort}", wu.effort)
            for p in CLAUDE_CMD]
     cmd = resolve_claude_cmd(cmd)
+    if dispatch_skills is None:
+        # Resolved here rather than threaded through execute_unit_attempt:
+        # every test fake of dispatch() takes the three positional arguments
+        # and nothing else, and the yaml read is nothing next to a session.
+        try:
+            dispatch_skills = resolve_dispatch_skills(load_verification())
+        except Exception:  # noqa: BLE001 - an unreadable config keeps the default
+            dispatch_skills = False
+    if not dispatch_skills:
+        # #3423: a dispatched unit invokes no skill, so the skills index is
+        # fixed context paid on every turn. `defaults.dispatch_skills: true`
+        # in verification.yml restores it (resolve_dispatch_skills).
+        if claude_supports_flag("--disable-slash-commands"):
+            cmd.insert(2, "--disable-slash-commands")
+        else:
+            _warn_flag_unsupported(
+                "--disable-slash-commands",
+                "the skills index stays in the session prompt (#3432)")
     if wu.unsandboxed:
         # Per-WU sandbox-escape. Audited via the unsandboxed_dispatch event
         # emitted in run()'s attempt loop; rationale lives in WU frontmatter.
@@ -7368,6 +7456,19 @@ def _reconcile_moved_section(
     return section_text
 
 
+def _post_merge_checklist_for_archive(feature_id: str, repo_root: Path) -> str | None:
+    """PLAN.md's `## Post-merge checklist` body for *feature_id*, or None (#3424)."""
+    features = repo_root / ".specfuse" / "features"
+    for plan in sorted(features.glob(f"{feature_id}-*/PLAN.md")):
+        try:
+            _, body = read_frontmatter(plan)
+        except Exception:  # noqa: BLE001 - archive must never fail on a bad PLAN
+            return None
+        section = find_post_merge_checklist_section(body)
+        return section.strip("\n") + "\n" if section else None
+    return None
+
+
 def auto_archive_feature(feature_id: str, repo_root: Path) -> str:
     """Re-implement roadmap-archive single-feature algorithm (Steps 1–6) in-driver.
 
@@ -7480,6 +7581,13 @@ def auto_archive_feature(feature_id: str, repo_root: Path) -> str:
         f"](roadmap.md#{feat_id_lower})", f"](#{feat_id_lower})"
     )
 
+    # #3424: the feature's post-merge checklist travels with the archived
+    # detail section instead of becoming an issue nobody actions. Read from
+    # the feature folder's PLAN.md when one exists; a row-only feature has none.
+    checklist = _post_merge_checklist_for_archive(feature_id, repo_root)
+    if checklist and "**Post-merge checklist.**" not in section_text:
+        section_text = section_text.rstrip("\n") + "\n\n**Post-merge checklist.**\n\n" + checklist
+
     marker_end = archive_text.index(marker) + len(marker)
     new_archive = archive_text[:marker_end] + f"\n{anchor}\n{section_text}" + archive_text[marker_end:]
     archive_path.write_text(new_archive)
@@ -8833,6 +8941,7 @@ def record_tracked_issue(
 
 def file_followup_issues(
     feature_dir: Path, repo_root: Path, runner=None, *, commit: bool | None = None,
+    post_merge_issue: bool | None = None,
 ) -> dict:
     """File one tracked GitHub issue per FOLLOW-UPS.md entry, after a close's squash.
 
@@ -8883,7 +8992,13 @@ def file_followup_issues(
                 followups_path,
             ))
 
-    if plan_fm.get("verdict") == "met" or plan_fm.get("status") == "done":
+    if post_merge_issue is None:
+        post_merge_issue = resolve_post_merge_issue(load_verification())
+    if post_merge_issue and (
+        plan_fm.get("verdict") == "met" or plan_fm.get("status") == "done"
+    ):
+        # #3424: off by default — the checklist lands under the archived
+        # detail section instead (auto_archive_feature).
         section = find_post_merge_checklist_section(plan_body)
         if section:
             entries.append((
@@ -9588,6 +9703,7 @@ def judge_close(
     payload: dict = {
         "gate": gate_number,
         "close_verdict": close_verdict,
+        "close_model": getattr(wu, "model", None),
         "judge_verdict": None,
         "verdict": close_verdict,
         "lowered": False,

{specfuse_loop-0.24.0 → specfuse_loop-0.25.0/specfuse_loop.egg-info}/PKG-INFO

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

{specfuse_loop-0.24.0 → specfuse_loop-0.25.0}/specfuse_loop.egg-info/SOURCES.txt

@@ -259,6 +259,7 @@ tests/test_closing_guard_contracts.py
 tests/test_closing_guard_prediction.py
 tests/test_closing_learnings_destination.py
 tests/test_closing_requirements.py
+tests/test_closing_sessions_on_sonnet.py
 tests/test_coauthor_trailer_allowlist.py
 tests/test_conditional_reflection.py
 tests/test_console_encoding.py
@@ -290,7 +291,9 @@ tests/test_diagnose_issue_skill.py
 tests/test_diagnosis.py
 tests/test_diagnosis_roundtrip_live.py
 tests/test_dispatch_model_from_fix_scope.py
+tests/test_dispatch_preamble_rules_pointer.py
 tests/test_dispatch_skeleton.py
+tests/test_dispatch_skills_index.py
 tests/test_distilled_accept_step.py
 tests/test_doctor.py
 tests/test_doctor_command_preflight.py

specfuse_loop-0.25.0/tests/test_closing_sessions_on_sonnet.py

@@ -0,0 +1,28 @@
+# Copyright 2026 Specfuse Contributors
+# Licensed under the Apache License, Version 2.0. See LICENSE.
+"""Closing sessions default to sonnet, like the judge that checks them (#3425)."""
+import unittest
+
+from tests._loop_loader import load_loop
+
+loop = load_loop()
+
+
+class ClosingTypesDefaultToSonnet(unittest.TestCase):
+    def test_the_three_closing_types_default_to_sonnet_high(self):
+        for wu_type in ("close", "close-intermediate", "plan-next"):
+            self.assertEqual(loop.MODEL_BY_TYPE[wu_type], "sonnet", wu_type)
+            self.assertEqual(loop.EFFORT_BY_TYPE[wu_type], "high", wu_type)
+
+    def test_implementation_default_is_unchanged(self):
+        self.assertEqual(loop.MODEL_BY_TYPE["implementation"], "sonnet")
+        self.assertEqual(loop.EFFORT_BY_TYPE["implementation"], "medium")
+
+    def test_the_judge_model_is_its_own_constant(self):
+        # The judge already ran on sonnet before this change; the close no
+        # longer needs a bigger model than the session that checks it.
+        self.assertEqual(loop.JUDGE_MODEL, "sonnet")
+
+
+if __name__ == "__main__":
+    unittest.main()

specfuse_loop-0.25.0/tests/test_dispatch_preamble_rules_pointer.py

@@ -0,0 +1,32 @@
+# Copyright 2026 Specfuse Contributors
+# Licensed under the Apache License, Version 2.0. See LICENSE.
+"""The dispatch preamble points at the injected binding block instead of
+telling every session to read `.specfuse/rules/` in full (#3422).
+
+Measured 2026-09-26: the "read in full" sentence cost every dispatched session
+ten files and 11,573 words of tool reads on top of the 2,461 words CLAUDE.md
+already injects, and those tokens rode along in every later turn's cache read.
+"""
+import unittest
+
+from tests._loop_loader import load_loop
+
+loop = load_loop()
+
+
+class PreamblePointsAtTheBindingBlock(unittest.TestCase):
+    def test_no_session_is_told_to_read_the_rules_in_full(self):
+        self.assertNotIn("in full", loop.PROMPT_PREAMBLE)
+
+    def test_preamble_names_the_injected_binding_block(self):
+        self.assertIn(".claude/CLAUDE.md", loop.PROMPT_PREAMBLE)
+        self.assertIn("only when your unit body names it", loop.PROMPT_PREAMBLE)
+
+    def test_the_other_obligations_survive(self):
+        for phrase in ("Do NOT run any git command", "narrow", "RESULT block",
+                       ".specfuse/rules/result-contract.md"):
+            self.assertIn(phrase, loop.PROMPT_PREAMBLE)
+
+
+if __name__ == "__main__":
+    unittest.main()

specfuse_loop-0.25.0/tests/test_dispatch_skills_index.py

@@ -0,0 +1,105 @@
+# Copyright 2026 Specfuse Contributors
+# Licensed under the Apache License, Version 2.0. See LICENSE.
+"""A dispatched session does not load the skills index unless the project asks
+for it (#3423).
+
+`dispatch()` passes `--disable-slash-commands` by default; the resolver reads
+`defaults.dispatch_skills` from verification.yml and `execute_unit_attempt`
+threads it through.
+"""
+import contextlib
+import io
+import unittest
+from pathlib import Path
+from unittest import mock
+
+from tests._loop_loader import load_loop
+
+loop = load_loop()
+
+
+def _wu(**over):
+    base = dict(
+        wu_id="FEAT-2026-9999/T01", file=Path("WU-T01.md"), depends_on=[],
+        type="implementation", model="claude-sonnet-4-6", effort="medium",
+        status="pending", attempts=0, title="t", body="body",
+    )
+    base.update(over)
+    return loop.WorkUnit(**base)
+
+
+class ResolverReadsTheDefaultsBlock(unittest.TestCase):
+    def test_absent_means_no_skills(self):
+        self.assertFalse(loop.resolve_dispatch_skills({}))
+        self.assertFalse(loop.resolve_dispatch_skills({"defaults": {}}))
+
+    def test_true_restores_the_index(self):
+        self.assertTrue(loop.resolve_dispatch_skills({"defaults": {"dispatch_skills": True}}))
+
+
+class DispatchCmdCarriesTheFlag(unittest.TestCase):
+    def _cmd(self, supported: bool = True, **kw):
+        fake_proc = mock.MagicMock(stdout="ignored", returncode=0)
+        with mock.patch.object(loop, "claude_supports_flag", return_value=supported), \
+             mock.patch.object(loop.subprocess, "run", return_value=fake_proc) as run:
+            loop.dispatch(_wu(), failure_note=None, cost_tracking=False, **kw)
+        return run.call_args[0][0]
+
+    def test_unsupported_cli_omits_the_flag_and_warns_once(self):
+        # #3432: an older CLI must not fail every dispatch on an unknown option.
+        loop._FLAG_WARNED.discard("--disable-slash-commands")
+        buf = io.StringIO()
+        with contextlib.redirect_stdout(buf):
+            first = self._cmd(supported=False)
+            second = self._cmd(supported=False)
+        self.assertNotIn("--disable-slash-commands", first)
+        self.assertNotIn("--disable-slash-commands", second)
+        self.assertEqual(buf.getvalue().count("does not accept --disable-slash-commands"), 1)
+
+    def test_default_disables_slash_commands_after_dash_p(self):
+        cmd = self._cmd()
+        self.assertEqual(cmd[:2], ["claude", "-p"])
+        self.assertIn("--disable-slash-commands", cmd)
+        self.assertLess(cmd.index("--disable-slash-commands"), cmd.index("--model"))
+
+    def test_opt_in_keeps_the_index(self):
+        self.assertNotIn("--disable-slash-commands", self._cmd(dispatch_skills=True))
+
+    def test_composes_with_the_sandbox_escape(self):
+        fake_proc = mock.MagicMock(stdout="ignored", returncode=0)
+        wu = _wu(unsandboxed=True, unsandboxed_rationale="needs gh")
+        with mock.patch.object(loop, "claude_supports_flag", return_value=True), \
+             mock.patch.object(loop.subprocess, "run", return_value=fake_proc) as run:
+            loop.dispatch(wu, failure_note=None, cost_tracking=False)
+        cmd = run.call_args[0][0]
+        self.assertIn("--dangerously-skip-permissions", cmd)
+        self.assertIn("--disable-slash-commands", cmd)
+        self.assertEqual(cmd[1], "-p")
+
+
+if __name__ == "__main__":
+    unittest.main()
+
+
+class ProbeReadsTheHelpText(unittest.TestCase):
+    def setUp(self):
+        loop.claude_supports_flag.cache_clear()
+
+    def tearDown(self):
+        loop.claude_supports_flag.cache_clear()
+
+    def test_flag_in_help_output_is_supported_and_cached(self):
+        fake = mock.MagicMock(stdout="Usage: claude\n  --disable-slash-commands  Disable all skills\n", stderr="")
+        with mock.patch.object(loop.subprocess, "run", return_value=fake) as run:
+            self.assertTrue(loop.claude_supports_flag("--disable-slash-commands"))
+            self.assertTrue(loop.claude_supports_flag("--disable-slash-commands"))
+        self.assertEqual(run.call_count, 1)
+
+    def test_flag_absent_or_cli_broken_is_not_supported(self):
+        fake = mock.MagicMock(stdout="Usage: claude\n  --model <m>\n", stderr="")
+        with mock.patch.object(loop.subprocess, "run", return_value=fake):
+            self.assertFalse(loop.claude_supports_flag("--disable-slash-commands"))
+        loop.claude_supports_flag.cache_clear()
+        with mock.patch.object(loop.subprocess, "run", side_effect=OSError("no claude")):
+            self.assertFalse(loop.claude_supports_flag("--disable-slash-commands"))
+

{specfuse_loop-0.24.0 → specfuse_loop-0.25.0}/tests/test_followups_artifact.py

@@ -404,7 +404,9 @@ class TestTitlesTrackingAndBoundaries(unittest.TestCase):
                 "## Post-merge checklist\n\n- **`gatecheck.py --forbid-no-changes` exits 0 on merged HEAD.**\n"
             )
             runner = _FakeGhRunner()
-            result = loop.file_followup_issues(feature_dir, feature_dir, runner=runner)
+            result = loop.file_followup_issues(
+                feature_dir, feature_dir, runner=runner, post_merge_issue=True,
+            )
             self.assertEqual(result["filed"], 1)
             argv = runner.create_calls[0]
             self.assertEqual(argv[argv.index("--title") + 1], "[FEAT-9999 post-merge] Post-merge checklist")
@@ -412,10 +414,32 @@ class TestTitlesTrackingAndBoundaries(unittest.TestCase):
             plan = (feature_dir / "PLAN.md").read_text()
             self.assertIn("## Post-merge checklist\n\n**Tracked as #101.**\n\n- **`gatecheck.py", plan)
             # And the tracked line makes the next call a no-op.
-            again = loop.file_followup_issues(feature_dir, feature_dir, runner=runner)
+            again = loop.file_followup_issues(
+                feature_dir, feature_dir, runner=runner, post_merge_issue=True,
+            )
             self.assertEqual((again["filed"], again["already_tracked"]), (0, 1))
             self.assertEqual(len(runner.create_calls), 1)
 
+    def test_post_merge_checklist_is_not_an_issue_by_default(self):
+        # #3424: ten filed across two repositories, eight never actioned.
+        with tempfile.TemporaryDirectory() as tmp:
+            feature_dir = Path(tmp)
+            (feature_dir / "PLAN.md").write_text(
+                "---\nfeature_id: FEAT-9999\nstatus: done\nverdict: met\n---\n\n# Plan\n\n"
+                "## Post-merge checklist\n\n- [ ] count the thing over the next ten features\n"
+            )
+            runner = _FakeGhRunner()
+            result = loop.file_followup_issues(
+                feature_dir, feature_dir, runner=runner, post_merge_issue=False,
+            )
+            self.assertEqual((result["filed"], result["unfiled"]), (0, 0))
+            self.assertEqual(runner.create_calls, [])
+            self.assertNotIn("Tracked as", (feature_dir / "PLAN.md").read_text())
+
+    def test_post_merge_default_reads_the_verification_defaults(self):
+        self.assertFalse(loop.resolve_post_merge_issue({}))
+        self.assertTrue(loop.resolve_post_merge_issue({"defaults": {"post_merge_issue": True}}))
+
 
 class TestTrackedLineIsReadUnderTheHeadingOnly(unittest.TestCase):
     def test_a_foreign_tracked_line_quoted_in_the_evidence_does_not_skip_the_entry(self):

{specfuse_loop-0.24.0 → specfuse_loop-0.25.0}/tests/test_lint_gate_proportionality.py

@@ -100,7 +100,7 @@ class TestLintGateProportionality(unittest.TestCase):
             ]
             self.assertEqual(len(warns), 1, f"out={out!r}")
             self.assertIn("6", warns[0])
-            self.assertIn("8", warns[0])
+            self.assertIn("12", warns[0])
 
     def test_small_feature_one_gate_clean(self):
         with tempfile.TemporaryDirectory() as tmpdir:
@@ -114,13 +114,28 @@ class TestLintGateProportionality(unittest.TestCase):
             out = self._run(feature)
             self.assertNotIn("WARN", out)
 
-    def test_nine_units_two_gates_clean(self):
+    def test_nine_units_two_gates_warns_since_the_line_moved_to_twelve(self):
+        # #3426: 9 substantive units sat just over the old line of 8.
+        with tempfile.TemporaryDirectory() as tmpdir:
+            feature = _make_feature(
+                tmpdir,
+                [["implementation"] * 5, ["implementation"] * 4],
+            )
+            out = self._run(feature)
+            warns = [
+                line for line in out.splitlines()
+                if "WARN" in line and "planned substantive WU count" in line
+            ]
+            self.assertEqual(len(warns), 1, f"out={out!r}")
+            self.assertIn("9", warns[0])
+
+    def test_thirteen_units_two_gates_clean(self):
         with tempfile.TemporaryDirectory() as tmpdir:
             feature = _make_feature(
                 tmpdir,
                 [
-                    ["implementation"] * 5,
-                    ["implementation"] * 4,
+                    ["implementation"] * 7,
+                    ["implementation"] * 6,
                 ],
             )
             out = self._run(feature)

{specfuse_loop-0.24.0 → specfuse_loop-0.25.0}/tests/test_loop_auto_archive.py

@@ -340,3 +340,32 @@ class TestAutoArchiveLeavesNeighbourAnchor(unittest.TestCase):
 
 if __name__ == "__main__":
     unittest.main()
+
+
+class TestPostMergeChecklistTravelsWithTheArchive(unittest.TestCase):
+    """#3424: the checklist lands under the archived detail, not in an issue."""
+
+    def test_checklist_appended_under_the_archived_section(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            repo = _make_repo(tmp)
+            fdir = repo / ".specfuse" / "features" / "FEAT-2026-9999-slug"
+            fdir.mkdir(parents=True)
+            (fdir / "PLAN.md").write_text(
+                "---\nfeature_id: FEAT-2026-9999\nstatus: done\n---\n\n# Plan\n\n"
+                "## Post-merge checklist\n\n- [ ] count the thing over the next ten features\n\n"
+                "## Notes\n\n- none\n"
+            )
+            self.assertEqual(loop.auto_archive_feature("FEAT-2026-9999", repo), "archived")
+            archive_text = (repo / ".specfuse" / "roadmap-archive.md").read_text()
+            self.assertIn("**Post-merge checklist.**", archive_text)
+            self.assertIn("- [ ] count the thing over the next ten features", archive_text)
+            self.assertNotIn("## Notes", archive_text)
+
+    def test_no_plan_means_no_checklist_and_no_change(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            repo = _make_repo(tmp)
+            self.assertEqual(loop.auto_archive_feature("FEAT-2026-9999", repo), "archived")
+            self.assertNotIn(
+                "Post-merge checklist", (repo / ".specfuse" / "roadmap-archive.md").read_text(),
+            )
+

{specfuse_loop-0.24.0 → specfuse_loop-0.25.0}/tests/test_loop_close_intermediate.py

@@ -22,7 +22,7 @@ loop = load_loop()
 class TestCloseIntermediateInDicts(unittest.TestCase):
 
     def test_close_intermediate_in_model_by_type(self):
-        self.assertEqual(loop.MODEL_BY_TYPE["close-intermediate"], "opus")
+        self.assertEqual(loop.MODEL_BY_TYPE["close-intermediate"], "sonnet")
 
     def test_close_intermediate_in_effort_by_type(self):
         self.assertEqual(loop.EFFORT_BY_TYPE["close-intermediate"], "high")
@@ -52,5 +52,5 @@ class TestLoadWuCloseIntermediate(unittest.TestCase):
                    "depends_on": []}
             wu = loop.load_wu(Path(tmp), ref)
             self.assertEqual(wu.type, "close-intermediate")
-            self.assertEqual(wu.model, "opus")
+            self.assertEqual(wu.model, "sonnet")
             self.assertEqual(wu.effort, "high")

specfuse_loop-0.24.0/specfuse/loop/data/VERSION

@@ -1 +0,0 @@
-0.24.0