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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.538
+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.538 → 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.538
+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.538 → 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.538 → 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.538 → code_coordinator-0.5.539}/code_coordinator.egg-info/scm_version.json

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

{code_coordinator-0.5.538 → 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.538 → 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"``)

{code_coordinator-0.5.538 → code_coordinator-0.5.539}/tests/test_stage_projection.py

@@ -477,6 +477,91 @@ def test_compute_issue_projection_stage_counts_test_counts_smoke_legs():
     assert out["stage_counts"]["test"] == 2
 
 
+def test_compute_issue_projection_stage_counts_test_fanout_legs_count_as_one_round():
+    """#3191: a #3182 capability-partition fan-out dispatches one
+    `type="smoke"` row PER partition for a SINGLE Test attempt — a flat row
+    count reports 2 for a clean, fully-successful first attempt, which every
+    board reader renders as "this needed a retry". Legs sharing the same
+    parent and `[[smoke-fanout:...]]` manifest must collapse to one round."""
+    from coord.smoke import _encode_fanout_manifest, smoke_leg_issue_title
+
+    manifest = _encode_fanout_manifest(
+        [("s1", ("gtk", "windows"), "pytest"), ("s2", ("macos",), "pytest")]
+    )
+    a = [
+        _work(
+            assignment_id="w1", status="done", dispatched_at=1.0,
+            test_state="passed", test_reason=f"{manifest}\nboth legs passed.",
+        ),
+        _work(
+            assignment_id="s1", type="smoke", status="done", test_state="passed",
+            dispatched_at=2.0, review_of_assignment_id="w1",
+            issue_title=smoke_leg_issue_title("t", ("gtk", "windows")),
+        ),
+        _work(
+            assignment_id="s2", type="smoke", status="done", test_state="passed",
+            dispatched_at=2.0, review_of_assignment_id="w1",
+            issue_title=smoke_leg_issue_title("t", ("macos",)),
+        ),
+    ]
+    out = sp.compute_issue_projection(
+        a, None, is_closed=False, require_plan=False, default_gates=["test", "review", "merge"],
+    )
+    assert out["stage_counts"]["test"] == 1
+
+
+def test_compute_issue_projection_stage_counts_test_fanout_two_rounds_count_as_two():
+    """A genuine retry (a fresh fan-out round after the first one failed and
+    was reset) must still surface as 2, not collapse into the same round as
+    the first — the fix must not hide real retries, only fold same-round
+    partitions together."""
+    from coord.smoke import _encode_fanout_manifest, smoke_leg_issue_title
+
+    round1_manifest = _encode_fanout_manifest(
+        [("s1", ("gtk", "windows"), "pytest"), ("s2", ("macos",), "pytest")]
+    )
+    round2_manifest = _encode_fanout_manifest(
+        [("s3", ("gtk", "windows"), "pytest"), ("s4", ("macos",), "pytest")]
+    )
+    a = [
+        # Round 1's manifest has since been overwritten by round 2's — its
+        # legs are now "orphaned" and counted individually (documented
+        # limitation), which still correctly signals "more than one round".
+        _work(
+            assignment_id="w1", status="done", dispatched_at=3.0,
+            test_state="passed", test_reason=f"{round2_manifest}\nboth legs passed.",
+        ),
+        _work(
+            assignment_id="s1", type="smoke", status="failed", test_state="failed",
+            dispatched_at=1.0, review_of_assignment_id="w1",
+            issue_title=smoke_leg_issue_title("t", ("gtk", "windows")),
+        ),
+        _work(
+            assignment_id="s2", type="smoke", status="done", test_state="passed",
+            dispatched_at=1.0, review_of_assignment_id="w1",
+            issue_title=smoke_leg_issue_title("t", ("macos",)),
+        ),
+        _work(
+            assignment_id="s3", type="smoke", status="done", test_state="passed",
+            dispatched_at=3.0, review_of_assignment_id="w1",
+            issue_title=smoke_leg_issue_title("t", ("gtk", "windows")),
+        ),
+        _work(
+            assignment_id="s4", type="smoke", status="done", test_state="passed",
+            dispatched_at=3.0, review_of_assignment_id="w1",
+            issue_title=smoke_leg_issue_title("t", ("macos",)),
+        ),
+    ]
+    out = sp.compute_issue_projection(
+        a, None, is_closed=False, require_plan=False, default_gates=["test", "review", "merge"],
+    )
+    # Round 2's two partitions collapse to 1 (live manifest); round 1's two
+    # orphaned legs count individually (2) — 3 total, still > 1, still
+    # visibly "more than a single clean attempt" even though it isn't an
+    # exact historical reconstruction (see the documented limitation).
+    assert out["stage_counts"]["test"] == 3
+
+
 def test_compute_issue_projection_stage_counts_merge_counts_conflict_fix_legs():
     """Repeated landing attempts show up as `type="conflict-fix"` legs
     (#241) — there is no `type="merge"` assignment to count directly."""
@@ -1272,3 +1357,92 @@ def test_compute_board_stage_projection_stage_counts_ordinary_issue_uses_own_key
     entry = out[0]
     assert entry["stage_counts"]["work"] == 2
     assert entry["stage_counts"]["review"] == 1
+
+
+# ── #3191 CI follow-up: the projection module stays a dependency-free leaf ──
+
+
+def test_stage_projection_imports_no_heavy_module():
+    """``coord.stage_projection`` must not pull the dispatch stack in.
+
+    Its own module docstring promises "Pure computation: every function here
+    takes already-loaded data and returns plain values — no I/O, no side
+    effects", and until #3191 its only production import was
+    ``coord.models``. #3191 needs the two #3182 fan-out text encodings
+    (``[smoke:<caps>]``, ``[[smoke-fanout:...]]``) to count Test *rounds*
+    instead of raw smoke rows; taking them from ``coord.smoke`` would have
+    dragged ``coord.config``, ``coord.dispatch``, ``coord.github_ops``,
+    ``coord.revalidate`` and ``httpx`` in with them — and
+    ``compute_board_stage_projection`` runs inside ``coord serve``'s
+    ``/board`` handler, so on a daemon that had not otherwise imported
+    ``coord.smoke`` the first ``/board`` request would have triggered that
+    whole import in a threadpool worker. They live in the leaf
+    ``coord.smoke_tags`` instead.
+
+    Runs in a **subprocess** for the same reason
+    ``tests/test_client_base_install.py`` does: by the time this test body
+    executes, collection has long since imported ``coord.smoke`` into *this*
+    interpreter, so an in-process ``sys.modules`` check would pass no matter
+    what the import graph looks like.
+    """
+    import subprocess
+    import sys
+
+    probe = (
+        "import sys, coord.stage_projection\n"
+        "heavy = ('coord.smoke', 'coord.dispatch', 'coord.github_ops',\n"
+        "         'coord.config', 'coord.revalidate', 'httpx')\n"
+        "print(','.join(m for m in heavy if m in sys.modules))\n"
+    )
+    proc = subprocess.run(
+        [sys.executable, "-c", probe], capture_output=True, text=True, timeout=120
+    )
+    assert proc.returncode == 0, proc.stderr
+    leaked = proc.stdout.strip()
+    assert leaked == "", (
+        f"importing coord.stage_projection pulled in {leaked} — keep it a "
+        "leaf (import fan-out encodings from coord.smoke_tags, not coord.smoke)"
+    )
+
+
+def test_smoke_reexports_the_fanout_encodings_from_the_leaf_module():
+    """One definition, two spellings: ``coord.smoke`` re-exports the encodings
+    so every pre-existing ``from coord.smoke import ...`` caller
+    (``coord.notify``, ``coord.diagnose``, ``coord.reconcile``, the tests) is
+    unaffected — and a future edit cannot fork the encoder from the parser by
+    redefining one of them in only one of the two modules."""
+    from coord import smoke, smoke_tags
+
+    for name in (
+        "smoke_leg_issue_title",
+        "smoke_leg_capabilities",
+        "_encode_fanout_manifest",
+        "_parse_fanout_manifest",
+    ):
+        assert getattr(smoke, name) is getattr(smoke_tags, name), name
+
+
+def test_fanout_encodings_round_trip_through_the_leaf_module():
+    """The moved code still behaves: a tag and a manifest written by
+    ``coord.smoke_tags`` parse back to exactly what went in, including the
+    #3298 base64 command field and the "unknown command" (``None``) case."""
+    from coord.smoke_tags import (
+        _encode_fanout_manifest,
+        _parse_fanout_manifest,
+        smoke_leg_capabilities,
+        smoke_leg_issue_title,
+    )
+
+    title = smoke_leg_issue_title("Fix the thing", ("windows", "gtk"))
+    assert title == "[smoke:gtk+windows] Fix the thing"
+    assert smoke_leg_capabilities(title) == ("gtk", "windows")
+    assert smoke_leg_capabilities("Fix the thing") is None
+
+    manifest = _encode_fanout_manifest(
+        [("s1", ("gtk", "windows"), "pytest -q, --x"), ("s2", ("macos",), None)]
+    )
+    assert _parse_fanout_manifest(f"{manifest}\ntrailing prose") == [
+        ("s1", ("gtk", "windows"), "pytest -q, --x"),
+        ("s2", ("macos",), None),
+    ]
+    assert _parse_fanout_manifest("no manifest here") is None