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

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

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

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

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

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

@@ -37,7 +37,11 @@ from typing import Callable, Optional
 
 from specfuse.agent.invoke import run_claude
 from specfuse.agent.triage_invoke import build_invocation, classify_severity
-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 import triage
 from specfuse.loop.build_provenance import warn_if_out_of_tree
@@ -50,7 +54,13 @@ def _default_runner(argv: list, check: bool = False):
     return subprocess.run(argv, check=check, capture_output=True, text=True)
 
 
-def apply_severity_backfill(runner: Callable, repo: str, decisions: list) -> list:
+def apply_severity_backfill(
+    runner: Callable,
+    repo: str,
+    decisions: list,
+    *,
+    label_projection: "dict | None" = None,
+) -> list:
     """Record each decision in `decisions` against its GitHub issue, marker
     first, label second.
 
@@ -65,6 +75,13 @@ def apply_severity_backfill(runner: Callable, repo: str, decisions: list) -> lis
     amended marker in place -- the marker is the authoritative record, the
     label a projection re-derived from it (`PLAN.md`'s "Record
     precedence").
+
+    `label_projection` maps a vocabulary value to the label this repository
+    spells it with (`labels.severity_label_projection`, #3353). The marker
+    always records the vocabulary value, so it stays comparable across
+    repositories; only the label takes the operator's own word. Absent or
+    missing a value, the vocabulary label is written -- the behaviour before
+    the projection existed.
     """
     results = []
     for decision in decisions:
@@ -104,7 +121,9 @@ def apply_severity_backfill(runner: Callable, repo: str, decisions: list) -> lis
             continue
         row["marker_written"] = True
 
