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

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

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.330",
+  "tag": "0.5.331",
   "distance": 0,
-  "node": "g1b5009cd9bd233460972d0e1bfca11135eb4058b",
+  "node": "g73f327b8112ca3cfc50ce512371659afb1a4c411",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-31"

{code_coordinator-0.5.330 → code_coordinator-0.5.331}/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": {

{code_coordinator-0.5.330 → code_coordinator-0.5.331}/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

{code_coordinator-0.5.330 → code_coordinator-0.5.331}/tests/test_stage_projection.py

@@ -397,6 +397,116 @@ def test_compute_issue_projection_includes_acceptance_box():
     assert out["acceptance_progress"] == {"passed": 5, "total": 5}
 
 
+def test_compute_issue_projection_stage_counts_has_same_keys_as_stages():
+    """Review fix (#3013): `stage_counts` must carry every key `stages`
+    does — including `acceptance`, which is added to `stages`
+    unconditionally outside `names`/`default_gates` and was previously
+    dropped from `stage_counts` entirely, contradicting the `/board` schema
+    description ('Same key set as `stages`') and risking a `KeyError` for
+    any client indexing `stage_counts` by every key in `stages`."""
+    a = [_work(status="done", acceptance_state="passed", acceptance_total=5, acceptance_passed=5)]
+    out = sp.compute_issue_projection(
+        a, None, is_closed=False, require_plan=False, default_gates=["test", "review", "merge"],
+    )
+    assert set(out["stage_counts"]) == set(out["stages"])
+    assert out["stage_counts"]["acceptance"] == 1
+
+
+def test_compute_issue_projection_stage_counts_acceptance_counts_verdict_legs():
+    """Each `type="work"` row carrying a recorded `acceptance_state` is a
+    separate acceptance-verdict leg — mirrors the `test`/`merge` special
+    cases: no dedicated assignment type exists to count directly."""
+    a = [
+        _work(assignment_id="w1", status="done", acceptance_state="failed", dispatched_at=1.0),
+        _work(assignment_id="w2", status="done", acceptance_state="passed", dispatched_at=2.0),
+        _work(assignment_id="w3", status="done", dispatched_at=3.0),  # no verdict yet
+    ]
+    out = sp.compute_issue_projection(
+        a, None, is_closed=False, require_plan=False, default_gates=["test", "review", "merge"],
+    )
+    assert out["stage_counts"]["acceptance"] == 2
+
+
+# ── compute_issue_projection: stage_counts (#3013) ──────────────────────────
+
+
+def test_compute_issue_projection_stage_counts_counts_separate_legs():
+    """A stage re-dispatched N times must report N in stage_counts, not
+    fold into the single status string the way `stages` does."""
+    a = [
+        _work(assignment_id="w1", status="failed", dispatched_at=1.0),
+        _work(assignment_id="w2", status="failed", dispatched_at=2.0),
+        _work(assignment_id="w3", status="done", test_state="passed", dispatched_at=3.0),
+        _review(
+            assignment_id="r1", review_of_assignment_id="w3",
+            review_verdict="request-changes", dispatched_at=4.0,
+        ),
+        _review(
+            assignment_id="r2", review_of_assignment_id="w3",
+            review_verdict="approve", dispatched_at=5.0,
+        ),
+    ]
+    out = sp.compute_issue_projection(
+        a, None, is_closed=False, require_plan=False, default_gates=["test", "review", "merge"],
+    )
+    assert out["stage_counts"]["work"] == 3
+    assert out["stage_counts"]["review"] == 2
+
+
+def test_compute_issue_projection_stage_counts_single_leg_is_one():
+    a = [_work(assignment_id="w1", status="done", dispatched_at=1.0)]
+    out = sp.compute_issue_projection(
+        a, None, is_closed=False, require_plan=False, default_gates=["test", "review", "merge"],
+    )
+    assert out["stage_counts"]["work"] == 1
+    assert out["stage_counts"]["review"] == 0
+
+
+def test_compute_issue_projection_stage_counts_test_counts_smoke_legs():
+    """The Test stage has no `type="test"` assignment — its dispatched
+    worker is `type="smoke"` (coord.smoke) — so the count must key off
+    that, not a literal type match."""
+    a = [
+        _work(assignment_id="w1", status="done", dispatched_at=1.0),
+        _work(assignment_id="s1", type="smoke", status="done", test_state="failed", dispatched_at=2.0),
+        _work(assignment_id="s2", type="smoke", status="done", test_state="passed", dispatched_at=3.0),
+    ]
+    out = sp.compute_issue_projection(
+        a, None, is_closed=False, require_plan=False, default_gates=["test", "review", "merge"],
+    )
+    assert out["stage_counts"]["test"] == 2
+
+
+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."""
+    a = [
+        _work(assignment_id="w1", status="done", dispatched_at=1.0),
+        _work(assignment_id="cf1", type="conflict-fix", status="done", dispatched_at=2.0),
+        _work(assignment_id="cf2", type="conflict-fix", status="failed", dispatched_at=3.0),
+    ]
+    out = sp.compute_issue_projection(
+        a, None, is_closed=False, require_plan=False, default_gates=["test", "review", "merge"],
+    )
+    assert out["stage_counts"]["merge"] == 2
+
+
+def test_compute_issue_projection_stage_counts_work_includes_test_author_legs():
+    """#3013's coord-portal#164 example: an oracle-loop acceptance slice's
+    repeated `test-author` legs must count as Work legs — a strict
+    `type == "work"` match would never see them."""
+    a = [
+        _work(assignment_id="ta1", type="test-author", status="failed", dispatched_at=1.0),
+        _work(assignment_id="ta2", type="test-author", status="failed", dispatched_at=2.0),
+        _work(assignment_id="ta3", type="test-author", status="failed", dispatched_at=3.0),
+        _work(assignment_id="ta4", type="test-author", status="done", dispatched_at=4.0),
+    ]
+    out = sp.compute_issue_projection(
+        a, None, is_closed=False, require_plan=False, default_gates=["test", "review", "merge"],
+    )
+    assert out["stage_counts"]["work"] == 4
+
+
 # ── issue_has_any_approved_review ───────────────────────────────────────────
 
 
@@ -839,3 +949,177 @@ def test_merged_test_author_entry_does_not_green_child_with_own_unmerged_work():
     )
     by_issue = {e["issue_number"]: e for e in out}
     assert by_issue[1122]["stages"]["merge"] == sp.PENDING
+
+
+# ── compute_board_stage_projection: stage_counts epic/slice keying (#3013) ──
+
+
+def test_compute_board_stage_projection_stage_counts_attributes_slice_legs_to_child():
+    """#3013's coord-portal#164 example: an oracle-loop acceptance slice's
+    test-author/review legs are booked (`issue_number`) to the milestone's
+    tracking issue but FOR the child (`for_issue_number`) — `coord gates
+    coord-portal 164` resolves them the same way. stage_counts must land on
+    the CHILD's own projection entry, not the epic's — and must not
+    double-count the same legs on both."""
+    issues = [
+        {"repo_name": "api", "number": 160, "title": "epic", "state": "open"},
+        {"repo_name": "api", "number": 164, "title": "slice", "state": "open"},
+    ]
+    assignments = [
+        _work(
+            assignment_id="ta1", issue_number=160, type="test-author",
+            status="failed", for_issue_number=164, dispatched_at=1.0,
+        ),
+        _work(
+            assignment_id="ta2", issue_number=160, type="test-author",
+            status="failed", for_issue_number=164, dispatched_at=2.0,
+        ),
+        _work(
+            assignment_id="ta3", issue_number=160, type="test-author",
+            status="failed", for_issue_number=164, dispatched_at=3.0,
+        ),
+        _work(
+            assignment_id="ta4", issue_number=160, type="test-author",
+            status="done", for_issue_number=164, dispatched_at=4.0,
+        ),
+        _review(
+            assignment_id="r1", issue_number=160, review_of_assignment_id="ta4",
+            for_issue_number=164, review_verdict="request-changes", dispatched_at=5.0,
+        ),
+        _review(
+            assignment_id="r2", issue_number=160, review_of_assignment_id="ta4",
+            for_issue_number=164, review_verdict="request-changes", dispatched_at=6.0,
+        ),
+        _review(
+            assignment_id="r3", issue_number=160, review_of_assignment_id="ta4",
+            for_issue_number=164, review_verdict="request-changes", dispatched_at=7.0,
+        ),
+        _review(
+            assignment_id="r4", issue_number=160, review_of_assignment_id="ta4",
+            for_issue_number=164, review_verdict="request-changes", dispatched_at=8.0,
+        ),
+        _review(
+            assignment_id="r5", issue_number=160, review_of_assignment_id="ta4",
+            for_issue_number=164, review_verdict="approve", dispatched_at=9.0,
+        ),
+    ]
+    out = sp.compute_board_stage_projection(
+        issues=issues,
+        assignments=assignments,
+        merge_queue_items=[],
+        default_gates=["test", "review", "merge"],
+    )
+    by_issue = {e["issue_number"]: e for e in out}
+    assert by_issue[164]["stage_counts"]["work"] == 4
+    assert by_issue[164]["stage_counts"]["review"] == 5
+    # The epic's own count must not also carry the slice's legs — they
+    # belong on exactly one entry, not both.
+    assert by_issue[160]["stage_counts"]["work"] == 0
+    assert by_issue[160]["stage_counts"]["review"] == 0
+
+
+def test_compute_board_stage_projection_phantom_slice_stages_match_stage_counts():
+    """Review fix (#3013 blocking finding): a slice/child issue whose ONLY
+    board rows are booked to the tracking issue — and which is NOT itself in
+    the `issues` table yet (unlike the sibling test above, where both #160
+    and #164 are already synced) — must not render a self-contradictory
+    board row: every stage PENDING/SKIPPED right next to a `stage_counts`
+    proving 4 work legs and 5 review legs ran. `stages` now falls back to
+    the same effective-keyed rows `stage_counts` uses whenever an issue has
+    zero rows keyed to its own raw `issue_number` (nothing separately
+    tracked for #1652's false-green concern to clobber)."""
+    issues = [
+        {"repo_name": "api", "number": 160, "title": "epic", "state": "open"},
+        # #164 deliberately absent — the phantom case: it only appears via
+        # the effective-key union below.
+    ]
+    assignments = [
+        _work(
+            assignment_id="ta1", issue_number=160, type="test-author",
+            status="failed", for_issue_number=164, dispatched_at=1.0,
+        ),
+        _work(
+            assignment_id="ta2", issue_number=160, type="test-author",
+            status="failed", for_issue_number=164, dispatched_at=2.0,
+        ),
+        _work(
+            assignment_id="ta3", issue_number=160, type="test-author",
+            status="failed", for_issue_number=164, dispatched_at=3.0,
+        ),
+        _work(
+            assignment_id="ta4", issue_number=160, type="test-author",
+            status="done", for_issue_number=164, dispatched_at=4.0,
+        ),
+        _review(
+            assignment_id="r1", issue_number=160, review_of_assignment_id="ta4",
+            for_issue_number=164, review_verdict="request-changes", dispatched_at=5.0,
+        ),
+        _review(
+            assignment_id="r2", issue_number=160, review_of_assignment_id="ta4",
+            for_issue_number=164, review_verdict="request-changes", dispatched_at=6.0,
+        ),
+        _review(
+            assignment_id="r3", issue_number=160, review_of_assignment_id="ta4",
+            for_issue_number=164, review_verdict="request-changes", dispatched_at=7.0,
+        ),
+        _review(
+            assignment_id="r4", issue_number=160, review_of_assignment_id="ta4",
+            for_issue_number=164, review_verdict="request-changes", dispatched_at=8.0,
+        ),
+        _review(
+            assignment_id="r5", issue_number=160, review_of_assignment_id="ta4",
+            for_issue_number=164, review_verdict="approve", dispatched_at=9.0,
+        ),
+    ]
+    out = sp.compute_board_stage_projection(
+        issues=issues,
+        assignments=assignments,
+        merge_queue_items=[],
+        default_gates=["test", "review", "merge"],
+    )
+    by_issue = {e["issue_number"]: e for e in out}
+    slice_entry = by_issue[164]
+
+    # The counts are unaffected by this fix — same as the synced-sibling case.
+    assert slice_entry["stage_counts"]["work"] == 4
+    assert slice_entry["stage_counts"]["review"] == 5
+
+    # The core fix: `stages` must no longer be a blanket PENDING default —
+    # it reflects the SAME rows the counts are drawn from.
+    assert slice_entry["stages"]["work"] == sp.DONE
+    assert slice_entry["stages"]["review"] == sp.DONE
+    assert slice_entry["has_approved_review"] is True
+    # No merge signal exists for a phantom entry (no merge-queue row keys to
+    # it) — PENDING here is honest (matches stage_counts["merge"] == 0), not
+    # a fabricated green.
+    assert slice_entry["stages"]["merge"] == sp.PENDING
+    assert slice_entry["stage_counts"]["merge"] == 0
+
+    # Genuinely unknown, not fabricated from the tracking issue's own title.
+    assert slice_entry["issue_title"] == ""
+
+    # The epic's own entry is completely unaffected (it has real raw-keyed
+    # rows, so the phantom fallback never applies to it).
+    assert by_issue[160]["stage_counts"]["work"] == 0
+    assert by_issue[160]["stage_counts"]["review"] == 0
+
+
+def test_compute_board_stage_projection_stage_counts_ordinary_issue_uses_own_key():
+    """An ordinary (non-oracle-loop) issue has no `for_issue_number` — its
+    stage_counts must come from its own rows, unaffected by the #3013
+    effective-key indirection added for the slice case above."""
+    issues = [{"repo_name": "api", "number": 1, "title": "t", "state": "open"}]
+    assignments = [
+        _work(assignment_id="w1", status="failed", dispatched_at=1.0),
+        _work(assignment_id="w2", status="done", dispatched_at=2.0),
+        _review(assignment_id="r1", review_of_assignment_id="w2", review_verdict="approve", dispatched_at=3.0),
+    ]
+    out = sp.compute_board_stage_projection(
+        issues=issues,
+        assignments=assignments,
+        merge_queue_items=[],
+        default_gates=["test", "review", "merge"],
+    )
+    entry = out[0]
+    assert entry["stage_counts"]["work"] == 2
+    assert entry["stage_counts"]["review"] == 1