code-coordinator 0.5.102__tar.gz → 0.5.105__tar.gz

{code_coordinator-0.5.102 → code_coordinator-0.5.105}/PKG-INFO

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.102
+Version: 0.5.105
 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.105/code_coordinator.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.5.105",
+  "distance": 0,
+  "node": "ge1d2140a49bec59697930f77304b2c0f62eef7c1",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-08-16"
+}

{code_coordinator-0.5.102 → code_coordinator-0.5.105}/coord/merge_queue.py

@@ -4481,6 +4481,63 @@ def _record_expected_red_audit(
     )
 
 
+def _acceptance_patch_id_matches(
+    entry: "QueuedMerge", acceptance_sha: str, gh_ops: "GhOps",
+) -> bool:
+    """#2298: True when *acceptance_sha* — the commit the trust-gate verdict
+    (``coord acceptance record``) was recorded against — introduced the
+    *same content* as the commit that just merged, even though the two
+    SHAs differ.
+
+    The merge queue's own ``checks_stale``/``smoke_required`` gates force a
+    PR sitting behind a moved base to rebase before it can merge at all (a
+    re-run CI needs a fresh SHA to attach to); rebasing rewrites
+    ``branch_head_sha`` by construction. :func:`_maybe_clear_expected_red`
+    treating that SHA change alone as "the content changed" made the two
+    gates mutually unsatisfiable on any PR that had to rebase — every such
+    merge skipped its ``expected_red`` clear and manually needed one, #2298.
+
+    This mirrors the exact rebase-survives-content fingerprint
+    ``has_approved_review`` already uses for the review gate (#1475): a
+    content-addressed patch-id (``git patch-id --stable`` over the unified
+    diff, via ``gh_ops.get_branch_patch_id``) is insensitive to which
+    commit the diff is replayed onto, so a pure rebase (no conflict, no new
+    commits) produces the *same* patch-id from a *different* SHA, while a
+    genuine content change (a conflict resolved differently, an extra
+    commit) does not.
+
+    Compares ``entry.branch_patch_id`` — the diff the commit that just
+    merged actually introduced, backfilled on demand via
+    :func:`_backfill_branch_patch_id` when `process()` never needed it
+    (e.g. neither review nor smoke was required for this entry, the only
+    two gates that consult it pre-merge) — against a patch-id computed
+    fresh for *acceptance_sha* against ``entry.target_branch``.
+    *acceptance_sha* need not be any branch's current tip: per
+    :func:`coord.github_ops.get_compare_diff`'s docstring, GitHub's
+    three-dot compare API accepts a raw commit SHA for *head* exactly like
+    a branch name, the same trick :func:`has_approved_review`'s #1476
+    scoped-re-review path already relies on for an old, superseded review
+    SHA.
+
+    Returns ``False`` — fail closed — whenever either side is unavailable
+    (no patch-id support, a `gh_ops` failure, or *acceptance_sha* no longer
+    resolving, e.g. long since garbage-collected): "cannot confirm
+    identical content" must never read as "confirmed identical".
+    """
+    branch_patch_id = getattr(entry, "branch_patch_id", None)
+    if branch_patch_id is None:
+        branch_patch_id = _backfill_branch_patch_id(entry, gh_ops)
+    if branch_patch_id is None:
+        return False
+    try:
+        acceptance_patch_id = gh_ops.get_branch_patch_id(
+            entry.repo_github, entry.target_branch, acceptance_sha,
+        )
+    except Exception:  # noqa: BLE001 — fail-safe, matches _backfill_branch_patch_id
+        acceptance_patch_id = None
+    return acceptance_patch_id is not None and acceptance_patch_id == branch_patch_id
+
+
 def _maybe_clear_expected_red(entry: QueuedMerge, board, gh_ops: GhOps) -> MergeEvent | None:
     """#2164: right after *entry*'s PR has actually merged into
     ``entry.target_branch``, clear any of its issue's ``expected_red``
@@ -4508,6 +4565,17 @@ def _maybe_clear_expected_red(entry: QueuedMerge, board, gh_ops: GhOps) -> Merge
     printing that same loud, actionable-looking text on every ordinary
     merge fleet-wide, contradicting the acceptance criterion that exempt
     issues and driverless repos stay unaffected.
+
+    #2298: the SHA-exact guard below is no longer the only path to a
+    clear. ``checks_stale``/``smoke_required`` refuse a PR whose CI
+    predates the current base, so a PR that sits long enough for the base
+    to move must rebase to merge at all — which rewrites
+    ``entry.branch_head_sha`` even when nothing about the PR's own diff
+    changed. Comparing SHAs alone made that guard and those gates mutually
+    unsatisfiable on exactly the PRs this whole trust gate exists to
+    protect (every rebased oracle-loop merge). See
+    :func:`_acceptance_patch_id_matches` for the content-addressed
+    fallback that tells a pure rebase apart from a genuine content change.
     """
     if entry.assignment_type not in CLOSES_ISSUE_TYPES:
         return None
