code-coordinator 0.5.453__tar.gz → 0.5.454__tar.gz

{code_coordinator-0.5.453 → code_coordinator-0.5.454}/PKG-INFO

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

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

@@ -657,6 +657,7 @@ tests/test_health_unit_drift.py
 tests/test_health_unit_enablement.py
 tests/test_health_wedged_drive_queue.py
 tests/test_hooks.py
+tests/test_housekeeping.py
 tests/test_human_attended_437.py
 tests/test_init.py
 tests/test_install_agent_venv_2911.py

{code_coordinator-0.5.453 → code_coordinator-0.5.454}/code_coordinator.egg-info/scm_file_list.json

@@ -683,6 +683,7 @@
     "tests/test_health_unit_enablement.py",
     "tests/test_health_wedged_drive_queue.py",
     "tests/test_hooks.py",
+    "tests/test_housekeeping.py",
     "tests/test_human_attended_437.py",
     "tests/test_init.py",
     "tests/test_install_agent_venv_2911.py",

{code_coordinator-0.5.453 → code_coordinator-0.5.454}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.453",
+  "tag": "0.5.454",
   "distance": 0,
-  "node": "gf9162e8b92018087ab923c640b8eb07b232cf9bd",
+  "node": "ga4a99bfd3ea79dd343b5828974ef637592ae4897",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-11"

{code_coordinator-0.5.453 → code_coordinator-0.5.454}/coord/housekeeping.py

@@ -41,6 +41,30 @@ is wired in too, reclaiming ``~/.coord/confirm-worktrees/`` entries that
 outlived ``confirm_branch``'s own per-run cleanup. That is disk hygiene, not
 DB archiving, but reusing this sweep's cadence beats inventing a second timer
 for a second maintenance job.
+
+#3296: the same sweep also archives two tables #1107/#762 never reached —
+both ~800 KB of every ``/board`` poll with no retention policy at all, per a
+live-fleet sample that found 1,114 ``drive_queue`` rows all ``state=done``
+and 13 of 14 ``plans`` rows belonging to assignments no longer on the board:
+
+* terminal ``drive_queue`` rows (:data:`coord.drive_queue.TERMINAL_QUEUE_STATES`
+  — the same "is this queue entry terminal" answer the tick processor itself
+  uses, not a second definition) older than the retention window ->
+  ``drive_queue_archive``. Age is read off the row's own last-touched
+  timestamp (``reason_at`` if the row was ever updated post-launch, else
+  ``launched_at``, else ``enqueued_at``) — the same fallback chain
+  ``merge_queue``'s ``last_attempt or enqueued_at`` uses just below.
+* ``plans`` rows whose ``assignment_id`` no longer appears in the live
+  ``assignments`` table (i.e. that assignment has itself already been
+  archived — by this sweep or an earlier one) -> ``plans_archive``. A plan
+  can only orphan once its assignment ages out, which already implies it is
+  past the retention window, so no separate cutoff is needed for ``plans``.
+
+Both move via the same ``_move_rows``/``_ensure_archive_mirror`` machinery
+above — move-not-delete, dumb-mirror archive tables — so ``GET
+/drive-queue?state=...`` can still retrieve archived history (see
+``coord.serve_app``) and nothing is ever unreachable, only un-shipped by
+default from the live table / board projection.
 """
 
 from __future__ import annotations
@@ -71,6 +95,10 @@ _NOTIFICATIONS_ARCHIVE = "notifications_archive"
 _MERGE_QUEUE = "merge_queue"
 _MERGE_QUEUE_ARCHIVE = "merge_queue_archive"
 _MERGE_QUEUE_MERGED_STATE = "merged"
+_DRIVE_QUEUE = "drive_queue"
+_DRIVE_QUEUE_ARCHIVE = "drive_queue_archive"
+_PLANS = "plans"
+_PLANS_ARCHIVE = "plans_archive"
 _BATCH = 400  # keep IN(...) clauses well under SQLite's 999-variable limit
 
 
@@ -148,20 +176,27 @@ def _move_rows(
 
 def sweep(*, dry_run: bool = False, now: float | None = None) -> dict:
     """Archive stale terminal assignments + their notifications + merged
