code-coordinator 0.5.537__tar.gz → 0.5.539__tar.gz

{code_coordinator-0.5.537 → code_coordinator-0.5.539}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.537
+Version: 0.5.539
 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.537 → code_coordinator-0.5.539}/code_coordinator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.537
+Version: 0.5.539
 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.537 → code_coordinator-0.5.539}/code_coordinator.egg-info/SOURCES.txt

@@ -151,6 +151,7 @@ coord/scorecard.py
 coord/self_health.py
 coord/serve_app.py
 coord/smoke.py
+coord/smoke_tags.py
 coord/spend_ceiling.py
 coord/split_work.py
 coord/sql.py

{code_coordinator-0.5.537 → code_coordinator-0.5.539}/code_coordinator.egg-info/scm_file_list.json

@@ -277,6 +277,7 @@
     "coord/skills/tui-quadraui-workflow/SKILL.md",
     "coord/skills/update-issue/SKILL.md",
     "coord/smoke.py",
+    "coord/smoke_tags.py",
     "coord/spend_ceiling.py",
     "coord/split_work.py",
     "coord/sql.py",

{code_coordinator-0.5.537 → code_coordinator-0.5.539}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.537",
+  "tag": "0.5.539",
   "distance": 0,
-  "node": "g0b0484bb17ec9c86ad41ee4d4d8123042044c389",
+  "node": "g3c6dd4b3b835b9bf4e21a725a6e45356f63dba5f",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-30"

{code_coordinator-0.5.537 → code_coordinator-0.5.539}/coord/commands/lifecycle.py

@@ -428,7 +428,7 @@ def done(config_path: Path) -> None:
             pass
 
     all_assignments = list(board.active) + list(board.completed)
-    session_usage = build_session_usage(all_assignments, started_at=started_at)
+    session_usage = build_session_usage(all_assignments, started_at=started_at, cfg=cfg)
     total_cost = session_usage.total_cost_usd
 
     click.echo("")

{code_coordinator-0.5.537 → code_coordinator-0.5.539}/coord/commands/status.py