-        label = triage.severity_label_for(severity)
+        label = (label_projection or {}).get(
+            severity, triage.severity_label_for(severity)
+        )
         try:
             runner(
                 ["gh", "issue", "edit", str(number), "--repo", repo, "--add-label", label],
@@ -156,7 +175,14 @@ def run_backfill(
     once `apply_severity_backfill` has run over it, that function's own
     `skipped`/`marker_written`/`label_written` fields.
     """
-    rubric = read_severity_rubric(working_dir, runner=runner, repo=repo)
+    # One `gh label list` feeds both the rubric and the write-side
+    # projection (#3353): the once-per-run listing this run is asserted on.
+    existing, _listing_reason = list_existing_labels(
+        working_dir, runner=runner, repo=repo
+    )
+    rubric = read_severity_rubric(
+        working_dir, runner=runner, repo=repo, existing=existing
+    )
     if not rubric:
         return {
             "rubric": {},
@@ -201,7 +227,14 @@ def run_backfill(
         decisions.append({"number": number, "body": body, "severity": severity})
 
     if apply and decisions:
-        write_results = apply_severity_backfill(runner, repo, decisions)
+        # A property of the repository's label set, not of any one issue
+        # (#3353) -- derived from the listing already read above.
+        projection = severity_label_projection(
+            [item.get("name", "") for item in (existing or [])]
+        )
+        write_results = apply_severity_backfill(
+            runner, repo, decisions, label_projection=projection
+        )
         by_number = {result["number"]: result for result in write_results}
         for row in rows:
             result = by_number.get(row["number"])

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

@@ -363,10 +363,21 @@ def describe_budget_sources(**caps) -> str:
     that is not capped: the operator cannot tell which of the two they have.
     Each value is a `(value, source)` pair, source being `flag`, `policy` or
     `none`.
+
+    `max_items` carries an explicit `per run` (#3340). The policy key it comes
+    from is named `max_items_per_day` and is applied per run -- enforcing it
+    across a day needs state that survives a process. Printing `max_items=62
+    (policy)` against that key invites the reading the name suggests, and the
+    wrong reading is the unsafe one: a day of runs can exceed the number the
+    operator believes they set. Only this cap is annotated, because only this
+    one has a name promising something wider than it delivers; an unset cap
+    prints `unbounded` and needs no qualifier.
     """
     parts = []
     for name, (value, source) in sorted(caps.items()):
-        parts.append(f"{name}={'unbounded' if value is None else value} ({source})")
+        rendered = "unbounded" if value is None else str(value)
+        qualifier = " per run" if name == "max_items" and value is not None else ""
+        parts.append(f"{name}={rendered} ({source}{qualifier})")
     return "budgets: " + ", ".join(parts)
 
 

specfuse_loop-0.22.2/specfuse/loop/data/VERSION

@@ -0,0 +1 @@
+0.22.2

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

@@ -402,11 +402,75 @@ def _ensure_severity_labels(target, *, runner, repo=None) -> list:
     return failed
 
 
+def severity_label_projection(label_names, *, aliases: Optional[dict] = None) -> dict:
+    """`{severity_value: label_name}` for the values a repository spells in its
+    own word (#3353), given the `severity:*` labels it defines.
+
+    `severity_aliases` (#3349) are honoured by the `min_severity` floor, which
+    reads an aliased label through `read_severity_label`. The classifier
+    FEAT-2026-0113 added answers in the published vocabulary instead, so the
+    write path projected `severity:high` at a repository whose issues all say
+    `severity:major` -- both spellings in circulation, and nothing reporting
+    the asymmetry.
+
+    This is the write-side half. The classifier is deliberately left answering
+    in the vocabulary so the marker's `severity=` field stays comparable across
+    repositories; only the *label* takes the repository's own word.
+
+    Pure over *label_names* rather than listing them itself, so the one caller
+    that needs both this and `read_severity_rubric` pays for a single
+    `gh label list` -- the once-per-run listing that run is asserted on.
+
+    Entries appear only where the projection actually differs, so an empty
+    result means "write the vocabulary label" and callers need no special case.
+    Two bounds keep it honest:
+
+    * **A label the repository does not define is never projected.** The
+      shipped `DEFAULT_SEVERITY_ALIASES` name words (`blocker`, `urgent`,
+      `trivial`) most repositories have never created; projecting one would
+      write a label that does not exist.
+    * **An in-vocabulary label always wins.** A repository defining both
+      `severity:high` and `severity:major` gets no entry for `high` -- the same
+      precedence `read_severity_rubric` applies when it builds the rubric.
+
+    Two aliases onto one value is the operator's own ambiguity. The lowest
+    label name sorts first, so a run is at least reproducible; defining the
+    vocabulary label is what removes the ambiguity.
+    """
+    prefix = agent_policy.SEVERITY_LABEL_PREFIX
+    try:
+        severity_names = sorted(
+            name for name in label_names if name.startswith(prefix)
+        )
+    except TypeError:
+        return {}
+
+    in_vocabulary = {
+        name[len(prefix):] for name in severity_names
+        if name[len(prefix):] in agent_policy.SEVERITY_VALUES
+    }
+
+    aliases = aliases if aliases is not None else agent_policy.resolve_severity_aliases()
+    projection: dict = {}
+    for name in severity_names:
+        word = name[len(prefix):]
+        if word in agent_policy.SEVERITY_VALUES:
+            continue
+        mapped = aliases.get(word.strip().lower())
+        if mapped not in agent_policy.SEVERITY_VALUES:
+            continue
+        if mapped in in_vocabulary or mapped in projection:
+            continue
+        projection[mapped] = name
+    return projection
+
+
 def read_severity_rubric(
     target: str | Path,
     *,
     runner: Optional[Callable] = None,
     repo: Optional[str] = None,
+    existing: Optional[list] = None,
 ) -> dict:
     """`{severity_value: description}` from the repo's own `severity:*` labels,
     or specfuse's `DEFAULT_SEVERITY_RUBRIC` when it has defined none (#3352).
@@ -428,7 +492,11 @@ def read_severity_rubric(
     """
     runner = runner if runner is not None else _default_runner
 
-    existing, _reason = list_existing_labels(target, runner=runner, repo=repo)
+    # `existing` lets a caller that already listed the repository's labels pass
+    # them in rather than pay for a second `gh label list` (#3353). Absent, the
+    # listing happens here exactly as it always did.
+    if existing is None:
+        existing, _reason = list_existing_labels(target, runner=runner, repo=repo)
     if existing is None:
         return {}
 

{specfuse_loop-0.22.1 → specfuse_loop-0.22.2}/specfuse/loop/loop.py

@@ -125,7 +125,7 @@ SPECFUSE_DIR = Path(".specfuse")
 REPO_ROOT = SPECFUSE_DIR.parent
 FEATURES_DIR = SPECFUSE_DIR / "features"
 VERIFICATION_PATH = SPECFUSE_DIR / "verification.yml"
-DRIVER_VERSION = "0.22.1"
+DRIVER_VERSION = "0.22.2"
 # 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

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

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

{specfuse_loop-0.22.1 → specfuse_loop-0.22.2}/specfuse_loop.egg-info/SOURCES.txt

@@ -367,6 +367,7 @@ tests/test_heartbeat.py
 tests/test_heartbeat_adapter.py
 tests/test_human_output_rule.py
 tests/test_human_work_unit.py
+tests/test_hygiene_boundary_guidance.py
 tests/test_hyphenated_gate_name.py
 tests/test_init_integration.py
 tests/test_installed_copy_driver_e2e.py
@@ -469,6 +470,7 @@ tests/test_notify_sla.py
 tests/test_operator_escalation_rule.py
 tests/test_oracle_set_declared.py
 tests/test_oracle_unrunnable_attribution.py
+tests/test_per_run_item_cap_disclosure.py
 tests/test_pick_feature_skill.py
 tests/test_pin_honesty_and_integrity.py
 tests/test_pin_marker_not_inherited.py
@@ -476,6 +478,7 @@ tests/test_pin_marker_spawn_sites.py
 tests/test_plan_baseline.py
 tests/test_planned_cost_lint.py
 tests/test_planning_cost_floor.py
+tests/test_plugin_prose_cross_refs.py
 tests/test_plugin_qualified_dispatch.py
 tests/test_policy_budgets_applied.py
 tests/test_policy_proposals.py
@@ -554,6 +557,7 @@ tests/test_severity_backfill_end_to_end.py
 tests/test_severity_backfill_limit.py
 tests/test_severity_backfill_marker.py
 tests/test_severity_backfill_run.py
+tests/test_severity_label_projection.py
 tests/test_severity_rubric.py
 tests/test_shipped_templates_parse.py
 tests/test_skill_discovery_links.py

specfuse_loop-0.22.2/tests/test_hygiene_boundary_guidance.py

@@ -0,0 +1,88 @@
+# Copyright 2026 Specfuse Contributors
+# Licensed under the Apache License, Version 2.0. See LICENSE.
+"""The authoring rule teaches the reword the lint asks for (#3357).
+
+`lint_plan` WARNs when a work unit declares a `produces:` path that also matches
+one of its own Do-not-touch patterns, and since #3357 that warning names the
+fix: reword the boundary to name the *surfaces* it protects rather than the file
+this unit also produces.
+
+The shape that trips it is not an edge case. A hygiene unit exists to make a
+bounded fix inside a file a previous unit built, so it has to declare that file
+in `produces:` *and* protect almost all of it — and §7 of the authoring skill,
+which is where an author is told how to write a hygiene unit, said to name the
+broken file in `produces:` without saying anything about how to word the
+boundary. The author met the warning with no guidance in the rule that
+generated the shape.
+
+Worse than unhelpful: FEAT-2026-0113's `T08H` wrote "every other function in
+`specfuse/loop/triage.py`", which read literally forbids editing the one
+function that unit existed to fix. It passed only because the acceptance
+criteria named the target unambiguously, so the boundary and the criteria
+contradicted each other and only the criteria were load-bearing.
+
+This guards the pairing rather than the prose: whatever wording either side
+uses, the authoring rule must teach surface-naming, so the lint's recommended
+fix and the rule that produces the shape cannot drift apart again.
+"""
+
+from __future__ import annotations
+
+import re
+import unittest
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+SKILL = REPO_ROOT / "plugins/specfuse/skills/authoring-work-units/SKILL.md"
+MIRROR = REPO_ROOT / ".specfuse/skills/authoring-work-units/SKILL.md"
+LINT = REPO_ROOT / "specfuse/loop/lint_plan.py"
+
+
+def _section_7(text: str) -> str:
+    """§7, the hygiene-work-unit section, up to the next top-level heading."""
+    match = re.search(r"^## 7\. .*?$(.*?)(?=^## \d+\. )", text, re.S | re.M)
+    assert match, "authoring skill has no '## 7.' section"
+    return match.group(1)
+
+
+class HygieneBoundaryGuidance(unittest.TestCase):
+
+    def test_the_lint_still_recommends_naming_surfaces(self):
+        # If this fails the lint changed its advice, and the rule below is
+        # now teaching the wrong reword rather than merely a stale one.
+        self.assertIn("surfaces it protects", LINT.read_text(encoding="utf-8"))
+
+    def test_section_7_tells_the_author_how_to_word_the_boundary(self):
+        body = _section_7(SKILL.read_text(encoding="utf-8"))
+
+        self.assertIn(
+            "surface", body.lower(),
+            "§7 tells an author to put the broken file in `produces:`, which is "
+            "exactly the shape that trips the Do-not-touch collision warning. "
+            "It must also tell them to word the boundary by naming the "
+            "surfaces it protects, or the rule generates a warning it gives no "
+            "way to answer (#3357).",
+        )
+
+    def test_section_7_warns_against_the_whole_file_wording(self):
+        body = _section_7(SKILL.read_text(encoding="utf-8")).lower()
+
+        self.assertTrue(
+            "every other function in" in body or "whole file" in body,
+            "§7 must show the wording that actually went wrong — a boundary "
+            "phrased over a whole file contradicts the criteria of a unit that "
+            "exists to edit one function in it (FEAT-2026-0113/T08H).",
+        )
+
+    def test_the_mirrored_copy_agrees(self):
+        # plugins/ is canonical; .specfuse/ is the synced scaffold copy.
+        self.assertEqual(
+            SKILL.read_text(encoding="utf-8"),
+            MIRROR.read_text(encoding="utf-8"),
+            "plugins/ and .specfuse/ copies of the authoring skill diverged — "
+            "run scripts/sync-scaffold.sh",
+        )
+
+
+if __name__ == "__main__":  # pragma: no cover
+    unittest.main()

specfuse_loop-0.22.2/tests/test_per_run_item_cap_disclosure.py

@@ -0,0 +1,80 @@
+# Copyright 2026 Specfuse Contributors
+# Licensed under the Apache License, Version 2.0. See LICENSE.
+"""`max_items_per_day` is enforced per run, and now says so (#3340).
+
+Most of #3340 landed: budgets resolve from the policy when no flag is given,
+`max_open_prs` gates bug-lane dispatch, and the run opens with a line naming
+each effective cap and its source.
+
+One expectation was left. The policy key is named `max_items_per_day` and is
+applied *per run* -- enforcing it across runs within a day needs state that
+survives a process, which is a feature, not this fix. `resolve_max_items`
+records that honestly in its docstring, but a docstring is not a surface an
+operator reads. The issue offered the alternative explicitly: enforce it across
+runs, **or** document it as per-run.
+
+So the operator-facing surfaces carry it. A run that prints `max_items=62
+(policy)` against a policy whose key says `per_day` invites exactly the wrong
+reading -- and the wrong reading is the unsafe one, since a day of runs can
+exceed the number the operator believes they set.
+"""
+
+from __future__ import annotations
+
+import unittest
+from pathlib import Path
+
+from specfuse.loop import agent_policy
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+SKILL = REPO_ROOT / "plugins/specfuse/skills/derive-agent-policy/SKILL.md"
+
+
+class PerRunItemCapDisclosure(unittest.TestCase):
+
+    def test_the_run_line_says_the_item_cap_is_per_run(self):
+        line = agent_policy.describe_budget_sources(
+            max_items=(62, "policy"),
+            max_tokens=(2800000, "policy"),
+            max_minutes=(None, "none"),
+        )
+
+        self.assertIn("per run", line)
+
+    def test_a_flag_sourced_item_cap_says_it_too(self):
+        # The cap is per-run whoever set it; the policy key's name is what
+        # misleads, but a flag run is bounded the same way.
+        line = agent_policy.describe_budget_sources(max_items=(5, "flag"))
+
+        self.assertIn("per run", line)
+
+    def test_other_caps_are_not_annotated(self):
+        # Only the item cap has a name that promises something wider than it
+        # delivers. Annotating the rest would be noise.
+        line = agent_policy.describe_budget_sources(
+            max_tokens=(2800000, "policy"),
+            max_open_prs=(3, "policy"),
+        )
+
+        self.assertNotIn("per run", line)
+
+    def test_an_absent_item_cap_is_not_annotated(self):
+        line = agent_policy.describe_budget_sources(max_items=(None, "none"))
+
+        self.assertIn("unbounded", line)
+        self.assertNotIn("per run", line)
+
+    def test_the_drafting_skill_discloses_the_semantics(self):
+        body = SKILL.read_text(encoding="utf-8")
+
+        self.assertIn(
+            "per run", body,
+            "/derive-agent-policy drafts `max_items_per_day` into an "
+            "operator's policy file. It must say that the key is applied per "
+            "run, or the operator writes a number believing it bounds a day "
+            "(#3340).",
+        )
+
+
+if __name__ == "__main__":  # pragma: no cover
+    unittest.main()

specfuse_loop-0.22.2/tests/test_plugin_prose_cross_refs.py

@@ -0,0 +1,80 @@
+#
+# Copyright 2026 Specfuse Contributors
+# Licensed under the Apache License, Version 2.0. See LICENSE.
+#
+"""Published prose cross-references this project only (#3378).
+
+Two surfaces are published content: everything under ``plugins/``, which ships
+in a ``specfuse-loop`` release, is mirrored into the umbrella marketplace repo
+and lands in every consumer's checkout when they install the plugin; and
+``CHANGELOG.md``, which ships in the pip package. Both are a far wider surface
+than the commit bodies, PR bodies, roadmap prose and ``events.jsonl`` notes the
+leak-scan discipline already guards.
+
+The failure this guards against is #3378: ``fix-bug/SKILL.md`` cited a real
+downstream consumer's ``org/repo#issue`` while explaining the ``Closes #<n>``
+rule, and the 0.22.1 changelog entry describing that same fix cited it again.
+Both shipped before anyone noticed.
+
+`leak_scan` could not catch it and still cannot. A bare ``org/repo#n`` token is
+indistinguishable from the many legitimate ``specfuse/loop#NNNN``
+cross-references the same prose uses, and the denylist is the wrong instrument
+here for a sharper reason: the consumer's name legitimately appears in
+``.specfuse/agent-policy.yml`` (it is the repo the bug lane is pointed at) and
+in this repo's own tests. A denylist entry cannot tell published prose from
+local configuration, so adding one would red the whole repository rather than
+the one file that was actually wrong.
+
+So the invariant is scoped to the published surfaces instead, and stated
+positively: prose under ``plugins/`` and in ``CHANGELOG.md`` may cross-reference
+this project's own repositories and nothing else. Any other ``org/repo#n`` is someone else's
+identity riding out in our release.
+"""
+
+from __future__ import annotations
+
+import re
+import unittest
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+PLUGINS_DIR = REPO_ROOT / "plugins"
+CHANGELOG = REPO_ROOT / "CHANGELOG.md"
+
+# `owner/repo#123`. Deliberately broad on the owner/repo halves: the point is to
+# catch an owner we have never seen, so the pattern cannot enumerate them.
+CROSS_REF_RE = re.compile(r"\b([A-Za-z0-9][A-Za-z0-9._-]*)/([A-Za-z0-9._-]+)#\d+")
+
+# The only owner published prose may name. This project's own repositories are
+# the ones a reader of a shipped skill can be expected to follow.
+ALLOWED_OWNERS = frozenset({"specfuse"})
+
+
+class PluginProseCrossRefs(unittest.TestCase):
+
+    def test_published_prose_references_only_this_project(self):
+        offenders = []
+        published = sorted(PLUGINS_DIR.rglob("*.md")) + [CHANGELOG]
+        for path in published:
+            for lineno, line in enumerate(
+                path.read_text(encoding="utf-8").splitlines(), start=1
+            ):
+                for owner, repo in CROSS_REF_RE.findall(line):
+                    if owner not in ALLOWED_OWNERS:
+                        rel = path.relative_to(REPO_ROOT)
+                        offenders.append(f"{rel}:{lineno}: {owner}/{repo}#…")
+
+        self.assertEqual(
+            offenders,
+            [],
+            "published plugin prose names a repository outside "
+            f"{sorted(ALLOWED_OWNERS)}. This content ships to every consumer, "
+            "so another party's org/repo must not ride along in it — describe "
+            "the repo instead ('a downstream consumer repo') and keep the "
+            "traceable reference on this project's own issue. Offenders:\n  "
+            + "\n  ".join(offenders),
+        )
+
+
+if __name__ == "__main__":  # pragma: no cover
+    unittest.main()

{specfuse_loop-0.22.1 → specfuse_loop-0.22.2}/tests/test_severity_backfill_run.py

@@ -222,5 +222,65 @@ class BackfillRun(unittest.TestCase):
         self.assertEqual([], label_create_calls)
 
 
+class AliasedSchemeWritesTheRepositorysOwnLabel(unittest.TestCase):
+    """End to end for #3353: a repository whose severity labels are its own
+    words gets those words written back, not the vocabulary spelling.
+
+    The unit tests for `severity_label_projection` prove the mapping; this
+    proves the wiring, which is where the defect actually lived -- the
+    projection existed nowhere and `apply_severity_backfill` wrote
+    `severity_label_for(value)` unconditionally.
+    """
+
+    ALIASED_LABELS = [
+        {"name": "severity:major", "description": "Wrong behavior."},
+        {"name": "severity:minor", "description": "Cosmetic."},
+    ]
+
+    def test_the_label_written_is_the_repositorys_word(self):
+        candidates = [_candidate(1)]
+        runner, calls = _make_runner(
+            candidates=candidates,
+            label_rows=self.ALIASED_LABELS,
+            claude_answers={1: _marker(1, "bug", "high", "high")},
+        )
+
+        report = run_backfill(runner, _REPO, apply=True)
+
+        self.assertEqual({"high", "low"}, set(report["rubric"]))
+
+        label_calls = [c for c in _issue_edit_calls(calls) if "--add-label" in c]
+        self.assertEqual(1, len(label_calls))
+        written = label_calls[0][label_calls[0].index("--add-label") + 1]
+        self.assertEqual("severity:major", written)
+
+    def test_the_marker_still_records_the_vocabulary_value(self):
+        candidates = [_candidate(1)]
+        runner, calls = _make_runner(
+            candidates=candidates,
+            label_rows=self.ALIASED_LABELS,
+            claude_answers={1: _marker(1, "bug", "high", "high")},
+        )
+
+        run_backfill(runner, _REPO, apply=True)
+
+        body_calls = [c for c in _issue_edit_calls(calls) if "--body" in c]
+        self.assertEqual(1, len(body_calls))
+        body = body_calls[0][body_calls[0].index("--body") + 1]
+        self.assertIn("severity=high", body)
+
+    def test_the_listing_is_still_read_exactly_once(self):
+        candidates = [_candidate(1)]
+        runner, calls = _make_runner(
+            candidates=candidates,
+            label_rows=self.ALIASED_LABELS,
+            claude_answers={1: _marker(1, "bug", "high", "high")},
+        )
+
+        run_backfill(runner, _REPO, apply=True)
+
+        self.assertEqual(1, len(_label_list_calls(calls)))
+
+
 if __name__ == "__main__":
     unittest.main()