-    merge_queue entries, and reclaim leaked confirm-worktree directories.
+    merge_queue entries + terminal drive_queue rows + orphaned plans, and
+    reclaim leaked confirm-worktree directories.
 
     Returns ``{"archived_assignments": N, "archived_notifications": M,
-    "archived_merge_queue": K, "removed_confirm_worktrees": W, "dry_run": bool,
-    "retention_days": D}``. ``archived_*``/``removed_confirm_worktrees`` are
-    the counts that were (or, for ``dry_run``, would be) moved/deleted.  A
-    no-op returns zeros.
+    "archived_merge_queue": K, "archived_drive_queue": Q, "archived_plans": P,
+    "removed_confirm_worktrees": W, "dry_run": bool, "retention_days": D}``.
+    ``archived_*``/``removed_confirm_worktrees`` are the counts that were (or,
+    for ``dry_run``, would be) moved/deleted.  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. 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``.
+    ``coord merge --drop``. Drive-queue entries are archived only once they
+    are in a :data:`coord.drive_queue.TERMINAL_QUEUE_STATES` state AND older
+    than the retention window (#3296) — a fresh ``done``/``blocked``/
+    ``failed`` row stays put until it ages out, same as everything else this
+    sweep touches. ``plans`` rows follow their assignment: once an
+    assignment_id no longer appears in the live ``assignments`` table, its
+    plan is orphaned and moves too.
 
     #2974: ``removed_confirm_worktrees`` is independent of the DB-archiving
     ``cutoff``/``retention_days`` above (it has its own, much shorter,
@@ -179,6 +214,8 @@ def sweep(*, dry_run: bool = False, now: float | None = None) -> dict:
         "archived_assignments": 0,
         "archived_notifications": 0,
         "archived_merge_queue": 0,
+        "archived_drive_queue": 0,
+        "archived_plans": 0,
         "removed_confirm_worktrees": len(swept_worktrees["removed"]),
         "dry_run": dry_run,
         "retention_days": _archive_retention_days(),
@@ -240,10 +277,47 @@ def sweep(*, dry_run: bool = False, now: float | None = None) -> dict:
         )
     ]
 
+    # #3296: terminal drive_queue rows past the retention window. Reuses
+    # `coord.drive_queue.TERMINAL_QUEUE_STATES` — the same "is this queue
+    # entry terminal" the tick processor itself answers — rather than a
+    # second, driftable definition here.
+    from coord.drive_queue import TERMINAL_QUEUE_STATES  # noqa: PLC0415
+
+    dq_rows = sql.execute(
+        conn,
+        "SELECT id, state, reason_at, launched_at, enqueued_at "  # noqa: S608
+        f"FROM {_DRIVE_QUEUE}",
+    ).fetchall()
+    dq_candidates = [
+        r["id"]
+        for r in dq_rows
+        if (r["state"] or "").lower() in TERMINAL_QUEUE_STATES
+        and (r["reason_at"] or r["launched_at"] or r["enqueued_at"] or 0) < cutoff
+    ]
+
+    # #3296: `plans` rows whose assignment is no longer in the live
+    # `assignments` table — orphaned either by the archiving just computed
+    # above, or by an earlier sweep (run before this feature existed, hence
+    # the live fleet's 13-of-14-orphaned sample). No separate cutoff: a plan
+    # can only orphan once its assignment ages out, which already implies
+    # it's past the retention window.
+    live_assignment_ids = {r["assignment_id"] for r in index} - candidate_set
+    plan_candidates = [
+        r["assignment_id"]
+        for r in sql.execute(
+            conn, f"SELECT assignment_id FROM {_PLANS}"  # noqa: S608
+        ).fetchall()
+        if r["assignment_id"] and r["assignment_id"] not in live_assignment_ids
+    ]
+
     result["archived_assignments"] = len(candidates)
     result["archived_notifications"] = len(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):
+    result["archived_drive_queue"] = len(dq_candidates)
+    result["archived_plans"] = len(plan_candidates)
+    if dry_run or not (
+        candidates or notif_ids or mq_merged_ids or dq_candidates or plan_candidates
+    ):
         return result
 
     with conn:
@@ -259,4 +333,8 @@ def sweep(*, dry_run: bool = False, now: float | None = None) -> dict:
             _move_rows(
                 conn, _MERGE_QUEUE, _MERGE_QUEUE_ARCHIVE, "assignment_id", mq_merged_ids
             )
