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

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

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

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

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

{code_coordinator-0.5.649 → code_coordinator-0.5.651}/coord/auto_loop.py

@@ -64,6 +64,8 @@ from coord.review import (
     dispatch_review,
     estimate_review_counts,
     maybe_scoped_review_for_completed_fix,
+    mechanical_gate_kind,
+    needs_redesign_escalation,
     parse_review_from_agent,
     parse_review_from_log,
 )
@@ -148,6 +150,11 @@ class LoopAction:
                                  for bookkeeping only (``dispatch_fixes=False``
                                  — the daemon drain, which must never spawn a
                                  fix worker; #476/#477)
+    - ``"needs_redesign"``     — #3721: the SAME structurally-unfixable
+                                 mechanical gate (sealed-path, breaking public
+                                 API) fired twice in a row for this issue; the
+                                 issue was parked with a durable escalation
+                                 instead of dispatching another fix round
     """
     assignment_id: str | None
     detail: str = ""
@@ -1126,6 +1133,30 @@ def _dispatch_fix_for_review(
             ),
         )]
 
+    # #3721: a mechanical request-changes verdict (sealed-path tamper,
+    # breaking-public-API semver check — the only two gate kinds a diff to
+    # THIS work leg can never satisfy without also breaking another
+    # unconditional rule) that fires for the SECOND time in a row on this
+    # issue means another fix round is pure churn, not a chance to improve.
+    # Park it with a durable escalation instead of re-dispatching. Checked
+    # only for mechanical verdicts — a real reviewer's request-changes
+    # always gets its normal fix round, however many times it repeats.
+    if review.verdict_source == "mechanical":
+        gate_kind = mechanical_gate_kind(review.verdict_source_reason)
+        escalation_reason = needs_redesign_escalation(
+            work, review, board, gate_kind=gate_kind,
+        )
+        if escalation_reason is not None:
+            log.warning(
+                "auto_loop: NOT dispatching fix for %s — %s",
+                work.assignment_id, escalation_reason,
+            )
+            return [LoopAction(
+                kind="needs_redesign",
+                assignment_id=review.assignment_id,
+                detail=escalation_reason,
+            )]
+
     # Compute the next iteration number and check the limit.  #3322: read it
     # off the WHOLE branch chain, not off `work` alone — the stalled-pipeline
     # sweep reaches this function with `work` bound to the ORIGINAL

{code_coordinator-0.5.649 → code_coordinator-0.5.651}/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.651}/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.651}/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.651}/coord/review.py

@@ -3441,6 +3441,131 @@ def _record_prereview_gate_verdict(
     )
 
 
+# (#3721) Mechanical gate kinds that are structurally unfixable within the
+# SAME work leg: no further diff can satisfy this gate while also satisfying
+# the rule that required it, so re-dispatching another fix round is pure
+# churn, not a chance to improve. Deliberately narrow — every OTHER
+# mechanical kind (``coordinator_doc``, ``lane_entrypoint_weakened``, a
+# generic ``prereview_gate`` finding) is fixable by a diff that simply stops
+# making the forbidden edit, so a repeat there is worker error, not a wall.
+NEEDS_REDESIGN_GATE_KINDS: frozenset[str] = frozenset(
+    {"sealed_path", "breaking_public_api"}
+)
+
+NEEDS_REDESIGN_ALERT_STAGE = "needs-redesign"
+
+_NEEDS_REDESIGN_GATE_DESCRIPTION: dict[str, str] = {
+    "sealed_path": (
+        "sealed-path violation — the fix would require editing a sealed "
+        "path (tests/acceptance/**), which is itself an unconditional "
+        "request-changes under this repo's own rules, so no single diff "
+        "can satisfy both at once"
+    ),
+    "breaking_public_api": (
+        "breaking public-API change flagged by the semver check — cannot "
+        "be resolved by further edits to this same PR; needs a "
+        "non-breaking redesign or the deprecate-first two-PR protocol"
+    ),
+}
+
+
+def mechanical_gate_kind(reason: str | None) -> str:
+    """Classify a mechanical ``verdict_source_reason`` into a stable
+    gate-kind tag (#3721).
+
+    Works off the reason TEXT rather than a persisted field, so it
+    classifies both freshly-recorded and historical ``board.completed``
+    rows identically, with no schema/signature change: every reason string
+    produced by :func:`_record_mechanical_review_verdict` or
+    :func:`_record_prereview_gate_verdict` already starts with one of
+    these stable prefixes.
+    """
+    if not reason:
+        return "other"
+    if reason.startswith("sealed path(s) violated:"):
+        return "sealed_path"
+    if reason.startswith("coordinator-owned doc(s) edited:"):
+        return "coordinator_doc"
+    if reason.startswith("Tier-2 lane smoke-spec entry point weakened:"):
+        return "lane_entrypoint_weakened"
+    if "semver check failed (" in reason:
+        return "breaking_public_api"
+    if reason.startswith("prereview mechanical gate:"):
+        return "prereview_gate"
+    return "other"
+
+
+def needs_redesign_escalation(
+    work: Assignment,
+    review: Assignment,
+    board: Board,
+    *,
+    gate_kind: str,
+) -> str | None:
+    """(#3721) Decide whether *work*'s issue should be parked as
+    needs-redesign instead of dispatching yet another fix round.
+
+    Returns the escalation reason once *gate_kind* is one of
+    :data:`NEEDS_REDESIGN_GATE_KINDS` AND this is at least the SECOND time
+    a mechanical verdict of that same kind has fired for this issue —
+    counted off ``board.completed`` (which reflects the full DB history,
+    not just this process's lifetime), excluding *review* itself so the
+    verdict that triggered this call isn't double-counted as its own
+    predecessor. A worker gets exactly one mechanical bounce on an eligible
+    gate before this escalates, since a lone occurrence could still be a
+    trivial mistake rather than the structural wall the issue describes.
+
+    Returns ``None`` (dispatch the fix as usual) for every other case:
+    *gate_kind* not eligible, or this is its first occurrence. Writes the
+    durable escalation itself (best-effort — a write failure here must not
+    block the caller's own fallback behavior) so the caller only needs to
+    check for a non-``None`` return to skip dispatch.
+    """
+    if gate_kind not in NEEDS_REDESIGN_GATE_KINDS:
+        return None
+    prior = sum(
+        1
+        for a in board.completed
+        if a.type == "review"
+        and a.assignment_id != review.assignment_id
+        and a.repo_name == work.repo_name
+        and a.issue_number == work.issue_number
+        and a.verdict_source == "mechanical"
+        and mechanical_gate_kind(a.verdict_source_reason) == gate_kind
+    )
+    if prior < 1:
+        return None
+    occurrences = prior + 1
+    description = _NEEDS_REDESIGN_GATE_DESCRIPTION.get(gate_kind, gate_kind)
+    reason = (
+        f"needs-redesign (#3721): {work.repo_name}#{work.issue_number} hit "
+        f"the same structurally-unfixable mechanical gate {occurrences} "
+        f"times in a row — {description}. Latest finding: "
+        f"{review.verdict_source_reason}"
+    )
+    try:
+        from coord.state import record_drive_escalation  # noqa: PLC0415
+
+        record_drive_escalation(
+            work.repo_name,
+            work.issue_number,
+            stage=NEEDS_REDESIGN_ALERT_STAGE,
+            reason=reason,
+            gate_readings=f"gate_kind={gate_kind} occurrences={occurrences}",
+            proposed_command=(
+                f"coord drive-queue remove {work.repo_name} {work.issue_number}"
+            ),
+            assignment_id=work.assignment_id,
+        )
+    except Exception as exc:  # noqa: BLE001 — the log line below is the floor
+        log.warning(
+            "auto_loop: failed to record needs-redesign escalation for "
+            "%s#%s: %s",
+            work.repo_name, work.issue_number, exc,
+        )
+    return reason
+
+
 def dispatch_review(
     completed: Assignment,
     board: Board,

{code_coordinator-0.5.649 → code_coordinator-0.5.651}/tests/test_auto_loop.py

@@ -3868,6 +3868,133 @@ class TestDispatchFixReachabilityFallback:
         assert "--machine" in actions[0].detail
 
 
+# ── #3721: needs-redesign escalation instead of churning the same gate ───────
+
+
+class TestNeedsRedesignEscalation:
+    """A mechanical request-changes verdict on a structurally-unfixable gate
+    (sealed-path, breaking public API) must get exactly one bounce before
+    the issue is parked instead of re-dispatched."""
+
+    def test_first_occurrence_dispatches_fix_normally(self, config: Config) -> None:
+        from coord.auto_loop import _dispatch_fix_for_review
+
+        work = _work_assignment(assignment_id="work-3721a")
+        review = _review_assignment(
+            assignment_id="review-3721a", review_of="work-3721a",
+        )
+        review.verdict_source = "mechanical"
+        review.verdict_source_reason = (
+            "sealed path(s) violated: tests/acceptance/foo.py"
+        )
+        board = _board_with(work, review)
+        findings = ReviewFindings(
+            verdict="request-changes", body="## Blocking\n- 1. don't touch it\n"
+        )
+
+        mock_http = MagicMock()
+        mock_http.post.return_value.json.return_value = {"id": "fix-3721a-2"}
+        mock_http.post.return_value.raise_for_status = MagicMock()
+
+        with patch("coord.auto_loop.record_dispatched_assignment"):
+            actions = _dispatch_fix_for_review(
+                review, findings, board, config, http_client=mock_http,
+            )
+
+        assert actions[0].kind == "fix_dispatched"
+
+    def test_second_occurrence_escalates_and_skips_dispatch(
+        self, config: Config
+    ) -> None:
+        from coord.auto_loop import _dispatch_fix_for_review
+
+        work = _work_assignment(assignment_id="work-3721b")
+        prior_review = _review_assignment(
+            assignment_id="review-3721b-1", review_of="work-3721b",
+        )
+        prior_review.verdict_source = "mechanical"
+        prior_review.verdict_source_reason = (
+            "sealed path(s) violated: tests/acceptance/bar.py"
+        )
+        review = _review_assignment(
+            assignment_id="review-3721b-2", review_of="work-3721b",
+        )
+        review.verdict_source = "mechanical"
+        review.verdict_source_reason = (
+            "sealed path(s) violated: tests/acceptance/foo.py"
+        )
+        board = Board(
+            repos=[Repo(name="api", github="acme/api")],
+            machines=[],
+            active=[],
+            completed=[work, prior_review, review],
+        )
+        findings = ReviewFindings(
+            verdict="request-changes", body="## Blocking\n- 1. don't touch it\n"
+        )
+
+        with patch("coord.state.record_drive_escalation") as mock_escalate:
+            actions = _dispatch_fix_for_review(review, findings, board, config)
+
+        assert len(actions) == 1
+        assert actions[0].kind == "needs_redesign"
+        assert "sealed-path" in actions[0].detail
+        assert "api#1" in actions[0].detail
+        mock_escalate.assert_called_once()
+        _, kwargs = mock_escalate.call_args
+        assert kwargs["stage"] == "needs-redesign"
+        assert kwargs["assignment_id"] == "work-3721b"
+        # No fix worker dispatched.
+        assert board.active == []
+
+    def test_non_eligible_mechanical_kind_never_escalates(
+        self, config: Config
+    ) -> None:
+        """A repeated coordinator-doc tamper is worker error, not a
+        structural wall — it must keep bouncing through the normal fix
+        loop, not get parked."""
+        from coord.auto_loop import _dispatch_fix_for_review
+
+        work = _work_assignment(assignment_id="work-3721c")
+        prior_review = _review_assignment(
+            assignment_id="review-3721c-1", review_of="work-3721c",
+        )
+        prior_review.verdict_source = "mechanical"
+        prior_review.verdict_source_reason = (
+            "coordinator-owned doc(s) edited: README.md"
+        )
+        review = _review_assignment(
+            assignment_id="review-3721c-2", review_of="work-3721c",
+        )
+        review.verdict_source = "mechanical"
+        review.verdict_source_reason = (
+            "coordinator-owned doc(s) edited: CHANGELOG.md"
+        )
+        board = Board(
+            repos=[Repo(name="api", github="acme/api")],
+            machines=[],
+            active=[],
+            completed=[work, prior_review, review],
+        )
+        findings = ReviewFindings(
+            verdict="request-changes", body="## Blocking\n- 1. don't touch it\n"
+        )
+
+        mock_http = MagicMock()
+        mock_http.post.return_value.json.return_value = {"id": "fix-3721c-2"}
+        mock_http.post.return_value.raise_for_status = MagicMock()
+
+        with patch("coord.auto_loop.record_dispatched_assignment"), patch(
+            "coord.state.record_drive_escalation"
+        ) as mock_escalate:
+            actions = _dispatch_fix_for_review(
+                review, findings, board, config, http_client=mock_http,
+            )
+
+        assert actions[0].kind == "fix_dispatched"
+        mock_escalate.assert_not_called()
+
+
 # ── #3322: the fix-round counter is monotonic across every dispatch path ─────
 
 

{code_coordinator-0.5.649 → code_coordinator-0.5.651}/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.651}/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"