code-coordinator 0.5.330__tar.gz → 0.5.332__tar.gz

{code_coordinator-0.5.330 → code_coordinator-0.5.332}/PKG-INFO

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

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

@@ -91,6 +91,7 @@ coord/interactive.py
 coord/issue_store.py
 coord/issues_sync_status.py
 coord/liveness_auditor.py
+coord/machine_metrics.py
 coord/machine_onboard.py
 coord/machine_pause.py
 coord/merge_queue.py
@@ -625,6 +626,7 @@ tests/test_issues_sync_status.py
 tests/test_liveness_auditor.py
 tests/test_liveness_notify.py
 tests/test_lock_contention_ratchet.py
+tests/test_machine_metrics.py
 tests/test_machine_onboard.py
 tests/test_machine_pause.py
 tests/test_merge_queue.py

{code_coordinator-0.5.330 → code_coordinator-0.5.332}/code_coordinator.egg-info/scm_file_list.json

@@ -181,6 +181,7 @@
     "coord/issue_store.py",
     "coord/issues_sync_status.py",
     "coord/liveness_auditor.py",
+    "coord/machine_metrics.py",
     "coord/machine_onboard.py",
     "coord/machine_pause.py",
     "coord/merge_queue.py",
@@ -651,6 +652,7 @@
     "tests/test_liveness_auditor.py",
     "tests/test_liveness_notify.py",
     "tests/test_lock_contention_ratchet.py",
+    "tests/test_machine_metrics.py",
     "tests/test_machine_onboard.py",
     "tests/test_machine_pause.py",
     "tests/test_merge_queue.py",

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

@@ -0,0 +1,8 @@
+{
+  "tag": "0.5.332",
+  "distance": 0,
+  "node": "g9eb084d2d068fc5fdf96e3a5de7f75bb41902679",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-09-01"
+}

code_coordinator-0.5.332/coord/machine_metrics.py