@@ -980,7 +980,7 @@ def status(config_path: Path, machine_filter: str | None, no_reconcile: bool, ti
                 pass
 
         all_assignments = list(board.active) + list(board.completed)
-        session_usage = build_session_usage(all_assignments, started_at=started_at)
+        session_usage = build_session_usage(all_assignments, started_at=started_at, cfg=cfg)
         burn_line = format_burn_rate_line(session_usage)
         if burn_line:
             click.echo("")
@@ -1103,7 +1103,7 @@ def status(config_path: Path, machine_filter: str | None, no_reconcile: bool, ti
         machine_by_aid = {
             a.assignment_id: a.machine_name for a in rows if a.assignment_id
         }
-        usage = build_session_usage(rows, remote_by_id=agent_completed or None)
+        usage = build_session_usage(rows, remote_by_id=agent_completed or None, cfg=cfg)
         for au in usage.assignments:
             # #3376 review round 2: `cost_unknown` means no local log AND no
             # remote entry. That is the ghost-dispatch signal ONLY if this
@@ -2992,6 +2992,14 @@ def usage(
             pass
 
     # Optionally fetch remote cost data for assignments without local logs.
+    # #2305: cfg is only loaded here (not unconditionally) — the bare
+    # `coord usage` view has always worked with no coordinator.yml present
+    # at all (see TestUsageCommandBareViewHonorsWindowFlags), and that must
+    # stay true. When it IS loaded (here, or by --remote below), it's
+    # threaded into build_session_usage() so a tier-named provider (e.g.
+    # "oc-mid") resolves correctly instead of degrading to ClaudeProvider
+    # log parsing.
+    cfg: "Config | None" = None
     remote_by_id: dict[str, dict] = {}
     if remote and all_assignments:
         cfg = _load_config(config_path)
@@ -3027,6 +3035,7 @@ def usage(
         all_assignments,
         remote_by_id=remote_by_id if remote_by_id else None,
         started_at=started_at,
+        cfg=cfg,
     )
     click.echo(format_usage_report(session, window_label=window_label))
 

{code_coordinator-0.5.537 → code_coordinator-0.5.539}/coord/failure_class.py

@@ -79,6 +79,7 @@ from coord.worker_events import (
 )
 
 if TYPE_CHECKING:
+    from coord.config import Config
     from coord.providers.base import Provider
 
 # ── the two classes ─────────────────────────────────────────────────────────
@@ -461,6 +462,7 @@ def classify_log(
     tail_bytes: int = 65536,
     provider_name: str | None = None,
     provider: "Provider | None" = None,
+    cfg: "Config | None" = None,
 ) -> FailureClassification:
     """Classify a worker's terminal state from its log.
 
@@ -484,6 +486,14 @@ def classify_log(
     an escape hatch for tests to pass an already-constructed provider
     directly, bypassing name resolution.
 
+    *cfg* (#2305): the coordinator's :class:`~coord.config.Config`, passed
+    straight through to :func:`coord.providers.get_provider` so a
+    tier-named ``providers.definitions`` entry (e.g. ``oc-mid``) resolves to
+    its real backend instead of silently degrading to
+    :class:`~coord.providers.claude.ClaudeProvider` — *provider_name* alone
+    only ever matches the built-in type names. ``None`` (the default)
+    preserves pre-#2305 behaviour.
+
     #1710 NOTE — a documented, narrow behaviour difference from the
     pre-#1710 implementation: that version additionally scanned the raw
     ``result`` event's ``error`` and bare ``subtype`` fields (via
@@ -509,7 +519,7 @@ def classify_log(
 
     if provider is None:
         from coord.providers import get_provider  # noqa: PLC0415
-        provider = get_provider(provider_name)
+        provider = get_provider(provider_name, cfg=cfg)
     summary = provider.parse_log(log_path, tail_bytes=tail_bytes)
 
     classification = classify_failure(

{code_coordinator-0.5.537 → code_coordinator-0.5.539}/coord/progress.py

@@ -26,6 +26,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
+    from coord.config import Config
     from coord.providers.base import Provider
 
 
@@ -118,6 +119,7 @@ def parse_progress(
     *,
     provider_name: str | None = None,
     provider: "Provider | None" = None,
+    cfg: "Config | None" = None,
 ) -> WorkerProgress:
     """Parse progress from a worker log.
 
@@ -137,6 +139,15 @@ def parse_progress(
             precedence over *provider_name*. Mainly for tests that want to
             exercise a specific (e.g. fake, non-claude) provider without
             wiring up a full :class:`~coord.config.Config`.
+        cfg: The coordinator's :class:`~coord.config.Config`, when the caller
+            has one in scope. #2305: without this, ``provider_name`` only
+            ever resolves against the built-in provider *types*
+            (``claude``/``claude-pty``/``opencode``) — a **tier-named**
+            ``providers.definitions`` entry (e.g. ``oc-mid``) silently
+            degrades to :class:`~coord.providers.claude.ClaudeProvider`.
+            Passed straight through to :func:`coord.providers.get_provider`;
+            ``None`` (the default) preserves the pre-#2305 built-ins-only
+            resolution, so existing callers are unaffected.
     """
     from coord.worker_events import detect_anomalies, is_stream_json
 
@@ -147,7 +158,7 @@ def parse_progress(
     if is_stream_json(p):
         if provider is None:
             from coord.providers import get_provider  # noqa: PLC0415
-            provider = get_provider(provider_name)
+            provider = get_provider(provider_name, cfg=cfg)
         summary = provider.parse_log(p, tail_bytes=tail_bytes)
         progress = WorkerProgress()
         # Synthesise a single rolling "update" line so coord status keeps

{code_coordinator-0.5.537 → code_coordinator-0.5.539}/coord/smoke.py

@@ -82,7 +82,6 @@ independence; for smoke we want a *capable* machine for hardware, and
 
 from __future__ import annotations
 
-import base64
 import json
 import logging
 import re
@@ -123,6 +122,24 @@ from coord.models import (
 # runner actually emits, or from what `coord.notify` parses back out of the
 # agent's own transcript (see `_smoke_baseline_red_reason` there).
 from coord.revalidate import BASELINE_RED_OUTPUT_MARKER, RUNNER_BASELINE_RED_EXIT
+# The #3182 fan-out's on-the-board text encodings, DEFINED in a leaf module
+# and re-exported here under their original spellings so every existing
+# importer (`coord.notify`, `coord.diagnose`, `coord.reconcile`, the tests)
+# still reads them off `coord.smoke`, with exactly one definition of each.
+# See `coord/smoke_tags.py`'s docstring for why they were split out: they are
+# pure `re`/`base64` string handling, and `coord.stage_projection` — a
+# deliberately dependency-free leaf module — has to parse both to count Test
+# rounds (#3191). Reaching them through THIS module would drag the whole
+# dispatch stack (`coord.config`, `coord.dispatch`, `coord.github_ops`,
+# `coord.revalidate`, `httpx`) into `coord serve`'s `/board` request path.
+from coord.smoke_tags import (  # noqa: F401  (re-export; see note above)
+    _FANOUT_MANIFEST_RE,
+    _LEG_TAG_RE,
+    _encode_fanout_manifest,
+    _parse_fanout_manifest,
+    smoke_leg_capabilities,
+    smoke_leg_issue_title,
+)
 
 logger = logging.getLogger("coord.smoke")
 
@@ -638,114 +655,13 @@ def partition_capability_requirements(
 # sweep if a partition never got a machine at all — the existing, generic
 # mechanism, not a fan-out-specific reinvention of it.
 
-# Restricted to `[a-z0-9+_-]` — every capability name in this codebase
-# (gtk, windows, macos, browser, provider:opencode via `+`-joining, etc.)
-# fits that class. If `coordinator.yml` ever declares a capability with an
-# uppercase letter, a dot, or another character outside it,
-# `smoke_leg_capabilities()` silently returns None for that leg (misread as
-# an ordinary untagged row) rather than raising — nothing today validates
-# capability naming at config-load time, so keep new capability names
-# lowercase/`[a-z0-9+_-]` until that validation exists.
-_LEG_TAG_RE = re.compile(r"^\[smoke:([a-z0-9+_-]+)\] ")
-
-
-def smoke_leg_issue_title(base_title: str, capabilities: tuple[str, ...]) -> str:
-    """The ``issue_title`` for one capability-partition leg of a #3182 fan-out.
-
-    Encodes *capabilities* (sorted, ``+``-joined) as a parseable prefix —
-    ``"[smoke:gtk+windows] <base_title>"`` — so :func:`smoke_leg_capabilities`
-    can read it back off the board. Used both for the per-partition in-flight
-    dedupe (:func:`_find_leg_for_partition`) and for telling a fan-out leg's
-    own verdict apart from an ordinary single-leg smoke row's when processing
-    it (``coord.notify``).
-    """
-    tag = "+".join(sorted(capabilities))
-    return f"[smoke:{tag}] {base_title}"
-
-
-def smoke_leg_capabilities(issue_title: str | None) -> tuple[str, ...] | None:
-    """The capability set :func:`smoke_leg_issue_title` encoded, or ``None``.
-
-    ``None`` for an ordinary (untagged) smoke row — every pre-#3182 ``[smoke]
-    ...`` single-partition dispatch, which never carries this prefix — or for
-    any non-smoke row. Never raises on a malformed or missing title.
-    """
-    if not issue_title:
-        return None
-    m = _LEG_TAG_RE.match(issue_title)
-    if not m:
-        return None
-    return tuple(m.group(1).split("+"))
-
-
-_FANOUT_MANIFEST_RE = re.compile(r"^\[\[smoke-fanout:([^\]]*)\]\]\n?")
-
-
-def _encode_fanout_manifest(
-    legs: list[tuple[str, tuple[str, ...], str | None]],
-) -> str:
-    """The manifest line stamped at the FRONT of the parent's ``test_reason``
-    for a #3182 fan-out: ``[[smoke-fanout:<id>=<caps>=<command_b64>,...]]``,
-    one entry per leg dispatched (or already active/completed) this round.
-    Preserved byte-for-byte across every later rewrite of the parent's
-    ``test_reason`` (the running-progress stamp, and the final aggregate) so
-    :func:`finalize_smoke_fanout` can always find its siblings again from
-    just the parent's own row — see the module note above for why this, and
-    not a new query endpoint.
-
-    ``command_b64`` (#3298) is the partition's own resolved Test-stage
-    command, URL-safe base64-encoded so an arbitrary shell command — commas,
-    brackets, newlines, anything a real ``test_command``/rule ``command`` can
-    contain — can never corrupt this manifest's own ``,``/``=``/``]``
-    delimiters. Encodes as an empty third field when the command is unknown
-    (``None``), which round-trips through :func:`_parse_fanout_manifest` as
-    ``command=None`` rather than raising or misparsing.
-    """
-    def _entry(leg_id: str, caps: tuple[str, ...], command: str | None) -> str:
-        cap_str = "+".join(sorted(caps))
-        cmd_b64 = (
-            base64.urlsafe_b64encode(command.encode()).decode() if command else ""
-        )
-        return f"{leg_id}={cap_str}={cmd_b64}"
-
-    body = ",".join(_entry(leg_id, caps, command) for leg_id, caps, command in legs)
-    return f"[[smoke-fanout:{body}]]"
-
-
-def _parse_fanout_manifest(
-    test_reason: str | None,
-) -> list[tuple[str, tuple[str, ...], str | None]] | None:
-    """The ``(leg_id, capabilities, command)`` triples
-    :func:`_encode_fanout_manifest` wrote, or ``None`` when *test_reason*
-    carries no manifest (not a fan-out row). Tolerates a malformed entry by
-    skipping just that entry, never raising.
-
-    ``command`` is ``None`` for a pre-#3298 two-field entry
-    (``<id>=<caps>``, no trailing ``=<command_b64>``) — an already-in-flight
-    row from before this field existed — as well as for a malformed base64
-    payload; either way the caller gets "unknown command", never a crash.
-    """
-    if not test_reason:
-        return None
-    m = _FANOUT_MANIFEST_RE.match(test_reason)
-    if not m:
-        return None
-    legs: list[tuple[str, tuple[str, ...], str | None]] = []
-    for entry in m.group(1).split(","):
-        if not entry:
-            continue
-        leg_id, _, rest = entry.partition("=")
-        caps, _, cmd_b64 = rest.partition("=")
-        if not leg_id or not caps:
-            continue
-        command: str | None = None
-        if cmd_b64:
-            try:
-                command = base64.urlsafe_b64decode(cmd_b64.encode()).decode()
-            except (ValueError, UnicodeDecodeError):
-                command = None
-        legs.append((leg_id, tuple(caps.split("+")), command))
-    return legs
+# `smoke_leg_issue_title` / `smoke_leg_capabilities` (the `[smoke:<caps>]`
+# tag on each leg's `issue_title`) and `_encode_fanout_manifest` /
+# `_parse_fanout_manifest` (the `[[smoke-fanout:...]]` manifest on the
+# parent's `test_reason`) used to be DEFINED here. They now live in
+# `coord/smoke_tags.py` and are re-exported by the import at the top of this
+# module, so `from coord.smoke import ...` is unchanged for every caller —
+# see that module's docstring for why the split exists.
 
 
 def _build_fanout_running_reason(

code_coordinator-0.5.539/coord/smoke_tags.py

@@ -0,0 +1,140 @@
+"""The #3182 fan-out's on-the-board *text encodings*, and nothing else.
+
+A capability-partition fan-out records two things as plain text on rows the
+board already has, rather than in a new table (see ``coord.smoke``'s own
+module note for why): each leg's ``issue_title`` carries a
+``[smoke:<caps>]`` tag, and the parent work row's ``test_reason`` carries a
+``[[smoke-fanout:...]]`` manifest naming every leg in that round.
+
+Those four functions used to live in ``coord/smoke.py``, next to the
+dispatcher that writes them. They are split out here because ``coord.smoke``
+imports the whole dispatch stack (``coord.config``, ``coord.dispatch``,
+``coord.github_ops``, ``coord.revalidate``, ``httpx``), while the encodings
+themselves are pure ``re``/``base64`` string handling with no coord
+dependency at all — and ``coord.stage_projection``, which has to *read* both
+encodings to count Test rounds (#3191), is deliberately a leaf module
+("Pure computation: ... no I/O, no side effects") whose only other
+production import is ``coord.models``. Importing ``coord.smoke`` from it
+just to reach two regexes would have dragged the entire dispatch stack into
+``coord serve``'s ``/board`` request path — a first-request-time import of
+half the package inside a threadpool worker — for no benefit.
+
+``coord.smoke`` re-exports every name below under its original spelling, so
+existing importers (``coord.notify``, ``coord.diagnose``,
+``coord.reconcile``, and the tests) are unaffected and there is exactly one
+definition of each encoding.
+"""
+
+from __future__ import annotations
+
+import base64
+import re
+
+# Restricted to `[a-z0-9+_-]` — every capability name in this codebase
+# (gtk, windows, macos, browser, provider:opencode via `+`-joining, etc.)
+# fits that class. If `coordinator.yml` ever declares a capability with an
+# uppercase letter, a dot, or another character outside it,
+# `smoke_leg_capabilities()` silently returns None for that leg (misread as
+# an ordinary untagged row) rather than raising — nothing today validates
+# capability naming at config-load time, so keep new capability names
+# lowercase/`[a-z0-9+_-]` until that validation exists.
+_LEG_TAG_RE = re.compile(r"^\[smoke:([a-z0-9+_-]+)\] ")
+
+
+def smoke_leg_issue_title(base_title: str, capabilities: tuple[str, ...]) -> str:
+    """The ``issue_title`` for one capability-partition leg of a #3182 fan-out.
+
+    Encodes *capabilities* (sorted, ``+``-joined) as a parseable prefix —
+    ``"[smoke:gtk+windows] <base_title>"`` — so :func:`smoke_leg_capabilities`
+    can read it back off the board. Used both for the per-partition in-flight
+    dedupe (``coord.smoke._find_leg_for_partition``) and for telling a
+    fan-out leg's own verdict apart from an ordinary single-leg smoke row's
+    when processing it (``coord.notify``).
+    """
+    tag = "+".join(sorted(capabilities))
+    return f"[smoke:{tag}] {base_title}"
+
+
+def smoke_leg_capabilities(issue_title: str | None) -> tuple[str, ...] | None:
+    """The capability set :func:`smoke_leg_issue_title` encoded, or ``None``.
+
+    ``None`` for an ordinary (untagged) smoke row — every pre-#3182 ``[smoke]
+    ...`` single-partition dispatch, which never carries this prefix — or for
+    any non-smoke row. Never raises on a malformed or missing title.
+    """
+    if not issue_title:
+        return None
+    m = _LEG_TAG_RE.match(issue_title)
+    if not m:
+        return None
+    return tuple(m.group(1).split("+"))
+
+
+_FANOUT_MANIFEST_RE = re.compile(r"^\[\[smoke-fanout:([^\]]*)\]\]\n?")
+
+
+def _encode_fanout_manifest(
+    legs: list[tuple[str, tuple[str, ...], str | None]],
+) -> str:
+    """The manifest line stamped at the FRONT of the parent's ``test_reason``
+    for a #3182 fan-out: ``[[smoke-fanout:<id>=<caps>=<command_b64>,...]]``,
+    one entry per leg dispatched (or already active/completed) this round.
+    Preserved byte-for-byte across every later rewrite of the parent's
+    ``test_reason`` (the running-progress stamp, and the final aggregate) so
+    ``coord.smoke.finalize_smoke_fanout`` can always find its siblings again
+    from just the parent's own row — see that module's note for why this, and
+    not a new query endpoint.
+
+    ``command_b64`` (#3298) is the partition's own resolved Test-stage
+    command, URL-safe base64-encoded so an arbitrary shell command — commas,
+    brackets, newlines, anything a real ``test_command``/rule ``command`` can
+    contain — can never corrupt this manifest's own ``,``/``=``/``]``
+    delimiters. Encodes as an empty third field when the command is unknown
+    (``None``), which round-trips through :func:`_parse_fanout_manifest` as
+    ``command=None`` rather than raising or misparsing.
+    """
+    def _entry(leg_id: str, caps: tuple[str, ...], command: str | None) -> str:
+        cap_str = "+".join(sorted(caps))
+        cmd_b64 = (
+            base64.urlsafe_b64encode(command.encode()).decode() if command else ""
+        )
+        return f"{leg_id}={cap_str}={cmd_b64}"
+
+    body = ",".join(_entry(leg_id, caps, command) for leg_id, caps, command in legs)
+    return f"[[smoke-fanout:{body}]]"
+
+
+def _parse_fanout_manifest(
+    test_reason: str | None,
+) -> list[tuple[str, tuple[str, ...], str | None]] | None:
+    """The ``(leg_id, capabilities, command)`` triples
+    :func:`_encode_fanout_manifest` wrote, or ``None`` when *test_reason*
+    carries no manifest (not a fan-out row). Tolerates a malformed entry by
+    skipping just that entry, never raising.
+
+    ``command`` is ``None`` for a pre-#3298 two-field entry
+    (``<id>=<caps>``, no trailing ``=<command_b64>``) — an already-in-flight
+    row from before this field existed — as well as for a malformed base64
+    payload; either way the caller gets "unknown command", never a crash.
+    """
+    if not test_reason:
+        return None
+    m = _FANOUT_MANIFEST_RE.match(test_reason)
+    if not m:
+        return None
+    legs: list[tuple[str, tuple[str, ...], str | None]] = []
+    for entry in m.group(1).split(","):
+        if not entry:
+            continue
+        leg_id, _, rest = entry.partition("=")
+        caps, _, cmd_b64 = rest.partition("=")
+        if not leg_id or not caps:
+            continue
+        command: str | None = None
+        if cmd_b64:
+            try:
+                command = base64.urlsafe_b64decode(cmd_b64.encode()).decode()
+            except (ValueError, UnicodeDecodeError):
+                command = None
+        legs.append((leg_id, tuple(caps.split("+")), command))
+    return legs

{code_coordinator-0.5.537 → code_coordinator-0.5.539}/coord/stage_projection.py

@@ -35,6 +35,15 @@ import dataclasses
 from typing import Any, Protocol, runtime_checkable
 
 from coord.models import CLOSES_ISSUE_TYPES, WORK_LIKE_TYPES, effective_issue_number
+# #3191: the two #3182 fan-out encodings this module has to PARSE to count
+# Test *rounds* rather than raw smoke rows — see `_test_stage_leg_count`.
+# Imported from the leaf `coord.smoke_tags`, never from `coord.smoke`, so
+# this module keeps the property its docstring above claims: the only thing
+# it pulls in is pure computation. `coord.smoke` would bring `coord.config`,
+# `coord.dispatch`, `coord.github_ops`, `coord.revalidate` and `httpx` with
+# it, and `compute_board_stage_projection` runs inside `coord serve`'s
+# `/board` handler.
+from coord.smoke_tags import _parse_fanout_manifest, smoke_leg_capabilities
 
 # ── Stage-status vocabulary — mirrors tui/src/app/pipeline.rs::StageStatus ──
 PENDING = "pending"
@@ -75,6 +84,7 @@ class _AssignmentLike(Protocol):
     review_verdict: str | None
     review_of_assignment_id: str | None
     test_state: str | None
+    test_reason: str | None
     repo_name: str
     issue_number: int
     acceptance_state: str | None
@@ -82,6 +92,7 @@ class _AssignmentLike(Protocol):
     acceptance_passed: int | None
     uat_state: str | None
     uat_reason: str | None
+    issue_title: str | None
 
 
 # ── Helpers ──────────────────────────────────────────────────────────────
@@ -195,7 +206,11 @@ def _leg_count_for_stage(
       field exists to surface, and a strict ``type == "work"`` match would
       never see them.
     * ``"test"`` has no ``type="test"`` assignment — the Test-stage's
-      dispatched worker is ``type="smoke"`` (``coord.smoke``).
+      dispatched worker is ``type="smoke"`` (``coord.smoke``). Since #3182,
+      one Test *attempt* can dispatch more than one ``type="smoke"`` row (a
+      fan-out leg per capability partition), so a flat row count over-reports
+      — see :func:`_test_stage_leg_count` for how rows are folded back into
+      rounds.
     * ``"merge"`` has no ``type="merge"`` assignment either — repeated
       landing attempts show up as ``type="conflict-fix"`` legs (#241). Note
       the counting convention this implies differs from every other stage:
@@ -230,7 +245,7 @@ def _leg_count_for_stage(
         ]
         return len(matching) + len(extra)
     if stage == "test":
-        return sum(1 for a in assignments_for_issue if (a.type or "work") == "smoke")
+        return _test_stage_leg_count(assignments_for_issue)
     if stage == "merge":
         return sum(1 for a in assignments_for_issue if (a.type or "work") == "conflict-fix")
     if stage == "acceptance":
@@ -242,6 +257,77 @@ def _leg_count_for_stage(
     return len(assignments_for_stage(assignments_for_issue, stage, require_plan=require_plan))
 
 
+def _test_stage_leg_count(assignments_for_issue: list) -> int:
+    """How many separate Test-stage *attempts* — not raw ``type="smoke"``
+    rows — this issue has had (#3191).
+
+    Before #3182, one Test attempt was always exactly one ``type="smoke"``
+    row, so :func:`_leg_count_for_stage`'s flat row count was already
+    correct. #3182's fan-out (``coord.smoke._dispatch_smoke_fanout``) breaks
+    that: a diff whose ``capability_rules`` matches span more than one
+    machine-satisfiable partition (e.g. ``gtk+windows`` and ``macos``)
+    dispatches one smoke row PER partition for a single Test round, so a
+    clean, fully-successful first attempt reported ``stage_counts["test"] ==
+    2`` — read by every board client as "this needed a retry" (#3013), which
+    is exactly backwards.
+
+    A fan-out leg's own ``issue_title`` carries a ``[smoke:<caps>]`` tag
+    (``coord.smoke_tags.smoke_leg_issue_title``/``smoke_leg_capabilities``);
+    an ordinary single-leg dispatch (the pre-#3182 path, and every row that
+    predates it) carries none. Untagged rows keep counting 1:1 — no
+    behaviour change for the common case.
+
+    A tagged leg's round is identified via the ``[[smoke-fanout:...]]``
+    manifest (``coord.smoke_tags._encode_fanout_manifest``/
+    ``_parse_fanout_manifest``) stamped on the leg's own parent row
+    (``review_of_assignment_id``) — every leg the manifest names is one
+    round, and rounds collapse to a single count regardless of how many
+    partitions they fanned out to.
+
+    Known limitation, not fixed here: a Test retry clears the parent's
+    ``test_reason`` (``coord.state.reset_work_test_state``) before the next
+    round dispatches and writes a fresh manifest, so a SUPERSEDED round's
+    manifest no longer exists to fold its legs back together by the time
+    this runs — those orphaned tagged legs fall back to counting 1 each,
+    same as before this fix. That only ever *over*-counts a past, already-
+    resolved round; it never reproduces the bug this closes, which was
+    about the live/most-recent round (the one every reader actually looks
+    at) reporting a false retry on a clean first attempt.
+    """
+    smoke_legs = [a for a in assignments_for_issue if (a.type or "work") == "smoke"]
+    if not smoke_legs:
+        return 0
+
+    # Every row's own manifest, keyed by that row's `assignment_id` — a
+    # fan-out leg's PARENT (the work-like row `review_of_assignment_id`
+    # points back to) is the one that carries it, not the leg itself.
+    manifest_leg_ids_by_parent: dict[str, frozenset[str]] = {}
+    for a in assignments_for_issue:
+        parsed = _parse_fanout_manifest(getattr(a, "test_reason", None))
+        if parsed and a.assignment_id:
+            manifest_leg_ids_by_parent[a.assignment_id] = frozenset(
+                leg_id for leg_id, _caps, _cmd in parsed if leg_id
+            )
+
+    count = 0
+    counted_rounds: set[tuple[str, frozenset[str]]] = set()
+    for leg in smoke_legs:
+        if smoke_leg_capabilities(getattr(leg, "issue_title", None)) is None:
+            count += 1
+            continue
+        manifest_ids = manifest_leg_ids_by_parent.get(leg.review_of_assignment_id or "")
+        if not manifest_ids or leg.assignment_id not in manifest_ids:
+            # Orphaned tagged leg — see the "Known limitation" note above.
+            count += 1
+            continue
+        round_key = (leg.review_of_assignment_id or "", manifest_ids)
+        if round_key in counted_rounds:
+            continue
+        counted_rounds.add(round_key)
+        count += 1
+    return count
+
+
 def _widen_work_like_types(assignments: list) -> list:
     """Return *assignments* with every :data:`WORK_LIKE_TYPES` row (#3013:
     ``mock-author``/``test-author``, not just literal ``type="work"``)