specfuse-loop 0.26.0__tar.gz → 0.27.0__tar.gz

{specfuse_loop-0.26.0/specfuse_loop.egg-info → specfuse_loop-0.27.0}/PKG-INFO

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

{specfuse_loop-0.26.0 → specfuse_loop-0.27.0}/pyproject.toml

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

{specfuse_loop-0.26.0 → specfuse_loop-0.27.0}/specfuse/agent/providers/bugs.py

@@ -16,7 +16,7 @@ import subprocess
 import time
 from typing import Any, Callable, Optional, Sequence
 
-from specfuse.agent.invoke import resolve_item_timeout_seconds
+from specfuse.agent.invoke import resolve_item_timeout_seconds, usage_spend
 from specfuse.agent.run import (
     KIND_BUG,
     STATUS_COMPLETED,
@@ -41,6 +41,7 @@ from specfuse.loop.bug_lane_run import (
     OUTCOME_DECLINED,
     OUTCOME_MERGED,
     OUTCOME_REFUSED,
+    OUTCOME_SUPERSEDED,
     REASON_PR_NOT_FOUND,
     pr_closes_issue,
     run_bug_lane,
@@ -63,7 +64,9 @@ _FIX_BUG_STOPPED_OUTCOMES = (OUTCOME_REFUSED, OUTCOME_COULD_NOT_PROCEED)
 #: "fix" its own "PR was declined by the merge guardrails" report.
 _HUMAN_OWNED_LABELS = frozenset({NEEDS_HUMAN_LABEL, "blocked-wu"})
 
-def _bounded_runner(runner: Callable, timeout_seconds: float) -> Callable:
+def _bounded_runner(
+    runner: Callable, timeout_seconds: float, working_dir: str = "."
+) -> Callable:
     """Wrap *runner* so the headless `claude` dispatch inside `run_bug_lane`
     (`specfuse.loop.bug_lane_run:595`, off-limits to this WU) gets a real
     wall-clock timeout without editing that module.
@@ -72,12 +75,24 @@ def _bounded_runner(runner: Callable, timeout_seconds: float) -> Callable:
     `claude` -- `run_bug_lane` reuses this same runner for every `gh` read
     and write along the way, and those must not inherit an item-scale
     deadline meant for one long-running session.
+
+    The same call is started with `cwd=working_dir` (#3420). The item's
+    worktree used to reach the session only as a `Working directory:` line in
+    its prompt, so a session that followed `/fix-bug`'s own branch workflow
+    from where it was launched branched and committed in the operator's
+    primary checkout. The process boundary is what isolates it, not the text.
+
+    Any other keyword a caller passes is forwarded untouched (#3452). The
+    red-on-base probe runs its command with `cwd=<base worktree>`; a wrapper
+    that accepted only `check` raised `TypeError`, which the probe's
+    fail-closed `except` turned into `red_on_base_unverified` on every PR.
     """
 
-    def wrapped(argv, check: bool = False):
-        kwargs = {"check": check}
+    def wrapped(argv, check: bool = False, **kwargs):
+        kwargs["check"] = check
         if argv and argv[0] == "claude":
             kwargs["timeout"] = timeout_seconds
+            kwargs.setdefault("cwd", working_dir)
         return runner(argv, **kwargs)
 
     return wrapped
@@ -725,7 +740,7 @@ class BugsProvider:
         started = time.monotonic()
         try:
             result = run_bug_lane(
-                _bounded_runner(self._runner, timeout_seconds),
+                _bounded_runner(self._runner, timeout_seconds, self._working_dir),
                 self._repo,
                 issue_number,
                 working_dir=self._working_dir,
@@ -738,9 +753,11 @@ class BugsProvider:
                 status=STATUS_ESCALATED,
                 detail=(
                     f"could_not_proceed: headless /fix-bug session timed out "
-                    f"after {elapsed:.0f}s"
+                    f"after {elapsed:.0f}s (its token spend is not counted)"
                 ),
                 escalation=_timed_out_payload(issue_number, elapsed),
+                # A session cut off by the timeout printed no usage envelope,
+                # so its spend is unknown, not zero (#3419) -- said in `detail`.
                 spend=0,
             )
 
@@ -750,17 +767,23 @@ class BugsProvider:
         # and therefore unevaluable — the one point the proposal called out as
         # mattering most.
         profile_note = _dispatch_profile_note(result.dispatch_profile)
+        # #3419: what the headless `/fix-bug` session spent, on every outcome.
+        # Was a hard-coded 0, so `max_tokens` bounded triage alone.
+        spend = usage_spend(result.usage)
 
         if result.outcome == OUTCOME_MERGED:
-            # `run_bug_lane` (`specfuse/loop/bug_lane_run.py`, T04's file) does
-            # not surface the headless `/fix-bug` session's usage envelope on
-            # `BugLaneResult` -- reporting the bug lane's real spend needs a
-            # change there, out of this WU's reach (`specfuse/loop/` is
-            # off-limits except what T01 declares). Explicit `spend=0` rather
-            # than a value this module cannot actually measure.
             return ActionOutcome(
                 status=STATUS_COMPLETED,
-                detail=f"{result.reason or ''}{profile_note}", spend=0)
+                detail=f"{result.reason or ''}{profile_note}", spend=spend)
+
+        if result.outcome == OUTCOME_SUPERSEDED:
+            # #3447: the issue was closed elsewhere and the lane closed its own
+            # duplicate PR. Done, with nothing for a human to merge or decide.
+            return ActionOutcome(
+                status=STATUS_COMPLETED,
+                detail=f"{result.reason}; PR #{result.pr_number} closed{profile_note}",
+                spend=spend,
+            )
 
         detail = result.reason if result.reason is not None else result.outcome
 
@@ -825,6 +848,7 @@ class BugsProvider:
             detail=f"{detail}{profile_note}",
             escalation=escalation,
             environmental=not result.outcome_named,
+            spend=spend,
         )
 
     def reconcile(self, item: ActionItem, outcome: ActionOutcome) -> None:

{specfuse_loop-0.26.0 → specfuse_loop-0.27.0}/specfuse/agent/run.py

@@ -389,15 +389,23 @@ def _resolve_bugs_preempt(policy_path: Optional[str]) -> bool:
     return bugs.get("preempt") is True
 
 
-def _default_runner(argv: list, check: bool = False, timeout: Optional[float] = None):
+def _default_runner(
+    argv: list,
+    check: bool = False,
+    timeout: Optional[float] = None,
+    cwd: Optional[str] = None,
+):
     """The real subprocess runner. Forwards *timeout* to `subprocess.run`
     (FEAT-2026-0108/T03) so a caller that bounds one call's wall-clock time --
     `BugsProvider.execute`'s headless `/fix-bug` dispatch, the one call this
     exists for -- gets a real `subprocess.TimeoutExpired` when the process
     outruns it, rather than the session's own turn or wall limit being the
-    only thing that ever ends it (#3178)."""
+    only thing that ever ends it (#3178).
+
+    Forwards *cwd* for the same dispatch (#3420): the session is started in
+    the item's worktree, not the run's own directory."""
     return subprocess.run(
-        argv, check=check, capture_output=True, text=True, timeout=timeout
+        argv, check=check, capture_output=True, text=True, timeout=timeout, cwd=cwd
     )
 
 
@@ -855,17 +863,15 @@ def run_agent(
                 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:
+        # The PR listing failing is NOT a refusal (#3412): work that opens no
+        # PR still runs. Under a declared `max_open_prs`, the PR-opening kinds
+        # are held back in the dispatch loop below until a refresh reads the
+        # listing; without a cap there is nothing to enforce, and the run says
+        # only that the listing is unreadable.
+        if snapshot.prs_error and agent_policy.resolve_max_open_prs(policy_path) is None:
             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"
+                "snapshot: the PR listing could not be read — no "
+                "max_open_prs is declared, so nothing is held back"
             )
 
         budget_kwargs = {}
@@ -916,7 +922,9 @@ def run_agent(
         #: only so the report fires on each transition rather than every pass:
         #: `snapshot.prs` is re-read between items (#3338), so a PR merged
         #: mid-run genuinely lifts this and the operator should see both edges.
-        open_prs_suppressed = False
+        # Why PR-opening kinds are held: "" (not held), "unreadable" or
+        # "cap" -- so each change of reason is reported once (#3412).
+        open_prs_suppressed = ""
         #: (signature, consecutive count) for the run-level failure breaker
         #: (#3343). Reset by an escalation with a different cause and by any
         #: completed item — a run making progress is not in the state this
@@ -956,26 +964,40 @@ def run_agent(
                 snapshot_stale = False
 
             # A failed PR listing leaves `snapshot.prs` empty with
-            # `prs_error` set. That reads as zero here, deliberately: the cap
-            # must not fire on a number the run could not measure, and #3338's
-            # refresh already carries the previous listing forward when it can.
+            # `prs_error` set -- not zero open PRs, an unknown number (#3412).
+            # Reading it as zero turned the cap off for the run, exactly when
+            # the run could see least. Under a cap the PR-opening kinds wait,
+            # the way reaching the cap already makes them wait, until a refresh
+            # reads the listing. #3338's refresh carries a previously read
+            # listing forward, so `prs_error` stays set only while this run has
+            # never read one.
             suppressed_kinds = frozenset()
-            if _open_pr_cap is not None and len(snapshot.prs) >= _open_pr_cap:
+            if _open_pr_cap is not None and snapshot.prs_error:
+                suppressed_kinds = PR_OPENING_KINDS
+                if open_prs_suppressed != "unreadable":
+                    report(
+                        f"max_open_prs NOT measurable — the PR listing could "
+                        f"not be read ({snapshot.prs_error}); not starting "
+                        f"{', '.join(sorted(PR_OPENING_KINDS))} items until it "
+                        f"can be"
+                    )
+                    open_prs_suppressed = "unreadable"
+            elif _open_pr_cap is not None and len(snapshot.prs) >= _open_pr_cap:
                 suppressed_kinds = PR_OPENING_KINDS
-                if not open_prs_suppressed:
+                if open_prs_suppressed != "cap":
                     report(
                         f"max_open_prs reached — {len(snapshot.prs)} open PR(s) "
                         f"at a cap of {_open_pr_cap}; not starting "
                         f"{', '.join(sorted(PR_OPENING_KINDS))} items until one "
                         f"closes"
                     )
-                    open_prs_suppressed = True
+                    open_prs_suppressed = "cap"
             elif open_prs_suppressed:
                 report(
                     f"max_open_prs cleared — {len(snapshot.prs)} open PR(s) "
                     f"against a cap of {_open_pr_cap}"
                 )
-                open_prs_suppressed = False
+                open_prs_suppressed = ""
 
             action, a, b = _select_next(
                 providers,

{specfuse_loop-0.26.0 → specfuse_loop-0.27.0}/specfuse/agent/severity_backfill.py

@@ -1,6 +1,6 @@
 # Copyright 2026 Specfuse Contributors
 # Licensed under the Apache License, Version 2.0. See LICENSE.
-"""`specfuse-backfill-severity` -- amend already-marked, severity-less issues
+"""`specfuse-backfill-severity` -- amend already-marked, severity-less bugs
 with a severity, for issues the normal triage path will never revisit
 (FEAT-2026-0113).
 
@@ -15,7 +15,7 @@ script is one deliberate command away, not one argv typo on the binary an
 unattended run uses.
 
 `run_backfill` (T10) is the real run shape: `triage.list_severity_backfill_candidates`
-(T08) selects the open, marked, severity-less issues; `labels.read_severity_rubric`
+(T08) selects the open, marked, severity-less bugs; `labels.read_severity_rubric`
 is read exactly once per run; each candidate is classified through
 `triage_invoke.build_invocation` + `triage_invoke.classify_severity` -- the same
 classifier a fresh triage uses, so a low-confidence or out-of-rubric answer fails
@@ -161,7 +161,7 @@ def run_backfill(
     effort: str = "medium",
 ) -> dict:
     """Select, classify, and (only under `apply=True`) write severities for
-    every open, marked, severity-less issue in `repo` -- the real run shape
+    every open, marked, severity-less bug in `repo` -- the real run shape
     T07's single-issue tracer bullet stood in for.
 
     The rubric is read exactly once, before any candidate is even selected:
@@ -289,7 +289,7 @@ def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
         prog="specfuse-backfill-severity",
         description=(
-            "Amend every open, marked, severity-less issue with a severity, "
+            "Amend every open, marked, severity-less bug with a severity, "
             "marker first, label projected after."
         ),
     )

{specfuse_loop-0.26.0 → specfuse_loop-0.27.0}/specfuse/agent/state.py

@@ -47,7 +47,7 @@ from typing import Callable, Optional
 from specfuse.loop import agent_policy
 from specfuse.loop.lint_plan import read_frontmatter
 from specfuse.loop.plan_baseline import load_plan_graph
-from specfuse.loop.triage import parse_marker
+from specfuse.loop.triage import effective_category, parse_marker
 
 DEFAULT_ISSUE_LIST_LIMIT = 100
 DEFAULT_PR_LIST_LIMIT = 100
@@ -166,6 +166,8 @@ def _to_issue_summary(raw: dict) -> IssueSummary:
     )
     marker = parse_marker(raw.get("body") or "")
     category, confidence = marker if marker is not None else (None, None)