@@ -0,0 +1,217 @@
+"""Coordinator-side machine metrics sampler + bounded ring buffer (#3020).
+
+Part of milestone #71 (Fleet metrics + machines API) — the backend half of
+the coord-web Machines panel.
+
+``coord-tui`` renders CPU/mem sparklines by polling **each agent's own**
+``/metrics`` endpoint directly on port 7433 (``coord.agent_app.metrics``, a
+``psutil`` cpu/mem snapshot) and buffering samples in-process for as long as
+the panel stays open (see ``coord-tui/src/app/data.rs``
+``spawn_machine_metrics``). A browser can't do that — ``coord web`` is a
+single-origin HTTP client of the dashboard API, not something that can fan
+out to N agent hosts — and nothing anywhere persists a series; the TUI's
+``VecDeque`` dies with the panel.
+
+This module is the one missing thing: a coordinator-side sampler, owned by
+the board daemon (``coord serve``) and driven off its existing periodic-loop
+machinery (mirrors ``coord.health.fleet_snapshot.FleetHealthRefresher`` and
+``coord.gate_snapshot.GateSnapshotRefresher`` — see ``coord.serve_app``'s
+``_machine_metrics_loop``, isolated from ``_tick_loop`` for the identical
+reason those two are: a fan-out HTTP GET per agent must never block, or be
+blocked by, the reconcile/enqueue/drain steps).
+
+**Bounded, not incidental (#3020).** Each machine gets its own
+``collections.deque(maxlen=...)`` ring buffer sized for a ~6h window at the
+default ~15s cadence (:data:`DEFAULT_MAX_SAMPLES` = 1440) — old samples are
+evicted automatically as new ones arrive; the process can never accumulate
+unbounded history no matter how long the daemon stays up.
+
+**``unknown``, never a silent gap (#1485).** A failed, timed-out, or 503
+(psutil not installed) poll still appends a sample — with
+``status="unknown"`` — never nothing. A renderer building a sparkline from
+this series must be able to tell "no data point" (a gap it filled in itself)
+from "the daemon tried and the agent didn't answer" (an explicit unknown
+sample); silently skipping the append would collapse that distinction back
+into "looks the same as healthy", the exact failure mode
+``coord.health.fleet_snapshot`` already guards against for machine health.
+
+**No persistence.** This is purely in-memory; history is lost on daemon
+restart by design (a sqlite time-series was considered and deliberately
+rejected for this milestone — see the issue).
+
+**Out of scope here.** The read endpoint for this series (#A2) and putting
+it on ``/board`` (explicitly rejected — every TUI client polls ``/board`` on
+a short interval and ``FleetHealthSnapshot`` already carries a 256 KiB cap
+for exactly this reason) are not this module's job.
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from collections import deque
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass
+
+import httpx
+
+from coord.network import AGENT_PORT, DEFAULT_TIMEOUT, classify_error
+
+log = logging.getLogger("coord.serve")
+
+# ~6h of history at the default ~15s cadence. Explicit and enforced (each
+# per-machine buffer is a `deque(maxlen=...)`, not a list someone forgot to
+# trim) rather than incidental.
+DEFAULT_MAX_SAMPLES = 1440
+DEFAULT_CADENCE_SECONDS = 15.0
+
+STATUS_OK = "ok"
+STATUS_UNKNOWN = "unknown"
+
+
+@dataclass(frozen=True)
+class MetricsSample:
+    """One machine, one point in time. ``status="unknown"`` carries no
+    cpu/mem values — never fabricated zeros — only a human-readable
+    ``reason`` for why the poll didn't produce a real reading.
+    """
+
+    timestamp: float
+    status: str  # STATUS_OK | STATUS_UNKNOWN
+    cpu_percent: float | None = None
+    mem_percent: float | None = None
+    mem_used_mb: float | None = None
+    mem_total_mb: float | None = None
+    reason: str = ""
+
+    def to_dict(self) -> dict:
+        return {
+            "timestamp": self.timestamp,
+            "status": self.status,
+            "cpu_percent": self.cpu_percent,
+            "mem_percent": self.mem_percent,
+            "mem_used_mb": self.mem_used_mb,
+            "mem_total_mb": self.mem_total_mb,
+            "reason": self.reason,
+        }
+
+
+def _unknown(reason: str, *, now: float | None = None) -> MetricsSample:
+    return MetricsSample(
+        timestamp=now if now is not None else time.time(),
+        status=STATUS_UNKNOWN,
+        reason=reason,
+    )
+
+
+def fetch_metrics(machine, timeout: float = DEFAULT_TIMEOUT) -> MetricsSample:  # noqa: ANN001 — coord.models.Machine
+    """GET one machine's agent ``/metrics`` and classify the result.
+
+    Mirrors ``coord.network.check_machine``'s error classification but
+    targets ``/metrics`` instead of ``/health``. Never raises: every failure
+    mode — connect/read timeout, DNS failure, connection refused, a non-200
+    status (including the documented 503 an agent returns when ``psutil``
+    isn't installed), and malformed/missing-field JSON — becomes an explicit
+    :data:`STATUS_UNKNOWN` sample rather than an exception or a dropped
+    point. The bounded ``timeout`` (default :data:`coord.network.
+    DEFAULT_TIMEOUT`, 3s) is what keeps one hanging agent from stalling this
+    call past that ceiling; :class:`MachineMetricsSampler.refresh` is what
+    keeps that bounded stall from serializing behind every other machine.
+    """
+    url = f"http://{machine.host}:{AGENT_PORT}/metrics"
+    try:
+        resp = httpx.get(url, timeout=timeout)
+    except Exception as e:  # noqa: BLE001 — classify every network error, never raise
+        _, reason = classify_error(e)
+        return _unknown(reason)
+
+    if resp.status_code == 503:
+        # #207's documented shape: psutil not installed on that agent.
+        return _unknown("psutil not installed on agent")
+    if resp.status_code != 200:
+        return _unknown(f"HTTP {resp.status_code}")
+
+    try:
+        data = resp.json()
+    except ValueError:
+        return _unknown("invalid JSON from /metrics")
+
+    try:
+        return MetricsSample(
+            timestamp=time.time(),
+            status=STATUS_OK,
+            cpu_percent=float(data["cpu_percent"]),
+            mem_percent=float(data["mem_percent"]),
+            mem_used_mb=float(data["mem_used_mb"]),
+            mem_total_mb=float(data["mem_total_mb"]),
+        )
+    except (KeyError, TypeError, ValueError):
+        return _unknown("malformed /metrics payload")
+
+
+class MachineMetricsSampler:
+    """Owns the bounded per-machine ring buffers; refreshed by the daemon tick.
+
+    ``series()``/``all_series()`` are the read path — bare in-memory reads,
+    no I/O, safe to call from a request handler. ``refresh(config)`` is the
+    only method that talks to agents and must only ever run from the
+    daemon's tick machinery (or a test driving it explicitly), exactly the
+    same split as ``coord.health.fleet_snapshot.FleetHealthRefresher``.
+    """
+
+    def __init__(
+        self,
+        *,
+        max_samples: int = DEFAULT_MAX_SAMPLES,
+        timeout: float = DEFAULT_TIMEOUT,
+    ) -> None:
+        if max_samples <= 0:
+            raise ValueError("max_samples must be positive")
+        self._max_samples = max_samples
+        self._timeout = timeout
+        self._buffers: dict[str, deque] = {}
+
+    def series(self, machine_name: str) -> list[dict]:
+        """This machine's samples, oldest first. ``[]`` if never polled."""
+        buf = self._buffers.get(machine_name)
+        return [s.to_dict() for s in buf] if buf else []
+
+    def all_series(self) -> dict[str, list[dict]]:
+        """Every known machine's series, oldest-first, keyed by name."""
+        return {name: [s.to_dict() for s in buf] for name, buf in self._buffers.items()}
+
+    def refresh(self, config) -> None:  # noqa: ANN001 — coord.config.Config
+        """Poll every machine in ``config.machines`` once and append a sample
+        each — :data:`STATUS_OK` or :data:`STATUS_UNKNOWN`, never neither.
+
+        Polls concurrently (mirrors ``coord.network.check_all``): each call
+        is individually bounded by ``timeout``, and running them in a thread
+        pool rather than sequentially means one slow/hanging agent's bounded
+        stall does not serialize in front of the rest of the fleet's polls —
+        the whole ``refresh()`` call takes roughly one ``timeout``, not
+        ``len(machines) * timeout``, no matter which machine is the slow
+        one. Called off the event loop (``run_in_threadpool`` from
+        ``coord.serve_app``'s own loop, isolated from ``_tick_loop``) so
+        even that bound never touches board-read latency.
+        """
+        machines = list(getattr(config, "machines", ()) or ())
+        if not machines:
+            return
+
+        workers = min(8, len(machines))
+        with ThreadPoolExecutor(max_workers=workers) as pool:
+            samples = list(pool.map(self._poll_one, machines))
+
+        for machine, sample in zip(machines, samples):
+            buf = self._buffers.get(machine.name)
+            if buf is None:
+                buf = deque(maxlen=self._max_samples)
+                self._buffers[machine.name] = buf
+            buf.append(sample)
+
+    def _poll_one(self, machine) -> MetricsSample:  # noqa: ANN001
+        try:
+            return fetch_metrics(machine, timeout=self._timeout)
+        except Exception as exc:  # noqa: BLE001 — one bad machine must never abort the refresh
+            log.warning("machine-metrics poll: %s raised %s", machine.name, exc)
+            return _unknown(f"poll raised: {exc}")

{code_coordinator-0.5.330 → code_coordinator-0.5.332}/coord/serve_app.py

@@ -2547,7 +2547,8 @@ def _board_response_schema(components: dict) -> dict:
                     "#550: server-computed per-issue stage/gate badges "
                     "(work/review/smoke/test/merge status, has_approved_review) — "
                     "generalizes the #776/#778 pattern so coord-tui's "
-                    "pipeline.rs stops re-deriving this from raw rows"
+                    "pipeline.rs stops re-deriving this from raw rows. #3013 adds "
+                    "a per-stage leg count (`stage_counts`) alongside the status."
                 ),
                 "items": {
                     "type": "object",
@@ -2560,6 +2561,24 @@ def _board_response_schema(components: dict) -> dict:
                             "description": "stage name -> pending|active|done|failed|stale|skipped",
                             "additionalProperties": {"type": "string"},
                         },
