specfuse-loop 0.28.2__tar.gz → 0.29.1__tar.gz

{specfuse_loop-0.28.2/specfuse_loop.egg-info → specfuse_loop-0.29.1}/PKG-INFO

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

{specfuse_loop-0.28.2 → specfuse_loop-0.29.1}/pyproject.toml

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

{specfuse_loop-0.28.2 → specfuse_loop-0.29.1}/specfuse/agent/diagnose_invoke.py

@@ -23,7 +23,7 @@ from __future__ import annotations
 
 from specfuse.agent.invoke import build_claude_argv
 from specfuse.monitor.diagnose_cli import AnalysisParseError, render_headless
-from specfuse.monitor.diagnosis import FIX_SCOPES
+from specfuse.monitor.diagnosis import FIX_SCOPES, SEVERITY_RUBRIC
 
 __all__ = ("AnalysisParseError", "build_invocation", "read_result")
 
@@ -69,7 +69,11 @@ def build_invocation(
         "partial evidence gets a low number.\n"
         f"- fix_scope: exactly one of {', '.join(FIX_SCOPES)} -- do not "
         "invent or default this value; if none plainly fits, say so in "
-        "candidate_fix and still pick the closest of the three.\n\n"
+        "candidate_fix and still pick the closest of the three.\n"
+        "- severity (optional): how serious the finding is, judged from its "
+        "evidence against this rubric; omit it if you cannot tell:\n"
+        + "".join(f"  - {line}\n" for line in SEVERITY_RUBRIC)
+        + "\n"
         "Do not post anything and do not run `gh issue comment` yourself; "
         "the caller renders and posts the diagnosis this session produces."
     )

{specfuse_loop-0.28.2 → specfuse_loop-0.29.1}/specfuse/agent/invoke.py

@@ -112,13 +112,24 @@ def _parse_envelope(raw: str) -> tuple:
     return result_text, (usage if usage else None)
 
 
+#: Every token field `budgets.max_tokens_per_run` is compared against (#3522).
+SPEND_TOKEN_FIELDS = (
+    "input_tokens",
+    "output_tokens",
+    "cache_read_input_tokens",
+    "cache_creation_input_tokens",
+)
+
+
 def usage_spend(usage: Optional[dict]) -> int:
