code-coordinator 0.5.234__tar.gz → 0.5.236__tar.gz

{code_coordinator-0.5.234 → code_coordinator-0.5.236}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.234
+Version: 0.5.236
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.234 → code_coordinator-0.5.236}/code_coordinator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.234
+Version: 0.5.236
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

code_coordinator-0.5.236/code_coordinator.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.5.236",
+  "distance": 0,
+  "node": "g5110d914da8b0140bb620fbe356079028f405900",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-08-23"
+}

{code_coordinator-0.5.234 → code_coordinator-0.5.236}/coord/acceptance.py

@@ -838,6 +838,36 @@ def _issue_header_re(issue_number: int) -> re.Pattern[str]:
     return re.compile(rf"^(\s*)['\"]?{issue_number}['\"]?\s*:\s*(#.*)?$")
 
 
+def _parse_list_item_scalar(line: str) -> str | None:
+    """Resolve one YAML block-sequence item line (``- ...``) to its parsed
+    scalar value — the same value :func:`parse_manifest_text` would produce
+    for it — rather than the raw text as written. #2296: a Playwright test id
+    always starts with ``[chromium]``, so its manifest entry is *always*
+    quoted (an unquoted leading ``[`` is a YAML flow sequence, not a string);
+    comparing the raw scalar against the parsed id then never matches. Going
+    through :mod:`yaml` here instead handles double- and single-quoted
+    scalars (incl. the ``''`` embedded-quote escape) and, since YAML's own
+    comment rule applies, a ``#`` inside a quoted scalar is correctly treated
+    as data rather than truncated as a comment.
+
+    Returns ``None`` for anything that isn't a well-formed single-item
+    sequence line (blank/comment-only, flow-style, malformed YAML, or a
+    non-string value) so the caller leaves such lines untouched rather than
+    risk misclassifying them.
+    """
+    stripped = line.strip()
+    if not stripped.startswith("-"):
+        return None
+    try:
+        parsed = yaml.safe_load(stripped)
+    except yaml.YAMLError:
+        return None
+    if not isinstance(parsed, list) or len(parsed) != 1:
+        return None
+    value = parsed[0]
+    return value if isinstance(value, str) else None
+
+
 def _strip_cleared_ids_from_issue_block(
     body: "list[str]", issue_number: int, cleared_ids: "set[str]",
 ) -> "tuple[list[str], bool]":
