code-coordinator 0.5.316__tar.gz → 0.5.318__tar.gz

{code_coordinator-0.5.316 → code_coordinator-0.5.318}/PKG-INFO

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

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

@@ -126,6 +126,7 @@ coord/release_cordon.py
 coord/release_propagate.py
 coord/release_verify.py
 coord/release_window.py
+coord/repo_dormancy.py
 coord/repo_edit.py
 coord/repo_onboard.py
 coord/reports.py
@@ -706,6 +707,7 @@ tests/test_release_window.py
 tests/test_remote_auto_prune.py
 tests/test_remote_interactive_reaper.py
 tests/test_repo_add.py
+tests/test_repo_dormancy.py
 tests/test_repo_edit_2220.py
 tests/test_repo_graph_fleet_2237.py
 tests/test_repo_onboard_2220.py

{code_coordinator-0.5.316 → code_coordinator-0.5.318}/code_coordinator.egg-info/scm_file_list.json

@@ -231,6 +231,7 @@
     "coord/release_propagate.py",
     "coord/release_verify.py",
     "coord/release_window.py",
+    "coord/repo_dormancy.py",
     "coord/repo_edit.py",
     "coord/repo_onboard.py",
     "coord/reports.py",
@@ -732,6 +733,7 @@
     "tests/test_remote_auto_prune.py",
     "tests/test_remote_interactive_reaper.py",
     "tests/test_repo_add.py",
+    "tests/test_repo_dormancy.py",
     "tests/test_repo_edit_2220.py",
     "tests/test_repo_graph_fleet_2237.py",
     "tests/test_repo_onboard_2220.py",

{code_coordinator-0.5.316 → code_coordinator-0.5.318}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.316",
+  "tag": "0.5.318",
   "distance": 0,
-  "node": "g84875a2c21cee2157331b4a2f1e92ca1c9b812fe",
+  "node": "g232148cbec6041ecf0afda964794347d61a21a64",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-31"

{code_coordinator-0.5.316 → code_coordinator-0.5.318}/coord/confirm_test.py

@@ -171,6 +171,23 @@ CONFIRM_DEFAULT_TIMEOUT_SECONDS = 60 * 20
 #: so a pass can confirm ~4 branches back to back) while the daemon-side worst
 #: case stays a number the thin client can actually be given — see
 #: :func:`notify_client_timeout_seconds`.
+#:
+#: #2975: that "~6 min serial" sizing is calibrated on THIS repo and does not
+#: hold everywhere — quadraui's ``cargo test --features tui`` builds every
+#: example/test executable (#305 in coordinator.yml) and blows straight past
+#: it, and every ceiling in this module (this one, ``CONFIRM_DEFAULT_
+#: TIMEOUT_SECONDS``, ``deploy/coord-notify.service``'s ``TimeoutStartSec``)
+#: is bigger than ``coord-notify.timer``'s 5-minute cadence, so one such
+#: confirmation can span several fires. Two changes close that without
+#: shrinking this constant (which would just make the COMMON case degrade to
+#: UNCONFIRMED instead): ``coord.notify``'s drain now dispatches pending
+#: Test/Review/PR-opens BEFORE running any confirmation each pass, so a slow
+#: suite on one repo can no longer queue another repo's dispatch behind it;
+#: and :func:`expected_confirmation_seconds` remembers how long a repo's
+#: confirmation last took, so :func:`confirmation_timeout` can recognise a
+#: repo whose suite structurally cannot fit this budget and skip straight to
+#: UNCONFIRMED instead of re-discovering that identical fact — and re-paying
+#: the full ceiling for it — on every single PASS claim.
 CONFIRM_PASS_BUDGET_SECONDS = 60 * 25
 
 #: Don't *start* a confirmation with less than this left in the pass budget.
@@ -232,6 +249,31 @@ KIND_NO_OUTPUT = "no_output"
 #: docstring's fail-direction section — this frozenset IS that safety property.
 REFUTING_KINDS = frozenset({KIND_BUILD, KIND_SUITE})
 
