code-coordinator 0.5.649__tar.gz → 0.5.650__tar.gz

{code_coordinator-0.5.649 → code_coordinator-0.5.650}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.649",
+  "tag": "0.5.650",
   "distance": 0,
-  "node": "g86804ec8747c96b5ade7034cf0c6d0a6f617febb",
+  "node": "gf6c0cf969776e35085b65dc340c118b19733079d",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-10-18"

{code_coordinator-0.5.649 → code_coordinator-0.5.650}/coord/drive_queue.py

@@ -1376,6 +1376,16 @@ QUEUE_ALERT_REPO = "(drive-queue)"
 QUEUE_ALERT_ISSUE = 0
 QUEUE_ALERT_STAGE = "drive-queue"
 
+#: #3720: the sentinel ``QueueAlert.command`` value meaning "no one-key
+#: remedy exists — there is nothing for a human to run." The step-4 "nothing
+#: eligible to launch" alert below is the only `QueueAlert` that omits
+#: ``command``, so it is the only one that carries this value; the notifier
+#: (`coord/notifier/collect.py`'s `halted_drives`) matches on it to tell that
+#: routine, self-healing condition apart from a genuine hold/cordon/drift
+#: escalation (each of which names its own real fix) without a DB schema
+#: change — `coord drive-queue status` still reads the record unchanged.
+QUEUE_ALERT_NO_REMEDY_COMMAND = "coord drive-queue list"
+
 #: #3413: a DISPLAY hint only — production's `coord-drive-queue.timer` fires
 #: every 3 minutes (`OnUnitActiveSec=3min`, `deploy/coord-drive-queue.timer`),
 #: not a value this module reads from the deployed unit (there is no seam to
@@ -2767,12 +2777,15 @@ class QueueAlert:
     ``command`` is the proposed fix written into the escalation record. It is
     carried here rather than derived in the shell so the alert's prose and its
     one-key remedy are decided together — a "HELD" alert whose command says
-    ``coord drive-queue list`` teaches the operator to ignore the field.
+    ``coord drive-queue list`` teaches the operator to ignore the field. Left
+    at its ``QUEUE_ALERT_NO_REMEDY_COMMAND`` default, it also doubles as the
+    signal the notifier uses to tell a routine, self-healing alert (nothing
+    names a real fix) apart from one that does.
     """
 
     reason: str
     details: tuple[str, ...] = ()
-    command: str = "coord drive-queue list"
+    command: str = QUEUE_ALERT_NO_REMEDY_COMMAND
 
 
 @dataclass(frozen=True)
@@ -8463,6 +8476,23 @@ def plan_tick(
     if launch is None and stalled:
         details = [f"{item.key}: {item.reason}" for item in deferrals]
         details += [f"{item.key}: BLOCKED — {item.reason}" for item in blocked]
+        # A tick where every stalled entry is a benign deferral has no
+        # one-key remedy — nothing is wedged, the fleet is just busy, and the
+        # next tick that finds capacity self-heals it — so `command` stays at
+        # `QueueAlert`'s `QUEUE_ALERT_NO_REMEDY_COMMAND` default, which is
+        # also the signal the notifier reads to treat the alert as routine.
+        # The moment even one entry is genuinely `blocked`, though, there IS
+        # a remedy (the same remove+add this module already surfaces for
+        # #2944's guaranteed-false waits), so the alert must carry it
+        # explicitly rather than let it fall through to the "nothing to do
+        # here" sentinel — a gate's failure must still be able to page.
+        command = QUEUE_ALERT_NO_REMEDY_COMMAND
+        if blocked:
+            command = (
+                "coord drive-queue remove <repo> <issue> && "
+                "coord drive-queue add <repo> <issue> — for each BLOCKED "
+                "entry named above"
+            )
         alert = QueueAlert(
             # "considered N" rather than "N waiting": some of those entries are
             # blocked by the time this line is written, and an alert that
@@ -8474,6 +8504,7 @@ def plan_tick(
                 f"{capacity - occupied} free slot(s)"
             ),
             details=tuple(details),
+            command=command,
         )
 
     return TickPlan(

{code_coordinator-0.5.649 → code_coordinator-0.5.650}/coord/notifier/collect.py

@@ -271,7 +271,25 @@ def halted_drives(*, notifier_state: NotifierState, now: float) -> list[HaltedDr
     A ``drive_escalations`` row is exactly the condition this feature
     exists for: the drive reached a decision it cannot make, exited, and
     nothing will tick that issue again until a human looks.
+
+    One queue-level row is the exception: `plan_tick`'s step 4 writes a
+    "nothing eligible to launch" record on an ordinary quiet tick whenever
+    every stalled entry is a benign deferral rather than an actual block —
+    self-healing (the next tick that finds something to launch clears it)
+    and carrying no real fix, which is exactly why its ``proposed_command``
+    is left at ``QUEUE_ALERT_NO_REMEDY_COMMAND`` instead of naming one (see
+    that constant). `coord drive-queue status` still shows it on request;
+    this function just stops it from becoming a push. A queue-level alert
+    that DOES carry a real ``proposed_command`` (because step 4 found at
+    least one genuinely blocked entry) is never a sentinel match here, so it
+    pages like any other halted drive.
     """