+        if dq_candidates:
+            _move_rows(conn, _DRIVE_QUEUE, _DRIVE_QUEUE_ARCHIVE, "id", dq_candidates)
+        if plan_candidates:
+            _move_rows(conn, _PLANS, _PLANS_ARCHIVE, "assignment_id", plan_candidates)
     return result

{code_coordinator-0.5.453 → code_coordinator-0.5.454}/coord/serve_app.py

@@ -4800,7 +4800,11 @@ def openapi_spec() -> dict:
                 "summary": (
                     "#1753: read the operator-declared `coord drive` work "
                     "queue in run order. Filter by repo_name (+ optional "
-                    "issue_number); omit both to list the whole queue."
+                    "issue_number); omit both to list the whole queue. "
+                    "#3296: an explicit `state` also pulls in matching rows "
+                    "`coord.housekeeping.sweep()` has since archived, so "
+                    "terminal history stays reachable after it ages out of "
+                    "the live table."
                 ),
                 "parameters": [
                     {
@@ -4811,6 +4815,16 @@ def openapi_spec() -> dict:
                         "name": "issue_number", "in": "query", "required": False,
                         "schema": {"type": "integer"},
                     },
+                    {
+                        "name": "state", "in": "query", "required": False,
+                        "schema": {"type": "string"},
+                        "description": (
+                            "#3296: filter by drive_queue.state (e.g. "
+                            "'done'/'blocked'/'failed'). When given, also "
+                            "reads drive_queue_archive so archived rows "
+                            "matching this state are still returned."
+                        ),
+                    },
                 ],
                 "responses": {
                     "200": {"description": "OK"},
@@ -8745,9 +8759,16 @@ def build_app(
         # filters to that repo; `repo_name` + `issue_number` narrows to the (at
         # most one) entry for that issue; neither given lists the whole queue
         # (hand-sized by definition — one row per issue an operator queued).
+        #
+        # #3296: `?state=` additionally reads `drive_queue_archive` — the
+        # live table alone would silently lose a terminal entry the moment
+        # `coord.housekeeping.sweep()` ages it out, making archived history
+        # unreachable rather than merely un-shipped-by-default from the
+        # unfiltered list.
         from coord import state  # noqa: PLC0415
 
         repo_name = request.query_params.get("repo_name")
+        state_filter = request.query_params.get("state")
         raw_issue = request.query_params.get("issue_number")
         issue_number = None
         if raw_issue is not None:
@@ -8760,9 +8781,21 @@ def build_app(
         try:
             if repo_name and issue_number is not None:
                 entry = state._get_drive_queue_entry_local(repo_name, issue_number)
+                if entry is None and state_filter:
+                    entry = state._get_drive_queue_archive_entry_local(
+                        repo_name, issue_number
+                    )
+                if (
+                    entry is not None
+                    and state_filter
+                    and entry.get("state") != state_filter
+                ):
+                    entry = None
                 entries = [entry] if entry else []
             else:
-                entries = state._list_drive_queue_local(repo_name)
+                entries = state._list_drive_queue_local(
+                    repo_name, state=state_filter
+                )
         except Exception as e:  # noqa: BLE001
             return JSONResponse(
                 {"error": "drive-queue read failed", "detail": str(e)},

{code_coordinator-0.5.453 → code_coordinator-0.5.454}/coord/state.py

@@ -7829,6 +7829,32 @@ def _get_drive_queue_entry_local(repo_name: str, issue_number: int) -> dict | No
     return _decode_drive_queue_row(row) if row is not None else None
 
 
+def _get_drive_queue_archive_entry_local(
+    repo_name: str, issue_number: int
+) -> dict | None:
+    """The archived drive-queue entry for one issue, or ``None``.
+
+    #3296: a live-table miss for (repo_name, issue_number) is ambiguous —
+    "never queued" and "archived after going terminal" look identical
+    without this. Callers that want to tell them apart (the `?state=`
+    history read in ``coord.serve_app``) fall back to this. Defensive
+    against ``drive_queue_archive`` not existing yet, same guard as
+    :func:`_drive_queue_archive_rows_local`.
+    """
+    conn = get_connection()
+    try:
+        row = sql.execute(
+            conn,
+            f"SELECT {_DRIVE_QUEUE_COLUMNS} FROM drive_queue_archive "  # noqa: S608 — constant
+            "WHERE repo_name = ? AND issue_number = ?",
+            (repo_name, issue_number),
+        ).fetchone()
+    except sql.driver_errors() as exc:  # #2784: not just sqlite3.OperationalError
+        rollback_after_driver_error(conn, exc)
+        return None
+    return _decode_drive_queue_row(row) if row is not None else None
+
+
 def list_drive_queue(repo_name: str | None = None) -> list[dict]:
     """Every drive-queue entry in run order, optionally filtered to one repo.
 
@@ -7843,19 +7869,67 @@ def list_drive_queue(repo_name: str | None = None) -> list[dict]:
     return _list_drive_queue_local(repo_name)
 
 
-def _list_drive_queue_local(repo_name: str | None = None) -> list[dict]:
+def _list_drive_queue_local(
+    repo_name: str | None = None, *, state: str | None = None
+) -> list[dict]:
+    """Live ``drive_queue`` rows, optionally filtered to one repo and/or one
+    ``state`` value.
+
+    #3296: an explicit ``state`` filter also pulls in matching
+    ``drive_queue_archive`` rows — ``coord.housekeeping.sweep()`` moves
+    terminal drive-queue rows there once they age out of the retention
+    window, and a caller asking "show me every `done` entry" must not have
+    them silently vanish the moment they're archived. Omitting ``state``
+    (the pre-#3296 call shape every other caller in this module still uses)
+    reads only the live table, unchanged.
+    """
+    conn = get_connection()
+    where: list[str] = []
+    params: list[object] = []
+    if repo_name:
+        where.append("repo_name = ?")
+        params.append(repo_name)
+    if state:
+        where.append("state = ?")
+        params.append(state)
+    clause = f" WHERE {' AND '.join(where)}" if where else ""
+    rows = sql.execute(
+        conn,
+        f"SELECT {_DRIVE_QUEUE_COLUMNS} FROM drive_queue{clause} "  # noqa: S608 — constant
+        "ORDER BY position, id",
+        params,
+    ).fetchall()
+    entries = [_decode_drive_queue_row(r) for r in rows]
+    if state:
+        entries.extend(_drive_queue_archive_rows_local(repo_name, state))
+    return entries
+
+
+def _drive_queue_archive_rows_local(repo_name: str | None, state: str) -> list[dict]:
+    """``drive_queue_archive`` rows matching *state* (+ optional *repo_name*).
+
+    Defensive against ``drive_queue_archive`` not existing yet — it is only
+    created the first time ``coord.housekeeping.sweep()`` archives a
+    drive-queue row — mirroring
+    :func:`coord.merge_queue._archived_merged_issue_keys`'s guard for the
+    same not-yet-archived case on ``merge_queue_archive``.
+    """
     conn = get_connection()
+    where = ["state = ?"]
+    params: list[object] = [state]
     if repo_name:
-        rows = sql.execute(conn,
-            f"SELECT {_DRIVE_QUEUE_COLUMNS} FROM drive_queue "  # noqa: S608 — constant
-            "WHERE repo_name = ? ORDER BY position, id",
-            (repo_name,),
-        ).fetchall()
-    else:
-        rows = sql.execute(conn,
-            f"SELECT {_DRIVE_QUEUE_COLUMNS} FROM drive_queue "  # noqa: S608 — constant
-            "ORDER BY position, id"
+        where.append("repo_name = ?")
+        params.append(repo_name)
+    try:
+        rows = sql.execute(
+            conn,
+            f"SELECT {_DRIVE_QUEUE_COLUMNS} FROM drive_queue_archive "  # noqa: S608 — constant
+            f"WHERE {' AND '.join(where)} ORDER BY id",
+            params,
         ).fetchall()
+    except sql.driver_errors() as exc:  # #2784: not just sqlite3.OperationalError
+        rollback_after_driver_error(conn, exc)
+        return []
     return [_decode_drive_queue_row(r) for r in rows]
 
 

code_coordinator-0.5.454/tests/test_housekeeping.py

@@ -0,0 +1,259 @@
+"""#3296: extend `coord housekeeping` to archive terminal `drive_queue` rows
+and `plans` rows orphaned by an archived assignment.
+
+`coord.housekeeping.sweep()` (#762/#1107) already moves stale terminal
+`assignments`/`notifications`/`merge_queue` rows to their `_archive` tables
+on a retention timer — move-not-delete, nothing ever deleted. A live-fleet
+sample found the two tables this issue covers made up ~800 KB of every
+`/board` poll with no retention policy at all: 1,114 `drive_queue` rows all
+`state=done`, and 13 of 14 `plans` rows belonging to assignments no longer
+on the board. These tests exercise the real write path (the sweep) and the
+real read paths (`SqliteStore.board_projection` + the `/drive-queue` HTTP
+route), not just a pure helper — the same shape as `tests/test_board_cap_762.py`.
+"""
+
+from __future__ import annotations
+
+import sqlite3
+import time
+
+import pytest
+
+from coord.dao import SqliteStore
+from coord.db import _ensure_schema
+
+NOW = time.time()
+RECENT = NOW - 2 * 86400      # 2 days ago  → inside the 30d archive window
+OLD = NOW - 40 * 86400        # 40 days ago → outside the archive window
+
+
+@pytest.fixture(autouse=True)
+def _isolated_confirm_worktrees_dir(monkeypatch, tmp_path):
+    """See `tests/test_board_cap_762.py`'s fixture of the same name:
+    `housekeeping.sweep()` always also sweeps `~/.coord/confirm-worktrees/`
+    (#2974), so every test in this module that calls the real sweep needs
+    `coord.state.COORD_DIR` pinned to a private tmp dir, or it would touch
+    the operator's real `~/.coord/` as a side effect of running pytest.
+    """
+    monkeypatch.setattr("coord.state.COORD_DIR", tmp_path / "coord-state")
+
+
+def _ins_assignment(
+    conn: sqlite3.Connection,
+    aid: str,
+    *,
+    status: str,
+    issue: int,
+    repo: str = "r",
+    dispatched_at: float | None = None,
+    finished_at: float | None = None,
+) -> None:
+    conn.execute(
+        "INSERT INTO assignments (assignment_id, machine_name, repo_name, "
+        "issue_number, issue_title, status, type, dispatched_at, finished_at) "
+        "VALUES (?,?,?,?,?,?,?,?,?)",
+        (aid, "m", repo, issue, f"#{issue}", status, "work", dispatched_at, finished_at),
+    )
+
+
+def _ins_issue(conn: sqlite3.Connection, number: int, state: str, repo: str = "r") -> None:
+    conn.execute(
+        "INSERT INTO issues (repo_name, number, state) VALUES (?,?,?)",
+        (repo, number, state),
+    )
+
+
+def _ins_drive_queue(
+    conn: sqlite3.Connection,
+    repo: str,
+    issue: int,
+    *,
+    position: int,
+    state: str,
+    enqueued_at: float,
+    reason_at: float | None = None,
+    launched_at: float | None = None,
+) -> None:
+    conn.execute(
+        "INSERT INTO drive_queue (repo_name, issue_number, position, state, "
+        "enqueued_at, reason_at, launched_at) VALUES (?,?,?,?,?,?,?)",
+        (repo, issue, position, state, enqueued_at, reason_at, launched_at),
+    )
+
+
+def _ins_plan(conn: sqlite3.Connection, assignment_id: str, plan_data: str = "{}") -> None:
+    conn.execute(
+        "INSERT INTO plans (assignment_id, plan_data) VALUES (?, ?)",
+        (assignment_id, plan_data),
+    )
+
+
+# ── drive_queue archival ───────────────────────────────────────────────────
+
+def test_housekeeping_archives_old_terminal_drive_queue(coord_db, monkeypatch):
+    monkeypatch.setenv("COORD_ARCHIVE_RETENTION_DAYS", "30")
+    from coord import housekeeping
+
+    conn = coord_db
+    _ins_drive_queue(conn, "r", 1, position=0, state="waiting", enqueued_at=OLD)
+    _ins_drive_queue(
+        conn, "r", 2, position=1, state="done", enqueued_at=RECENT, reason_at=RECENT
+    )
+    _ins_drive_queue(
+        conn, "r", 3, position=2, state="done", enqueued_at=OLD, reason_at=OLD
+    )
+    _ins_drive_queue(
+        conn, "r", 4, position=3, state="blocked", enqueued_at=OLD, reason_at=OLD
+    )
+    # No reason_at/launched_at at all → falls back to enqueued_at, same
+    # fallback chain merge_queue's archival already relies on.
+    _ins_drive_queue(conn, "r", 5, position=4, state="failed", enqueued_at=OLD)
+    conn.commit()
+
+    dry = housekeeping.sweep(dry_run=True)
+    assert dry["archived_drive_queue"] == 3 and dry["dry_run"] is True
+    assert conn.execute("SELECT COUNT(*) FROM drive_queue").fetchone()[0] == 5
+
+    res = housekeeping.sweep()
+    assert res["archived_drive_queue"] == 3
+    live = {r[0] for r in conn.execute("SELECT issue_number FROM drive_queue")}
+    arch = {r[0] for r in conn.execute("SELECT issue_number FROM drive_queue_archive")}
+    assert live == {1, 2}          # non-terminal + recent-terminal untouched
+    assert arch == {3, 4, 5}        # old done/blocked/failed all moved
+    # conservation: nothing lost
+    assert len(live) + len(arch) == 5
+
+
+def test_housekeeping_drive_queue_archive_row_shape_preserved(coord_db, monkeypatch):
+    """The archived row keeps its full column set (position, after_json, ...)
+    — dumb-mirror storage, not a lossy projection."""
+    monkeypatch.setenv("COORD_ARCHIVE_RETENTION_DAYS", "30")
+    from coord import housekeeping
+
+    conn = coord_db
+    _ins_drive_queue(conn, "r", 9, position=0, state="done", enqueued_at=OLD, reason_at=OLD)
+    conn.commit()
+
+    housekeeping.sweep()
+    row = conn.execute(
+        "SELECT repo_name, issue_number, state, position FROM drive_queue_archive"
+    ).fetchone()
+    assert tuple(row) == ("r", 9, "done", 0)
+
+
+# ── plans archival ─────────────────────────────────────────────────────────
+
+def test_housekeeping_archives_orphaned_plans(coord_db, monkeypatch):
+    monkeypatch.setenv("COORD_ARCHIVE_RETENTION_DAYS", "30")
+    from coord import housekeeping
+
+    conn = coord_db
+    _ins_assignment(conn, "active", status="running", issue=1, dispatched_at=OLD)
+    _ins_assignment(
+        conn, "old_closed", status="merged", issue=2, dispatched_at=OLD, finished_at=OLD
+    )
+    _ins_issue(conn, 2, "closed")
+    _ins_plan(conn, "active")       # assignment stays live → plan stays
+    _ins_plan(conn, "old_closed")   # assignment archived THIS sweep → plan archived
+    _ins_plan(conn, "long_gone")    # no matching assignment at all → pre-existing orphan
+    conn.commit()
+
+    dry = housekeeping.sweep(dry_run=True)
+    assert dry["archived_plans"] == 2 and dry["dry_run"] is True
+    assert conn.execute("SELECT COUNT(*) FROM plans").fetchone()[0] == 3
+
+    res = housekeeping.sweep()
+    assert res["archived_plans"] == 2
+    live = {r[0] for r in conn.execute("SELECT assignment_id FROM plans")}
+    arch = {r[0] for r in conn.execute("SELECT assignment_id FROM plans_archive")}
+    assert live == {"active"}
+    assert arch == {"old_closed", "long_gone"}
+    # conservation: nothing lost
+    assert len(live) + len(arch) == 3
+
+
+# ── board_projection excludes archived rows (real read path, file-backed) ──
+
+@pytest.fixture
+def file_db(tmp_path):
+    path = tmp_path / "coord.db"
+    conn = sqlite3.connect(path)
+    conn.row_factory = sqlite3.Row
+    _ensure_schema(conn)
+    yield path, conn
+    conn.close()
+
+
+def test_board_projection_excludes_archived_drive_queue_and_plans(file_db, monkeypatch):
+    monkeypatch.setenv("COORD_ARCHIVE_RETENTION_DAYS", "30")
+    from coord import db, housekeeping
+
+    path, conn = file_db
+    _ins_assignment(
+        conn, "old_closed", status="merged", issue=3, dispatched_at=OLD, finished_at=OLD
+    )
+    _ins_issue(conn, 3, "closed")
+    _ins_drive_queue(conn, "r", 1, position=0, state="done", enqueued_at=OLD, reason_at=OLD)
+    _ins_drive_queue(conn, "r", 2, position=1, state="waiting", enqueued_at=RECENT)
+    _ins_plan(conn, "old_closed")
+    conn.commit()
+
+    # housekeeping.sweep() reads/writes via coord.db.get_connection() — point
+    # that singleton at this same file-backed connection so the sweep and the
+    # projection read agree, mirroring test_board_cap_762's daemon-route test.
+    db.override_connection(conn)
+    housekeeping.sweep()
+
+    proj = SqliteStore(path).board_projection()
+    dq_issues = {e["issue_number"] for e in proj["drive_queue"]}
+    assert dq_issues == {2}                 # the archived 'done' row is gone
+    assert proj["plans"] == {}               # the orphaned plan is gone
+
+
+# ── GET /drive-queue?state= reaches the archive (black-box, real route) ────
+
+def test_drive_queue_endpoint_state_param_reads_archived_history(
+    tmp_path, valid_config_path, monkeypatch
+):
+    monkeypatch.setenv("COORD_ARCHIVE_RETENTION_DAYS", "30")
+    from starlette.testclient import TestClient
+
+    from coord import db, housekeeping
+    from coord.config import load as load_config
+    from coord.dao import SqliteStore
+    from coord.serve_app import build_app
+
+    path = tmp_path / "coord.db"
+    conn = sqlite3.connect(str(path), check_same_thread=False)
+    conn.row_factory = sqlite3.Row
+    _ensure_schema(conn)
+    db.override_connection(conn)
+    _ins_drive_queue(conn, "r", 7, position=0, state="done", enqueued_at=OLD, reason_at=OLD)
+    _ins_drive_queue(conn, "r", 8, position=1, state="waiting", enqueued_at=RECENT)
+    conn.commit()
+    housekeeping.sweep()  # moves issue 7 to drive_queue_archive
+
+    app = build_app(SqliteStore(path), load_config(valid_config_path))
+    with TestClient(app) as cli:
+        # Un-shipped-by-default: no `state` filter → archived row stays hidden.
+        default = cli.get("/drive-queue", params={"repo_name": "r"}).json()
+        assert {e["issue_number"] for e in default["entries"]} == {8}
+
+        # Explicit `state=done` reaches into the archive → archived row returns.
+        by_state = cli.get(
+            "/drive-queue", params={"repo_name": "r", "state": "done"}
+        ).json()
+        assert {e["issue_number"] for e in by_state["entries"]} == {7}
+
+        # Point lookup by (repo_name, issue_number) + state also finds it.
+        point = cli.get(
+            "/drive-queue",
+            params={"repo_name": "r", "issue_number": 7, "state": "done"},
+        ).json()
+        assert {e["issue_number"] for e in point["entries"]} == {7}
+
+        # Same point lookup with NO state param stays un-shipped-by-default.
+        point_no_state = cli.get(
+            "/drive-queue", params={"repo_name": "r", "issue_number": 7}
+        ).json()
+        assert point_no_state["entries"] == []

{code_coordinator-0.5.453 → code_coordinator-0.5.454}/tests/test_sqlite_connect_ratchet.py

@@ -458,6 +458,23 @@ SQLITE_CONNECT_ALLOWLIST: dict[str, Classification] = {
         "A file DB for board_projection, plus a check_same_thread=False "
         "connection for the daemon threadpool sweep.",
     ),
+    "test_housekeeping.py": Classification(
+        2, (BUCKET_C,),
+        "#3296's drive_queue/plans archival tests, the same two shapes as "
+        "test_board_cap_762.py above (the file this one extends the sweep "
+        "alongside). One is a `file_db` fixture whose *path* is handed to "
+        "SqliteStore(path) for the board_projection read while its *conn* is "
+        "handed to db.override_connection() for the sweep's write, so both "
+        "halves must agree on one on-disk database; the other is a "
+        "check_same_thread=False connection because the /drive-queue route "
+        "runs on a TestClient worker thread. Neither fits the autouse "
+        "coord_db fixture (`:memory:` has no path for SqliteStore to open, "
+        "and it is single-thread-bound) nor tests.backends."
+        "scratch_database() (it yields a connection, not the path "
+        "SqliteStore needs, and SqliteStore is the SQLite arm of the store "
+        "seam by definition — following COORD_TEST_BACKEND to Postgres "
+        "would hand it a database it cannot open).",
+    ),
     "test_approved_work_2532.py": Classification(
         2, (BUCKET_C,),
         "A thread-safe rw_db override for the write side plus a detail_db "