code-coordinator 0.5.269__tar.gz → 0.5.270__tar.gz

{code_coordinator-0.5.269 → code_coordinator-0.5.270}/PKG-INFO

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

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

@@ -714,6 +714,7 @@ tests/test_split.py
 tests/test_split_work.py
 tests/test_sql_dialect.py
 tests/test_stage_projection.py
+tests/test_stale_busy_reviewer_697.py
 tests/test_stalled_pipeline.py
 tests/test_state.py
 tests/test_state_review_findings_daemon.py

{code_coordinator-0.5.269 → code_coordinator-0.5.270}/code_coordinator.egg-info/scm_file_list.json

@@ -786,6 +786,7 @@
     "tests/test_split_work.py",
     "tests/test_sql_dialect.py",
     "tests/test_stage_projection.py",
+    "tests/test_stale_busy_reviewer_697.py",
     "tests/test_stalled_pipeline.py",
     "tests/test_state.py",
     "tests/test_state_review_findings_daemon.py",

{code_coordinator-0.5.269 → code_coordinator-0.5.270}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.269",
+  "tag": "0.5.270",
   "distance": 0,
-  "node": "gfb3b3633ce05c303a5c7243c93486fab73020f5e",
+  "node": "g03d05893c4dd0a33802455a4bac412f730e4f018",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-28"

{code_coordinator-0.5.269 → code_coordinator-0.5.270}/coord/review.py

@@ -1090,6 +1090,104 @@ class ReviewerChoice:
     rationale: str
 
 