-    """`spend` for `ActionOutcome`: input + output tokens, cache reads
-    excluded -- matching the driver's own cost line (`loop.py:7300-7302`).
+    """`spend` for `ActionOutcome`: all four usage token fields, cache reads
+    and cache creation included (#3522). With prompt caching nearly all of a
+    headless session's input is cache traffic, so leaving it out reported a
+    small fraction of the real volume and `max_tokens_per_run` never bound.
     Zero for a `None` usage, never a `KeyError`."""
     if not usage:
         return 0
-    return int(usage.get("input_tokens", 0)) + int(usage.get("output_tokens", 0))
+    return sum(int(usage.get(key, 0)) for key in SPEND_TOKEN_FIELDS)
 
 
 def run_claude(

{specfuse_loop-0.28.2 → specfuse_loop-0.29.1}/specfuse/agent/providers/findings_autofix.py

@@ -7,7 +7,8 @@ confidence threshold, `fix_scope` routing, fingerprint rate limit, and daily
 cap all stay in `specfuse.monitor.autofix`/`autofix_state`, read only
 through `run_autofix`.
 
-`advertise` returns one `kind="finding-autofix"` item per open snapshot
+`advertise` returns, most severe diagnosis first (stable within a severity),
+one `kind="finding-autofix"` item per open snapshot
 issue carrying `specfuse.monitor.issues.FINDING_LABEL` that already has a
 diagnosis comment -- the mirror of T10's filter, read the same way via
 `gh issue view N --json body,comments` and `specfuse.monitor.diagnosis.parse`.
@@ -63,6 +64,7 @@ from specfuse.monitor.issues import FINDING_LABEL
 
 _ITEM_ID_PREFIX = "finding-autofix-"
 _DEFAULT_MONITORING_CONFIG_PATH = ".specfuse/monitoring.yml"
+_SEVERITY_ORDER = ("critical", "high", "medium", "low")
 _FAILING_OUTCOMES = ("refused", "could_not_proceed")
 
 
@@ -91,6 +93,24 @@ def _has_diagnosis(comments: list) -> bool:
     return False
 
 
+def _latest_diagnosis(comments: list):
+    latest = None
+    for comment in comments or []:
+        body = comment.get("body", "") if isinstance(comment, dict) else ""
+        try:
+            diagnosis = parse(body)
+        except DiagnosisParseError:
+            continue
+        if diagnosis is not None:
+            latest = diagnosis
+    return latest
+
+
+def _severity_rank(diagnosis) -> int:
+    severity = diagnosis.severity if diagnosis is not None else None
+    return _SEVERITY_ORDER.index(severity) if severity in _SEVERITY_ORDER else len(_SEVERITY_ORDER)
+
+
 def _known_components(monitoring_config: Any) -> set:
     components = monitoring_config.get("components") if isinstance(monitoring_config, dict) else None
     if not isinstance(components, list):
@@ -171,6 +191,7 @@ class FindingsAutofixProvider:
         known_components = _known_components(monitoring_config)
 
         items = []
+        ranks = {}
         for issue in snapshot.issues:
             if FINDING_LABEL not in issue.labels:
                 continue
@@ -183,7 +204,8 @@ class FindingsAutofixProvider:
             if component is None or component not in known_components:
                 continue
 
-            if not _has_diagnosis(comments):
+            diagnosis = _latest_diagnosis(comments)
+            if diagnosis is None:
                 continue
 
             item_id = f"{_ITEM_ID_PREFIX}{issue.number}"
@@ -192,6 +214,7 @@ class FindingsAutofixProvider:
                 "component": component,
                 "monitoring_config": monitoring_config,
             }
+            ranks[item_id] = _severity_rank(diagnosis)
             items.append(
                 ActionItem(
                     item_id=item_id,
@@ -200,6 +223,7 @@ class FindingsAutofixProvider:
                     queue_key=None,
                 )
             )
+        items.sort(key=lambda item: ranks[item.item_id])
         return items
 
     def execute(self, item: ActionItem) -> ActionOutcome:

{specfuse_loop-0.28.2 → specfuse_loop-0.29.1}/specfuse/agent/providers/findings_diagnose.py

@@ -7,8 +7,9 @@
 `AgentSnapshot` cannot answer.
 
 `advertise` returns one `kind="finding-diagnose"` item per open snapshot
-issue carrying `specfuse.monitor.issues.FINDING_LABEL` that has no diagnosis
-comment yet. The snapshot's `IssueSummary` carries no body, so this
+issue carrying `specfuse.monitor.issues.FINDING_LABEL` that needs a diagnosis:
+none yet, a monitor reopen comment newer than its latest diagnosis, or the
+`rediagnose` label (#3487). The snapshot's `IssueSummary` carries no body, so this
 provider reads each candidate's body and comments itself with
 `gh issue view N --json body,comments` -- the same read
 `autofix_run._read_finding_issue` performs and the same softening of "the
@@ -25,8 +26,8 @@ The rendered comment body is `diagnosis.render`'s, unaltered -- this module
 holds no heading template and no marker string of its own. An unparseable
 analysis result posts nothing: `execute` escalates with the parse error's
 own message and never retries, defaults a field, or posts a partial body.
-This provider performs no git mutation and no label write of its own; a
-diagnosis is a comment.
+This provider performs no git mutation. Its only label write is the
+`severity:<value>` label of a diagnosis that carries a severity.
 """
 
 from __future__ import annotations
@@ -51,14 +52,16 @@ from specfuse.agent.run import (
     _default_runner,
 )
 from specfuse.agent.state import AgentSnapshot
+from specfuse.loop.agent_policy import SEVERITY_LABEL_PREFIX
 from specfuse.monitor.diagnosis import DiagnosisParseError, parse
-from specfuse.monitor.issues import FINDING_LABEL
+from specfuse.monitor.issues import FINDING_LABEL, REDIAGNOSE_LABEL, is_reopen_comment
 
 _ITEM_ID_PREFIX = "finding-diagnose-"
 _DEFAULT_MONITORING_CONFIG_PATH = ".specfuse/monitoring.yml"
 _DIAGNOSE_DIAL_AUTO = "auto"
 
 
+
 def _read_issue(runner: Callable, repo: str, issue_number: int) -> dict:
     result = runner(
         ["gh", "issue", "view", str(issue_number), "--repo", repo, "--json", "body,comments"],
@@ -73,15 +76,25 @@ def _read_issue(runner: Callable, repo: str, issue_number: int) -> dict:
     return parsed if isinstance(parsed, dict) else {}
 
 
-def _already_diagnosed(comments: list) -> bool:
-    for comment in comments or []:
+def _is_diagnosis(body: str) -> bool:
+    try:
+        return parse(body) is not None
+    except DiagnosisParseError:
+        return False
+
+
+def _needs_diagnosis(comments: list) -> bool:
+    """True when the finding has no diagnosis yet, or the monitor reopened it
+    after its latest diagnosis (#3487: a regression after a fix is diagnosed
+    again, once per reopen). `gh issue view` lists comments oldest first."""
+    last_diagnosis = last_reopen = -1
+    for index, comment in enumerate(comments or []):
         body = comment.get("body", "") if isinstance(comment, dict) else ""
-        try:
-            if parse(body) is not None:
-                return True
-        except DiagnosisParseError:
-            continue
-    return False
+        if _is_diagnosis(body):
+            last_diagnosis = index
+        elif is_reopen_comment(body):
+            last_reopen = index
+    return last_diagnosis < 0 or last_reopen > last_diagnosis
 
 
 def _unparseable_diagnosis_payload(number: int, error: str) -> EscalationPayload:
@@ -168,11 +181,15 @@ class FindingsDiagnoseProvider:
             if dial != _DIAGNOSE_DIAL_AUTO:
                 continue
 
-            if _already_diagnosed(comments):
+            relabelled = REDIAGNOSE_LABEL in issue.labels
+            if not relabelled and not _needs_diagnosis(comments):
                 continue
 
             item_id = f"{_ITEM_ID_PREFIX}{issue.number}"
-            self._rows[item_id] = {"number": issue.number, "title": issue.title, "body": body}
+            self._rows[item_id] = {
+                "number": issue.number, "title": issue.title, "body": body,
+                "relabelled": relabelled, "labels": tuple(issue.labels),
+            }
             items.append(
                 ActionItem(
                     item_id=item_id,
@@ -221,11 +238,59 @@ class FindingsDiagnoseProvider:
             ],
             check=False,
         )
+        self._label_severity(number, rendered, row.get("labels", ()))
+        if row.get("relabelled"):
+            # Consume the request so the next run does not diagnose again.
+            self._runner(
+                ["gh", "issue", "edit", str(number), "--repo", self._repo,
+                 "--remove-label", REDIAGNOSE_LABEL],
+                check=False,
+            )
         return ActionOutcome(
             status=STATUS_COMPLETED,
             detail=f"issue #{number} diagnosed",
             spend=spend,
         )
 
+    def _read_labels(self, number: int) -> set:
+        result = self._runner(
+            ["gh", "issue", "view", str(number), "--repo", self._repo, "--json", "labels"],
+            check=False,
+        )
+        if getattr(result, "returncode", 1) != 0 or not getattr(result, "stdout", None):
+            return set()
+        try:
+            parsed = json.loads(result.stdout)
+        except ValueError:
+            return set()
+        entries = parsed.get("labels") if isinstance(parsed, dict) else None
+        return {
+            e["name"] for e in entries or []
+            if isinstance(e, dict) and isinstance(e.get("name"), str)
+        }
+
+    def _label_severity(self, number: int, rendered: str, labels) -> None:
+        """Give the finding exactly one `severity:<value>` label, replacing any
+        previous one. No severity on the diagnosis, no label write."""
+        diagnosis = parse(rendered)
+        severity = diagnosis.severity if diagnosis is not None else None
+        if severity is None:
+            return
+        wanted = f"{SEVERITY_LABEL_PREFIX}{severity}"
+        self._runner(
+            ["gh", "label", "create", wanted, "--force", "--repo", self._repo],
+            check=False,
+        )
+        current = set(labels) | self._read_labels(number)
+        stale = [
+            label for label in sorted(current)
+            if label.startswith(SEVERITY_LABEL_PREFIX) and label != wanted
+        ]
+        argv = ["gh", "issue", "edit", str(number), "--repo", self._repo]
+        for label in stale:
+            argv += ["--remove-label", label]
+        argv += ["--add-label", wanted]
+        self._runner(argv, check=False)
+
     def reconcile(self, item: ActionItem, outcome: ActionOutcome) -> None:
         return None

{specfuse_loop-0.28.2 → specfuse_loop-0.29.1}/specfuse/agent/providers/triage.py

@@ -303,7 +303,8 @@ class TriageProvider:
 
         rubric = self._rubric_for_run()
         argv, prompt = build_invocation(
-            number, title, body, self._repo, self._working_dir, rubric=rubric
+            number, title, body, self._repo, self._working_dir, rubric=rubric,
+            comments=row.get("comments") or [],
         )
         invoked = run_claude(argv, prompt, runner=self._runner)
         spend = usage_spend(invoked.usage)
@@ -368,6 +369,9 @@ class TriageProvider:
                 "category": category,
                 "confidence": confidence,
                 "severity": severity,
+                # #3521: without the issue's labels `apply_triage` cannot see
+                # a person's `severity:*` label, and adds a second one beside it.
+                "labels": row.get("labels") or [],
             }
         ]
         results = apply_triage(
@@ -391,11 +395,14 @@ class TriageProvider:
                 spend=spend,
             )
 
