specfuse-loop 0.22.2__tar.gz → 0.23.0__tar.gz

{specfuse_loop-0.22.2/specfuse_loop.egg-info → specfuse_loop-0.23.0}/PKG-INFO

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

{specfuse_loop-0.22.2 → specfuse_loop-0.23.0}/pyproject.toml

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

{specfuse_loop-0.22.2 → specfuse_loop-0.23.0}/specfuse/agent/providers/bugs.py

@@ -642,6 +642,23 @@ def _timed_out_payload(issue_number: int, elapsed_seconds: float) -> EscalationP
     )
 
 
+def _dispatch_profile_note(profile) -> str:
+    """` [dispatched opus/high via diagnosis:large]`, or empty (#3391).
+
+    Appended to every bug-lane item's `detail` so the run log states what each
+    item cost and why. The proposal's closing point was that without it the
+    effect of selecting a model by `fix_scope` is unmeasurable; a dial nobody
+    can evaluate is worse than no dial, because it looks like evidence.
+
+    Empty for a result carrying no profile, so a caller predating this reads
+    exactly as it did.
+    """
+    if not profile or len(profile) != 3:
+        return ""
+    model, effort, source = profile
+    return f" [dispatched {model}/{effort} via {source}]"
+
+
 class BugsProvider:
     """`ActionProvider` over the bug lane."""
 
@@ -727,6 +744,13 @@ class BugsProvider:
                 spend=0,
             )
 
+        # #3391: state which model this item was dispatched with and where
+        # that came from. Without this line nobody can tell afterwards whether
+        # selecting by `fix_scope` helped, which makes the dial unmeasurable
+        # and therefore unevaluable — the one point the proposal called out as
+        # mattering most.
+        profile_note = _dispatch_profile_note(result.dispatch_profile)
+
         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
@@ -734,7 +758,9 @@ class BugsProvider:
             # 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=result.reason or "", spend=0)
+            return ActionOutcome(
+                status=STATUS_COMPLETED,
+                detail=f"{result.reason or ''}{profile_note}", spend=0)
 
         detail = result.reason if result.reason is not None else result.outcome
 
@@ -796,7 +822,7 @@ class BugsProvider:
         # queue holds three feature-scoped issues, not that anything is broken.
         return ActionOutcome(
             status=STATUS_ESCALATED,
-            detail=detail,
+            detail=f"{detail}{profile_note}",
             escalation=escalation,
             environmental=not result.outcome_named,
         )

{specfuse_loop-0.22.2 → specfuse_loop-0.23.0}/specfuse/agent/severity_backfill.py

@@ -43,7 +43,7 @@ from specfuse.loop.labels import (
     severity_label_projection,
 )
 
-from specfuse.loop import triage
+from specfuse.loop import agent_policy, triage
 from specfuse.loop.build_provenance import warn_if_out_of_tree
 
 #: Stands in for T10's classification session (gate 3, walking skeleton).
@@ -105,6 +105,7 @@ def apply_severity_backfill(
             "number": number,
             "severity": severity,
             "skipped": False,
+            "severity_source": decision.get("severity_source", "classifier"),
         }
 
         new_body = triage.amend_marker_severity(body, severity)
@@ -121,6 +122,16 @@ def apply_severity_backfill(
             continue
         row["marker_written"] = True
 
+        if decision.get("severity_source") == "label":
+            # Reconciled (#3360): the label IS the source of this severity, so
+            # it is already on the issue. Writing one would at best re-apply
+            # what is there and at worst add a second spelling beside the
+            # person's, which is the collision this path exists to avoid.
+            row["label_written"] = False
+            row["label_skipped_reason"] = "severity read from the issue's own label"
+            results.append(row)
+            continue
+
         label = (label_projection or {}).get(
             severity, triage.severity_label_for(severity)
         )
@@ -206,6 +217,8 @@ def run_backfill(
             ),
         }
 
+    aliases = agent_policy.resolve_severity_aliases()
+
     rows = []
     decisions = []
     for issue in candidates:
@@ -213,6 +226,31 @@ def run_backfill(
         title = issue.get("title", "")
         body = issue.get("body") or ""
 
+        # The label is consulted BEFORE any classification session (#3360): an
+        # issue a person already labelled must have its marker written from
+        # that label, never from a fresh opinion about it. This also means a
+        # reconciled issue costs no `claude` invocation at all.
+        action, labelled_severity, reason = triage.severity_decision(
+            issue.get("labels"), aliases)
+
+        if action == triage.SEVERITY_SKIP:
+            rows.append({
+                "number": number, "classified": False, "severity": None,
+                "severity_source": "label", "skipped_reason": reason,
+            })
+            continue
+
+        if action == triage.SEVERITY_RECONCILE:
+            rows.append({
+                "number": number, "classified": True,
+                "severity": labelled_severity, "severity_source": "label",
+            })
+            decisions.append({
+                "number": number, "body": body,
+                "severity": labelled_severity, "severity_source": "label",
+            })
+            continue
+
         argv, prompt = build_invocation(
             number, title, body, repo, working_dir, model=model, effort=effort, rubric=rubric
         )
@@ -220,11 +258,14 @@ def run_backfill(
         severity = classify_severity(invoked.text, rubric)
 
         if severity is None:
-            rows.append({"number": number, "classified": False, "severity": None})
+            rows.append({"number": number, "classified": False, "severity": None,
+                         "severity_source": "classifier"})
             continue
 
-        rows.append({"number": number, "classified": True, "severity": severity})
-        decisions.append({"number": number, "body": body, "severity": severity})
+        rows.append({"number": number, "classified": True, "severity": severity,
+                     "severity_source": "classifier"})
+        decisions.append({"number": number, "body": body, "severity": severity,
+                          "severity_source": "classifier"})
 
     if apply and decisions:
         # A property of the repository's label set, not of any one issue
@@ -271,7 +312,19 @@ def _print_run_report(report: dict) -> None:
         return
     for row in report["rows"]:
         if not row["classified"]:
-            print(f"#{row['number']}: no usable classification, skipped")
+            # A refusal to overwrite a person is not a classification failure,
+            # and #3360's re-run condition is read off these lines: it asks for
+            # zero rows the run would contradict, which is unanswerable if both
+            # print the same sentence.
+            reason = row.get("skipped_reason")
+            if reason:
+                print(f"#{row['number']}: left alone — {reason}")
+            else:
+                print(f"#{row['number']}: no usable classification, skipped")
+            continue
+        if row.get("severity_source") == "label":
+            print(f"#{row['number']}: severity={row['severity']} "
+                  f"(reconciled from its own label, not classified)")
             continue
         print(f"#{row['number']}: severity={row['severity']}")
 

{specfuse_loop-0.22.2 → specfuse_loop-0.23.0}/specfuse/loop/agent_policy.py

@@ -335,6 +335,95 @@ def resolve_required_checks(path: "str | Path | None" = None) -> tuple:
     return tuple(str(n).strip() for n in raw if str(n).strip())
 
 
+#: What each `fix_scope` costs to dispatch, as `(model, effort)` (#3391).
+#:
+#: `small` is the historical default, so an issue diagnosed as a small fix is
+#: dispatched exactly as every bug was before this existed. `large` is the only
+#: entry that spends more: a fix whose direction has consequences is where a
+#: cheaper session produced coherent, wrong work.
+#:
+#: `external` deliberately keeps the cheap profile. The fix lives outside this
+#: repository, so the session's job is to recognise that and stop — paying for
+#: a stronger model to reach the same refusal buys nothing.
+DEFAULT_MODEL_BY_FIX_SCOPE = {
+    "small": ("sonnet", "medium"),
+    "large": ("opus", "high"),
+    "external": ("sonnet", "medium"),
+}
+
+
+def resolve_model_by_fix_scope(path: "str | Path | None" = None) -> dict:
+    """`rules.bugs.model_by_fix_scope` merged over `DEFAULT_MODEL_BY_FIX_SCOPE`.
+
+    A deployment chooses what each scope costs it: `large: [sonnet, high]` for
+    one that would rather not spend on Opus, and so on. Merged rather than
+    replaced, so naming one scope does not silently drop the others.
+
+    Every unusable value falls back to the shipped pair for that scope rather
+    than raising or disabling dispatch — an unreadable policy must not decide
+    that no bug can be worked on. An unknown scope name is ignored: it is a
+    typo, and inventing a profile for it would route nothing while looking
+    configured.
+    """
+    resolved = dict(DEFAULT_MODEL_BY_FIX_SCOPE)
+    try:
+        policy = load_policy(path)
+    except (FileNotFoundError, OSError):
+        return resolved
+    rules = policy.get("rules") if isinstance(policy, dict) else None
+    bugs = rules.get("bugs") if isinstance(rules, dict) else None
+    raw = bugs.get("model_by_fix_scope") if isinstance(bugs, dict) else None
+    if not isinstance(raw, dict):
+        return resolved
+    for scope, value in raw.items():
+        if scope not in resolved:
+            continue
+        if not isinstance(value, (list, tuple)) or len(value) != 2:
+            continue
+        model, effort = (str(v).strip() for v in value)
+        if model and effort:
+            resolved[scope] = (model, effort)
+    return resolved
+
+
+def resolve_require_red_on_base(path: "str | Path | None" = None) -> bool:
+    """`rules.bugs.require_red_on_base` — must a new test be proven red on the
+    merge base before the lane may merge unattended (#3377)?
+
+    `False` unless explicitly `true`. Defaulting on would decline every merge
+    for any deployment that has not also declared how to run the check, which
+    is a silent automerge shutdown rather than a guardrail — and the reason a
+    deployment turns this on is precisely to bring unattended merging *back*
+    on evidence.
+    """
+    try:
+        policy = load_policy(path)
+    except (FileNotFoundError, OSError):
+        return False
+    rules = policy.get("rules") if isinstance(policy, dict) else None
+    bugs = rules.get("bugs") if isinstance(rules, dict) else None
+    return (bugs.get("require_red_on_base") if isinstance(bugs, dict) else None) is True
+
+
+def resolve_red_on_base_command(path: "str | Path | None" = None) -> str:
+    """`rules.bugs.red_on_base_command` — the operator's own test command, with
+    a `{tests}` placeholder (#3377).
+
+    Empty when absent or unusable, which leaves the check unverifiable and so
+    declines the merge when it is required. That is deliberate: a guessed
+    command that silently matched no tests would exit non-zero, read as "red on
+    base", and wave every PR through — strictly worse than the gap it closes.
+    """
+    try:
+        policy = load_policy(path)
+    except (FileNotFoundError, OSError):
+        return ""
+    rules = policy.get("rules") if isinstance(policy, dict) else None
+    bugs = rules.get("bugs") if isinstance(rules, dict) else None
+    raw = bugs.get("red_on_base_command") if isinstance(bugs, dict) else None
+    return raw.strip() if isinstance(raw, str) else ""
+
+
 def resolve_max_open_prs(path: "str | Path | None" = None) -> "int | None":
     """`budgets.max_open_prs`, or None when unset or unusable (#3340).
 

{specfuse_loop-0.22.2 → specfuse_loop-0.23.0}/specfuse/loop/arm_eval.py

@@ -98,6 +98,7 @@ JUDGE_MODULES = tuple(
         "bug_lane.py",           # the merge-guardrail verdict
         "bug_lane_run.py",       # holds the single `gh pr merge` call site
         "bug_lane_state.py",     # the rolling merge cap a guardrail reads
+        "red_on_base.py",        # produces the red-on-base verdict a merge guardrail reads (#3377)
         "upgrade_merge_gate.py",  # the scaffold-upgrade merge gate
         # The dials, budgets and command sets a verdict is measured against.
         "agent_policy.py",       # automerge dial, diff/merge caps, test paths

{specfuse_loop-0.22.2 → specfuse_loop-0.23.0}/specfuse/loop/bug_lane.py

@@ -46,6 +46,15 @@ REASON_UNTRACEABLE = "untraceable_provenance"
 REASON_DAILY_CAP_REACHED = "daily_cap_reached"
 REASON_ELIGIBLE = "eligible"
 REASON_UNREADABLE_INPUT = "unreadable_input"
+#: The PR's own new test passed at the merge base, so it proves nothing about
+#: the fix — it asserts pre-existing behaviour, or tests something adjacent to
+#: the defect (#3377).
+REASON_TEST_NOT_RED_ON_BASE = "test_not_red_on_base"
+#: The red-on-base check was required and could not be run. Deliberately
+#: distinct from the reason above: "the check said no" and "the check never
+#: ran" are different situations with different fixes, and collapsing them is
+#: exactly how a guard comes to report clean because it could not look.
+REASON_RED_ON_BASE_UNVERIFIED = "red_on_base_unverified"
 
 # Public label names for the declining reasons (#1420). The REASON_* values above
 # are internal identifiers and must not double as labels: they are snake_case
@@ -66,6 +75,8 @@ DECLINE_LABELS = {
     REASON_DAILY_CAP_REACHED: "bug-lane:daily-cap-reached",
     REASON_UNREADABLE_INPUT: "bug-lane:unreadable-input",
     REASON_CI_PENDING: "bug-lane:ci-pending",
+    REASON_TEST_NOT_RED_ON_BASE: "bug-lane:test-not-red-on-base",
+    REASON_RED_ON_BASE_UNVERIFIED: "bug-lane:red-on-base-unverified",
 }
 
 PROVENANCE_KINDS = ("triaged_issue", "diagnosed_finding")
@@ -155,6 +166,11 @@ def evaluate_merge_guardrails(
     # as before #1418. An explicitly malformed value still fails closed —
     # omission means "use the default", not "skip the guardrail".
     test_paths: Any = (_TESTS_PREFIX,),
+    # #3377. Off by default: a deployment that has not declared how to run the
+    # check would otherwise have every merge declined on upgrade, which is a
+    # silent automerge shutdown rather than a guardrail.
+    require_red_on_base: Any = False,
+    red_on_base: Any = None,
     state_reader: MergeCapStateReader,
 ) -> MergeDecision:
     """Decide whether a bug-lane PR may auto-merge.
@@ -167,6 +183,25 @@ def evaluate_merge_guardrails(
     `state_reader` answers the rolling-24h merge-count question T03 owns the
     storage for. Any failure to evaluate an input returns
     `eligible=False`.
+
+    `red_on_base` is the one guardrail that measures whether the PR *works*
+    rather than what shape it has (#3377). Every other check here reads the
+    form of the diff; a PR can satisfy all of them and still not fix the thing
+    the issue reported. Audited on one consumer repository: seven lane PRs
+    passed all six form checks and four were incomplete for the issue they
+    claimed to close, two of them merging unattended and closing the issue
+    behind a symptom that still reproduced.
+
+    The caller runs the PR's own added test at the merge base and passes the
+    verdict here: `True` means it failed there (so it measures something the
+    fix changed), `False` means it passed there and therefore proves nothing.
+    Evaluated last, after every cheap check, because it is the only one whose
+    input costs a test run to produce.
+
+    Its limit, stated rather than implied: this catches "the test proves
+    nothing", not "the test proves the wrong thing". A test red on base for a
+    reason unrelated to the reported symptom still passes. Closing that needs
+    the issue to carry a machine-readable reproduction.
     """
     # The two checks that precede the CI read keep their own inline form, so
     # the CI check stays exactly where it was in the sequence and no declining
@@ -212,6 +247,15 @@ def evaluate_merge_guardrails(
     if merge_count >= max_merges:
         return _decline(REASON_DAILY_CAP_REACHED)
 
+    # Last, so the two test runs its input costs are only ever paid by a PR
+    # that has already cleared everything cheaper.
+    if require_red_on_base is True:
+        if red_on_base is True:
+            return MergeDecision(eligible=True, reason=REASON_ELIGIBLE)
+        if red_on_base is False:
+            return _decline(REASON_TEST_NOT_RED_ON_BASE)
+        return _decline(REASON_RED_ON_BASE_UNVERIFIED)
+
     return MergeDecision(eligible=True, reason=REASON_ELIGIBLE)
 
 

{specfuse_loop-0.22.2 → specfuse_loop-0.23.0}/specfuse/loop/bug_lane_run.py

@@ -31,6 +31,7 @@ failure -- leaves the PR open, optionally labelled with the declining reason.
 from __future__ import annotations
 
 import json
+import tempfile
 import re
 import time
 from dataclasses import dataclass
@@ -41,6 +42,9 @@ from specfuse.loop.agent_policy import (
     resolve_required_checks,
     bug_lane_limits,
     resolve_bug_automerge,
+    resolve_model_by_fix_scope,
+    resolve_require_red_on_base,
+    resolve_red_on_base_command,
 )
 from specfuse.loop.bug_lane import (
     DECLINE_LABELS,
@@ -53,7 +57,10 @@ from specfuse.loop.bug_lane import (
 )
 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.triage import parse_marker
+from specfuse.monitor.diagnosis import DiagnosisParseError
+from specfuse.monitor.diagnosis import parse as parse_diagnosis
 from specfuse.monitor.autofix_invoke import (
     build_invocation,
     classify_outcome,
@@ -84,6 +91,7 @@ CORRELATION_ID = "FEAT-2026-0048/T04"
 
 OUTCOME_REFUSED = "refused"
 OUTCOME_COULD_NOT_PROCEED = "could_not_proceed"
+OUTCOME_NEEDS_DECISION = "needs_decision"
 OUTCOME_MERGED = "merged"
 OUTCOME_DECLINED = "declined"
 
@@ -96,7 +104,12 @@ OUTCOME_DECLINED = "declined"
 #: when the guardrails had passed and the dial was the only thing in the way.
 OUTCOME_AUTOMERGE_OFF = "automerge_off"
 
-_ESCALATING_OUTCOMES = (OUTCOME_REFUSED, OUTCOME_COULD_NOT_PROCEED)
+#: `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).
+_ESCALATING_OUTCOMES = (
+    OUTCOME_REFUSED, OUTCOME_COULD_NOT_PROCEED, OUTCOME_NEEDS_DECISION,
+)
 
 _CI_UNKNOWN = "unknown"
 #: Checks exist but have not concluded yet -- internal to this module; never
@@ -149,6 +162,12 @@ class BugLaneResult:
     #: was throwing it away, so three refusals in one run were three
     #: identical escalations saying only which word came back.
     stop_rationale: str = ""
+    #: `(model, effort, source)` this issue was dispatched with, and where that
+    #: profile came from -- `diagnosis:<fix_scope>` or `default` (#3391).
+    #: Carried so a run can state it per item: without that line nobody can
+    #: tell afterwards whether selecting the model by scope helped, which
+    #: would make the dial unmeasurable and therefore unevaluable.
+    dispatch_profile: tuple = ()
     #: Whether the session actually named one of `OUTCOMES`, as opposed to
     #: `classify_outcome` failing closed to `could_not_proceed` for output
     #: naming none (#3343). Defaults True so a caller constructing a result by
@@ -658,6 +677,7 @@ def _declined(
     working_dir: str,
     *,
     evidence: tuple = (),
+    dispatch_profile: tuple = (),
 ) -> BugLaneResult:
     """Label the PR with *reason* (best-effort) and return the declined result."""
     # The public label name, never the raw reason constant (#1420): the
@@ -675,9 +695,102 @@ def _declined(
         pr_number=pr_number,
         label_written=label_written,
         evidence=evidence,
+        dispatch_profile=dispatch_profile,
     )
 
 
+def _merge_base_sha(runner: Callable, repo: str, pr_number: int) -> str:
+    """The commit the PR is measured against, or `""` (#3377).
+
+    `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.
+    """
+    try:
+        result = runner(
+            ["gh", "pr", "view", str(pr_number), "--repo", repo,
+             "--json", "baseRefOid"],
+            check=False,
+        )
+    except Exception:  # noqa: BLE001 - a lookup failure declines, never raises
+        return ""
+    if getattr(result, "returncode", 1) != 0 or not getattr(result, "stdout", None):
+        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 ""
+
+
+def dispatch_profile_for(
+    runner: Callable, repo: str, issue_number: int, policy_path: Any = None,
+) -> tuple:
+    """`(model, effort, source)` for one issue's `/fix-bug` dispatch (#3391).
+
+    Every bug was dispatched at `sonnet`/`medium` — `build_invocation`'s
+    defaults, never overridden — whether it was a one-line template fix or a
+    change whose direction has architectural consequences. Of seven bugs a run
+    dispatched, the two that produced correct fixes had issues already carrying
+    a diagnosis that named the file and the shape of the fix; the two closed on
+    review as wrong reported a symptom and left the fix location open.
+
+    The signal read here is `fix_scope`, from the `/diagnose-issue` comment
+    `specfuse.monitor.diagnosis.parse` recovers. That is deliberate: the
+    alternative proposal was an `effort=` field triage guesses from issue text
+    in about eight seconds, and effort is a property of the codebase rather
+    than of the report — the issue in that run that *read* as most mechanical
+    was the one whose correct fix required knowing where a seed value came
+    from. `fix_scope` rests on something a tool produced.
+
+    `source` names where the profile came from (`diagnosis:<scope>` or
+    `default`) so the run can say it. Without that line nobody can tell
+    afterwards whether the dial helped, which makes the whole change
+    unmeasurable.
+
+    Never raises. An unreadable issue, an absent diagnosis and a malformed
+    marker all resolve to the historical default, so this can only ever spend
+    more deliberately — never refuse to dispatch.
+    """
+    profiles = resolve_model_by_fix_scope(policy_path)
+    default = profiles["small"]
+    try:
+        result = runner(
+            ["gh", "issue", "view", str(issue_number), "--repo", repo,
+             "--json", "body,comments"],
+            check=False,
+        )
+    except Exception:  # noqa: BLE001 - a diagnostic read never stops a dispatch
+        return (*default, "default")
+    if getattr(result, "returncode", 1) != 0 or not getattr(result, "stdout", None):
+        return (*default, "default")
+    try:
+        payload = json.loads(result.stdout)
+    except ValueError:
+        return (*default, "default")
+    if not isinstance(payload, dict):
+        return (*default, "default")
+
+    bodies = [payload.get("body") or ""]
+    for comment in payload.get("comments") or []:
+        if isinstance(comment, dict):
+            bodies.append(comment.get("body") or "")
+
+    for body in bodies:
+        try:
+            diagnosis = parse_diagnosis(body)
+        except DiagnosisParseError:
+            continue
+        if diagnosis is None:
+            continue
+        scope = getattr(diagnosis, "fix_scope", None)
+        if scope in profiles:
+            return (*profiles[scope], f"diagnosis:{scope}")
+    return (*default, "default")
+
+
 def run_bug_lane(
     runner: Callable,
     repo: str,
@@ -700,7 +813,13 @@ 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.
     """
-    argv, prompt = build_invocation(issue_number, repo, working_dir)
+    model, effort, profile_source = dispatch_profile_for(
+        runner, repo, issue_number, policy_path
+    )
+    _profile = (model, effort, profile_source)
+    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 ""
     outcome = classify_outcome(session_output)
@@ -719,6 +838,7 @@ def run_bug_lane(
             unpushed_work=unpushed_work_for_issue(runner, issue_number),
             stop_rationale=extract_stop_rationale(session_output),
             outcome_named=outcome_was_named(session_output),
+            dispatch_profile=_profile
         )
 
     # The session's own account first (#3180) -- it never re-discovers what it
@@ -731,7 +851,9 @@ def run_bug_lane(
         pr_lookup_sleep(PR_LOOKUP_RETRY_SECONDS)
         pr_number = _find_pr_for_issue(runner, repo, issue_number)
     if pr_number is None:
-        return BugLaneResult(outcome=OUTCOME_DECLINED, reason=_REASON_PR_NOT_FOUND, pr_number=None)
+        return BugLaneResult(
+            outcome=OUTCOME_DECLINED, reason=_REASON_PR_NOT_FOUND,
+            pr_number=None, dispatch_profile=_profile)
 
     changed_files, diff_lines = _pr_changed_files_and_diff_lines(runner, repo, pr_number)
     limits = bug_lane_limits(policy_path)
@@ -755,6 +877,7 @@ def run_bug_lane(
             evidence=_evidence_for(
                 shape.reason, changed_files, diff_lines, limits,
             ),
+            dispatch_profile=_profile,
         )
 
     deadline_seconds = (
@@ -773,6 +896,21 @@ def run_bug_lane(
     )
     state_reader = GitHubMergeCapState(runner=runner, repo=repo, now=now)
 
+    # #3377: the only guardrail that asks whether the change works rather than
+    # what shape it has. Computed here and not inside the predicate, which
+    # stays pure — and only when the deployment asked for it, since it costs a
+    # test run.
+    require_red = resolve_require_red_on_base(policy_path)
+    red_on_base = None
+    if require_red:
+        red_on_base = test_was_red_on_base(
+            runner,
+            base_sha=_merge_base_sha(runner, repo, pr_number),
+            test_files=select_test_files(changed_files, limits["test_paths"]),
+            command_template=resolve_red_on_base_command(policy_path),
+            worktree_root=tempfile.gettempdir(),
+        )
+
     decision = evaluate_merge_guardrails(
         changed_files=changed_files,
         ci_conclusion=ci_conclusion,
@@ -781,6 +919,8 @@ def run_bug_lane(
         provenance=provenance,
         max_merges_per_day=limits["max_merges_per_day"],
         test_paths=limits["test_paths"],
+        require_red_on_base=require_red,
+        red_on_base=red_on_base,
         state_reader=state_reader,
     )
     dial = resolve_bug_automerge(policy_path)
@@ -791,7 +931,9 @@ def run_bug_lane(
             check=True,
         )
         record_merge(runner, repo, pr_number, at=time.time() if now is None else now)
-        return BugLaneResult(outcome=OUTCOME_MERGED, reason=decision.reason, pr_number=pr_number)
+        return BugLaneResult(
+            outcome=OUTCOME_MERGED, reason=decision.reason,
+            pr_number=pr_number, dispatch_profile=_profile)
 
     if decision.eligible:
         # Eligible but not merged: the dial is the only thing in the way, and
@@ -799,7 +941,8 @@ def run_bug_lane(
         # declining reason to project, and `DECLINE_LABELS` deliberately has no
         # entry for `REASON_ELIGIBLE`.
         return BugLaneResult(
-            outcome=OUTCOME_AUTOMERGE_OFF, reason=decision.reason, pr_number=pr_number
+            outcome=OUTCOME_AUTOMERGE_OFF, reason=decision.reason,
+            pr_number=pr_number, dispatch_profile=_profile,
         )
 
     # Reaching here means `decision.eligible` is False, so the reason is a real
@@ -808,4 +951,5 @@ def run_bug_lane(
     return _declined(
         runner, repo, pr_number, decision.reason, working_dir,
         evidence=_evidence_for(decision.reason, changed_files, diff_lines, limits),
+        dispatch_profile=_profile,
     )

specfuse_loop-0.23.0/specfuse/loop/data/VERSION

@@ -0,0 +1 @@
+0.23.0

{specfuse_loop-0.22.2 → specfuse_loop-0.23.0}/specfuse/loop/labels.py

@@ -199,6 +199,24 @@ LABEL_REGISTRY: tuple[LabelSpec, ...] = (
         ),
         consumer="loop/bug_lane_run.py",
     ),
+    LabelSpec(
+        name=bug_lane.DECLINE_LABELS[bug_lane.REASON_TEST_NOT_RED_ON_BASE],
+        colour="fbca04",
+        description=(
+            "Bug-lane auto-merge declined: the PR's new test passes at the "
+            "merge base, so it proves nothing about the fix"
+        ),
+        consumer="loop/bug_lane_run.py",
+    ),
+    LabelSpec(
+        name=bug_lane.DECLINE_LABELS[bug_lane.REASON_RED_ON_BASE_UNVERIFIED],
+        colour="fbca04",
+        description=(
+            "Bug-lane auto-merge declined: the red-on-base check was required "
+            "and could not be run; declare rules.bugs.red_on_base_command"
+        ),
+        consumer="loop/bug_lane_run.py",
+    ),
 )