@@ -871,9 +901,8 @@ def _strip_cleared_ids_from_issue_block(
             i += 1
         new_sub = []
         for sub_line in sub:
-            code = sub_line.split("#", 1)[0].strip()
-            item_m = re.match(r"^-\s*(.+?)\s*$", code)
-            if item_m and item_m.group(1) in cleared_ids:
+            item = _parse_list_item_scalar(sub_line)
+            if item is not None and item in cleared_ids:
                 changed = True
                 continue
             new_sub.append(sub_line)
@@ -1286,7 +1315,12 @@ def clear_expected_red_via_pr(
 
     new_text = clear_expected_red_entries(text, issue_number, ids)
     if new_text is None:
-        return "expected_red text unchanged (nothing matched)"
+        # #2296: ids were passed in and none matched — that's a defect in
+        # the text surgery (or a manifest that no longer has this issue's
+        # block), not a benign no-op. Prefix `warning:` so it's greppable
+        # and so `coord acceptance expected-red --clear` doesn't report a
+        # clean sweep over an operation that actually did nothing.
+        return "warning: expected_red text unchanged (nothing matched)"
 
     get_head = getattr(ops, "get_default_branch_head", None)
     create_branch = getattr(ops, "create_remote_branch", None)

{code_coordinator-0.5.234 → code_coordinator-0.5.236}/coord/agent.py

@@ -1110,14 +1110,36 @@ def _pushed_commits_ahead(repo_path: Path, base: str, branch: str) -> int | None
 _ISSUE_REF_RE = re.compile(r"#(\d+)")
 
 
-def _foreign_issue_refs(subject: str, issue_number: int) -> frozenset[int]:
+def _foreign_issue_refs(
+    subject: str,
+    issue_number: int,
+    extra_allowed: frozenset[int] = frozenset(),
+) -> frozenset[int]:
     """Return the set of *foreign* issue numbers referenced in *subject* —
-    those that are not *issue_number*.  Empty if the subject doesn't reference
-    any foreign issue."""
+    those that are neither *issue_number* nor in *extra_allowed*.  Empty if
+    the subject doesn't reference any foreign issue.
+
+    *extra_allowed* (#2545): for a ``type="test-author"``/``"mock-author"``
+    merge entry, *issue_number* is the milestone's TRACKING issue (every JIT
+    slice for one milestone shares a single branch/PR — see
+    ``Assignment.for_issue_number``'s docstring), but the slice's own commit
+    correctly and necessarily cites its OWN child issue
+    (``test(ms-4): ... slice #132``). Without this, every such commit was
+    flagged FOREIGN on every single verify, regardless of whether the rebase
+    was actually clean. Callers resolve the slice's own issue number (e.g.
+    via ``coord.models.effective_issue_number``) and pass it here so a
+    reference to *either* the tracking issue or the resolved slice issue
+    counts as home, not foreign. Defaults to empty, preserving the original
+    all-blocking-except-``issue_number`` behaviour for ordinary ``work``
+    assignments.
+    """
     refs = {int(m) for m in _ISSUE_REF_RE.findall(subject)}
-    if not refs or issue_number in refs:
+    if not refs:
         return frozenset()
-    return frozenset(refs - {issue_number})
+    home = {issue_number} | extra_allowed
+    if refs & home:
+        return frozenset()
+    return frozenset(refs - home)
 
 
 def _resolve_base_ref(wt_path: Path, base: str) -> str | None:
@@ -1218,6 +1240,7 @@ def verify_merge_branch(
     *,
     base: str,
     issue_number: int,
+    extra_allowed_issue_numbers: frozenset[int] = frozenset(),
     closed_issue_numbers: frozenset[int] = frozenset(),
 ) -> MergeVerify:
     """Verify a ``--merge-of`` branch before its terminal ``done`` is recorded.
@@ -1233,10 +1256,17 @@ def verify_merge_branch(
     ``claude``, no PTY — so the gate runs as a fast local-only test fixture.
 
     Args:
+        extra_allowed_issue_numbers: Additional issue numbers, besides
+            *issue_number*, that a commit subject may legitimately reference
+            without being flagged foreign (#2545) — see
+            :func:`_foreign_issue_refs`'s ``extra_allowed`` for why a
+            ``test-author``/``mock-author`` merge entry needs this (its own
+            slice issue, not just the milestone's tracking issue).
         closed_issue_numbers: Issue numbers that are known to be closed/merged
             in the upstream repo.  When a commit's subject references *only*
-            issues in this set (and not ``issue_number``), it is downgraded
-            from a **blocking** foreign finding to an **advisory** one (#1279).
+            issues in this set (and not ``issue_number`` or
+            ``extra_allowed_issue_numbers``), it is downgraded from a
+            **blocking** foreign finding to an **advisory** one (#1279).
             The rationale: a commit referencing a *closed* issue cannot be
             live rebase-pollution — it is almost certainly a worker typo in the
             commit subject.  Pass the empty frozenset (default) to preserve the
@@ -1271,7 +1301,9 @@ def verify_merge_branch(
     foreign: list[tuple[str, str]] = []
     advisory_foreign: list[tuple[str, str]] = []
     for sha, subj in added:
-        foreign_refs = _foreign_issue_refs(subj, issue_number)
+        foreign_refs = _foreign_issue_refs(
+            subj, issue_number, extra_allowed=extra_allowed_issue_numbers
+        )
         if not foreign_refs:
             continue  # not flagged — own work or bare message
         # #1279: downgrade to advisory when ALL referenced foreign issues are
@@ -1312,6 +1344,17 @@ def resolve_closed_issue_numbers(
     Returns an empty frozenset immediately when *repo_github* is falsy or
     *foreign_commits* is empty, so callers can skip the second verify pass
     entirely (``if closed: ...``) without an extra branch.
+
+    Deliberately does **not** accept an ``extra_allowed_issue_numbers``
+    parameter to thread through to :func:`_foreign_issue_refs` (#2545
+    review): *foreign_commits* here is always the ``.foreign`` list a prior,
+    ``extra_allowed``-aware :func:`verify_merge_branch` pass already
+    produced, and ``_foreign_issue_refs`` treats any overlap with the "home"
+    set (``{issue_number} | extra_allowed``) as voiding a commit's foreign
+    status entirely — so no subject surviving into *foreign_commits* can
+    reference an ``extra_allowed`` issue in the first place. If a future
+    caller ever feeds this something other than a prior pass's ``.foreign``,
+    re-check this assumption before relying on it.
     """
     foreign_commits = list(foreign_commits)
     if not repo_github or not foreign_commits:

{code_coordinator-0.5.234 → code_coordinator-0.5.236}/coord/commands/dispatch_workers.py

@@ -3355,6 +3355,26 @@ def _dispatch_merge_of(
         )
         sys.exit(2)
 
+    # #2545: a `type="test-author"`/`"mock-author"` work row's `issue_number`
+    # (== `issue` above) is always the milestone's TRACKING issue, but its
+    # commit correctly cites the slice's OWN child issue — resolved via the
+    # canonical `coord.models.effective_issue_number` helper (built for
+    # exactly this tracking-vs-slice distinction, #1553) rather than reading
+    # `for_issue_number` directly, so this stays in sync with the other
+    # callers of that helper (e.g. `merge_queue._test_author_effective_
+    # issue_number`) instead of drifting as an independent copy. Without
+    # allowing the resolved issue too, the #604 FOREIGN check below flags
+    # every JIT slice's own, correctly-labeled commit on every single verify.
+    # Ordinary `work` assignments have no `for_issue_number`, so this
+    # resolves to `issue` itself — already in the "home" set, a harmless
+    # no-op.
+    from coord.models import effective_issue_number as _mg_effective_issue_number  # noqa: PLC0415
+
+    _mg_for_issue = _mg_effective_issue_number(work)
+    _mg_extra_allowed = (
+        frozenset({_mg_for_issue}) if _mg_for_issue and _mg_for_issue != issue else frozenset()
+    )
+
     resolved_model = model if model else cfg.models.default
     assignment_id = _uuid.uuid4().hex[:12]
     if _is_local:
@@ -3607,6 +3627,9 @@ def _dispatch_merge_of(
                 # #604: git truth overrides the agent's self-report on the
                 # merge path — a botched rebase records `blocked`, not `done`.
                 verify_merge=True,
+                # #2545: allow the JIT slice's own child issue, not just the
+                # tracking issue, in the FOREIGN check.
+                extra_allowed_issue_numbers=_mg_extra_allowed,
                 branch=work.branch,
             )
             _echo_merge_finalize(finalize_result, merge_target_branch)
@@ -3869,6 +3892,9 @@ def _dispatch_merge_of(
             exit_code=exit_code,
             started_at=started_at,
             verify_merge=True,
+            # #2545: allow the JIT slice's own child issue, not just the
+            # tracking issue, in the FOREIGN check.
+            extra_allowed_issue_numbers=_mg_extra_allowed,
         )
         _echo_merge_finalize(finalize_result, merge_target_branch)
         _mv = finalize_result.merge_verify

{code_coordinator-0.5.234 → code_coordinator-0.5.236}/coord/commands/merge.py

@@ -11,7 +11,7 @@ import click
 
 
 from coord.commands._common import _CONFIG_OPTION, _load_config
-from coord.models import WORK_LIKE_TYPES
+from coord.models import WORK_LIKE_TYPES, effective_issue_number
 
 
 def _machine_for_assignment(board, assignment_id: str | None) -> str | None:
@@ -726,10 +726,26 @@ def verify_merge(
                 err=True,
             )
             sys.exit(2)
+        extra_allowed: frozenset[int] = frozenset()
     else:
         repo_name = work.repo_name
         issue_num = int(work.issue_number)
         branch_display = work.branch or "(unknown)"
+        # #2545: a `type="test-author"`/`"mock-author"` merge entry's
+        # `issue_number` is always the milestone's TRACKING issue (every JIT
+        # slice for one milestone shares a branch/PR), but its commit
+        # correctly cites the slice's OWN child issue — resolved via the
+        # canonical `effective_issue_number` helper (built for exactly this
+        # tracking-vs-slice distinction, #1553) rather than reading
+        # `for_issue_number` directly, so this stays in sync with the other
+        # callers of that helper (e.g. `merge_queue._test_author_effective_
+        # issue_number`) instead of drifting as an independent copy. Ordinary
+        # `work` assignments have no `for_issue_number`, so this resolves to
+        # `issue_num` itself — already in the "home" set, a harmless no-op.
+        _for_issue = effective_issue_number(work)
+        extra_allowed = (
+            frozenset({_for_issue}) if _for_issue and _for_issue != issue_num else frozenset()
+        )
 
     repo_cfg = cfg.repo(repo_name)
     base = (repo_cfg.default_branch if repo_cfg else None) or "main"
@@ -747,14 +763,23 @@ def verify_merge(
     repo_github = repo_cfg.github if repo_cfg else None
     wt_path = Path(path_opt).expanduser() if path_opt else Path.cwd()
 
-    mv = verify_merge_branch(wt_path, base=base, issue_number=issue_num)
+    mv = verify_merge_branch(
+        wt_path,
+        base=base,
+        issue_number=issue_num,
+        extra_allowed_issue_numbers=extra_allowed,
+    )
     # #1279: only worth a `gh` round-trip when the cheap git-only pass above
     # actually found blocking foreign commits — corroborate against GitHub's
     # closed-issue state and re-verify with the downgrade signal populated.
     closed = resolve_closed_issue_numbers(repo_github, mv.foreign, issue_num)
     if closed:
         mv = verify_merge_branch(
-            wt_path, base=base, issue_number=issue_num, closed_issue_numbers=closed
+            wt_path,
+            base=base,
+            issue_number=issue_num,
+            extra_allowed_issue_numbers=extra_allowed,
+            closed_issue_numbers=closed,
         )
 
     click.echo(f"branch:        {branch_display}")

{code_coordinator-0.5.234 → code_coordinator-0.5.236}/coord/interactive.py

@@ -3057,6 +3057,7 @@ def finalize_interactive_exit(
     repo_path: str | None = None,
     artifact_paths: list[str] | None = None,
     verify_merge: bool = False,
+    extra_allowed_issue_numbers: frozenset[int] = frozenset(),
     ssh_target: str | None = None,
     branch: str | None = None,
     smoke_repo_path: str | None = None,
@@ -3116,6 +3117,12 @@ def finalize_interactive_exit(
     session, with no structured block, no transcript floor, and no fallback
     if that command never ran (#1351). ``None`` (every non-smoke caller)
     makes this an unconditional no-op.
+
+    *extra_allowed_issue_numbers* (#2545): forwarded to
+    :func:`coord.agent.verify_merge_branch`'s parameter of the same name —
+    additional issue numbers a merge-prep commit subject may legitimately
+    reference (besides *issue_number*) without tripping the #604 FOREIGN
+    check. Only meaningful when *verify_merge* is set; ignored otherwise.
     """
     _effective_patterns = list(artifact_paths or [])
 
@@ -3197,7 +3204,10 @@ def finalize_interactive_exit(
             )
 
             merge_verify = verify_merge_branch(
-                wt_v, base=base_branch, issue_number=issue_number
+                wt_v,
+                base=base_branch,
+                issue_number=issue_number,
+                extra_allowed_issue_numbers=extra_allowed_issue_numbers,
             )
             # #1279: corroborate blocking foreign commits against GitHub's
             # closed-issue state before deciding — a typo'd reference to an
@@ -3210,6 +3220,7 @@ def finalize_interactive_exit(
                     wt_v,
                     base=base_branch,
                     issue_number=issue_number,
+                    extra_allowed_issue_numbers=extra_allowed_issue_numbers,
                     closed_issue_numbers=closed,
                 )
             if not merge_verify.ok:
@@ -3915,6 +3926,7 @@ def _remote_verify_merge_branch(
     base: str,
     issue_number: int,
     timeout: float = 30.0,
+    extra_allowed_issue_numbers: frozenset[int] = frozenset(),
     closed_issue_numbers: frozenset[int] = frozenset(),
 ) -> MergeVerify:
     """Remote (over ssh) analogue of :func:`coord.agent.verify_merge_branch`
@@ -3935,6 +3947,11 @@ def _remote_verify_merge_branch(
     same conservative "unverifiable ⇒ not ok" fallback as the local function.
 
     Args:
+        extra_allowed_issue_numbers: Mirrors the same parameter in
+            :func:`coord.agent.verify_merge_branch` (#2545) — additional
+            issue numbers, besides *issue_number*, that a commit subject may
+            legitimately reference without being flagged foreign (a
+            ``test-author``/``mock-author`` slice's own child issue).
         closed_issue_numbers: Mirrors the same parameter in
             :func:`coord.agent.verify_merge_branch` — issue numbers known to
             be closed/merged.  Foreign-subject commits referencing only
@@ -3990,7 +4007,9 @@ def _remote_verify_merge_branch(
     foreign: list[tuple[str, str]] = []
     advisory_foreign: list[tuple[str, str]] = []
     for sha, subj in added:
-        foreign_refs = _foreign_issue_refs(subj, issue_number)
+        foreign_refs = _foreign_issue_refs(
+            subj, issue_number, extra_allowed=extra_allowed_issue_numbers
+        )
         if not foreign_refs:
             continue
         if closed_issue_numbers and foreign_refs.issubset(closed_issue_numbers):
@@ -4088,6 +4107,7 @@ def finalize_remote_interactive_exit(
     started_at: float | None = None,
     artifact_paths: list[str] | None = None,
     verify_merge: bool = False,
+    extra_allowed_issue_numbers: frozenset[int] = frozenset(),
 ) -> InteractiveFinalizeResult:
     """Remote (#486d) analog of :func:`finalize_interactive_exit` for a remote
     interactive FIX (and, since #1007, a remote ``--merge-of``).
@@ -4116,6 +4136,12 @@ def finalize_remote_interactive_exit(
     self-report, so a botched remote rebase is never silently accepted as
     ``done``.  This check runs FIRST, before the ``_assignment_already_recorded``
     fast path below — do NOT reorder it after that check.
+
+    ``extra_allowed_issue_numbers`` (#2545): mirrors the same parameter on
+    :func:`finalize_interactive_exit` — forwarded to
+    :func:`_remote_verify_merge_branch` so a ``test-author``/``mock-author``
+    slice's own child-issue commit doesn't trip the FOREIGN check just
+    because *issue_number* here is the milestone's tracking issue.
     """
     _effective_patterns = list(artifact_paths or [])
 
@@ -4130,6 +4156,7 @@ def finalize_remote_interactive_exit(
         merge_verify = _remote_verify_merge_branch(
             ssh_target, remote_worktree_sh,
             base=base_branch, issue_number=issue_number,
+            extra_allowed_issue_numbers=extra_allowed_issue_numbers,
         )
         # #1279: same corroboration as the local finalize path — re-verify
         # with the closed-issue downgrade signal only when the first (cheap,
@@ -4141,6 +4168,7 @@ def finalize_remote_interactive_exit(
             merge_verify = _remote_verify_merge_branch(
                 ssh_target, remote_worktree_sh,
                 base=base_branch, issue_number=issue_number,
+                extra_allowed_issue_numbers=extra_allowed_issue_numbers,
                 closed_issue_numbers=closed,
             )
         if not merge_verify.ok:

{code_coordinator-0.5.234 → code_coordinator-0.5.236}/tests/test_acceptance.py

@@ -571,6 +571,94 @@ class TestClearExpectedRedEntries:
         assert clear_expected_red_entries("tests:\n  a: 1\n", 1, {"a"}) is None
 
 
+class TestClearExpectedRedEntriesQuotedIds:
+    """#2296: every Playwright manifest id is double-quoted (an unquoted
+    leading `[chromium]` would parse as a YAML flow sequence, not a string),
+    so the clearer must compare the *parsed* scalar, not the raw line text,
+    or it can never match a real web-playwright manifest."""
+
+    PLAYWRIGHT_ID = "[chromium] ms-1/84-front-door.spec.ts › placeholder"
+
+    def test_double_quoted_id_is_cleared(self) -> None:
+        text = (
+            "expected_red:\n"
+            f'  84:\n    - "{self.PLAYWRIGHT_ID}"\n'
+        )
+        result = clear_expected_red_entries(text, 84, {self.PLAYWRIGHT_ID})
+        assert result is not None
+        assert "expected_red" not in result
+        data = parse_manifest_text(text)
+        assert data.expected_red == {84: frozenset({self.PLAYWRIGHT_ID})}
+
+    def test_single_quoted_id_is_cleared(self) -> None:
+        text = "expected_red:\n  1:\n    - 'plain single quoted'\n"
+        result = clear_expected_red_entries(text, 1, {"plain single quoted"})
+        assert result is not None
+        assert "expected_red" not in result
+
+    def test_single_quoted_id_with_embedded_quote_escape_is_cleared(self) -> None:
+        # YAML's single-quote escape for an embedded `'` is `''`.
+        text = "expected_red:\n  1:\n    - 'it''s red'\n"
+        data = parse_manifest_text(text)
+        assert data.expected_red == {1: frozenset({"it's red"})}
+        result = clear_expected_red_entries(text, 1, {"it's red"})
+        assert result is not None
+        assert "expected_red" not in result
+
+    def test_plain_unquoted_id_still_clears(self) -> None:
+        """The unquoted case already worked before #2296 — must keep working."""
+        text = "expected_red:\n  1:\n    - plain_unquoted_id\n"
+        result = clear_expected_red_entries(text, 1, {"plain_unquoted_id"})
+        assert result is not None
+        assert "expected_red" not in result
+
+    def test_id_containing_a_hash_is_cleared_not_truncated_as_a_comment(self) -> None:
+        """Inside a quoted scalar, `#` is data, not a comment delimiter —
+        `sub_line.split("#", 1)` would truncate the id and miss it."""
+        id_with_hash = "issue #84 regression check"
+        text = f'expected_red:\n  1:\n    - "{id_with_hash}"\n'
+        data = parse_manifest_text(text)
+        assert data.expected_red == {1: frozenset({id_with_hash})}
+        result = clear_expected_red_entries(text, 1, {id_with_hash})
+        assert result is not None
+        assert "expected_red" not in result
+
+    def test_quoted_id_with_trailing_comment_is_still_cleared(self) -> None:
+        text = (
+            "expected_red:\n"
+            f'  84:\n    - "{self.PLAYWRIGHT_ID}"  # flaky, see #91\n'
+        )
+        result = clear_expected_red_entries(text, 84, {self.PLAYWRIGHT_ID})
+        assert result is not None
+        assert "expected_red" not in result
+
+    def test_mixed_quoted_and_plain_partial_clear_preserves_the_other(self) -> None:
+        text = (
+            "expected_red:\n"
+            "  84:\n"
+            f'    - "{self.PLAYWRIGHT_ID}"\n'
+            "    - plain_id_stays\n"
+        )
+        result = clear_expected_red_entries(text, 84, {self.PLAYWRIGHT_ID})
+        assert result is not None
+        assert "plain_id_stays" in result
+        data = parse_manifest_text(result)
+        assert data.expected_red == {84: frozenset({"plain_id_stays"})}
+
+    def test_playwright_manifest_reproduction(self) -> None:
+        """The exact reproduction from #2296: a manifest with several
+        double-quoted Playwright ids has ALL of them cleared and returns
+        updated (non-None) text."""
+        ids = [f"[chromium] ms-1/84-front-door.spec.ts › case {i}" for i in range(6)]
+        body = "\n".join(f'    - "{i}"' for i in ids)
+        text = f"expected_red:\n  84:\n{body}\n"
+        parsed_ids = parse_manifest_text(text).expected_red[84]
+        assert len(parsed_ids) == 6
+        result = clear_expected_red_entries(text, 84, parsed_ids)
+        assert result is not None
+        assert "expected_red" not in result
+
+
 class _FakeApiGhOps:
     """Stub for the GitHub-API-only surface #2164's post-merge clearing
     sweep needs — no `gh` subprocess, no local checkout. Mirrors
@@ -861,6 +949,26 @@ class TestClearExpectedRedViaPr:
         msg = clear_expected_red_via_pr("acme/x", "coord-tui", "main", 944, gh_ops=ops)
         assert "no expected_red entries found" in msg
 
+    def test_no_match_in_text_surgery_is_reported_as_a_warning(self) -> None:
+        """#2296: when ids were resolved from the parsed manifest but the
+        text-surgery pass finds nothing to remove (e.g. a flow-style
+        `944: [ms01::a]` entry the block-style-only text surgery doesn't
+        understand — see `_issue_header_re`'s docstring), that is a defect,
+        not a benign no-op, and must be `warning:`-prefixed so
+        `classify_expected_red_clear_result` reads it as "failed" rather
+        than a clean sweep."""
+        ops = _FakeApiGhOps({
+            "tests/acceptance/ms01/manifest.yml": (
+                "tests:\n  ms01::a: 944\n"
+                "expected_red:\n  944: [ms01::a]\n"
+            ),
+        })
+        msg = clear_expected_red_via_pr("acme/x", "coord-tui", "main", 944, gh_ops=ops)
+        assert msg.startswith("warning:")
+        assert "nothing matched" in msg
+        assert classify_expected_red_clear_result(msg) == "failed"
+        assert not ops.created_prs
+
     def test_clears_a_per_issue_fragment_file(self) -> None:
         """#2543: clearing an issue whose expected_red lives in its OWN
         manifest.d/<issue>.yml fragment edits exactly that file, and the
@@ -927,7 +1035,7 @@ class TestClassifyExpectedRedClearResult:
 
     def test_unchanged_text_is_a_failure(self) -> None:
         assert classify_expected_red_clear_result(
-            "expected_red text unchanged (nothing matched)"
+            "warning: expected_red text unchanged (nothing matched)"
         ) == "failed"