-        return ActionOutcome(
-            status=STATUS_COMPLETED,
-            detail=f"issue #{number} triaged as {row_result.get('category')}",
-            spend=spend,
-        )
+        detail = f"issue #{number} triaged as {row_result.get('category')}"
+        if row_result.get("severity_conflict"):
+            detail += (
+                f"; severity label left as "
+                f"{', '.join(row_result['severity_conflict'])} "
+                f"(triage judged {severity})"
+            )
+        return ActionOutcome(status=STATUS_COMPLETED, detail=detail, spend=spend)
 
     def reconcile(self, item: ActionItem, outcome: ActionOutcome) -> None:
         return None

{specfuse_loop-0.28.2 → specfuse_loop-0.29.1}/specfuse/agent/run.py

@@ -62,6 +62,7 @@ from specfuse.loop.build_provenance import warn_if_out_of_tree
 from specfuse.loop.escalation import (
     CREATED_NUMBER_UNKNOWN,
     annotate_escalation,
+    clear_closed_escalation_labels,
     emit_escalation,
 )
 
@@ -198,8 +199,8 @@ class ActionOutcome:
     `spend` is real tokens, not a proxy — a provider that dispatches a
     headless `claude` session reports it through
     `specfuse.agent.invoke.usage_spend(invoke_result.usage)`