+#: #2975: kinds whose elapsed wall-clock time is a trustworthy signal of how
+#: long THIS repo's confirmation genuinely takes, worth remembering for next
+#: time via :func:`record_confirmation_duration`.
+#:
+#: ``KIND_OK``/``KIND_BUILD``/``KIND_SUITE``/``KIND_BASELINE_RED``/
+#: ``KIND_NO_OUTPUT`` all ran the command to actual completion — a real
+#: measurement. ``KIND_TIMEOUT`` ran for at least the ceiling it was given —
+#: not exact, but a valid LOWER BOUND, and a lower bound is exactly what lets
+#: a chronically-too-slow repo (quadraui's ``cargo test --features tui``
+#: builds every example/test executable, #305 in coordinator.yml) be
+#: recognised as such after a single attempt instead of re-discovering it on
+#: every PASS claim — see :func:`expected_confirmation_seconds`.
+#:
+#: ``KIND_SETUP``/``KIND_INFRA``/``KIND_SIGNAL`` are deliberately excluded:
+#: none of them ran the real command for a representative duration (no
+#: checkout, no toolchain, or killed externally mid-run), and recording their
+#: near-zero elapsed time would silently erase a previously-learned
+#: expectation — exactly the failure mode that would make a single lock
+#: contention hiccup or a missing checkout reset a repo's hard-won "this one
+#: is slow" memory back to "assume it's fast."
+RECORDABLE_DURATION_KINDS = frozenset({
+    KIND_OK, KIND_BUILD, KIND_SUITE, KIND_BASELINE_RED, KIND_NO_OUTPUT,
+    KIND_TIMEOUT,
+})
+
 #: Kinds meaning "the check could not reach a verdict". The caller falls back to
 #: the worker's own claim on any of these, which is pre-#2464 behaviour.
 INCONCLUSIVE_KINDS = frozenset({
@@ -270,7 +312,7 @@ def begin_confirmation_pass(total: float = CONFIRM_PASS_BUDGET_SECONDS) -> None:
     _pass_state.remaining = float(total)
 
 
-def confirmation_timeout() -> int | None:
+def confirmation_timeout(expected_seconds: float | None = None) -> int | None:
     """Seconds the next confirmation in this pass may take, or ``None``.
 
     ``None`` means the pass budget is spent (or too nearly spent to be worth
@@ -279,13 +321,31 @@ def confirmation_timeout() -> int | None:
 
     Outside a pass — a direct :func:`confirm_branch` call, a unit test — there
     is no budget to draw down and the full per-run ceiling applies.
+
+    *expected_seconds* (#2975) is the caller's best estimate of how long THIS
+    repo's confirmation will actually take — see
+    :func:`expected_confirmation_seconds`, which reads it back from what
+    :func:`record_confirmation_duration` learned last time. When it is
+    already at or past what this pass has left to spend, starting the run
+    would only spend the remainder re-discovering a fact already on record —
+    this repo cannot be confirmed in what is left — so this returns ``None``
+    immediately instead of paying for that discovery again. This is what
+    turns a repo whose suite structurally cannot fit the ceiling (quadraui's
+    ``cargo test --features tui``, #2975) from a repeated worst-case cost —
+    every PASS claim spending the full budget to learn the identical lesson —
+    into a one-time one: the FIRST attempt still spends up to the full
+    ceiling discovering the suite is too slow, and every attempt after that
+    skips straight to UNCONFIRMED.
     """
     remaining = getattr(_pass_state, "remaining", None)
     if remaining is None:
         return int(CONFIRM_DEFAULT_TIMEOUT_SECONDS)
     if remaining < CONFIRM_MIN_RUN_SECONDS:
         return None
-    return int(min(float(CONFIRM_DEFAULT_TIMEOUT_SECONDS), remaining))
+    ceiling = min(float(CONFIRM_DEFAULT_TIMEOUT_SECONDS), remaining)
+    if expected_seconds is not None and expected_seconds >= ceiling:
+        return None
+    return int(ceiling)
 
 
 def spend_confirmation_budget(seconds: float) -> None:
@@ -300,6 +360,112 @@ def spend_confirmation_budget(seconds: float) -> None:
     _pass_state.remaining = max(0.0, remaining - max(0.0, float(seconds)))
 
 
+#: #2975: filename under ``COORD_DIR`` for the per-repo measured-duration map
+#: :func:`record_confirmation_duration` / :func:`expected_confirmation_seconds`
+#: read and write. A tiny flat file, not a lock-guarded store: the worst case
+#: of a torn read/write is one stale or missing estimate, which degrades to
+#: exactly pre-#2975 behaviour (attempt the run, learn the hard way) — never
+#: a correctness problem, so it does not warrant the ceremony
+#: ``confirm_lock_path`` needs for the worktree lifecycle it guards.
+_CONFIRM_HISTORY_FILENAME = "confirm_test_history.json"
+
+
+def _confirm_history_path() -> Path:
+    """Where per-repo measured confirmation durations are persisted (#2975).
+
+    Resolved against ``coord.state.COORD_DIR`` freshly on every call — the
+    same discipline :func:`confirm_worktree_path` /
+    :func:`write_confirmation_output` already use above — so a test's
+    ``monkeypatch.setattr("coord.state.COORD_DIR", ...)`` is honoured rather
+    than this module caching a stale path at import time.
+    """
+    from coord.state import COORD_DIR  # noqa: PLC0415
+
+    return COORD_DIR / _CONFIRM_HISTORY_FILENAME
+
+
+def _load_confirm_history() -> dict[str, float]:
+    """Best-effort read of the persisted per-repo duration map.
+
+    Fail-soft on everything — a missing file, corrupt JSON, an unexpected
+    shape, a hand-edited value — because this is purely an optimisation hint
+    for :func:`confirmation_timeout`, never a correctness dependency. A file
+    this cannot make sense of must read as "nothing learned yet", the same
+    posture as :func:`coord.commands.drive_queue.read_roll_pending`.
+    """
+    import json  # noqa: PLC0415
+
+    try:
+        raw = _confirm_history_path().read_text(encoding="utf-8")
+    except OSError:
+        return {}
+    try:
+        data = json.loads(raw)
+    except ValueError:
+        return {}
+    if not isinstance(data, dict):
+        return {}
+    out: dict[str, float] = {}
+    for key, value in data.items():
+        if isinstance(key, str) and isinstance(value, (int, float)) and value > 0:
+            out[key] = float(value)
+    return out
+
+
+def record_confirmation_duration(repo_name: str, seconds: float) -> None:
+    """Remember how long *repo_name*'s confirmation attempt just took (#2975).
+
+    Callers pass this only results whose ``kind`` is in
+    :data:`RECORDABLE_DURATION_KINDS` — see that frozenset's docstring for
+    which outcomes are a trustworthy signal of real suite duration.
+
+    Overwrites any previous value for this repo outright, with no averaging:
+    the LAST attempt is a better estimate of the CURRENT suite than a rolling
+    average across however long ago the repo's test suite was this size.
+
+    Best-effort and atomic (tempfile-then-rename, mirroring
+    :func:`coord.commands.drive_queue.write_roll_pending`) — a full disk, an
+    unwritable ``COORD_DIR``, or a concurrent writer must not break the
+    confirmation this is charging against; the caller already has its real
+    result, this is purely a hint for next time.
+    """
+    if seconds <= 0:
+        return
+    import json  # noqa: PLC0415
+    import tempfile  # noqa: PLC0415
+
+    path = _confirm_history_path()
+    history = _load_confirm_history()
+    history[repo_name] = float(seconds)
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        fd, tmp_name = tempfile.mkstemp(
+            prefix=".confirm_test_history.", suffix=".tmp", dir=str(path.parent),
+        )
+        try:
+            with os.fdopen(fd, "w", encoding="utf-8") as fh:
+                json.dump(history, fh)
+            os.replace(tmp_name, path)
+        except OSError:
+            try:
+                os.unlink(tmp_name)
+            except OSError:
+                pass
+    except OSError:
+        pass
+
+
+def expected_confirmation_seconds(repo_name: str) -> float | None:
+    """The most recently measured confirmation duration for *repo_name*.
+
+    ``None`` when this repo has never produced a
+    :data:`RECORDABLE_DURATION_KINDS` result — the common case for most
+    repos most of the time, and the caller's cue to fall back to the
+    un-informed ceiling exactly as before #2975.
+    """
+    return _load_confirm_history().get(repo_name)
+
+
 def notify_client_timeout_seconds(
     budget: float = CONFIRM_PASS_BUDGET_SECONDS,
 ) -> float:
@@ -1067,6 +1233,7 @@ __all__ = [
     "KIND_SIGNAL",
     "NOTIFY_BASE_CLIENT_TIMEOUT_SECONDS",
     "PERMISSION_DENIED_EXIT",
+    "RECORDABLE_DURATION_KINDS",
     "REFUTING_KINDS",
     "STALE_WORKTREE_MAX_AGE_HOURS",
     "ConfirmationResult",
@@ -1077,7 +1244,9 @@ __all__ = [
     "confirm_worktree_path",
     "confirmation_enabled",
     "confirmation_timeout",
+    "expected_confirmation_seconds",
     "notify_client_timeout_seconds",
+    "record_confirmation_duration",
     "spend_confirmation_budget",
     "sweep_stale_confirm_worktrees",
     "unmet_confirmation_capabilities",

{code_coordinator-0.5.316 → code_coordinator-0.5.318}/coord/notify.py

@@ -2033,9 +2033,12 @@ def _run_pass_confirmation(transition: Transition, entry: dict):
     that cannot run must degrade to pre-#2464 behaviour, never break the reap.
     """
     from coord.confirm_test import (  # noqa: PLC0415
+        RECORDABLE_DURATION_KINDS,
         confirm_branch,
         confirmation_enabled,
         confirmation_timeout,
+        expected_confirmation_seconds,
+        record_confirmation_duration,
         spend_confirmation_budget,
     )
 
@@ -2066,15 +2069,34 @@ def _run_pass_confirmation(transition: Transition, entry: dict):
     # `/notify` request the thin client is blocked on — scale with board
     # activity. Exhausted budget means UNCONFIRMED, which is pre-#2464
     # behaviour, and it is said out loud rather than truncating silently.
-    timeout = confirmation_timeout()
+    #
+    # #2975: also hand in whatever this repo's OWN last confirmation measured
+    # (`expected_confirmation_seconds`) — a repo whose suite structurally
+    # cannot finish inside the budget (quadraui's `cargo test --features
+    # tui`) would otherwise spend the full ceiling relearning that identical
+    # fact on every single PASS claim, serialising every other repo's Test/
+    # Review dispatch behind it each time. Knowing the answer already lets
+    # `confirmation_timeout` skip straight to UNCONFIRMED instead.
+    expected = expected_confirmation_seconds(transition.repo_name)
+    timeout = confirmation_timeout(expected)
     if timeout is None:
-        log.warning(
-            "smoke %s: this notify pass has spent its confirmation budget "
-            "(coord.confirm_test.CONFIRM_PASS_BUDGET_SECONDS) — recording the "
-            "worker's own claim for %s UNCONFIRMED rather than holding "
-            "notify.lock any longer (#2464).",
-            transition.assignment_id, transition.repo_name,
-        )
+        if expected is not None:
+            log.warning(
+                "smoke %s: %s's last measured confirmation took about %.0fs, "
+                "at or beyond what this pass has left to spend — skipping "
+                "the run and recording the worker's own claim UNCONFIRMED "
+                "rather than repeating a run already known not to finish "
+                "(#2975).",
+                transition.assignment_id, transition.repo_name, expected,
+            )
+        else:
+            log.warning(
+                "smoke %s: this notify pass has spent its confirmation budget "
+                "(coord.confirm_test.CONFIRM_PASS_BUDGET_SECONDS) — recording the "
+                "worker's own claim for %s UNCONFIRMED rather than holding "
+                "notify.lock any longer (#2464).",
+                transition.assignment_id, transition.repo_name,
+            )
         return None
 
     branch = entry.get("branch")
@@ -2084,10 +2106,12 @@ def _run_pass_confirmation(transition: Transition, entry: dict):
         transition.assignment_id, transition.repo_name, branch, timeout,
     )
     started = time.monotonic()
+    result: ConfirmationResult | None = None
     try:
-        return confirm_branch(
+        result = confirm_branch(
             transition.repo_name, branch, config, timeout=timeout,
         )
+        return result
     except Exception as exc:  # noqa: BLE001
         log.warning(
             "smoke %s: confirmation run raised (%s) — falling back to the "
@@ -2100,7 +2124,15 @@ def _run_pass_confirmation(transition: Transition, entry: dict):
         # It really did hold the drain (and `notify.lock`) for those seconds,
         # and a run that reliably blows up after ten minutes must not be able
         # to repeat that for every row on the board free of charge.
-        spend_confirmation_budget(time.monotonic() - started)
+        elapsed = time.monotonic() - started
+        spend_confirmation_budget(elapsed)
+        # #2975: only remember the duration when the result is actually a
+        # trustworthy measurement (see RECORDABLE_DURATION_KINDS) — an
+        # exception, a disabled config load, or a KIND_SETUP/INFRA/SIGNAL
+        # short-circuit tells us nothing about how long the real suite takes
+        # and must never overwrite a previously-learned expectation.
+        if result is not None and result.kind in RECORDABLE_DURATION_KINDS:
+            record_confirmation_duration(transition.repo_name, elapsed)
 
 
 def _confirmed_pass_verdict(
@@ -4155,6 +4187,20 @@ def run_drain(
     *notifications*, not pipeline advancement, and giving the daemon a
     periodic detector is #1632's job (which is blocked on this).
 
+    **Dispatch order (#2975).** Smoke/review/PR-open dispatch also runs as a
+    HEAD START right at the top of the pass, before this pass's own
+    transition detection (which is where a #2464 out-of-band confirmation
+    runs — see :mod:`coord.confirm_test`). A confirmation re-runs a repo's
+    real build+test synchronously and can hold this very lock for the whole
+    confirmation-pass budget, several timer fires' worth for a repo whose
+    suite is structurally too slow. Every row already eligible for dispatch
+    as of the top of the pass must not queue behind that — a slow suite on
+    one repo must delay only its own confirmation, never another repo's
+    Test/Review dispatch. The three dispatch functions run a second time
+    afterward too, in their historical place, to pick up anything the
+    transition-detection step below made newly eligible; all three are
+    idempotent, so the repeat costs only a second, mostly-empty scan.
+
     **Concurrency.**  The whole pass runs under ``~/.coord/notify.lock`` —
     literally :class:`coord.filelock.FileLock`, the same class on the same
     path ``coord drive``'s ``run_notify()`` takes — so a drive's nudge and the
@@ -4203,6 +4249,56 @@ def _run_drain_locked(config: Config) -> DrainResult:
 
     begin_confirmation_pass()
 
+    # Step 0a (#2803, moved up by #2975): clear any work row wedged at
+    # test_state='running' well past its Test-stage child's own terminal
+    # resolution (or absence) — a lost verdict write, never a fabricated one
+    # (see `sweep_stuck_test_state_rows`'s docstring). It still runs BEFORE
+    # every smoke dispatch in this pass, which is #2803's invariant: a row
+    # this clears is picked up and redispatched in THIS SAME pass, not the
+    # next one. It now runs before step 0b's head start as well, so a row it
+    # clears gets that head start too rather than waiting behind step 1's
+    # confirmations. Nothing is lost by sweeping before transition detection:
+    # every case the sweep acts on is gated on
+    # `STUCK_TEST_STATE_GRACE_SECONDS` (10 minutes) having elapsed since the
+    # child's own resolution, so a child that only just went terminal in
+    # THIS pass is out of scope either way.
+    try:
+        _sweep_stuck_test_state(config)
+    except Exception:  # noqa: BLE001
+        log.exception("notify drain: stuck test_state sweep failed")
+
+    # Step 0b (#2975): dispatch pending Test-stage smoke / PR-opens / reviews
+    # from the board exactly as it reads RIGHT NOW — before step 1 below gets
+    # anywhere near a `confirm_branch` call. A confirmation re-runs one
+    # repo's real build+test synchronously inside THIS pass and can
+    # legitimately hold `notify.lock` for the whole `CONFIRM_PASS_BUDGET_
+    # SECONDS` ceiling — several `coord-notify.timer` fires' worth (#2975).
+    # Every row already eligible for dispatch as of the top of this pass
+    # must not queue behind that: a slow suite on one repo should delay only
+    # its own confirmation, never another repo's Test/Review dispatch.
+    #
+    # Steps 2-3 below repeat these same three calls after the transition
+    # detection has had a chance to add anything newly eligible (a work leg
+    # that just finished, a PR that just opened) — this head start is
+    # additive, not a replacement.
+    # All three are idempotent (`_dispatch_board_pending_pr_opens`'s and
+    # `_dispatch_board_pending_smoke`'s own docstrings: "safe to call even
+    # when the board file doesn't exist", find-or-create PRs, dedupe via
+    # `has_active_followup`), so calling each twice in one pass costs
+    # nothing beyond a second, mostly-empty scan.
+    try:
+        _dispatch_board_pending_pr_opens(config)
+    except Exception:  # noqa: BLE001
+        log.exception("notify drain: head-start PR-open dispatch failed")
+    try:
+        _dispatch_board_pending_smoke(config)
+    except Exception:  # noqa: BLE001
+        log.exception("notify drain: head-start smoke dispatch failed")
+    try:
+        _dispatch_board_pending_reviews(config)
+    except Exception:  # noqa: BLE001
+        log.exception("notify drain: head-start review dispatch failed")
+
     # Step 1: post completion/failure/advisory/plan/review comments for rows
     # the agent reports terminal.  This is what stamps `finished_at` (via
     # mark_notified) and captures cost / SMOKE_TESTS / summary / session id /
@@ -4234,18 +4330,7 @@ def _run_drain_locked(config: Config) -> DrainResult:
     except Exception:  # noqa: BLE001
         log.exception("notify drain: detect_transitions failed")
 
-    # Step 2 (#2803): clear any work row wedged at test_state='running' well
-    # past its Test-stage child's own terminal resolution (or absence) — a
-    # lost verdict write, never a fabricated one (see `sweep_stuck_test_
-    # state_rows`'s docstring). Runs BEFORE step 3's smoke dispatch so a row
-    # this clears is picked up and redispatched in THIS SAME pass, not the
-    # next one.
-    try:
-        _sweep_stuck_test_state(config)
-    except Exception:  # noqa: BLE001
-        log.exception("notify drain: stuck test_state sweep failed")
-
-    # Step 2.5 (#2844): open PRs for work-leg completions still missing one —
+    # Step 2 (#2844): open PRs for work-leg completions still missing one —
     # BEFORE the Test-stage dispatch below, so the pull_request CI run starts
     # overlapping smoke instead of waiting for review dispatch to open the
     # PR ~20 minutes later.
@@ -4447,6 +4532,31 @@ def run(
     # why this reads the marker but never writes it.
     _roll_pending = _roll_pending_blocks_new_dispatch()
 
+    # Step 0 (#2975): same head start `_run_drain_locked` takes, and for the
+    # identical reason — dispatch pending Test-stage smoke / PR-opens /
+    # reviews from the board exactly as it reads RIGHT NOW, before the
+    # transition-detection loop below gets anywhere near a `confirm_branch`
+    # call that can hold `notify.lock` for up to `CONFIRM_PASS_BUDGET_
+    # SECONDS`. Gated on `_roll_pending` like every other NEW-leg dispatch in
+    # this function (#2587) — the later calls to the same three functions,
+    # a few dozen lines down, repeat this after the loop below has had a
+    # chance to add anything newly eligible; this is a head start, not a
+    # replacement, and all three are idempotent so calling each twice costs
+    # only a second, mostly-empty scan.
+    if not _roll_pending:
+        try:
+            _dispatch_board_pending_pr_opens(config)
+        except Exception:  # noqa: BLE001
+            pass
+        try:
+            _dispatch_board_pending_smoke(config)
+        except Exception:  # noqa: BLE001
+            pass
+        try:
+            _dispatch_board_pending_reviews(config)
+        except Exception:  # noqa: BLE001
+            pass
+
     # #522: one terminal-state cache shared across every gh-hitting check in
     # this notify run (the auto-loop review/fix dispatches below, and the
     # #1441 stalled-pipeline sweep at the end), so a burst of activity for

{code_coordinator-0.5.316 → code_coordinator-0.5.318}/coord/reconcile.py

@@ -2791,9 +2791,11 @@ def _extract_issue_number(branch: str) -> int | None:
 def close_stale_prs(
     config: Config,
     *,
+    board: Board | None = None,
     repo: str | None = None,
     issue: int | None = None,
     dry_run: bool = False,
+    skip_dormant_repos: bool = False,
 ) -> list[str]:
     """Close open PRs whose work is already on main or whose issue is closed.
 
@@ -2808,15 +2810,46 @@ def close_stale_prs(
 
     Stale PRs are closed with an explanatory comment.  Non-stale PRs are left
     untouched.  *dry_run* lists what would change without writing.  Idempotent.
+
+    #2994: when *skip_dormant_repos* is set (the daemon tick's opt-in — see
+    ``coord.serve_app._reconcile_merges_tick``; a manual ``coord
+    reconcile-merges`` leaves this False), a repo with no open assignment, no
+    drive-queue entry, and no coord-authored open PR (``coord.repo_dormancy.
+    should_skip_sweep``) is skipped this call rather than costing a
+    ``list_open_prs`` call — bounded by ``coord.repo_dormancy.
+    DORMANT_SWEEP_FLOOR_S`` so it's still swept eventually. Requires *board*
+    to evaluate; with *board* left ``None`` this is a no-op regardless of
+    *skip_dormant_repos* (no activity signal to check against, so never
+    skip).
+
+    Note: the floor is recorded as soon as a repo is deemed due, before
+    ``list_open_prs`` is even attempted, and it stays recorded if that call
+    then raises (deliberate — see ``coord.repo_dormancy.record_swept``'s
+    docstring: it tracks "a real gh call was spent", not "and it worked").
+    One operator-facing consequence: a repo that is persistently failing
+    (renamed, deleted, secondary-rate-limited) goes quiet for up to
+    ``DORMANT_SWEEP_FLOOR_S`` between retries rather than being retried
+    sooner, same as a genuinely idle repo would be.
     """
     from coord import github_ops  # noqa: PLC0415
 
     actions: list[str] = []
+    dormant_skipped = 0
 
     for repo_cfg in config.repos:
         if repo is not None and repo_cfg.name != repo:
             continue
 
+        if skip_dormant_repos and board is not None:
+            from coord import repo_dormancy  # noqa: PLC0415
+
+            if repo_dormancy.should_skip_sweep(
+                repo_cfg.name, board, repo_dormancy.KIND_PRS
+            ):
+                dormant_skipped += 1
+                continue
+            repo_dormancy.record_swept(repo_cfg.name, repo_dormancy.KIND_PRS)
+
         try:
             open_prs = github_ops.list_open_prs(repo_cfg.github)
         except Exception as exc:  # noqa: BLE001
@@ -2891,6 +2924,14 @@ def close_stale_prs(
                 except Exception as exc:  # noqa: BLE001
                     actions.append(f"  ↳ error closing PR #{pr_number}: {exc}")
 
+    if dormant_skipped:
+        # #2994: one aggregate line rather than one per repo — visible
+        # without being noisy on a fleet with many idle repos.
+        actions.append(
+            f"stale-PR sweep: skipped {dormant_skipped} dormant repo(s) "
+            "(no open assignment, drive-queue entry, or open PR)"
+        )
+
     return actions
 
 
@@ -2926,6 +2967,7 @@ def reconcile_board_merges(
     issue: int | None = None,
     dry_run: bool = False,
     throttle_false_merge_audit: bool = False,
+    skip_dormant_repos: bool = False,
 ) -> list[str]:
     """Reconcile done work assignments against git/GitHub reality.
 
@@ -2995,7 +3037,13 @@ def reconcile_board_merges(
     the daemon's 30s tick (97% of a pass's ``gh`` calls). Set
     *throttle_false_merge_audit* to run that sweep at most hourly; the
     daemon tick does, a manual ``coord reconcile-merges`` deliberately does
-    not. See the inline block above ``_false_merge_candidates``.)
+    not. See the inline block above ``_false_merge_candidates``.
+
+    #2994: *skip_dormant_repos* (also daemon-tick-only, also off for a
+    manual ``coord reconcile-merges``) is threaded through to sweep (c),
+    :func:`close_stale_prs` — see its own docstring — so a repo with no open
+    assignment, no drive-queue entry, and no coord-authored open PR doesn't
+    cost a ``list_open_prs`` call on every tick either.)
     """
     from coord import github_ops, state  # noqa: PLC0415
 
@@ -3139,7 +3187,16 @@ def reconcile_board_merges(
                     state.mark_work_review_settled(a.assignment_id or "")
 
     # (c) #721 — close open PRs whose work has already landed.
-    actions.extend(close_stale_prs(config, repo=repo, issue=issue, dry_run=dry_run))
+    actions.extend(
+        close_stale_prs(
+            config,
+            board=board,
+            repo=repo,
+            issue=issue,
+            dry_run=dry_run,
+            skip_dormant_repos=skip_dormant_repos,
+        )
+    )
 
     # (d) #732 — prune stale merge_queue entries for closed issues / merged PRs.
     # Runs after the board sweeps so a just-marked-merged assignment doesn't