@@ -4544,18 +4612,41 @@ def _maybe_clear_expected_red(entry: QueuedMerge, board, gh_ops: GhOps) -> Merge
         )
         return MergeEvent(entry, "expected_red_clear_skipped_no_acceptance", msg)
     acceptance_sha = getattr(work, "acceptance_sha", None)
-    if acceptance_sha is None or acceptance_sha != entry.branch_head_sha:
+    sha_matches = acceptance_sha is not None and acceptance_sha == entry.branch_head_sha
+    # #2298: a bare SHA mismatch no longer voids the verdict outright.
+    # `checks_stale`/`smoke_required` force a rebase before a PR sitting
+    # behind a moved base can merge at all — which rewrites
+    # `branch_head_sha` on every such PR by construction, making this
+    # guard and those gates mutually unsatisfiable pre-#2298 (see the
+    # issue). Mirror `has_approved_review`'s #1475 patch-id fallback: a
+    # SHA mismatch whose content-addressed patch-id still matches is a
+    # pure rebase, not a stale observation.
+    patch_id_verified = (
+        acceptance_sha is not None
+        and not sha_matches
+        and _acceptance_patch_id_matches(entry, acceptance_sha, gh_ops)
+    )
+    if not sha_matches and not patch_id_verified:
         # The recorded trust-gate verdict isn't for the exact commit that
