code-coordinator 0.5.262__tar.gz → 0.5.263__tar.gz

{code_coordinator-0.5.262 → code_coordinator-0.5.263}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.262",
+  "tag": "0.5.263",
   "distance": 0,
-  "node": "g0ef4d9fe88b17a02b984541dc5f936ddefb6ec56",
+  "node": "g48c97e278762fe857dec843b91373c0a1ce790b2",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-28"

{code_coordinator-0.5.262 → code_coordinator-0.5.263}/coord/housekeeping.py

@@ -21,6 +21,18 @@ Two guarantees make the sweep safe:
 The sweep runs automatically on a low-cadence daemon tick and on demand via
 ``coord housekeeping`` (which routes through the daemon — the canonical DB lives
 there).
+
+#1107 Part 3: the same sweep also archives ``merge_queue`` rows in the
+``MERGED`` terminal state once they're older than the retention window, into
+``merge_queue_archive`` — mirroring the move-not-delete pattern above.
+``merge_queue`` has no natural "close" event of its own (unlike assignments,
+which age out via ``TERMINAL_STATUSES``), so without this a MERGED row lives
+forever: 192 such rows had accumulated by 2026-07-12 and 61 more by
+2026-07-30, both requiring a manual one-off ``DELETE``/``coord merge --drop``
+declog. ``coord.merge_queue.merged_issue_keys()`` unions the live table with
+the archive so the "already merged, don't re-enqueue" dedup in
+``enqueue_approved_work``/``staging_items`` keeps working after a row ages
+out.
 """
 
 from __future__ import annotations
@@ -48,6 +60,9 @@ _ASSIGNMENTS = "assignments"
 _ASSIGNMENTS_ARCHIVE = "assignments_archive"
 _NOTIFICATIONS = "notifications"
 _NOTIFICATIONS_ARCHIVE = "notifications_archive"
+_MERGE_QUEUE = "merge_queue"
+_MERGE_QUEUE_ARCHIVE = "merge_queue_archive"
+_MERGE_QUEUE_MERGED_STATE = "merged"
 _BATCH = 400  # keep IN(...) clauses well under SQLite's 999-variable limit
 
 
@@ -124,20 +139,26 @@ def _move_rows(
 
 
 def sweep(*, dry_run: bool = False, now: float | None = None) -> dict:
-    """Archive stale terminal assignments + their notifications.
+    """Archive stale terminal assignments + their notifications + merged
+    merge_queue entries.
 
     Returns ``{"archived_assignments": N, "archived_notifications": M,
-    "dry_run": bool, "retention_days": D}``.  ``archived_*`` are the counts that
-    were (or, for ``dry_run``, would be) moved.  A no-op returns zeros.
+    "archived_merge_queue": K, "dry_run": bool, "retention_days": D}``.
+    ``archived_*`` are the counts that were (or, for ``dry_run``, would be)
+    moved.  A no-op returns zeros.
 
     Conservative by construction: nothing active, recent (within the archive
     window), queued-for-merge, latest-of-an-open-issue, or review-linked to any
-    such row is ever moved.
+    such row is ever moved. Merge queue entries are archived only once they
+    are in the terminal ``MERGED`` state (#1107 Part 3) — non-terminal /
+    conflicted entries are left for ``prune_stale_queue_entries`` or manual
+    ``coord merge --drop``.
     """
     cutoff = _archive_cutoff(now)
     result = {
         "archived_assignments": 0,
         "archived_notifications": 0,
+        "archived_merge_queue": 0,
         "dry_run": dry_run,
         "retention_days": _archive_retention_days(),
     }
@@ -151,13 +172,19 @@ def sweep(*, dry_run: bool = False, now: float | None = None) -> dict:
             conn, f"SELECT {_KEEP_INDEX_COLUMNS} FROM {_ASSIGNMENTS}"  # noqa: S608
         ).fetchall()
     ]