+    # #3415: an operator's relabel overrides the marker triage wrote.
+    category = effective_category(category, labels)
     return IssueSummary(
         number=raw.get("number"),
         title=raw.get("title", ""),

{specfuse_loop-0.26.0 → specfuse_loop-0.27.0}/specfuse/loop/bug_lane_run.py

@@ -34,7 +34,7 @@ import json
 import tempfile
 import re
 import time
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 from typing import Any, Callable, Optional
 
 from specfuse.loop.agent_policy import (
@@ -51,13 +51,15 @@ from specfuse.loop.bug_lane import (
     REASON_DIFF_TOO_LARGE,
     REASON_JUDGE_PATH_TOUCHED,
     REASON_NO_TEST_EVIDENCE,
+    REASON_RED_ON_BASE_UNVERIFIED,
     evaluate_merge_guardrails,
     evaluate_pr_shape_guardrails,
     judge_paths_touched,
 )
 from specfuse.loop.bug_lane_state import GitHubMergeCapState, record_merge
 from specfuse.loop.labels import provision_labels
-from specfuse.loop.red_on_base import select_test_files, test_was_red_on_base
+from specfuse.loop.loop import parse_claude_json_output
+from specfuse.loop.red_on_base import probe_red_on_base, select_test_files
 from specfuse.loop.triage import parse_marker
 from specfuse.monitor.diagnosis import DiagnosisParseError
 from specfuse.monitor.diagnosis import parse as parse_diagnosis
@@ -76,6 +78,7 @@ __all__ = (
     "OUTCOME_MERGED",
     "OUTCOME_DECLINED",
     "OUTCOME_AUTOMERGE_OFF",
+    "OUTCOME_SUPERSEDED",
     "run_bug_lane",
     "pr_ci_conclusion",
     "add_guardrail_label",
@@ -104,6 +107,12 @@ OUTCOME_DECLINED = "declined"
 #: when the guardrails had passed and the dial was the only thing in the way.
 OUTCOME_AUTOMERGE_OFF = "automerge_off"
 
+#: The issue was closed while the item ran -- by another PR, or by hand -- so
+#: the lane's PR duplicates work already done and was closed (#3447). Not an
+#: escalation: nothing is left for a human to decide, and asking one to merge
+#: a duplicate of a closed fix was the bug.
+OUTCOME_SUPERSEDED = "superseded"
+
 #: `needs_decision` escalates like the other two: the session opened no PR,
 #: so there is nothing for the guardrails to evaluate, and what the operator
 #: owes is an answer rather than a review (#3390).
@@ -182,6 +191,10 @@ class BugLaneResult:
     #: telling them apart is the difference between "fix this by hand" and
     #: "push the branch that already exists".
     unpushed_work: Optional[tuple] = None
+    #: The headless session's usage envelope (#3419), `None` when the CLI
+    #: printed none. `BugsProvider` turns it into `ActionOutcome.spend`;
+    #: without it `max_tokens` never bounded the lane that spends.
+    usage: Optional[dict] = None
 
 
 #: How long to wait for a freshly-opened PR's checks to reach a conclusion,
@@ -216,6 +229,10 @@ _BUCKET_PENDING = "pending"
 
 _CI_FAILING = "fail"
 
+#: What `gh pr checks` prints on stderr, with empty stdout and exit 1, for a PR
+#: that has no check runs at all (#3445).
+_NO_CHECKS_REPORTED = "no checks reported"
+
 
 def _required_checks_verdict(rows: list, required) -> str:
     """`""` when every required check is present and passing, else why not.
@@ -272,6 +289,12 @@ def _read_ci_conclusion_once(
     # only a fallback when there is no parseable output.
     stdout = getattr(result, "stdout", None)
     if not stdout:
+        # #3445: `gh` never prints `[]` for a PR with no check runs. It prints
+        # nothing, says `no checks reported on the '<branch>' branch` on stderr
+        # and exits 1. That is the "no check registered yet" state below, not
+        # an unreadable read, and must not decline as `ci_not_green`.
+        if _NO_CHECKS_REPORTED in (getattr(result, "stderr", None) or ""):
+            return _CI_PENDING
         return _CI_UNKNOWN
 
     try:
@@ -586,6 +609,70 @@ def _issue_provenance(runner: Callable, repo: str, issue_number: int) -> Optiona
     return {"kind": "triaged_issue", "ref": str(issue_number)}
 
 
+def _superseded_by(
+    runner: Callable, repo: str, issue_number: int, own_pr: int
+) -> tuple[bool, Optional[int]]:
+    """Whether *issue_number* was closed by something other than *own_pr*,
+    and the PR that closed it when GitHub knows one (#3447).
+
+    Fails open: an unreadable issue reads as not superseded, so a `gh` hiccup
+    leaves the lane exactly where it was before this check existed rather than
+    closing a PR that may be the only fix.
+    """
+    result = runner(
+        [
+            "gh", "issue", "view", str(issue_number), "--repo", repo,
+            "--json", "state,closedByPullRequestsReferences",
+        ],
+        check=False,
+    )
+    if getattr(result, "returncode", 1) != 0 or not getattr(result, "stdout", None):
+        return False, None
+    try:
+        data = json.loads(result.stdout)
+    except ValueError:
+        return False, None
+    if not isinstance(data, dict) or data.get("state") != "CLOSED":
+        return False, None
+    closers = [
+        ref.get("number")
+        for ref in data.get("closedByPullRequestsReferences") or ()
+        if isinstance(ref, dict)
+    ]
+    closers = [n for n in closers if isinstance(n, int) and not isinstance(n, bool)]
+    if own_pr in closers:
+        return False, None
+    return True, (closers[0] if closers else None)
+
+
+def _close_superseded(
+    runner: Callable,
+    repo: str,
+    issue_number: int,
+    pr_number: int,
+    by_pr: Optional[int],
+    dispatch_profile: tuple,
+) -> BugLaneResult:
+    """Close the lane's own PR as a duplicate of a fix already done (#3447)."""
+    by = f"PR #{by_pr}" if by_pr else "another change"
+    runner(
+        [
+            "gh", "pr", "close", str(pr_number), "--repo", repo,
+            "--comment",
+            f"Superseded: issue #{issue_number} was closed by {by} while the "
+            "bug lane was evaluating this PR. Closing it as a duplicate.",
+        ],
+        check=False,
+    )
+    return BugLaneResult(
+        outcome=OUTCOME_SUPERSEDED,
+        reason=f"superseded by {by}",
+        pr_number=pr_number,
+        evidence=(f"Issue #{issue_number} was closed by {by}.",),
+        dispatch_profile=dispatch_profile,
+    )
+
+
 #: Branch shape `/fix-bug` uses for an issue it is fixing.
 _WORK_BRANCH_GLOB = "fix/issue-{number}-*"
 
@@ -641,9 +728,21 @@ def unpushed_work_for_issue(runner: Callable, issue_number: int) -> Optional[tup
 
 
 def _evidence_for(
-    reason: str, changed_files: list, diff_lines: int, limits: dict
+    reason: str,
+    changed_files: list,
+    diff_lines: int,
+    limits: dict,
+    *,
+    red_on_base_reason: str = "",
 ) -> tuple:
     """Render the measurement behind *reason* as sentences a human can read."""
+    if reason == REASON_RED_ON_BASE_UNVERIFIED and red_on_base_reason:
+        # #3416: which step of the probe gave up. Without it `unverified` is
+        # the one decline nobody can act on short of re-running it by hand.
+        return (
+            f"The red-on-base probe could not run the PR's tests at the merge "
+            f"base: {red_on_base_reason}.",
+        )
     if reason == REASON_JUDGE_PATH_TOUCHED:
         hits = judge_paths_touched(changed_files)
         if not hits:
@@ -699,30 +798,37 @@ def _declined(
     )
 
 
-def _merge_base_sha(runner: Callable, repo: str, pr_number: int) -> str:
-    """The commit the PR is measured against, or `""` (#3377).
+def _pr_base_and_head(runner: Callable, repo: str, pr_number: int) -> tuple[str, str]:
+    """`(baseRefOid, headRefOid)` for the PR, `""` for whichever is unknown.
 
     `baseRefOid` is the tip of the base branch as GitHub sees it now, which is
-    what the PR would merge into — the tree the fix was written against, and so
-    the tree its new test must fail on. An empty string makes the probe decline
-    rather than guess a commit.
+    what the PR would merge into -- the tree its new test must fail on
+    (#3377). `headRefOid` is the PR's own commit, whose test files the probe
+    runs on that tree (#3417). An empty string makes the probe decline rather
+    than guess a commit.
     """
     try:
         result = runner(
             ["gh", "pr", "view", str(pr_number), "--repo", repo,
-             "--json", "baseRefOid"],
+             "--json", "baseRefOid,headRefOid"],
             check=False,
         )
     except Exception:  # noqa: BLE001 - a lookup failure declines, never raises
-        return ""
+        return "", ""
     if getattr(result, "returncode", 1) != 0 or not getattr(result, "stdout", None):
-        return ""
+        return "", ""
     try:
         payload = json.loads(result.stdout)
     except ValueError:
-        return ""
-    sha = payload.get("baseRefOid") if isinstance(payload, dict) else None
-    return sha.strip() if isinstance(sha, str) else ""
+        return "", ""
+    if not isinstance(payload, dict):
+        return "", ""
+
+    def _sha(key: str) -> str:
+        value = payload.get(key)
+        return value.strip() if isinstance(value, str) else ""
+
+    return _sha("baseRefOid"), _sha("headRefOid")
 
 
 def dispatch_profile_for(
@@ -813,6 +919,33 @@ def run_bug_lane(
     always accurate) and merges only when the dial is `on` *and* the
     guardrails are eligible -- the module's single merge call site.
     """
+    session: dict = {}
+    result = _run_bug_lane(
+        runner, repo, issue_number,
+        working_dir=working_dir, policy_path=policy_path, now=now,
+        ci_sleep=ci_sleep, ci_clock=ci_clock,
+        ci_deadline_seconds=ci_deadline_seconds,
+        pr_lookup_sleep=pr_lookup_sleep, session=session,
+    )
+    # #3419: every outcome carries the session's usage, whichever of the
+    # lane's many return paths produced it.
+    return replace(result, usage=session.get("usage"))
+
+
+def _run_bug_lane(
+    runner: Callable,
+    repo: str,
+    issue_number: int,
+    *,
+    working_dir: str,
+    policy_path: Any,
+    now: Optional[float],
+    ci_sleep: Callable,
+    ci_clock: Callable,
+    ci_deadline_seconds: Optional[float],
+    pr_lookup_sleep: Callable,
+    session: dict,
+) -> BugLaneResult:
     model, effort, profile_source = dispatch_profile_for(
         runner, repo, issue_number, policy_path
     )
@@ -820,8 +953,13 @@ def run_bug_lane(
     argv, prompt = build_invocation(
         issue_number, repo, working_dir, model=model, effort=effort
     )
-    invocation = runner(argv + [prompt], check=False)
-    session_output = getattr(invocation, "stdout", "") or ""
+    # #3419: ask for the CLI's JSON envelope so the session's usage is known.
+    # Its `result` is the same final text plain `-p` printed, so everything
+    # below reads `session_output` exactly as before.
+    invocation = runner(argv + ["--output-format", "json", prompt], check=False)
+    session_output, session["usage"] = parse_claude_json_output(
+        getattr(invocation, "stdout", "") or ""
+    )
     outcome = classify_outcome(session_output)
 
     if outcome in _ESCALATING_OUTCOMES:
@@ -855,6 +993,13 @@ def run_bug_lane(
             outcome=OUTCOME_DECLINED, reason=_REASON_PR_NOT_FOUND,
             pr_number=None, dispatch_profile=_profile)
 
+    # #3447: another session may have fixed the issue while this one ran.
+    superseded, by_pr = _superseded_by(runner, repo, issue_number, pr_number)
+    if superseded:
+        return _close_superseded(
+            runner, repo, issue_number, pr_number, by_pr, _profile,
+        )
+
     changed_files, diff_lines = _pr_changed_files_and_diff_lines(runner, repo, pr_number)
     limits = bug_lane_limits(policy_path)
     provenance = _issue_provenance(runner, repo, issue_number)
@@ -902,14 +1047,18 @@ def run_bug_lane(
     # test run.
     require_red = resolve_require_red_on_base(policy_path)
     red_on_base = None
+    red_on_base_reason = ""
     if require_red:
-        red_on_base = test_was_red_on_base(
+        base_sha, head_sha = _pr_base_and_head(runner, repo, pr_number)
+        probe = probe_red_on_base(
             runner,
-            base_sha=_merge_base_sha(runner, repo, pr_number),
+            base_sha=base_sha,
+            head_sha=head_sha,
             test_files=select_test_files(changed_files, limits["test_paths"]),
             command_template=resolve_red_on_base_command(policy_path),
             worktree_root=tempfile.gettempdir(),
         )
+        red_on_base, red_on_base_reason = probe.verdict, probe.reason
 
     decision = evaluate_merge_guardrails(
         changed_files=changed_files,
@@ -925,6 +1074,15 @@ def run_bug_lane(
     )
     dial = resolve_bug_automerge(policy_path)
 
+    # #3447: asked again after the CI wait, the longest stretch an item spends
+    # -- the observed duplicates were closed elsewhere during exactly this
+    # window. Neither merging nor escalating a duplicate of a closed fix.
+    superseded, by_pr = _superseded_by(runner, repo, issue_number, pr_number)
+    if superseded:
+        return _close_superseded(
+            runner, repo, issue_number, pr_number, by_pr, _profile,
+        )
+
     if dial and decision.eligible:
         runner(
             ["gh", "pr", "merge", str(pr_number), "--repo", repo, "--squash", "--delete-branch"],
@@ -950,6 +1108,9 @@ def run_bug_lane(
     # case returned above.
     return _declined(
         runner, repo, pr_number, decision.reason, working_dir,
-        evidence=_evidence_for(decision.reason, changed_files, diff_lines, limits),
+        evidence=_evidence_for(
+            decision.reason, changed_files, diff_lines, limits,
+            red_on_base_reason=red_on_base_reason,
+        ),
         dispatch_profile=_profile,
     )

specfuse_loop-0.27.0/specfuse/loop/data/VERSION

@@ -0,0 +1 @@
+0.27.0