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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specfuse-loop
-Version: 0.23.3
+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.23.3 → specfuse_loop-0.25.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "specfuse-loop"
-version = "0.23.3"
+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.23.3 → specfuse_loop-0.25.0}/specfuse/agent/providers/triage.py

@@ -40,7 +40,11 @@ from specfuse.agent.invoke import run_claude, usage_spend
 from specfuse.agent.state import AgentSnapshot
 from specfuse.agent.triage_invoke import build_invocation, classify_result, classify_severity
 from specfuse.loop.escalation import CATEGORY_LABELS
-from specfuse.loop.labels import read_severity_rubric
+from specfuse.loop.labels import (
+    list_existing_labels,
+    read_severity_rubric,
+    severity_label_projection,
+)
 from specfuse.loop.triage import CATEGORIES, apply_triage, list_untriaged
 
 _ITEM_ID_PREFIX = "triage-"
@@ -188,6 +192,7 @@ class TriageProvider:
         self._rows: dict = {}
         self._auto = False
         self._rubric: Any = _RUBRIC_UNSET
+        self._projection: Any = _RUBRIC_UNSET
 
     def _rubric_for_run(self) -> dict:
         """The repository's severity rubric, read at most once per run
@@ -195,14 +200,40 @@ class TriageProvider:
         `execute()` call after an `advertise()`, so a run that classifies
         nothing issues no `gh label list` at all."""
         if self._rubric is _RUBRIC_UNSET:
-            self._rubric = read_severity_rubric(
-                self._working_dir, runner=self._runner, repo=self._repo
-            )
+            self._read_labels_once()
         return self._rubric
 
+    def _projection_for_run(self) -> dict:
+        """`{canonical value: the label this repository spells it with}` (#3386).
+
+        Triage wrote canonical labels a repository may never have defined; the
+        write failed, and because the bug lane reads severity from the label
+        rather than the marker, triage removed from the lane the issues it had
+        just classified for it. Derived from the same listing as the rubric —
+        one `gh label list` per run, which is the invariant that accessor
+        already carried."""
+        if self._projection is _RUBRIC_UNSET:
+            self._read_labels_once()
+        return self._projection
+
+    def _read_labels_once(self) -> None:
+        existing, _reason = list_existing_labels(
+            self._working_dir, runner=self._runner, repo=self._repo
+        )
+        self._rubric = read_severity_rubric(
+            self._working_dir, runner=self._runner, repo=self._repo,
+            existing=existing,
+        )
+        try:
+            names = [item["name"] for item in (existing or [])]
+        except (TypeError, KeyError):
+            names = []
+        self._projection = severity_label_projection(names)
+
     def advertise(self, snapshot: AgentSnapshot) -> Sequence[ActionItem]:
         self._auto = snapshot.triage_auto
         self._rubric = _RUBRIC_UNSET
+        self._projection = _RUBRIC_UNSET
         rows = list_untriaged(self._runner, self._repo)
 
         self._rows = {}
@@ -250,7 +281,9 @@ class TriageProvider:
                     "labels": row.get("labels") or [],
                 }
             ]
-            results = apply_triage(self._runner, self._repo, decisions, auto=self._auto)
+            results = apply_triage(
+                self._runner, self._repo, decisions, auto=self._auto,
+                label_projection=self._projection_for_run())
             row_result = results[0]
             if row_result.get("label_written"):
                 return ActionOutcome(
@@ -337,7 +370,9 @@ class TriageProvider:
                 "severity": severity,
             }
         ]
-        results = apply_triage(self._runner, self._repo, decisions, auto=self._auto)
+        results = apply_triage(
+            self._runner, self._repo, decisions, auto=self._auto,
+            label_projection=self._projection_for_run())
         row_result = results[0]
 
         if row_result.get("skipped"):

{specfuse_loop-0.23.3 → specfuse_loop-0.25.0}/specfuse/agent/run.py

@@ -76,6 +76,13 @@ STATUS_ESCALATED = "escalated"
 #: (FEAT-2026-0108/T02). Not one of `budget.py`'s stop reasons -- nothing was
 #: budgeted, because nothing was dispatched.
 STOP_DIRTY_TREE = "dirty_tree"
+#: The run could not read the queue it was meant to work through (#3392).
+#: Distinct from `STOP_DRAINED`, which means the opposite: a drained run saw
+#: everything there was and finished it. Reported identically, they are
+#: indistinguishable in the summary — the part an operator reads and the only
+#: part automation parses — so a nightly run whose credentials broke looks like
+#: a quiet backlog.
+STOP_SNAPSHOT_UNREADABLE = "snapshot_unreadable"
 
 KIND_BUG = "bug"
 KIND_FEATURE = "feature"
@@ -706,6 +713,43 @@ def _refuse_dirty_tree(reason: str, report: Callable[[str], None]) -> RunSummary
     )
 
 