-    mq_ids = {
+    mq_rows = sql.execute(
+        conn,
+        "SELECT assignment_id, state, last_attempt, enqueued_at "  # noqa: S608
+        f"FROM {_MERGE_QUEUE}",
+    ).fetchall()
+    mq_ids = {r["assignment_id"] for r in mq_rows if r["assignment_id"]}
+    mq_merged_ids = [
         r["assignment_id"]
-        for r in sql.execute(
-            conn, f"SELECT assignment_id FROM merge_queue"  # noqa: S608
-        ).fetchall()
+        for r in mq_rows
         if r["assignment_id"]
-    }
+        and (r["state"] or "").lower() == _MERGE_QUEUE_MERGED_STATE
+        and (r["last_attempt"] or r["enqueued_at"] or 0) < cutoff
+    ]
     open_keys = {
         (r["repo_name"], r["number"])
         for r in sql.execute(
@@ -194,7 +221,8 @@ def sweep(*, dry_run: bool = False, now: float | None = None) -> dict:
 
     result["archived_assignments"] = len(candidates)
     result["archived_notifications"] = len(notif_ids)
-    if dry_run or (not candidates and not notif_ids):
+    result["archived_merge_queue"] = len(mq_merged_ids)
+    if dry_run or (not candidates and not notif_ids and not mq_merged_ids):
         return result
 
     with conn:
@@ -206,4 +234,8 @@ def sweep(*, dry_run: bool = False, now: float | None = None) -> dict:
             _move_rows(
                 conn, _ASSIGNMENTS, _ASSIGNMENTS_ARCHIVE, "assignment_id", candidates
             )
+        if mq_merged_ids:
+            _move_rows(
+                conn, _MERGE_QUEUE, _MERGE_QUEUE_ARCHIVE, "assignment_id", mq_merged_ids
+            )
     return result

{code_coordinator-0.5.262 → code_coordinator-0.5.263}/coord/merge_queue.py

@@ -12,6 +12,7 @@ from __future__ import annotations
 import inspect
 import json
 import logging
+import sqlite3
 import time
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
@@ -3753,6 +3754,58 @@ def save_queue(items: list[QueuedMerge]) -> None:
     retry_on_locked(_write)
 
 
+# ── Merged-history lookups (#1107 Part 3) ───────────────────────────────────
+#
+# `housekeeping.sweep()` archives MERGED merge_queue rows older than the
+# archive retention window into `merge_queue_archive` (same move-not-delete
+# pattern as `assignments`/`notifications`) so the live table stays bounded
+# instead of growing forever. `enqueue_approved_work()` and `staging_items()`
+# both dedup on "(repo, issue) already merged" to avoid re-surfacing an issue
+# whose prior work attempt already shipped — once the winning entry ages out
+# of the live table, that check must still see it, so it consults the
+# archive too.
+
+def _archived_merged_issue_keys(conn: sqlite3.Connection) -> set[tuple[str, int]]:
+    """(repo_name, issue_number) pairs recorded MERGED in the archive.
+
+    `merge_queue_archive` only exists once a housekeeping sweep has archived
+    at least one row (or archiving is disabled entirely), so this is
+    defensive against the table being absent.
+    """
+    try:
+        rows = sql.execute(
+            conn,
+            "SELECT repo_name, issue_number FROM merge_queue_archive WHERE state = ?",
+            (MERGED,),
+        ).fetchall()
+    except sql.driver_errors():  # #2784: not just sqlite3.OperationalError
+        # "no such table" surfaces as a *different* driver-named exception
+        # per backend (sqlite3.OperationalError vs psycopg.errors.
+        # UndefinedTable), so this must go through the dialect seam or the
+        # not-yet-archived case becomes an uncaught crash on Postgres.
+        return set()
+    return {(r["repo_name"], r["issue_number"]) for r in rows}
+
+
+def merged_issue_keys() -> set[tuple[str, int]]:
+    """All ``(repo_name, issue_number)`` pairs ever recorded MERGED.
+
+    Unions the live ``merge_queue`` table with ``merge_queue_archive`` so
+    callers get a correct answer regardless of whether the winning entry has
+    since been archived by ``housekeeping.sweep()``.
+    """
+    conn = get_connection()
+    live = {
+        (r["repo_name"], r["issue_number"])
+        for r in sql.execute(
+            conn,
+            "SELECT repo_name, issue_number FROM merge_queue WHERE state = ?",
+            (MERGED,),
+        ).fetchall()
+    }
+    return live | _archived_merged_issue_keys(conn)
+
+
 # ── Enqueue ──────────────────────────────────────────────────────────────
 
 def enqueue(
@@ -5403,12 +5456,10 @@ def staging_items(board, config, gh_ops: "GhOps | None" = None) -> list[StagingI
     queued_branches: set[str] = {x.branch for x in existing_queue if x.branch}
 
     # Fast-lookup: (repo_name, issue_number) pairs already MERGED so we skip
-    # issues whose prior attempt was already shipped.
-    already_merged: set[tuple[str, int]] = {
-        (x.repo_name, x.issue_number)
-        for x in existing_queue
-        if x.state == MERGED
-    }
+    # issues whose prior attempt was already shipped. Consults the archive
+    # too (#1107 Part 3) since the winning entry may have aged out of the
+    # live table by the time a later duplicate work item shows up here.
+    already_merged = merged_issue_keys()
 
     result: list[StagingItem] = []
     completed = list(getattr(board, "completed", []) or [])

{code_coordinator-0.5.262 → code_coordinator-0.5.263}/coord/serve_app.py

@@ -677,7 +677,8 @@ def _audit_housekeeping_sweep(swept: dict) -> None:
         summary=(
             f"housekeeping: archived {swept.get('archived_assignments', 0)} "
             f"assignment(s), {swept.get('archived_notifications', 0)} "
-            "notification(s)"
+            f"notification(s), {swept.get('archived_merge_queue', 0)} "
+            "merge_queue entry(ies)"
         ),
         details=swept,
     )
@@ -8500,14 +8501,17 @@ def build_app(store: CoordStore, config: Config, *, token: str | None = None) ->
 
                         os.environ["COORD_HOUSEKEEPING_ON_DAEMON"] = "1"
                         swept = await run_in_threadpool(_hk.sweep)
-                        if swept.get("archived_assignments") or swept.get(
-                            "archived_notifications"
+                        if (
+                            swept.get("archived_assignments")
+                            or swept.get("archived_notifications")
+                            or swept.get("archived_merge_queue")
                         ):
                             log.info(
                                 "housekeeping: archived %d assignment(s), "
-                                "%d notification(s)",
+                                "%d notification(s), %d merge_queue entry(ies)",
                                 swept["archived_assignments"],
                                 swept["archived_notifications"],
+                                swept.get("archived_merge_queue", 0),
                             )
                             _audit_housekeeping_sweep(swept)
                     except Exception:  # noqa: BLE001

{code_coordinator-0.5.262 → code_coordinator-0.5.263}/tests/test_board_cap_762.py

@@ -56,6 +56,27 @@ def _ins_merge_queue(conn: sqlite3.Connection, aid: str, issue: int, repo: str =
     )
 
 
+def _ins_merge_queue_entry(
+    conn: sqlite3.Connection,
+    aid: str,
+    issue: int,
+    *,
+    state: str,
+    last_attempt: float | None = None,
+    enqueued_at: float | None = None,
+    repo: str = "r",
+) -> None:
+    """Like ``_ins_merge_queue`` but with an explicit terminal ``state`` +
+    timestamps, for #1107 Part 3 archival tests."""
+    conn.execute(
+        "INSERT INTO merge_queue (assignment_id, repo_name, repo_github, branch, "
+        "target_branch, issue_number, issue_title, state, last_attempt, "
+        "enqueued_at) VALUES (?,?,?,?,?,?,?,?,?,?)",
+        (aid, repo, "gh/r", f"issue-{issue}", "main", issue, f"#{issue}",
+         state, last_attempt, enqueued_at),
+    )
+
+
 # ── pure keep-set helper ──────────────────────────────────────────────────────
 
 def test_compute_keep_ids_rules():
@@ -266,3 +287,82 @@ def test_housekeeping_never_archives_referenced(coord_db, monkeypatch):
     res = housekeeping.sweep()
     assert res["archived_assignments"] == 0
     assert conn.execute("SELECT COUNT(*) FROM assignments").fetchone()[0] == 1
+
+
+# ── #1107 Part 3: merge_queue archival ─────────────────────────────────────
+
+def test_housekeeping_archives_old_merged_queue_entries(coord_db, monkeypatch):
+    """Stale MERGED merge_queue rows move to merge_queue_archive; pending /
+    recent / non-merged rows are left in the live table untouched."""
+    monkeypatch.setenv("COORD_ARCHIVE_RETENTION_DAYS", "30")
+    from coord import housekeeping
+
+    conn = coord_db
+    _ins_merge_queue_entry(conn, "old_merged", 1, state="merged", last_attempt=OLD)
+    _ins_merge_queue_entry(conn, "recent_merged", 2, state="merged", last_attempt=RECENT)
+    _ins_merge_queue_entry(conn, "old_pending", 3, state="pending", enqueued_at=OLD)
+    conn.commit()
+
+    dry = housekeeping.sweep(dry_run=True)
+    assert dry["archived_merge_queue"] == 1
+    assert conn.execute("SELECT COUNT(*) FROM merge_queue").fetchone()[0] == 3
+
+    res = housekeeping.sweep()
+    assert res["archived_merge_queue"] == 1
+    live = {r[0] for r in conn.execute("SELECT assignment_id FROM merge_queue")}
+    arch = {r[0] for r in conn.execute("SELECT assignment_id FROM merge_queue_archive")}
+    assert live == {"recent_merged", "old_pending"}
+    assert arch == {"old_merged"}
+    # conservation: nothing lost
+    assert len(live) + len(arch) == 3
+
+
+def test_housekeeping_merge_queue_archive_falls_back_to_enqueued_at(coord_db, monkeypatch):
+    """A MERGED row with no last_attempt (legacy/hand-seeded) still ages out
+    using enqueued_at."""
+    monkeypatch.setenv("COORD_ARCHIVE_RETENTION_DAYS", "30")
+    from coord import housekeeping
+
+    conn = coord_db
+    _ins_merge_queue_entry(conn, "old_merged_no_attempt", 1, state="merged", enqueued_at=OLD)
+    conn.commit()
+
+    res = housekeeping.sweep()
+    assert res["archived_merge_queue"] == 1
+    arch = {r[0] for r in conn.execute("SELECT assignment_id FROM merge_queue_archive")}
+    assert arch == {"old_merged_no_attempt"}
+
+
+def test_merged_issue_keys_survives_archival(coord_db, monkeypatch):
+    """coord.merge_queue.merged_issue_keys() must keep returning an archived
+    entry's (repo, issue) — enqueue_approved_work/staging_items dedup on this
+    to avoid re-surfacing an issue whose winning PR already merged."""
+    monkeypatch.setenv("COORD_ARCHIVE_RETENTION_DAYS", "30")
+    from coord import housekeeping, merge_queue
+
+    conn = coord_db
+    _ins_merge_queue_entry(conn, "old_merged", 42, state="merged", last_attempt=OLD, repo="r")
+    conn.commit()
+
+    # Before archival: visible via the live table.
+    assert ("r", 42) in merge_queue.merged_issue_keys()
+
+    housekeeping.sweep()
+    # merge_queue no longer holds the row...
+    assert conn.execute("SELECT COUNT(*) FROM merge_queue").fetchone()[0] == 0
+    # ...but the dedup lookup still sees it via merge_queue_archive.
+    assert ("r", 42) in merge_queue.merged_issue_keys()
+
+
+def test_merged_issue_keys_defensive_when_archive_table_absent(coord_db):
+    """Before any sweep has ever run, merge_queue_archive doesn't exist yet —
+    merged_issue_keys() must not raise."""
+    from coord import merge_queue
+
+    conn = coord_db
+    _ins_merge_queue_entry(conn, "a", 1, state="merged", last_attempt=OLD)
+    conn.commit()
+    assert conn.execute(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name='merge_queue_archive'"
+    ).fetchone() is None
+    assert ("r", 1) in merge_queue.merged_issue_keys()

{code_coordinator-0.5.262 → code_coordinator-0.5.263}/tests/test_thin_client_board_audit.py

@@ -415,6 +415,11 @@ EXTENDED_ALLOWLIST: dict[str, set[tuple[str, str]]] = {
         ("save_queue", "get_connection"),
         ("drop_entry", "get_connection"),
         ("_load_milestones_for_queue", "get_connection"),
+        # #1107 Part 3: unions merge_queue with merge_queue_archive so the
+        # "already merged" dedup in enqueue_approved_work/staging_items still
+        # works after housekeeping.sweep() archives a row. Same daemon-side
+        # merge-queue-table seam as the others above.
+        ("merged_issue_keys", "get_connection"),
     },
     # coord/issue_store.py — raw get_connection calls for the issue-store
     # seam; these write notifications/results into the DB and are called from