+# #697: how far past a row's OWN needs-attention threshold a `pending`/
+# `running` row must sit before reviewer selection stops counting its machine
+# as busy.  One hour of margin on top of a threshold that is itself measured
+# in tens of minutes: comfortably longer than any reap path needs
+# (`coord.reconcile._reconcile_no_agent_record` on the daemon's 30s tick,
+# `coord.diagnose.sweep_dead_running_rows` on `coord-notify.timer`'s 5min
+# cadence), so a row still counted busy here is one every reaper has already
+# had many chances at.
+STALE_BUSY_BUFFER_SECONDS = 3600.0
+
+# The same horizon for rows whose type has NO wall-clock threshold at all —
+# `PipelineConfig.attention_threshold_for` returns `inf` for the attended
+# chat/troubleshoot/audit family (#1133).  Those are exactly the rows #697
+# observed at 51h and 70h, so "never expires" is not an option here; a flat,
+# deliberately generous day is.  A human really attending a chat session for
+# a full day is far rarer than a tmux session that died without being reaped.
+STALE_BUSY_INTERACTIVE_SECONDS = 24 * 3600.0
+
+
+def _is_stale_busy_row(a: Assignment, config: Config, now: float) -> bool:
+    """True when *a* is too old to still be believed as occupying its machine (#697).
+
+    Reviewer selection's ``busy`` set used to count **every** ``pending``/
+    ``running`` board row, which is how a zombie row broke dispatch in #697:
+    rows whose worker had been dead for hours-to-days kept inflating the set,
+    so real machines looked occupied and selection was pushed onto whatever
+    candidate happened to look "free" — on #669 that was an *offline* machine,
+    and the review could not be dispatched at all.
+
+    This is deliberately **not** a liveness probe, and deliberately **not** a
+    reap.  The reapers (``coord.reconcile._reconcile_no_agent_record``,
+    ``coord.interactive.reap_stale_interactive_sessions``,
+    ``coord.diagnose.sweep_dead_running_rows``) own the "is it actually dead?"
+    question, they answer it with a positive disproof or a real tmux/agent
+    probe, and they are the only things allowed to write a terminal status.
+    Guessing from age alone would be #1870's mistake if it gated a *write*.
+
+    Here it gates only a *ranking*, where being wrong is cheap and
+    self-correcting in both directions:
+
+    * Wrong about a genuinely-live row → its machine is ranked as idle and may
+      receive the review.  That is the SAME outcome fallback 1
+      ("different machine, currently busy — review will queue") already
+      produces on a one-other-machine fleet, and a genuinely-saturated agent
+      answers with a rejection that ``_ranked_reviewer_candidates`` already
+      falls through on (#904).
+    * Wrong about a dead row (age not yet reached) → status quo ante: the
+      machine stays "busy" and merely ranks lower.
+
+    A row with no ``dispatched_at`` is never stale — there is nothing to
+    compute an age from, and this path never guesses, mirroring
+    ``sweep_dead_running_rows``.
+    """
+    dispatched_at = getattr(a, "dispatched_at", None)
+    if not dispatched_at:
+        return False
+    try:
+        dispatched = float(dispatched_at)
+    except (TypeError, ValueError):
+        return False
+
+    threshold = config.pipeline.attention_threshold_for(
+        a.type or "work",
+        provider_name=a.provider_name,
+        review_of_assignment_id=a.review_of_assignment_id,
+    )
+    if threshold == float("inf"):
+        horizon = STALE_BUSY_INTERACTIVE_SECONDS
+    else:
+        horizon = threshold + STALE_BUSY_BUFFER_SECONDS
+    return (now - dispatched) > horizon
+
+
+def busy_machine_names(
+    board: Board,
+    config: Config,
+    *,
+    now: float | None = None,
+) -> set[str]:
+    """Machines with at least one *believable* in-flight row (#697).
+
+    The shared ``busy`` set for :func:`pick_reviewer_machine` and
+    :func:`_ranked_reviewer_candidates` — a ``pending``/``running`` row whose
+    age is past :func:`_is_stale_busy_row`'s horizon is presumed dead and no
+    longer holds its machine down.  See that function for why an age-only
+    heuristic is the right instrument *for a ranking* and the wrong one for a
+    reap.
+    """
+    if now is None:
+        now = time.time()
+    return {
+        a.machine_name
+        for a in board.active
+        if a.status in ("pending", "running")
+        and not _is_stale_busy_row(a, config, now)
+    }
+
+
 def pick_reviewer_machine(
     worker_machine_name: str,
     repo_name: str,
@@ -1111,6 +1209,11 @@ def pick_reviewer_machine(
     cordon blocked the review, the unreviewable entry stayed `running`, the
     running entry deferred the roll, and the deferred roll left the cordon
     up. Explicit pauses and quiet hours still apply.
+
+    #697: the ``busy`` set is :func:`busy_machine_names`, which drops
+    ``pending``/``running`` rows too old to still be believed — a zombie row
+    used to make a real machine look occupied indefinitely and push selection
+    onto an offline "free" candidate.
     """
     from coord.machine_pause import follow_on_paused_set
     paused = follow_on_paused_set(config.machines)
@@ -1121,7 +1224,7 @@ def pick_reviewer_machine(
     if not candidates:
         return None
 
-    busy = {a.machine_name for a in board.active if a.status in ("pending", "running")}
+    busy = busy_machine_names(board, config)
 
     different = [
         m for m in candidates
@@ -1191,6 +1294,9 @@ def _ranked_reviewer_candidates(
     literal "no eligible reviewer machine configured for repo
     'claude-coordinator'" that a cordoned fleet answered every review
     dispatch with for 70 minutes.
+
+    #697: shares :func:`busy_machine_names` with ``pick_reviewer_machine``, so
+    tier 1 vs tier 2 here is decided on *believable* in-flight rows only.
     """
     from coord.machine_pause import follow_on_paused_set  # noqa: PLC0415
 
@@ -1202,7 +1308,7 @@ def _ranked_reviewer_candidates(
     if not candidates:
         return []
 
-    busy = {a.machine_name for a in board.active if a.status in ("pending", "running")}
+    busy = busy_machine_names(board, config)
 
     result: list[tuple[Machine, bool]] = []
     for m in candidates:

code_coordinator-0.5.270/tests/test_stale_busy_reviewer_697.py

@@ -0,0 +1,192 @@
+"""#697 — zombie `running` rows must stop inflating reviewer selection's busy set.
+
+The issue's live 2026-06-23 board carried `running` rows aged 4.4h, 7.9h, 51h
+and 70h whose workers were long dead (empty logs; the owning agent answered
+404 on `/cancel`).  Reaping those rows is owned elsewhere (#2275's no-record
+arm, #1396's tmux reaper, #2536's fleet sweep); this file covers the OTHER
+half of #697's acceptance — that `pick_reviewer_machine` /
+`_ranked_reviewer_candidates` no longer treat such a row as evidence that its
+machine is occupied.
+"""
+
+from __future__ import annotations
+
+import time
+
+import pytest
+
+from coord.config import Config, ReviewsConfig
+from coord.models import Assignment, Board, Machine, Repo
+from coord.review import (
+    STALE_BUSY_INTERACTIVE_SECONDS,
+    _ranked_reviewer_candidates,
+    busy_machine_names,
+    pick_reviewer_machine,
+)
+
+
+@pytest.fixture
+def repo() -> Repo:
+    return Repo(name="api", github="acme/api", depends_on=[], default_branch="main")
+
+
+@pytest.fixture
+def two_machine_config(repo: Repo) -> Config:
+    return Config(
+        repos=[repo],
+        machines=[
+            Machine(
+                name="laptop", host="laptop.tail",
+                capabilities=["python"], repos=["api"],
+                repo_paths={"api": "/work/api"},
+            ),
+            Machine(
+                name="server", host="server.tail",
+                capabilities=["python", "gtk"], repos=["api"],
+                repo_paths={"api": "/srv/api"},
+            ),
+        ],
+        reviews=ReviewsConfig(enabled=True, auto_dispatch=True),
+    )
+
+
+def _row(
+    *,
+    machine: str = "server",
+    age_seconds: float,
+    status: str = "running",
+    type_: str = "work",
+    provider_name: str | None = None,
+) -> Assignment:
+    return Assignment(
+        machine_name=machine,
+        repo_name="api",
+        issue_number=669,
+        issue_title="busy work",
+        assignment_id=f"zombie-{type_}-{int(age_seconds)}",
+        status=status,
+        type=type_,
+        provider_name=provider_name,
+        dispatched_at=time.time() - age_seconds,
+    )
+
+
+# ── busy_machine_names ──────────────────────────────────────────────────────
+
+
+def test_fresh_running_row_still_counts_as_busy(two_machine_config: Config) -> None:
+    board = Board(active=[_row(age_seconds=60.0)])
+    assert busy_machine_names(board, two_machine_config) == {"server"}
+
+
+def test_zombie_work_row_no_longer_counts_as_busy(two_machine_config: Config) -> None:
+    # 4.4h — the shortest zombie in #697's table. `work`'s threshold is 45m,
+    # plus a 1h buffer, so this is far past the horizon.
+    board = Board(active=[_row(age_seconds=4.4 * 3600.0)])
+    assert busy_machine_names(board, two_machine_config) == set()
+
+
+def test_row_just_under_the_horizon_still_counts_as_busy(
+    two_machine_config: Config,
+) -> None:
+    # 45m threshold + 1h buffer = 1h45m; 1h30m must NOT be presumed dead.
+    board = Board(active=[_row(age_seconds=90 * 60.0)])
+    assert busy_machine_names(board, two_machine_config) == {"server"}
+
+
+def test_row_without_dispatched_at_is_never_presumed_dead(
+    two_machine_config: Config,
+) -> None:
+    """No `dispatched_at` → nothing to compute an age from → never guess."""
+    board = Board(active=[Assignment(
+        machine_name="server", repo_name="api", issue_number=99,
+        issue_title="busy work", status="running", assignment_id="no-time",
+    )])
+    assert busy_machine_names(board, two_machine_config) == {"server"}
+
+
+def test_pending_zombie_row_is_also_dropped(two_machine_config: Config) -> None:
+    board = Board(active=[_row(age_seconds=8 * 3600.0, status="pending")])
+    assert busy_machine_names(board, two_machine_config) == set()
+
+
+def test_terminal_rows_never_counted(two_machine_config: Config) -> None:
+    board = Board(active=[_row(age_seconds=60.0, status="done")])
+    assert busy_machine_names(board, two_machine_config) == set()
+
+
+# ── Attended (inf-threshold) rows ───────────────────────────────────────────
+
+
+def test_attended_chat_row_still_busy_within_a_day(two_machine_config: Config) -> None:
+    """A human really attending a chat session for 6h is normal, not a zombie."""
+    board = Board(active=[_row(
+        age_seconds=6 * 3600.0, type_="chat", provider_name="claude-pty",
+    )])
+    assert busy_machine_names(board, two_machine_config) == {"server"}
+
+
+def test_51_hour_chat_zombie_is_dropped(two_machine_config: Config) -> None:
+    """#697's `dc2257047c6f`: a `chat` row `running` for 51 hours."""
+    board = Board(active=[_row(
+        age_seconds=51 * 3600.0, type_="chat", provider_name="claude-pty",
+    )])
+    assert 51 * 3600.0 > STALE_BUSY_INTERACTIVE_SECONDS
+    assert busy_machine_names(board, two_machine_config) == set()
+
+
+# ── Reviewer selection ──────────────────────────────────────────────────────
+
+
+def test_zombie_row_no_longer_demotes_its_machine_to_the_busy_tier(
+    two_machine_config: Config,
+) -> None:
+    """The #697 dispatch bug, end to end through the public entry point.
+
+    With the zombie counted as busy, `server` fell to fallback 1 ("currently
+    busy, review will queue") — on the real fleet that pushed selection onto
+    the only other "free" candidate, which was offline, and the review could
+    not be dispatched at all.
+    """
+    board = Board(active=[_row(age_seconds=7.9 * 3600.0)])
+    choice = pick_reviewer_machine("laptop", "api", board, two_machine_config)
+    assert choice is not None
+    assert choice.machine.name == "server"
+    assert choice.same_as_worker is False
+    assert "currently busy" not in choice.rationale
+    assert "different machine from worker" in choice.rationale
+
+
+def test_live_row_still_lands_in_the_busy_tier(two_machine_config: Config) -> None:
+    board = Board(active=[_row(age_seconds=120.0)])
+    choice = pick_reviewer_machine("laptop", "api", board, two_machine_config)
+    assert choice is not None
+    assert choice.machine.name == "server"
+    assert "currently busy" in choice.rationale
+
+
+def test_ranked_candidates_promote_the_zombie_machine_above_a_live_one(
+    repo: Repo,
+) -> None:
+    """Tier 1 (different + idle) must be decided on *believable* rows only."""
+    config = Config(
+        repos=[repo],
+        machines=[
+            Machine(name="laptop", host="laptop.tail", repos=["api"],
+                    repo_paths={"api": "/work/api"}),
+            Machine(name="busy-box", host="busy.tail", repos=["api"],
+                    repo_paths={"api": "/srv/api"}),
+            Machine(name="zombie-box", host="zombie.tail", repos=["api"],
+                    repo_paths={"api": "/srv/api"}),
+        ],
+        reviews=ReviewsConfig(enabled=True, auto_dispatch=True),
+    )
+    board = Board(active=[
+        _row(machine="busy-box", age_seconds=120.0),
+        _row(machine="zombie-box", age_seconds=70 * 3600.0),
+    ])
+    ranked = [m.name for m, _ in _ranked_reviewer_candidates(
+        "laptop", "api", board, config,
+    )]
+    # zombie-box is idle-tier, busy-box is busy-tier, laptop is last resort.
+    assert ranked == ["zombie-box", "busy-box", "laptop"]