+def _refuse_unreadable_snapshot(reason: str, *, report) -> "RunSummary":
+    """Refuse a run whose issue listing failed, rather than draining it (#3392).
+
+    Every provider that matters reads `snapshot.issues`, so a run without it
+    can do nothing except mislead. Shaped like `_refuse_dirty_tree`: zero
+    attempted, zero completed, one escalation carrying the reason, and a
+    distinct stop reason so the summary cannot be mistaken for a healthy run
+    against an empty queue.
+
+    Refusing is the conservative direction here for the same reason it is
+    there. A blind run that dispatches nothing has cost nothing; a blind run
+    reported as `drained` costs the operator their belief that the queue is
+    empty.
+    """
+    report(f"run refused to start — {reason}")
+    return RunSummary(
+        items_attempted=0,
+        items_completed=0,
+        items_escalated=1,
+        stop_reason=STOP_SNAPSHOT_UNREADABLE,
+        elapsed_minutes=0.0,
+        tokens_spent=0,
+        escalations=(Escalation(item_id="run:snapshot", reason=reason),),
+    )
+
+
+def exit_code_for(stop_reason: str) -> int:
+    """The process exit code a run ending in *stop_reason* should report.
+
+    Non-zero only for a refusal — a run that did not happen. Every outcome,
+    including `drained`, keeps 0: those are runs that ran. Narrow on purpose,
+    so a new stop reason does not silently become a failing exit code for
+    whatever automation is watching.
+    """
+    return 1 if stop_reason == STOP_SNAPSHOT_UNREADABLE else 0
+
+
 def _dirty_tree_reason(paths) -> str:
     shown = ", ".join(paths[:10])
     if len(paths) > 10:
@@ -799,6 +843,31 @@ def run_agent(
             if error:
                 report(f"snapshot: {section} unreadable — {error}")
 
+        # #3392: an unreadable issue listing is not an empty queue. Every
+        # provider that matters reads `snapshot.issues`, so continuing here
+        # finds no candidates and stops with `drained` — "worked through
+        # everything there was" reported for "could not see anything". Measured
+        # with nine dispatchable bugs in the queue at the time.
+        if snapshot.issues_error:
+            return _refuse_unreadable_snapshot(
+                f"the issue listing failed, so the queue could not be read: "
+                f"{snapshot.issues_error}",
+                report=report,
+            )
+
+        # The PR listing failing is NOT a refusal: `max_open_prs` deliberately
+        # reads an unreadable listing as zero rather than firing on a number
+        # the run could not measure. But that leaves the cap silently disabled
+        # for this run, so the summary says so rather than the operator finding
+        # it in the log. Whether it should refuse instead is a live question
+        # (#3392 item 3) and not decided here.
+        if snapshot.prs_error:
+            report(
+                "snapshot: max_open_prs is NOT enforced this run — the PR "
+                "listing could not be read, so the cap has no number to "
+                "measure against"
+            )
+
         budget_kwargs = {}
         if pause_marker is not None:
             budget_kwargs["pause_marker"] = pause_marker
@@ -1294,7 +1363,9 @@ def main(argv: Optional[Sequence[str]] = None) -> int:
         worktree.restore_branch(started_on, report=_default_reporter)
 
     print(_format_summary(summary))
-    return 0
+    # #3392: a refusal exits non-zero so a scheduled run's exit status is
+    # self-describing without its log. Outcomes — `drained` included — keep 0.
+    return exit_code_for(summary.stop_reason)
 
 
 if __name__ == "__main__":

specfuse_loop-0.25.0/specfuse/loop/data/VERSION

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

{specfuse_loop-0.23.3 → 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
@@ -759,7 +787,17 @@ when and how these get created.
 | State backend  | WU / GATE file frontmatter          | GitHub issue labels + feature registry |
 | Dispatch       | driver shells out (`claude -p`)     | inbox files + polling loop             |
 | Branch / merge | one branch, squash per WU            | branch + PR per task, merge watcher    |
-| Spec front-end | optional; task graph authored directly | spec-first (specs agent + codegen)  |
+| Spec front-end | one of: **none** (task graph authored directly), **consumed** (specs authored upstream, the loop implements against a handoff manifest), or **authored** (the spec tree is the deliverable — work units author spec files) | spec-first (specs agent + codegen), from a dossier **or** from an upstream handoff manifest |
+
+The loop's spec front-end is three-valued because a repository whose entire
+deliverable **is** the spec tree fits neither of the two values this row
+carried before (#3407): it is not "optional", and the task graph is not
+"authored directly" — the work units author spec files. One consumer carried
+that third case in about forty lines of project `CLAUDE.md` because the row
+could not express it. In the **authored** mode the work-unit contract picks up
+two constraints that do not apply to code units — see
+`authoring-work-units` §6 (the whole tree validates) and §12 (a structural
+assertion substitutes for the red test).
 
 Everything above those rows — the unit hierarchy, ownership split, WU contract,
 verification-as-oracle, the gate cycle, plan-next, LEARNINGS, and autonomy — is

{specfuse_loop-0.23.3 → 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.23.3 → 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.23.3 → 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.23.3"
+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((
@@ -9488,6 +9603,15 @@ def capture_gate_diff(
     return "\n\n".join(parts)
 
 
+def _is_relative_to(path: Path, other: Path) -> bool:
+    """`Path.is_relative_to`, tolerant of paths that do not resolve."""
+    try:
+        path.relative_to(other)
+    except ValueError:
+        return False
+    return True
+
+
 def write_judge_followups(
     feature_dir: Path, gate_number: int, findings: list,
 ) -> Path:
@@ -9579,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,
@@ -9644,6 +9769,32 @@ def judge_close(
             feature_dir, gate_number, result.findings)
         payload["lowered"] = True
         payload["verdict"] = "not_met"
+        # Say WHERE the findings went (#3406). They are written verbatim to
+        # FOLLOW-UPS.md above and committed below, but the event said only
+        # `findings: N` with `reason: null` — so a reader of events.jsonl had
+        # nothing pointing out of it. One operator searched events.jsonl,
+        # `work/` and for a repository-level judge artifact, concluded the text
+        # did not exist, and priced a third close at ~$12 to re-derive a
+        # finding that was sitting in a committed file.
+        #
+        # The criteria go in; the finding TEXT deliberately does not. It is
+        # already recorded verbatim in one place, and copying it into a second
+        # invites the two to disagree — `write_judge_followups` exists so the
+        # judge's words are not reformatted by the driver.
+        payload["findings_path"] = str(
+            Path(followups).relative_to(Path(feature_dir).parent.parent)
+            if _is_relative_to(Path(followups), Path(feature_dir).parent.parent)
+            else Path(followups)
+        )
+        payload["finding_criteria"] = [
+            f.criterion for f in result.findings if getattr(f, "criterion", None)
+        ]
+        _named = ", ".join(payload["finding_criteria"]) or "no named criterion"
+        payload["reason"] = (
+            f"judge lowered the verdict on {payload['findings']} finding(s) "
+            f"({_named}); the judge's own words are in "
+            f"{payload['findings_path']}"
+        )
         commit_bookkeeping(
             [wu.file, followups],
             f"chore(loop): {wu.wu_id} judge lowered verdict to not_met"

{specfuse_loop-0.23.3 → specfuse_loop-0.25.0}/specfuse/loop/triage.py

@@ -182,7 +182,10 @@ def _list_open_issues(runner: Callable, repo: str, *, limit: int) -> list:
         return []
 
 
-def apply_triage(runner: Callable, repo: str, decisions: list, *, auto: bool = False) -> list:
+def apply_triage(
+    runner: Callable, repo: str, decisions: list, *,
+    auto: bool = False, label_projection: "dict | None" = None,
+) -> list:
     """Record each decision in `decisions` against its GitHub issue.
 
     Each decision is a mapping carrying at least `number`, `body` (the
@@ -195,6 +198,18 @@ def apply_triage(runner: Callable, repo: str, decisions: list, *, auto: bool = F
     marker. But a marker with no matching label on the issue (the label
     write failed on an earlier pass, e.g. because the label did not exist
     yet) is not fully idempotent -- it is missing its projection, so this
+    `label_projection` maps a canonical severity value to the label this
+    repository actually spells it with (`labels.severity_label_projection`,
+    #3386). Without it `severity_aliases` was one-directional: the bug lane
+    translated a repository's own words inbound while triage wrote canonical
+    words outbound, which that repository may never have defined. The write then
+    failed, and since the lane reads severity from the LABEL rather than the
+    marker, triage removed from the lane the very issues it had just classified
+    for it. The marker always records the canonical value, so it stays
+    comparable across repositories; only the label takes the operator's word.
+    Absent, or missing a value, the canonical label is written — the behaviour
+    before the projection existed.
+
     retries only the label write. `decision["labels"]` (as returned by
     `gh issue list --json ...,labels`, i.e. a list of `{"name": ...}`
     mappings) is what `labels` is checked against; a decision with no
@@ -226,7 +241,10 @@ def apply_triage(runner: Callable, repo: str, decisions: list, *, auto: bool = F
             marked_severity = (parse_marker_fields(body) or {}).get("severity")
             target_labels = labels_for(marked_category) if marked_category in CATEGORIES else ()
             if marked_severity:
-                target_labels = tuple(target_labels) + (severity_label_for(marked_severity),)
+                target_labels = tuple(target_labels) + (
+                    (label_projection or {}).get(
+                        marked_severity, severity_label_for(marked_severity)),
+                )
             existing_labels = {
                 label.get("name") for label in decision.get("labels") or []
             }
@@ -288,7 +306,9 @@ def apply_triage(runner: Callable, repo: str, decisions: list, *, auto: bool = F
 
         labels_to_add = list(labels_for(applied_category))
         if severity:
-            labels_to_add.append(severity_label_for(severity))
+            labels_to_add.append(
+                (label_projection or {}).get(
+                    severity, severity_label_for(severity)))
 
         try:
             runner(

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

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