-        # just merged (acceptance never ran, or new commits landed after
-        # the last `record`) — skip rather than clear on a stale
-        # observation. Will pick back up once `record` runs again for the
-        # fresh SHA and this issue's fix merges again... though ordinarily
-        # a merge only happens once per issue, so a mismatch here more
-        # likely means acceptance was simply never recorded for this SHA.
+        # just merged, and its diff doesn't match the merged commit's diff
+        # either (acceptance never ran, a genuine content change landed
+        # after the last `record`, or the patch-id comparison itself
+        # couldn't be confirmed) — skip rather than clear on a stale
+        # observation. #2298 (also worth fixing here): the issue this
+        # entry closed is already closed by the time this runs, so
+        # `coord acceptance record --sha` (which targets an *open* issue's
+        # work assignment) has nothing left to attach to; point at the
+        # remedy that actually works from here instead.
         msg = (
-            "acceptance_sha does not match the merged commit — skipping "
-            "expected_red clear (re-run `coord acceptance record` against "
-            "the merged SHA if entries should have cleared)"
+            "acceptance_sha does not match the merged commit, and its "
+            "content-addressed patch-id does not confirm a pure rebase "
+            "either (#2298) — skipping expected_red clear. If this was "
+            "genuinely just a rebase onto a moved base, clear by hand: "
+            f"`coord acceptance expected-red {entry.repo_name} --clear "
+            f"--issue {entry.issue_number}`. If the content actually "
+            "changed, a fresh `coord acceptance record` against the "
+            "merged SHA (while the issue was still open) was the correct "
+            "fix and did not happen."
         )
         _record_expected_red_audit(
             entry, "expected_red_clear_skipped_sha_mismatch", msg,
@@ -4572,6 +4663,19 @@ def _maybe_clear_expected_red(entry: QueuedMerge, board, gh_ops: GhOps) -> Merge
     # manifest, so looking this up afterwards would just find the ids the
     # clear itself just removed (#2266 review non-blocking finding).
     ids = _expected_red_ids_for_entry(entry, gh_ops)
+    if patch_id_verified:
+        # #2298: name the arm taken — a durable row independent of whether
+        # there ends up being anything to clear (the "no_op" branch below
+        # never gets one of those), so this rebase-not-content-change call
+        # is queryable on its own, the same way every other skip/clear
+        # branch here names itself rather than staying silent (#2199).
+        _record_expected_red_audit(
+            entry, "expected_red_sha_mismatch_patch_id_verified",
+            "acceptance_sha does not match the merged commit, but its "
+            "content-addressed patch-id does — a pure rebase, not a "
+            "content change (#2298); proceeding with expected_red clear",
+            test_ids=ids,
+        )
     msg = clear_expected_red_via_pr(
         entry.repo_github, entry.repo_name, entry.target_branch, entry.issue_number,
         gh_ops=gh_ops,
@@ -4594,6 +4698,13 @@ def _maybe_clear_expected_red(entry: QueuedMerge, board, gh_ops: GhOps) -> Merge
         "pending_retry": "expected_red_clear_pending",
         "failed": "expected_red_clear_failed",
     }[status]
+    if patch_id_verified:
+        # #2298: keep the arm visible on the terminal `coord merge` line
+        # too, not just in the audit row above.
+        msg = (
+            f"{msg} (acceptance_sha rebased since verdict — content "
+            "verified identical via patch-id, #2298)"
+        )
     # #2266 review (non-blocking finding): `clear_expected_red_via_pr`
     # never raises — every genuine failure degrades to a "warning: ..."
     # string. Make that durable too, not just a merge-output line: a

{code_coordinator-0.5.102 → code_coordinator-0.5.105}/coord/reports.py

@@ -59,6 +59,9 @@ __all__ = [
     "ReportParam",
     "ReportDef",
     "ColumnMeta",
+    "ChartSeries",
+    "ChartSpec",
+    "CHART_KINDS",
     "ReportResult",
     "REPORTS",
     "catalogue",
@@ -78,6 +81,7 @@ __all__ = [
     "QUEUE_OUTCOMES_WINDOW_CHOICES",
     "resolve_queue_outcomes_window",
     "fold_queue_outcomes",
+    "queue_outcomes_chart",
     "run_queue_outcomes",
     "parse_duration",
     "result_to_csv",
@@ -190,6 +194,90 @@ class ColumnMeta:
         }
 
 
+# ── chart declaration (#2271) ──────────────────────────────────────────────
+#
+# A report says "this table also reads as a chart"; it does NOT ship a second
+# copy of the numbers.  Every series names a `columns[]` id and the renderer
+# reads the same `rows` the table renders, so there is exactly one source of
+# truth, the table stays the fallback rendering, and `result_to_csv` (#1765)
+# needs no change at all — it is driven by `columns`/`rows`/`totals` and never
+# looks at this block.
+#
+# THE COMPATIBILITY RULE, same as `ColumnMeta.kind`'s (#1760): a client that
+# does not understand this block, or meets a `kind` it predates, **renders the
+# table and ignores the chart**.  It must never fail to parse and must never
+# leave a hole where the chart would have gone.  That matters more than usual
+# here because coord-tui ships as a per-host locally-built binary, outside
+# propagation's reach, so the fleet routinely runs mixed versions.
+
+#: Open vocabulary — the kinds a client is *expected* to know today.  A newer
+#: daemon may name one that is not here; see the compatibility rule above.
+CHART_KINDS = ("bar", "line", "sparkline")
+
+
+@dataclass(frozen=True)
+class ChartSeries:
+    """One series of a :class:`ChartSpec`, derived from an existing column.
+
+    ``column`` is a ``ReportResult.columns`` id whose per-row value supplies
+    the y-values; ``label`` is what the legend shows.  ``color`` is an
+    optional ``"#rrggbb"`` hint — when :attr:`ChartSpec.group_by` is set the
+    series are generated per group and the backend palette picks the colours
+    instead, because one declared colour cannot describe N groups.
+    """
+
+    label: str
+    column: str
+    color: str | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"label": self.label, "column": self.column, "color": self.color}
+
+
+@dataclass(frozen=True)
+class ChartSpec:
+    """An optional chart rendering of a :class:`ReportResult`'s own rows.
+
+    Two shapes, and which one you get depends on ``group_by``:
+
+    * **``group_by is None`` — one data point per row, in the report's
+      canonical row order.**  ``x`` names the column supplying each point's
+      category/time label; each :class:`ChartSeries` reads its own column
+      straight off the row.  This is the "one bar per category" shape.
+    * **``group_by`` set — a pivot.**  The x-axis is the *distinct* values of
+      ``x`` in first-appearance order, and one output series is produced per
+      distinct ``group_by`` value.  Rows landing in the same ``(group, x)``
+      cell are **summed**, and an empty cell is ``0`` — so this shape is for
+      magnitudes (counts, totals), not for averages or rates.  This is the
+      "one trendline per bucket" shape that a long-form result needs.
+
+    ``stacked`` is bar-only and ignored by every other kind.  Rendering a
+    multi-series bar chart at all needs quadraui#584; a client whose pinned
+    build predates it must degrade the section to a table with a stated
+    reason rather than draw a chart that silently omits every series but the
+    first.
+    """
+
+    kind: str
+    series: tuple[ChartSeries, ...]
+    x: str | None = None
+    group_by: str | None = None
+    stacked: bool = False
+    title: str = ""
+    y_label: str = ""
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "kind": self.kind,
+            "series": [s.to_dict() for s in self.series],
+            "x": self.x,
+            "group_by": self.group_by,
+            "stacked": self.stacked,
+            "title": self.title,
+            "y_label": self.y_label,
+        }
+
+
 @dataclass
 class ReportResult:
     """The wire contract (#1741 renders against these exact field names).
@@ -210,6 +298,12 @@ class ReportResult:
     before.  Identity columns are deliberately *absent* from the dict rather
     than filled with a placeholder — a renderer that wants a ``Σ`` marker
     picks one itself, and one that doesn't leaves the cell blank.
+
+    ``chart`` (#2271) is an optional declaration that this result also reads
+    as a chart, derived from the very columns the table renders — see
+    :class:`ChartSpec`.  **Additive and defaulting to ``None``**, and a
+    client that ignores the key (or meets a ``kind`` it predates) renders the
+    table exactly as it did before.
     """
 
     report_id: str