+                        "stage_counts": {
+                            "type": "object",
+                            "description": (
+                                "#3013: stage name -> count of separate dispatched "
+                                "legs at that stage (e.g. a stage re-dispatched 4 "
+                                "times reads 4, not 1) — lets a client render "
+                                "'Work (2)' / 'Review (5)' and suppress the suffix "
+                                "at 1. Same key set as `stages` (including "
+                                "`acceptance`). Caveat: `merge` uses a different "
+                                "convention from every other key — it counts "
+                                "conflict-fix RETRIES (0 for a clean single merge, "
+                                "not 1 for 'one attempt happened'), so a uniform "
+                                "'suppress at <= 1' rule will also suppress a "
+                                "single conflict-fix retry, which is usually the "
+                                "most useful count to surface."
+                            ),
+                            "additionalProperties": {"type": "integer"},
+                        },
                         "has_approved_review": {"type": "boolean"},
                         "uat_preview_url": {
                             "type": ["string", "null"],
@@ -2571,7 +2590,13 @@ def _board_response_schema(components: dict) -> dict:
                             ),
                         },
                     },
-                    "required": ["repo_name", "issue_number", "stages", "has_approved_review"],
+                    "required": [
+                        "repo_name",
+                        "issue_number",
+                        "stages",
+                        "stage_counts",
+                        "has_approved_review",
+                    ],
                 },
             },
             "plan_roster": {
@@ -5315,6 +5340,15 @@ def build_app(store: CoordStore, config: Config, *, token: str | None = None) ->
 
     _fleet_health_refresher = FleetHealthRefresher()
 
+    # #3020: same shape again — polling every agent's own /metrics is real
+    # per-machine I/O, so it runs on the tick loop's cadence
+    # (`_machine_metrics_loop` below), never inline off a request handler.
+    # Series live only in this sampler's bounded in-memory ring buffers; no
+    # read endpoint exists yet (that's #A2) and nothing here touches /board.
+    from coord.machine_metrics import MachineMetricsSampler  # noqa: PLC0415
+
+    _machine_metrics_sampler = MachineMetricsSampler()
+
     # Short-TTL cache for the computed /board projection so burst polls from the
     # TUI don't each pay the full board_projection + merge-plan + stage-projection
     # recomputation (~465-issue load measured in the issue). Keyed to nothing
@@ -9427,6 +9461,26 @@ def build_app(store: CoordStore, config: Config, *, token: str | None = None) ->
                 except Exception:  # noqa: BLE001 — keep serving the old snapshot
                     log.warning("fleet-health refresh failed", exc_info=True)
 
+        # #3020: CPU/mem sampler for the coord-web Machines panel — default
+        # 15s (env COORD_METRICS_POLL_INTERVAL; 0 disables). Own loop, not a
+        # `_tick_loop` step, for the identical reason as `_health_refresh_loop`
+        # just above: it fans out one HTTP GET per agent and must never be
+        # held up behind, or hold up, the reconcile/enqueue/drain steps.
+        try:
+            metrics_poll_interval = float(
+                os.environ.get("COORD_METRICS_POLL_INTERVAL", "15")
+            )
+        except ValueError:
+            metrics_poll_interval = 15.0
+
+        async def _machine_metrics_loop() -> None:
+            while True:
+                await asyncio.sleep(metrics_poll_interval)
+                try:
+                    await run_in_threadpool(_machine_metrics_sampler.refresh, config)
+                except Exception:  # noqa: BLE001 — a tick must never crash the daemon
+                    log.warning("machine-metrics refresh failed", exc_info=True)
+
         # #2570: the #2536 phantom-row auto-heal, run a SECOND time from
         # inside this long-lived process rather than relying solely on
         # `coord-notify.timer`'s oneshot `~/.coord-venv/bin/coord notify`
@@ -10193,12 +10247,18 @@ def build_app(store: CoordStore, config: Config, *, token: str | None = None) ->
                 else None,
                 "auto-revalidate",
             )