+    from coord.drive_queue import (  # noqa: PLC0415
+        QUEUE_ALERT_ISSUE,
+        QUEUE_ALERT_NO_REMEDY_COMMAND,
+        QUEUE_ALERT_REPO,
+    )
+
     try:
         from coord.state import list_drive_escalations  # noqa: PLC0415
 
@@ -288,6 +306,13 @@ def halted_drives(*, notifier_state: NotifierState, now: float) -> list[HaltedDr
             issue = int(record.get("issue_number"))
         except (TypeError, ValueError):
             continue
+        command = str(record.get("proposed_command") or "").strip()
+        if (
+            repo == QUEUE_ALERT_REPO
+            and issue == QUEUE_ALERT_ISSUE
+            and command == QUEUE_ALERT_NO_REMEDY_COMMAND
+        ):
+            continue
         stage = str(record.get("stage") or "").strip()
         reason = str(record.get("reason") or "").strip()
         out.append(
@@ -296,6 +321,7 @@ def halted_drives(*, notifier_state: NotifierState, now: float) -> list[HaltedDr
                 issue=issue,
                 reason=f"{stage + ': ' if stage else ''}{reason}".strip(),
                 urgent=urgent_key(repo, issue) in urgent,
+                proposed_command=command or None,
             )
         )
     return out

{code_coordinator-0.5.649 → code_coordinator-0.5.650}/coord/notifier/predicate.py

@@ -124,6 +124,7 @@ class HaltedDrive:
     reason: str = ""
     exit_code: int | None = None
     urgent: bool = False
+    proposed_command: str | None = None
 
 
 @dataclass(frozen=True)
@@ -361,20 +362,25 @@ def _parked_event(gate: ParkedGate, snapshot: PipelineSnapshot) -> NotifyEvent:
 
 def _halted_event(drive: HaltedDrive, snapshot: PipelineSnapshot) -> NotifyEvent:
     where = f"{drive.repo}#{drive.issue}"
+    command = (drive.proposed_command or "").strip() or None
+    body = f"The drive reached a terminal state and will not tick again. {drive.reason.strip()}".strip()
+    if command:
+        body = f"{body} Fix: {command}"
     return NotifyEvent(
         subject=f"drive:{where}",
         condition=CONDITION_DRIVE_HALTED,
         title=f"{where} — {CONDITION_LABELS[CONDITION_DRIVE_HALTED]}",
-        body=(
-            f"The drive reached a terminal state and will not tick again. "
-            f"{drive.reason.strip()}".strip()
-        ),
+        body=body,
         created_at=snapshot.now,
         repo=drive.repo,
         issue=drive.issue,
         urgent=drive.urgent,
         link=deep_link(snapshot.web_base_url, drive.repo, drive.issue),
-        detail={"reason": drive.reason, "exit_code": drive.exit_code},
+        detail={
+            "reason": drive.reason,
+            "exit_code": drive.exit_code,
+            "proposed_command": command,
+        },
     )
 
 

{code_coordinator-0.5.649 → code_coordinator-0.5.650}/tests/test_notifier_cli.py

@@ -190,6 +190,65 @@ def test_tick_dry_run_delivers_nothing_and_writes_no_ledger(config_path, monkeyp
     assert store.load_state().ledger == {}
 
 
+def test_tick_dry_run_pages_nothing_for_a_routine_queue_alert(config_path, monkeypatch):
+    """The real `halted_drives()` collector runs end to end through `tick
+    --dry-run`: a step-4 "nothing eligible to launch" escalation whose
+    `proposed_command` is still the no-remedy sentinel must not surface as
+    a `drive_halted` event."""
+    import coord.state as state_mod
+    from coord.drive_queue import QUEUE_ALERT_ISSUE, QUEUE_ALERT_NO_REMEDY_COMMAND, QUEUE_ALERT_REPO
+
+    now = 3_000_000.0
+    monkeypatch.setattr(
+        state_mod, "list_drive_escalations",
+        lambda *a, **kw: [
+            {
+                "repo_name": QUEUE_ALERT_REPO,
+                "issue_number": QUEUE_ALERT_ISSUE,
+                "stage": "drive-queue",
+                "reason": "nothing eligible to launch: considered 2 waiting entries, 0 free slot(s)",
+                "proposed_command": QUEUE_ALERT_NO_REMEDY_COMMAND,
+            }
+        ],
+    )
+    monkeypatch.setattr("coord.notifier.collect.history_rows", lambda: [])
+    monkeypatch.setattr("coord.notifier.collect.issue_label_index", lambda: {})
+    monkeypatch.setattr("time.time", lambda: now)
+
+    result = run("notifier", "tick", "--config", config_path, "--dry-run")
+    assert result.exit_code == 0
+    assert "drive_halted" not in result.output
+
+
+def test_tick_dry_run_pages_a_genuine_queue_hold(config_path, monkeypatch):
+    """The same synthetic queue-alert key, but with a real remedy command
+    (a fleet hold rather than a benign "nothing to do" tick), must surface
+    as a `drive_halted` event through the same `tick --dry-run` path."""
+    import coord.state as state_mod
+    from coord.drive_queue import QUEUE_ALERT_ISSUE, QUEUE_ALERT_REPO
+
+    now = 3_000_000.0
+    monkeypatch.setattr(
+        state_mod, "list_drive_escalations",
+        lambda *a, **kw: [
+            {
+                "repo_name": QUEUE_ALERT_REPO,
+                "issue_number": QUEUE_ALERT_ISSUE,
+                "stage": "drive-queue",
+                "reason": "fleet hold: operator declared",
+                "proposed_command": "coord drive-queue resume",
+            }
+        ],
+    )
+    monkeypatch.setattr("coord.notifier.collect.history_rows", lambda: [])
+    monkeypatch.setattr("coord.notifier.collect.issue_label_index", lambda: {})
+    monkeypatch.setattr("time.time", lambda: now)
+
+    result = run("notifier", "tick", "--config", config_path, "--dry-run")
+    assert result.exit_code == 0
+    assert "drive_halted" in result.output
+
+
 def test_pending_lists_held_events():
     from coord.notifier.models import NotifyEvent
 

{code_coordinator-0.5.649 → code_coordinator-0.5.650}/tests/test_notifier_collect.py

@@ -314,3 +314,94 @@ def test_unavailable_labels_degrade_to_untiered(monkeypatch):
 
     monkeypatch.setattr(dao, "SqliteStore", Boom)
     assert collect.issue_label_index() == {}
+
+
+# ── the step-4 queue alert is a halted drive only when it names a remedy ──
+#
+# `plan_tick`'s step 4 writes one `drive_escalations` row for the whole
+# queue (keyed by `QUEUE_ALERT_REPO`/`QUEUE_ALERT_ISSUE`) whenever nothing
+# launched. Whether that row should page is decided once, at the producer:
+# `command` stays at `QUEUE_ALERT_NO_REMEDY_COMMAND` when every stalled
+# entry is a benign deferral (nothing to fix, self-heals next tick), and
+# carries a real remedy the moment even one entry is genuinely blocked.
+# `halted_drives()` only ever reads that single field back.
+
+
+def test_a_routine_nothing_eligible_queue_alert_is_not_a_halted_drive(monkeypatch):
+    import coord.state as state_mod
+    from coord.drive_queue import (
+        QUEUE_ALERT_ISSUE,
+        QUEUE_ALERT_NO_REMEDY_COMMAND,
+        QUEUE_ALERT_REPO,
+    )
+
+    monkeypatch.setattr(
+        state_mod, "list_drive_escalations",
+        lambda *a, **kw: [
+            {
+                "repo_name": QUEUE_ALERT_REPO,
+                "issue_number": QUEUE_ALERT_ISSUE,
+                "stage": "drive-queue",
+                "reason": "nothing eligible to launch: considered 3 waiting entries, 0 free slot(s)",
+                "proposed_command": QUEUE_ALERT_NO_REMEDY_COMMAND,
+            }
+        ],
+    )
+    assert collect.halted_drives(notifier_state=NotifierState(), now=NOW) == []
+
+
+def test_a_queue_alert_naming_a_blocked_entrys_remedy_becomes_a_halted_drive(monkeypatch):
+    """A step-4 alert produced with at least one genuinely `blocked` entry
+    carries a real remedy command rather than the no-remedy sentinel, so it
+    pages exactly like any other halted drive."""
+    import coord.state as state_mod
+    from coord.drive_queue import QUEUE_ALERT_ISSUE, QUEUE_ALERT_REPO
+
+    monkeypatch.setattr(
+        state_mod, "list_drive_escalations",
+        lambda *a, **kw: [
+            {
+                "repo_name": QUEUE_ALERT_REPO,
+                "issue_number": QUEUE_ALERT_ISSUE,
+                "stage": "drive-queue",
+                "reason": "nothing eligible to launch: considered 1 waiting entry, 0 free slot(s)",
+                "proposed_command": (
+                    "coord drive-queue remove <repo> <issue> && "
+                    "coord drive-queue add <repo> <issue> — for each BLOCKED "
+                    "entry named above"
+                ),
+            }
+        ],
+    )
+    out = collect.halted_drives(notifier_state=NotifierState(), now=NOW)
+    assert len(out) == 1
+    assert out[0].repo == QUEUE_ALERT_REPO
+    assert out[0].issue == QUEUE_ALERT_ISSUE
+    assert out[0].proposed_command and "drive-queue remove" in out[0].proposed_command
+
+
+def test_a_genuine_queue_hold_alert_still_becomes_a_halted_drive(monkeypatch):
+    """A hold/cordon/drift escalation names a real one-key fix, so it keeps
+    producing a `HaltedDrive` even though it shares the same synthetic
+    queue-alert key as the routine "nothing eligible" record."""
+    import coord.state as state_mod
+    from coord.drive_queue import QUEUE_ALERT_ISSUE, QUEUE_ALERT_REPO
+
+    monkeypatch.setattr(
+        state_mod, "list_drive_escalations",
+        lambda *a, **kw: [
+            {
+                "repo_name": QUEUE_ALERT_REPO,
+                "issue_number": QUEUE_ALERT_ISSUE,
+                "stage": "drive-queue",
+                "reason": "fleet hold: operator declared",
+                "proposed_command": "coord drive-queue resume",
+            }
+        ],
+    )
+    out = collect.halted_drives(notifier_state=NotifierState(), now=NOW)
+    assert len(out) == 1
+    assert out[0].repo == QUEUE_ALERT_REPO
+    assert out[0].issue == QUEUE_ALERT_ISSUE
+    assert "fleet hold" in out[0].reason
+    assert out[0].proposed_command == "coord drive-queue resume"