-    (FEAT-2026-0108/T01): input plus output tokens, cache reads excluded, so
-    it lines up with the driver's own cost line. It defaults to zero so a
+    (FEAT-2026-0108/T01): all four usage token fields, cache reads and cache
+    creation included (#3522). It defaults to zero so a
     provider that dispatches nothing, or whose session reported no usage
     envelope, leaves the run's total spend untouched. `escalation`, when set
     on a `STATUS_ESCALATED` outcome, is recorded — on `target_issue` when the
@@ -299,6 +300,10 @@ class RunSummary:
     #: re-run, because a triage-only run otherwise looks like a bug lane that
     #: declined everything.
     newly_triaged_bugs_undispatched: tuple = ()
+    #: `(number, reason)` for bugs this run triaged that the severity floor
+    #: holds back (#3521). Kept apart from the re-run list above: a re-run
+    #: would not dispatch them either, so the summary names the floor instead.
+    newly_triaged_bugs_below_floor: tuple = ()
 
 
 def _bug_marked_numbers(snapshot: AgentSnapshot) -> set:
@@ -306,6 +311,30 @@ def _bug_marked_numbers(snapshot: AgentSnapshot) -> set:
     return {issue.number for issue in snapshot.issues if issue.triage_category == "bug"}
 
 
+def _split_by_severity_floor(numbers, snapshot: AgentSnapshot,
+                             policy_path: Optional[str]) -> tuple:
+    """`(re-runnable, [(number, reason), ...])` for bugs triaged and never
+    dispatched (#3521).
+
+    Reads the floor exactly as `BugsProvider.advertise` does, so a bug this
+    returns as held back is one the next run's lane would skip too -- telling
+    the operator to re-run for it was a promise the lane would not keep.
+    """
+    floor = agent_policy.resolve_min_severity(policy_path)
+    aliases = agent_policy.resolve_severity_aliases(policy_path)
+    labels_by_number = {issue.number: issue.labels for issue in snapshot.issues}
+    rerun, held = [], []
+    for number in numbers:
+        severity, via = agent_policy.read_severity_label(
+            labels_by_number.get(number), aliases)
+        ok, why = agent_policy.meets_severity_floor(severity, floor, via=via)
+        if ok:
+            rerun.append(number)
+        else:
+            held.append((number, why))
+    return rerun, held
+
+
 def _refresh_snapshot(
     previous: AgentSnapshot,
     *,
@@ -838,6 +867,13 @@ def run_agent(
             policy_path=policy_path,
             features_root=features_root,
         )
+        # #3523: a closed issue keeps no escalation labels the lane wrote.
+        cleared = clear_closed_escalation_labels(runner, repo)
+        if cleared:
+            report(
+                "cleared needs-human from closed escalated issue(s): "
+                + ", ".join(f"#{number}" for number in cleared)
+            )
         bugs_preempt = _resolve_bugs_preempt(policy_path)
         report(
             f"snapshot: {len(snapshot.issues)} open issues, "
@@ -1179,6 +1215,10 @@ def run_agent(
             for number in _bug_marked_numbers(snapshot) - bugs_marked_at_start
             if f"bug-{number}" not in handled_ids
         )
+        newly_triaged, below_floor = _split_by_severity_floor(
+            newly_triaged, snapshot, policy_path)
+        for number, why in below_floor:
+            report(f"#{number} newly triaged as bug, not dispatched — {why}")
         if newly_triaged:
             report(
                 f"{len(newly_triaged)} issue(s) newly triaged as bug and not "
@@ -1200,6 +1240,7 @@ def run_agent(
             escalations=tuple(escalations),
             wip_refs=tuple(wip_refs),
             newly_triaged_bugs_undispatched=tuple(newly_triaged),
+            newly_triaged_bugs_below_floor=tuple(below_floor),
         )
     finally:
         lock_fd.close()
@@ -1229,6 +1270,8 @@ def _format_summary(summary: RunSummary) -> str:
             f"    {len(summary.newly_triaged_bugs_undispatched)} newly triaged "
             f"as bug, not dispatched — re-run to fix them: {numbers}"
         )
+    for number, why in summary.newly_triaged_bugs_below_floor:
+        lines.append(f"    #{number} newly triaged as bug, not dispatched — {why}")
     return "\n".join(lines)
 
 

{specfuse_loop-0.28.2 → specfuse_loop-0.29.1}/specfuse/agent/triage_invoke.py

@@ -47,6 +47,7 @@ def build_invocation(
     model: str = "sonnet",
     effort: str = "medium",
     rubric: Optional[dict] = None,
+    comments: Optional[list] = None,
 ):
     """Build argv and prompt text for a headless triage-classification
     session against one issue. Returns a `(argv, prompt)` tuple; runs
@@ -60,6 +61,12 @@ def build_invocation(
     session -- and the marker instruction grows a third `severity=` field.
     The prompt is built from `rubric`'s own mapping alone; it holds no copy
     of any shipped default definitions.
+
+    `comments` is the issue's comment list as `gh issue list --json comments`
+    returns it (#3520): a maintainer often routes an issue -- folds it into a
+    feature, marks it a duplicate -- in a comment, and a classifier reading
+    the body alone labels it `bug` anyway. No comments leaves the prompt
+    byte-identical to the one built without them.
     """
     argv = build_claude_argv(model, effort)
     if rubric:
@@ -88,6 +95,7 @@ def build_invocation(
         f"Issue number: {issue_number}\n"
         f"Issue title: {title}\n\n"
         f"Issue body:\n{body}\n\n"
+        f"{_comments_block(comments)}"
         "Classify this issue into exactly one of the categories: "
         f"{', '.join(CATEGORIES)}.\n\n"
         f"{marker_instruction}"
@@ -95,6 +103,23 @@ def build_invocation(
     return argv, prompt
 
 
+def _comments_block(comments: Optional[list]) -> str:
+    if not comments:
+        return ""
+    rendered = []
+    for comment in comments:
+        author = (comment.get("author") or {}).get("login") or "unknown"
+        association = comment.get("authorAssociation") or "NONE"
+        rendered.append(f"--- @{author} ({association}):\n{comment.get('body') or ''}")
+    return (
+        "Issue comments, oldest first:\n"
+        + "\n\n".join(rendered)
+        + "\n\nIf a maintainer comment already routes this issue -- folds it "
+        "into a feature or another issue, or marks it a duplicate -- classify "
+        "it by that decision, not by the body alone.\n\n"
+    )
+
+
 def classify_result(result_text: str) -> Optional[tuple]:
     """Return the `(category, confidence)` pair a classification session's
     output names, or `None` if the output carries no parseable triage

specfuse_loop-0.29.1/specfuse/loop/data/VERSION

@@ -0,0 +1 @@
+0.29.1