@@ -220,6 +314,7 @@ class ReportResult:
     notes: list[str]
     column_meta: list[ColumnMeta] = field(default_factory=list)
     totals: dict[str, Any] | None = None
+    chart: ChartSpec | None = None
 
     def to_dict(self) -> dict[str, Any]:
         return {
@@ -231,6 +326,7 @@ class ReportResult:
             "rows": list(self.rows),
             "notes": list(self.notes),
             "totals": None if self.totals is None else dict(self.totals),
+            "chart": None if self.chart is None else self.chart.to_dict(),
         }
 
 
@@ -1677,6 +1773,50 @@ def fold_queue_outcomes(
         rows=rows,
         notes=notes,
         totals=totals,
+        chart=queue_outcomes_chart(rows, n_periods),
+    )
+
+
+def queue_outcomes_chart(
+    rows: Sequence[Mapping[str, Any]], n_periods: int
+) -> ChartSpec | None:
+    """The chart declaration for a ``queue-outcomes`` fold (#2271).
+
+    Exactly the two views the report's own description already promises:
+    ``24h`` is a single period, so it is **one stacked bar per bucket** over
+    the categories in it; ``7d``/``4w`` are the same arithmetic in 7 daily /
+    4 weekly points, so they are **one trendline per bucket** over
+    ``period_start``.  Both derive from ``count`` — the column the table
+    renders — so there is nothing to keep in sync.
+
+    ``None`` when there is nothing to plot: an empty fold is an EMPTY result,
+    and an axis with no marks on it reads as a zero score rather than as no
+    measurement.
+    """
+    if not rows:
+        return None
+    if n_periods > 1:
+        return ChartSpec(
+            kind="line",
+            series=(ChartSeries(label="Entries", column="count"),),
+            x="period_start",
+            group_by="bucket",
+            title="Outcomes per period",
+            y_label="Entries",
+        )
+    # `x` and `group_by` are deliberately the same column. A terminal chart
+    # has a legend but no per-tick category text, so the legend is the only
+    # place a bucket NAME can appear — grouping on the axis column is what
+    # puts "succeeded / auto_resolved_* / human / open" on screen next to its
+    # own colour, instead of five anonymous bars.
+    return ChartSpec(
+        kind="bar",
+        series=(ChartSeries(label="Entries", column="count"),),
+        x="bucket",
+        group_by="bucket",
+        stacked=True,
+        title="Outcomes by bucket",
+        y_label="Entries",
     )
 
 

