code-coordinator 0.5.575__tar.gz → 0.5.576__tar.gz

{code_coordinator-0.5.575 → code_coordinator-0.5.576}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.575",
+  "tag": "0.5.576",
   "distance": 0,
-  "node": "g22daba195f41dce89012e37ebdeb524a5b332d51",
+  "node": "g3da50042b74f92cdac51303b6f3672b6568b1a02",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-10-03"

{code_coordinator-0.5.575 → code_coordinator-0.5.576}/coord/dashboard/server.py

@@ -4329,6 +4329,19 @@ def build_app(
         ``dispatched_at`` is unconditionally stamped at dispatch time by
         every code path, so the bound holds even for a row whose
         ``finished_at`` never got recorded.
+
+        #1277: separately from the age-based cutoff above, a ``failed`` row
+        is also dropped (default view only — ``?include=all`` still returns
+        it) once ``PipelineView.superseded`` says a LATER work assignment
+        for the same ``(repo, issue)`` actually succeeded — a retry/fix/
+        rework attempt shipped the issue, so the earlier failed attempt is
+        pure historical noise, no matter how recent it was. This is
+        deliberately narrower than "the GitHub issue is closed": that would
+        also cover a failure resolved by hand with no coord-dispatched
+        retry, but checking it here would mean a live ``gh`` call on every
+        failed row of every ``/api/pipeline`` request — left as a follow-up
+        rather than risking the hot GET path on GitHub API latency/rate
+        limits (and `compute_pipeline`'s pure-computation contract above).
         """
         from dataclasses import asdict
 
@@ -4377,6 +4390,15 @@ def build_app(
                 ts = pv.finished_at if pv.finished_at is not None else a.dispatched_at
                 if ts is not None and ts < cutoff:
                     continue
+            # #1277: a `failed` row whose issue later shipped via a
+            # different (retry/fix/rework) assignment is pure historical
+            # noise on the default view — suppress it regardless of its own
+            # age (unlike the recency cutoff above, this doesn't depend on
+            # how recently the failure happened, only on whether a later
+            # attempt superseded it). `?include=all` still returns it — this
+            # is a display-layer filter, the DB row is untouched (#1041).
+            if cutoff is not None and pv.superseded:
+                continue
             rev_aid = review_by_work.get(a.assignment_id)
             if rev_aid:
                 found = (

{code_coordinator-0.5.575 → code_coordinator-0.5.576}/coord/pipeline.py

@@ -114,6 +114,20 @@ class PipelineView:
     # recently made progress) — see compute_pipeline for the derivation.
     # None only when nothing involved has finished yet (still coding).
     finished_at: float | None = None
+    # #1277: True when this is a `current_stage == "failed"` row AND a later
+    # work assignment for the same (repo_name, issue_number) reached a
+    # genuinely successful terminal status ("done"/"merged") — i.e. a
+    # retry/fix/rework attempt superseded this failure and the issue
+    # shipped. Always False for any other current_stage. Pure — derived
+    # entirely from the already-passed-in `board` (every work assignment
+    # ever dispatched for this issue), no I/O — so it recomputes fresh on
+    # every call rather than needing a persisted flag, and self-corrects the
+    # instant a pending retry's own status flips to "done"/"merged". The
+    # dashboard (coord/dashboard/server.py's api_pipeline) uses this to
+    # suppress stale failed rows from the default view while leaving the DB
+    # rows themselves untouched (#1041 audit trail) — `?include=all` still
+    # surfaces them.
+    superseded: bool = False
 
 
 # ── GateSpec registry (#3261 S-2) ────────────────────────────────────────────
@@ -602,6 +616,32 @@ def compute_pipeline(
         review_of_assignment_id=assignment.review_of_assignment_id,
     )
 
+    # #1277: a failed row is "superseded" once a LATER work assignment for
+    # the same (repo, issue) actually succeeded ("done"/"merged" — not
+    # merely dispatched again; an in-flight retry doesn't supersede anything
+    # until it itself lands). Ordered by `dispatched_at` — the attempt
+    # order, and per the #2066 docstring above the one timestamp every
+    # assignment is unconditionally stamped with, unlike `finished_at`.
+    # Scoped to `current_stage == "failed"` only: a review/smoke failure on
+    # the SAME work assignment (review_failed/smoke_failed) isn't this kind
+    # of "stale duplicate row" — the work assignment itself is still the
+    # live one.
+    superseded = False
+    if current_stage == "failed":
+        this_dispatched = assignment.dispatched_at
+        for other in all_assignments:
+            if (
+                other.assignment_id != aid
+                and other.type in ("work", None, "")
+                and other.repo_name == assignment.repo_name
+                and other.issue_number == assignment.issue_number
+                and other.status in ("done", "merged")
+                and other.dispatched_at is not None
+                and (this_dispatched is None or other.dispatched_at > this_dispatched)
+            ):
+                superseded = True
+                break
+
     # #1218: most-recent finished_at across the work assignment and any
     # linked review/smoke assignment — whichever last made progress. This is
     # what the dashboard sorts the collapsed "Work done" section by, so it
@@ -641,4 +681,5 @@ def compute_pipeline(
         needs_attention_reason=needs_attention_reason,
         needs_attention_detail=needs_attention_detail,
         finished_at=finished_at,
+        superseded=superseded,
     )

{code_coordinator-0.5.575 → code_coordinator-0.5.576}/tests/test_pipeline.py

@@ -524,6 +524,85 @@ class TestFinishedAtField:
         assert pv.finished_at == 100.0
 
 
+# ── #1277: superseded field (stale failed row hidden after a later success) ─
+
+
+class TestSupersededField:
+    def test_failed_with_no_sibling_is_not_superseded(self) -> None:
+        a = _work(aid="work-1", status="failed")
+        pv = compute_pipeline(a, _board(a), [], _config())
+        assert pv.current_stage == "failed"
+        assert pv.superseded is False
+
+    def test_failed_superseded_by_later_successful_retry(self) -> None:
+        """The canonical #790 shape: a failed attempt, then a later retry
+        (different assignment_id, same repo+issue) that actually succeeded."""
+        failed = _work(aid="work-1", status="failed")
+        failed.dispatched_at = 100.0
+        retry = _work(aid="work-2", status="done")
+        retry.dispatched_at = 200.0
+        board = Board(active=[], completed=[failed, retry])
+        pv = compute_pipeline(failed, board, [], _config())
+        assert pv.current_stage == "failed"
+        assert pv.superseded is True
+
+    def test_merged_retry_also_supersedes(self) -> None:
+        failed = _work(aid="work-1", status="failed")
+        failed.dispatched_at = 100.0
+        retry = _work(aid="work-2", status="merged")
+        retry.dispatched_at = 200.0
+        board = Board(active=[], completed=[failed, retry])
+        pv = compute_pipeline(failed, board, [], _config())
+        assert pv.superseded is True
+
+    def test_earlier_success_does_not_supersede_a_later_failure(self) -> None:
+        """Ordering matters: a success dispatched BEFORE this failure doesn't
+        make the failure stale — it's the live, most-recent attempt."""
+        earlier_success = _work(aid="work-1", status="done")
+        earlier_success.dispatched_at = 100.0
+        failed = _work(aid="work-2", status="failed")
+        failed.dispatched_at = 200.0
+        board = Board(active=[], completed=[earlier_success, failed])
+        pv = compute_pipeline(failed, board, [], _config())
+        assert pv.current_stage == "failed"
+        assert pv.superseded is False
+
+    def test_later_in_flight_retry_does_not_supersede_yet(self) -> None:
+        """A retry that hasn't itself succeeded (still running/pending)
+        doesn't retroactively clear the earlier failure — only an actual
+        success does."""
+        failed = _work(aid="work-1", status="failed")
+        failed.dispatched_at = 100.0
+        retry = _work(aid="work-2", status="running")
+        retry.dispatched_at = 200.0
+        board = Board(active=[retry], completed=[failed])
+        pv = compute_pipeline(failed, board, [], _config())
+        assert pv.superseded is False
+
+    def test_sibling_in_a_different_repo_does_not_supersede(self) -> None:
+        failed = _work(aid="work-1", status="failed")
+        failed.dispatched_at = 100.0
+        other_repo_success = Assignment(
+            machine_name="laptop", repo_name="other-repo",
+            issue_number=42, issue_title="Fix auth", assignment_id="work-2",
+            status="done", type="work", dispatched_at=200.0,
+        )
+        board = Board(active=[], completed=[failed, other_repo_success])
+        pv = compute_pipeline(failed, board, [], _config())
+        assert pv.superseded is False
+
+    def test_non_failed_stage_is_never_superseded(self) -> None:
+        """superseded is scoped to current_stage == 'failed' — a review/smoke
+        failure on the SAME still-live work assignment isn't this kind of
+        stale duplicate row."""
+        a = _work(status="done")
+        smk = _smoke(of_aid="work-1", status="failed")
+        board = Board(active=[], completed=[a, smk])
+        pv = compute_pipeline(a, board, [], _config())
+        assert pv.current_stage == "smoke_failed"
+        assert pv.superseded is False
+
+
 # ── #846: needs_attention field ─────────────────────────────────────────────
 
 
@@ -992,6 +1071,94 @@ class TestPipelineRetention:
         assert r.json() == []
 
 
+class TestPipelineAPISupersededFiltering:
+    """#1277: /api/pipeline suppresses a `failed` row by default once a
+    later retry/fix for the same (repo, issue) actually succeeded — one
+    current-stage row per issue, not a growing pile of dead retries."""
+
+    def test_failed_then_succeeded_yields_one_row_by_default(self) -> None:
+        """The exact scenario from the issue: two assignments for the same
+        issue — one failed, one later succeeded — yields a single
+        current-stage pipeline row, not two."""
+        import time
+
+        now = time.time()
+        failed = Assignment(
+            machine_name="laptop", repo_name="api",
+            issue_number=790, issue_title="Flaky thing",
+            assignment_id="w-fail", status="failed", type="work",
+            dispatched_at=now - 3600, finished_at=now - 3600,
+        )
+        succeeded = Assignment(
+            machine_name="laptop", repo_name="api",
+            issue_number=790, issue_title="Flaky thing",
+            assignment_id="w-retry", status="done", type="work",
+            dispatched_at=now - 1800, finished_at=now - 1800,
+        )
+        board = Board(active=[], completed=[failed, succeeded])
+        client = _dashboard_client()
+        with (
+            patch("coord.dashboard.server.read_board", return_value=board),
+            patch("coord.merge_queue.load_queue", return_value=[]),
+        ):
+            r = client.get("/api/pipeline")
+        assert r.status_code == 200
+        data = r.json()
+        ids = [pv["assignment_id"] for pv in data]
+        assert ids == ["w-retry"]
+
+    def test_include_all_still_returns_the_superseded_failed_row(self) -> None:
+        """Display-layer filter, not a delete (#1041): the full history is
+        still reachable via ?include=all."""
+        import time
+
+        now = time.time()
+        failed = Assignment(
+            machine_name="laptop", repo_name="api",
+            issue_number=790, issue_title="Flaky thing",
+            assignment_id="w-fail", status="failed", type="work",
+            dispatched_at=now - 3600, finished_at=now - 3600,
+        )
+        succeeded = Assignment(
+            machine_name="laptop", repo_name="api",
+            issue_number=790, issue_title="Flaky thing",
+            assignment_id="w-retry", status="done", type="work",
+            dispatched_at=now - 1800, finished_at=now - 1800,
+        )
+        board = Board(active=[], completed=[failed, succeeded])
+        client = _dashboard_client()
+        with (
+            patch("coord.dashboard.server.read_board", return_value=board),
+            patch("coord.merge_queue.load_queue", return_value=[]),
+        ):
+            r = client.get("/api/pipeline?include=all")
+        assert r.status_code == 200
+        ids = {pv["assignment_id"] for pv in r.json()}
+        assert ids == {"w-fail", "w-retry"}
+
+    def test_still_open_failure_with_no_later_success_stays_visible(self) -> None:
+        """#772's shape — only failed row for an issue, never retried — must
+        not be swept away by this filter."""
+        import time
+
+        failed = Assignment(
+            machine_name="laptop", repo_name="api",
+            issue_number=772, issue_title="Optional thing",
+            assignment_id="w-fail-only", status="failed", type="work",
+            dispatched_at=time.time() - 3600, finished_at=time.time() - 3600,
+        )
+        board = Board(active=[], completed=[failed])
+        client = _dashboard_client()
+        with (
+            patch("coord.dashboard.server.read_board", return_value=board),
+            patch("coord.merge_queue.load_queue", return_value=[]),
+        ):
+            r = client.get("/api/pipeline")
+        assert r.status_code == 200
+        ids = [pv["assignment_id"] for pv in r.json()]
+        assert ids == ["w-fail-only"]
+
+
 class TestPipelineActionAPI:
     def test_missing_fields_returns_400(self) -> None:
         client = _dashboard_client()