+            machine_metrics_task = _watch(
+                asyncio.create_task(_machine_metrics_loop())
+                if interval > 0 and metrics_poll_interval > 0
+                else None,
+                "machine-metrics",
+            )
             try:
                 yield
             finally:
                 for t in (
                     task, gate_task, health_task, phantom_heal_task,
-                    auto_revalidate_task,
+                    auto_revalidate_task, machine_metrics_task,
                 ):
                     if t is not None:
                         t.cancel()

{code_coordinator-0.5.330 → code_coordinator-0.5.332}/coord/stage_projection.py

@@ -31,9 +31,10 @@ plain values — no I/O, no side effects.
 
 from __future__ import annotations
 
+import dataclasses
 from typing import Any, Protocol, runtime_checkable
 
-from coord.models import CLOSES_ISSUE_TYPES
+from coord.models import CLOSES_ISSUE_TYPES, WORK_LIKE_TYPES, effective_issue_number
 
 # ── Stage-status vocabulary — mirrors tui/src/app/pipeline.rs::StageStatus ──
 PENDING = "pending"
@@ -172,6 +173,102 @@ def assignments_for_stage(
     return out
 
 
+def _leg_count_for_stage(
+    assignments_for_issue: list,
+    stage: str,
+    *,
+    require_plan: bool,
+) -> int:
+    """How many separate dispatched attempts ("legs") this issue has had at
+    *stage* (#3013) — "attempts a human would recognise as separate", not a
+    raw row count. Each retry/redispatch is already its own board row (a
+    retry dispatches a fresh assignment id rather than mutating the failed
+    one, see ``coord.reconcile._reassign``), so counting rows already gives
+    the right number for stages backed by their own dedicated assignment
+    ``type`` — this only needs to special-case the stages that aren't:
+
+    * ``"work"`` is widened from a literal ``type == "work"`` (plus the
+      existing plan-fold) to the full :data:`WORK_LIKE_TYPES` — an
+      oracle-loop acceptance slice's repeated ``test-author``/``mock-author``
+      legs (#3013's coord-portal#164 example: 4 ``test-author`` legs, 5
+      ``review`` legs on one branch) are exactly the kind of repetition this
+      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``).
+    * ``"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:
+      a clean single merge with no conflict reports ``0`` (no *retry* was
+      needed), whereas one ordinary ``"work"``/``"review"``/``"test"`` leg
+      reports ``1`` (one attempt happened). A client applying one uniform
+      "suppress the number at <= 1" rule across every stage — as the
+      ``/board`` schema description implies — will suppress a single
+      conflict-fix leg (``count == 1``, arguably the most useful case to
+      surface: "this needed a rebase") exactly like "no problem at all". No
+      code path here can distinguish the two without a wire-schema change,
+      so this is flagged for the client rather than fixed on this side.
+    * ``"acceptance"`` (review fix, #3013) has no dedicated assignment type
+      either — like ``test_state``/``uat_state``, ``acceptance_state`` is
+      stamped directly onto the ``type="work"`` row a
+      ``coord acceptance record`` verdict belongs to (see
+      :func:`acceptance_stage_status_for`, which reads the same rows), so a
+      generic ``assignments_for_stage(..., "acceptance", ...)`` scan would
+      always return zero.
+
+    Every other stage (``"plan"``, ``"review"``, ``"uat"``, ...) already has
+    a 1:1 assignment ``type``, so :func:`assignments_for_stage` alone gives
+    the right count.
+    """
+    if stage == "work":
+        matching = assignments_for_stage(assignments_for_issue, "work", require_plan=require_plan)
+        seen = {id(a) for a in matching}
+        extra = [
+            a
+            for a in assignments_for_issue
+            if id(a) not in seen and (a.type or "work") in WORK_LIKE_TYPES
+        ]
+        return len(matching) + len(extra)
+    if stage == "test":
+        return sum(1 for a in assignments_for_issue if (a.type or "work") == "smoke")
+    if stage == "merge":
+        return sum(1 for a in assignments_for_issue if (a.type or "work") == "conflict-fix")
+    if stage == "acceptance":
+        return sum(
+            1
+            for a in assignments_for_issue
+            if (a.type or "work") == "work" and (a.acceptance_state or "") != ""
+        )
+    return len(assignments_for_stage(assignments_for_issue, stage, require_plan=require_plan))
+
+
+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"``)
+    presented as ``type="work"`` to the generic per-stage dispatcher
+    (:func:`stage_status_for`, :func:`assignments_for_stage`,
+    :func:`acceptance_stage_status_for`, ...), all of which key strictly off
+    ``a.type``.
+
+    Used ONLY by :func:`compute_board_stage_projection`'s phantom-entry
+    fallback (see that function's docstring) — without it, a slice whose
+    only rows are ``test-author``/``mock-author`` legs got
+    ``stage_counts["work"] == 4`` (via :func:`_leg_count_for_stage`, which
+    already widens the same way) sitting next to ``stages["work"] ==
+    "pending"`` forever, since the strict-``type`` dispatcher never
+    recognised those rows as "work" activity. Every other field (status,
+    dispatched_at, test_state, acceptance_state, ...) is preserved
+    unchanged — this only relabels the ``type`` a downstream ``==`` check
+    sees.
+    """
+    out = []
+    for a in assignments:
+        t = a.type or "work"
+        widen = t in WORK_LIKE_TYPES and t != "work"
+        out.append(dataclasses.replace(a, type="work") if widen else a)
+    return out
+
+
 def upstream_max_dispatched_at(
     assignments_for_issue: list,
     stage: str,
@@ -698,6 +795,7 @@ def compute_issue_projection(
     ci_store: Any | None = None,
     uat_enabled: bool = False,
     uat_preview_url: str | None = None,
+    stage_count_assignments: list | None = None,
 ) -> dict[str, Any]:
     """Compute the full per-issue stage badge dict.
 
@@ -717,6 +815,15 @@ def compute_issue_projection(
     carried through unconditionally so a caller can show it next to the
     badge instead of sending the operator to ``coord merge``'s refusal
     message to find it (#2951 item 3).
+
+    ``stage_count_assignments`` (#3013) is the assignment list
+    :func:`_leg_count_for_stage` scans to fill ``stage_counts`` — a client
+    can then render ``Work (2)`` / ``Review (5)`` next to the status badge
+    and suppress the suffix at 1. Defaults to *assignments_for_issue* (the
+    same list ``stages`` uses) when omitted, which is correct for an
+    ordinary issue; :func:`compute_board_stage_projection` passes a
+    separately-keyed list for the #1553 oracle-loop epic/slice case — see
+    that function's docstring.
     """
     names = issue_stage_names(assignments_for_issue, default_gates, uat_enabled=uat_enabled)
     stages: dict[str, str] = {}
@@ -741,8 +848,29 @@ def compute_issue_projection(
     # excluded from the per-issue stage-strip ordering that `default_gates`
     # drives, since it only applies to oracle-loop milestones.
     stages["acceptance"] = acceptance_stage_status_for(assignments_for_issue)
+
+    count_source = (
+        assignments_for_issue if stage_count_assignments is None else stage_count_assignments
+    )
+    stage_counts: dict[str, int] = {
+        name: _leg_count_for_stage(count_source, name, require_plan=require_plan) for name in names
+    }
+    stage_counts.setdefault(
+        "merge", _leg_count_for_stage(count_source, "merge", require_plan=require_plan)
+    )
+    # Review fix (#3013): `stages` always carries "acceptance" (added
+    # unconditionally above, outside `names`/`default_gates`), but
+    # `stage_counts` was built only from `names` plus an explicit "merge"
+    # fallback — so it silently dropped "acceptance", contradicting the
+    # `/board` schema's documented "same key set as `stages`" guarantee
+    # (coord/serve_app.py) and leaving a client that indexes `stage_counts`
+    # by every key in `stages` with a plain `KeyError`.
+    stage_counts.setdefault(
+        "acceptance", _leg_count_for_stage(count_source, "acceptance", require_plan=require_plan)
+    )
     return {
         "stages": stages,
+        "stage_counts": stage_counts,
         "acceptance_progress": acceptance_progress_for(assignments_for_issue),
         "uat_preview_url": uat_preview_url if uat_enabled else None,
         "has_approved_review": issue_has_any_approved_review(
@@ -779,6 +907,44 @@ def compute_board_stage_projection(
     ``None`` (the default — e.g. a caller with no config loaded) means no
     repo is treated as opted in, matching :func:`pipeline_stage_names`'s own
     fail-toward-hidden default.
+
+    ``stage_counts`` (#3013) is deliberately built from a SECOND index keyed
+    by ``coord.models.effective_issue_number`` rather than the raw
+    ``assignments_by_key`` below: an oracle-loop acceptance slice's
+    ``test-author``/``mock-author``/``review`` legs are booked
+    (``issue_number``) to the milestone's *tracking* issue, with the child
+    they're actually FOR named in ``for_issue_number`` (see
+    ``coord gates <repo> <slice>``, which resolves the same way). Reusing
+    ``assignments_by_key`` for the count would leave a slice's own
+    ``stage_counts`` reading 0 forever — the same keying trap noted in the
+    #3013 issue's "drive-queue sweep bug" reference. For an issue that ALSO
+    has its own raw-keyed rows, this does NOT touch ``stages``: that stays
+    keyed on the raw ``issue_number`` on purpose (#1652 — re-attributing
+    status by ``for_issue_number`` moved a false "merged" green from the
+    epic onto a child that already had its own, separately-tracked state; a
+    leg *count* carries no such false-green risk, so the two fields are
+    allowed to disagree on which issue owns which rows in that case).
+
+    Review fix (#3013): a *phantom* entry — ANY key whose raw-keyed
+    assignment list is empty, whether it exists in ``issues`` with no
+    assignments of its own (the coord-portal#164 test below: the slice IS
+    already synced, but every one of its legs is booked to the tracking
+    issue) or exists ONLY via the effective-key union (never synced at all:
+    not yet caught up by ``_sync_issues_tick``, or a closed slice pruned
+    from ``issues`` after 7 days while assignment retention runs 14, see
+    ``coord/state.py``) — has nothing raw-keyed to protect from the #1652
+    clobber, because there IS no separately-tracked state for it to
+    conflict with. Rendering ``stages`` from the empty raw list anyway
+    produced a self-contradictory row: every stage PENDING (acceptance
+    SKIPPED) right next to a ``stage_counts`` proving real legs ran. So for
+    that case only, ``stages``/``acceptance``/``has_approved_review`` fall
+    back to the same effective-keyed list ``stage_counts`` already uses,
+    widened through :func:`_widen_work_like_types` so a `test-author`/
+    `mock-author` leg registers as "work" activity to the generic
+    per-stage dispatcher — see the ``projection_assignments`` fallback
+    below. ``issue_title`` still reads ``""`` for a phantom entry that
+    isn't itself in ``issues`` (genuinely unknown — not fabricated from the
+    tracking issue's own title, which would be actively wrong).
     """
     is_closed_by_key: dict[tuple[str, int], bool] = {
         (i["repo_name"], i["number"]): str(i.get("state", "")).lower() == "closed"
@@ -794,6 +960,17 @@ def compute_board_stage_projection(
             continue
         assignments_by_key.setdefault((a.repo_name, a.issue_number), []).append(a)
 
+    # #3013: effective-issue-keyed index — see docstring above. Used only to
+    # fill `stage_counts`, never `stages`.
+    assignments_by_effective_key: dict[tuple[str, int], list] = {}
+    for a in assignments:
+        if not a.repo_name:
+            continue
+        eff = effective_issue_number(a)
+        if not eff:
+            continue
+        assignments_by_effective_key.setdefault((a.repo_name, eff), []).append(a)
+
     merge_by_key: dict[tuple[str, int], Any] = {}
     for m in merge_queue_items:
         assignment_type = getattr(m, "assignment_type", "work") or "work"
@@ -815,7 +992,11 @@ def compute_board_stage_projection(
         # `load_queue()`/`board_projection()` both order by `id` ascending.
         merge_by_key.setdefault(key, m)
 
-    keys = set(is_closed_by_key) | set(assignments_by_key)
+    # #3013: also union in the effective-key index so an acceptance slice
+    # whose only board rows are booked to the tracking issue (nothing keyed
+    # to the slice's own issue_number, e.g. never separately synced) still
+    # gets a projection row for stage_counts to land in.
+    keys = set(is_closed_by_key) | set(assignments_by_key) | set(assignments_by_effective_key)
 
     uat_enabled_by_repo: dict[str, bool] = {}
 
@@ -823,12 +1004,25 @@ def compute_board_stage_projection(
     for repo_name, issue_number in keys:
         key = (repo_name, issue_number)
         issue_assignments = assignments_by_key.get(key, [])
+        effective_assignments = assignments_by_effective_key.get(key, [])
+        # Review fix (#3013): a phantom entry (see docstring) has no
+        # raw-keyed rows at all, so falling back to the effective-keyed list
+        # here — instead of leaving `stages` computed from `[]` — keeps
+        # `stages`/`acceptance`/`has_approved_review` consistent with the
+        # non-zero `stage_counts` this same entry reports below. Widened
+        # through `_widen_work_like_types` so a `test-author`/`mock-author`
+        # leg (WORK_LIKE_TYPES, not literal `type="work"`) registers with
+        # the generic per-stage dispatcher's strict `type` check the same
+        # way `_leg_count_for_stage` already widens it for `stage_counts`.
+        # A no-op for every ordinary issue: `issue_assignments or ...` only
+        # reaches the fallback when the raw list is empty.
+        projection_assignments = issue_assignments or _widen_work_like_types(effective_assignments)
         merge_entry = merge_by_key.get(key)
         if repo_name not in uat_enabled_by_repo:
             uat_enabled_by_repo[repo_name] = repo_has_uat_preview(repo_name, config)
         uat_enabled = uat_enabled_by_repo[repo_name]
         entry = compute_issue_projection(
-            issue_assignments,
+            projection_assignments,
             merge_entry,
             is_closed=is_closed_by_key.get(key, False),
             require_plan=require_plan,
@@ -840,6 +1034,7 @@ def compute_board_stage_projection(
                 if uat_enabled
                 else None
             ),
+            stage_count_assignments=effective_assignments,
         )
         entry["repo_name"] = repo_name
         entry["issue_number"] = issue_number