{code_coordinator-0.5.102 → code_coordinator-0.5.105}/coord/serve_app.py

@@ -3566,6 +3566,10 @@ def _openapi_spec() -> dict:
                                             "type": ["object", "null"],
                                             "description": "#1763: optional grand-total row keyed by the same column ids as `rows`. `null` for reports with no meaningful sum (issue-activity, drive-queue-status); a client that ignores it renders exactly as before.",
                                         },
+                                        "chart": {
+                                            "type": ["object", "null"],
+                                            "description": "#2271: optional chart declaration — `kind` (open vocabulary: bar/line/sparkline), `series[]` each naming a `columns[]` id, `x`, `group_by`, `stacked`. It carries NO numbers of its own; the renderer reads the same `rows` the table does. A client that ignores the key, or meets a `kind` it predates, renders the table and no chart.",
+                                        },
                                     },
                                     "required": [
                                         "report_id", "generated_at", "window",

{code_coordinator-0.5.102 → code_coordinator-0.5.105}/tests/test_merge_queue.py

@@ -1118,6 +1118,23 @@ class _ExpectedRedGh(FakeGh):
         return "new-sha"
 
 
+class _PatchIdGh(_ExpectedRedGh):
+    """#2298: `_ExpectedRedGh` + a controllable `get_branch_patch_id`, keyed
+    by the *branch* arg (either the live PR branch name or a bare
+    acceptance_sha) so a test can simulate "same content, different SHA"
+    (a pure rebase) independently of `get_branch_sha`/`branch_head_sha`.
+    """
+
+    def __init__(self, *, patch_ids: dict[str, str | None], **kw):
+        super().__init__(**kw)
+        self._patch_ids = patch_ids
+        self.patch_id_calls: list[tuple[str, str, str]] = []
+
+    def get_branch_patch_id(self, repo: str, base: str, branch: str) -> str | None:
+        self.patch_id_calls.append((repo, base, branch))
+        return self._patch_ids.get(branch)
+
+
 class TestExpectedRedClearOnMerge:
     """#2164 review (blocking finding 1): clearing `expected_red` must wait
     for the fix's own PR to actually merge into the default branch, not
@@ -1372,6 +1389,98 @@ class TestExpectedRedClearOnMerge:
             "SELECT 1 FROM audit_log WHERE event_type = 'expected_red_clear'",
         ).fetchall()
 
+    # ── #2298: SHA mismatch ≠ content change ────────────────────────────
+
+    def test_clears_when_sha_mismatches_but_patch_id_confirms_a_pure_rebase(
+        self,
+    ) -> None:
+        """#2298: `checks_stale`/`smoke_required` force a rebase before a
+        PR sitting behind a moved base can merge at all — which rewrites
+        `branch_head_sha` even when nothing about the PR's own diff
+        changed. A patch-id match (the branch's current diff against
+        target == the diff `acceptance_sha` introduced against target)
+        must clear exactly like an exact-SHA match does, not skip."""
+        work = self._work("w1", acceptance_state="passed", acceptance_sha="old-sha")
+        board = self._board(completed=[work])
+        gh = _PatchIdGh(
+            branch_sha="new-sha",  # branch_head_sha != acceptance_sha
+            patch_ids={"worker/w1": "same-patch", "old-sha": "same-patch"},
+        )
+
+        events = process([_q("w1", size=10)], gh, board=board)
+
+        assert events[-1].kind == "expected_red_clear"
+        assert "ms01::a" in events[-1].message
+        assert "patch-id" in events[-1].message  # names the arm it took
+        assert gh.update_repo_file_calls  # the manifest text was actually edited
+
+    def test_still_skips_when_sha_mismatches_and_patch_id_also_differs(self) -> None:
+        """The counterpart: content genuinely changed after the verdict
+        was recorded (a conflict resolved differently, an extra commit) —
+        must still skip, same named event as a bare SHA mismatch."""
+        work = self._work("w1", acceptance_state="passed", acceptance_sha="old-sha")
+        board = self._board(completed=[work])
+        gh = _PatchIdGh(
+            branch_sha="new-sha",
+            patch_ids={"worker/w1": "patch-new", "old-sha": "patch-old"},
+        )
+
+        events = process([_q("w1", size=10)], gh, board=board)
+
+        assert events[-1].kind == "expected_red_clear_skipped"
+        assert not gh.update_repo_file_calls
+
+    def test_still_skips_when_patch_id_is_unavailable(self) -> None:
+        """Fail closed: a SHA mismatch with no patch-id on either side
+        (an older `gh_ops`, or a lookup failure) must skip exactly like
+        before #2298 — "cannot confirm identical" is never "confirmed"."""
+        work = self._work("w1", acceptance_state="passed", acceptance_sha="old-sha")
+        board = self._board(completed=[work])
+        gh = _PatchIdGh(branch_sha="new-sha", patch_ids={})  # every lookup -> None
+
+        events = process([_q("w1", size=10)], gh, board=board)
+
+        assert events[-1].kind == "expected_red_clear_skipped"
+        assert not gh.update_repo_file_calls
+
+    def test_patch_id_verified_clear_writes_a_distinct_durable_audit_row(
+        self, coord_db,
+    ) -> None:
+        """The rebase-not-content-change arm is queryable on its own —
+        not just implied by the eventual `expected_red_clear` row — the
+        same "name every branch" posture #2199/#2266 already established
+        for the other arms of this function."""
+        work = self._work("w1", acceptance_state="passed", acceptance_sha="old-sha")
+        board = self._board(completed=[work])
+        gh = _PatchIdGh(
+            branch_sha="new-sha",
+            patch_ids={"worker/w1": "same-patch", "old-sha": "same-patch"},
+        )
+
+        process([_q("w1", size=10)], gh, board=board)
+
+        rows = coord_db.execute(
+            "SELECT issue FROM audit_log "
+            "WHERE event_type = 'expected_red_sha_mismatch_patch_id_verified'",
+        ).fetchall()
+        assert len(rows) == 1
+        assert rows[0]["issue"] == 1
+
+    def test_skip_remedy_points_at_a_command_that_works_post_merge(self) -> None:
+        """#2298 (also worth fixing here): the pre-#2298 advice —
+        `coord acceptance record --sha <merged sha>` — targets an open
+        issue's live work assignment. By the time this guard skips, the
+        issue this entry closed is already closed (`gh_ops.close_issue`
+        ran just before this), so that advice leads nowhere. Point at the
+        remedy that actually works from the state the operator is in."""
+        work = self._work("w1", acceptance_state="passed", acceptance_sha="an-old-sha")
+        board = self._board(completed=[work])
+        gh = _ExpectedRedGh(branch_sha="cafesha")  # branch_head_sha != acceptance_sha
+
+        events = process([_q("w1", size=10)], gh, board=board)
+
+        assert "coord acceptance expected-red api --clear --issue 1" in events[-1].message
+
 
 class _TestAuthorGateGh(FakeGh):
     """#2191: FakeGh + the API-only manifest/issue-state surface