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

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

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

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

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

{code_coordinator-0.5.316 → code_coordinator-0.5.317}/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

code_coordinator-0.5.317/coord/repo_dormancy.py

@@ -0,0 +1,225 @@
+"""Per-repo dormancy skip for the daemon's periodic GitHub sweeps (#2994).
+
+**The problem this closes.** Two of the daemon's slow-cadence ticks —
+``coord.serve_app._sync_issues_tick`` and the stale-PR sweep inside
+``coord.reconcile.close_stale_prs`` (driven by ``_reconcile_merges_tick``) —
+loop over *every registered repo, unconditionally, every tick* and spend a
+``gh`` call (or two) on each. GitHub call volume this way scales with how
+many repos have ever been registered, not with how much work is actually in
+flight: a repo nobody has touched in months costs exactly as much per tick
+as a repo mid-pipeline.
+
+**This module's job.** A repo counts as dormant when it has no open
+assignment, no drive-queue entry, and no coord-authored open PR — see
+:func:`repo_has_activity`, computed live from in-memory board state plus a
+local (non-GitHub) drive-queue read, never cached. Because it is live, the
+instant work is queued for a dormant repo the very next tick sees it as
+active again — there is no separate "wake" call to remember to make.
+
+A dormant repo is not *permanently* skipped, only skipped until
+:data:`DORMANT_SWEEP_FLOOR_S` has passed since its last real sweep — a
+floor, not a wall — so out-of-band activity (a human-opened PR, an issue
+filed by someone who isn't coord) is still noticed eventually even though
+nothing coord-side would otherwise prompt a look. Same best-effort,
+JSON-backed, never-raises shape as the sibling starvation-floor tracker
+:mod:`coord.issues_sync_status` established for exactly this kind of
+bookkeeping — one file, one dict, no new persistence layer.
+
+**Two independent sweep kinds, two independent floors (#2994 review).**
+``_sync_issues_tick`` (issues-sync, ``gh issue list``) and
+``close_stale_prs`` (stale-PR sweep, ``gh pr list``) both call this module
+for the *same repo* in the same daemon tick, one right after the other
+(``_tick_loop``). They are unrelated ``gh`` calls that happen to run
+back-to-back — if they shared one ``{repo_name: last_swept_at}`` clock,
+whichever tick ran first would refresh it before the second ever saw a
+stale-enough value, permanently starving the loser. So every entry point
+takes a mandatory ``kind`` (a short tag like ``"issues"`` or ``"prs"``) and
+the on-disk state is keyed by ``f"{repo_name}:{kind}"`` — same file, two
+disjoint sets of keys, each consumer only ever reads/writes its own.
+
+Both consumers follow the same two-call contract:
+
+* :func:`should_skip_sweep` before spending the real ``gh`` call — True
+  means skip this repo this tick.
+* :func:`record_swept` right after deciding *not* to skip (regardless of
+  whether the sweep itself succeeded) — resets the floor timer.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import tempfile
+import time
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from coord.platform_paths import default_coord_dir
+
+if TYPE_CHECKING:
+    from coord.models import Board
+
+_log = logging.getLogger(__name__)
+
+_STATE_FILENAME = "repo_dormancy_status.json"
+
+# How long a genuinely-idle repo may go without a real sweep before the next
+# tick forces one anyway, so out-of-band activity is still noticed within a
+# bounded window rather than never. Comfortably above the default 300s tick
+# cadence (COORD_RECONCILE_MERGES_INTERVAL) so an idle repo actually saves
+# calls on most ticks, short enough that "eventually" reads as "within the
+# hour" to an operator rather than "whenever someone notices."
+DORMANT_SWEEP_FLOOR_S = 3600.0
+
+# Sweep-kind tags (#2994 review): each gets its own floor timer, keyed by
+# f"{repo_name}:{kind}" on disk, so the issues-sync tick and the stale-PR
+# sweep never clobber each other's clock even when they run back-to-back
+# for the same repo in the same tick (`_tick_loop`).
+KIND_ISSUES = "issues"
+KIND_PRS = "prs"
+
+
+def _state_path() -> Path:
+    """Resolve the dormancy state file path.
+
+    ``$COORD_REPO_DORMANCY_STATE`` overrides first — same seam
+    ``coord.issues_sync_status._state_path`` documents: lets a test redirect
+    this with a one-line ``monkeypatch.setenv`` instead of risking a stray
+    write into the operator's real ``~/.coord``.
+    """
+    override = os.environ.get("COORD_REPO_DORMANCY_STATE")
+    if override:
+        return Path(override).expanduser()
+    return default_coord_dir() / _STATE_FILENAME
+
+
+def _read_all() -> dict[str, float]:
+    path = _state_path()
+    try:
+        raw = path.read_text(encoding="utf-8")
+    except OSError:
+        return {}
+    try:
+        data = json.loads(raw)
+    except (json.JSONDecodeError, ValueError):
+        return {}
+    if not isinstance(data, dict):
+        return {}
+    return {k: float(v) for k, v in data.items() if isinstance(v, (int, float))}
+
+
+def _write_all(data: dict[str, float]) -> None:
+    try:
+        path = _state_path()
+        path.parent.mkdir(parents=True, exist_ok=True)
+        fd, tmp = tempfile.mkstemp(
+            prefix=".repo_dormancy.", suffix=".tmp", dir=path.parent
+        )
+        try:
+            with os.fdopen(fd, "w", encoding="utf-8") as fh:
+                json.dump(data, fh, sort_keys=True)
+                fh.write("\n")
+            os.replace(tmp, path)
+        except Exception:
+            try:
+                os.unlink(tmp)
+            except OSError:
+                pass
+            raise
+    except Exception as exc:  # noqa: BLE001 -- best-effort, never raises
+        _log.debug("repo_dormancy: write failed: %s", exc)
+
+
+def _key(repo_name: str, kind: str) -> str:
+    return f"{repo_name}:{kind}"
+
+
+def record_swept(repo_name: str, kind: str, *, now: float | None = None) -> None:
+    """Best-effort: stamp *repo_name*'s *kind* sweep as having run just now.
+
+    *kind* is a short tag identifying which independent sweep this is (e.g.
+    ``"issues"`` for the issues-sync tick, ``"prs"`` for the stale-PR sweep)
+    — each gets its own floor timer, keyed by ``f"{repo_name}:{kind}"``, so
+    the two sweeps never clobber each other's clock.
+
+    Called right after a tick decides NOT to skip a repo — regardless of
+    whether the sweep itself goes on to succeed or fail — so the floor timer
+    reflects "a real gh call was spent on this repo", not "and it worked".
+    """
+    now = now if now is not None else time.time()
+    data = _read_all()
+    data[_key(repo_name, kind)] = now
+    _write_all(data)
+
+
+def _last_swept_at(repo_name: str, kind: str) -> float | None:
+    return _read_all().get(_key(repo_name, kind))
+
+
+def repo_has_activity(repo_name: str, board: Board) -> bool:
+    """True when *repo_name* is NOT idle: an open assignment, a
+    coord-authored open PR, or a drive-queue entry.
+
+    * "Open assignment" — anything in ``board.active`` for this repo
+      (pending or running work/review/smoke/conflict-fix sessions).
+    * "Coord-authored open PR" — a ``board.completed`` row for this repo
+      still sitting at ``status == 'done'`` (landed, PR presumably open,
+      not yet flipped to ``'merged'``) — this is tracked locally already
+      (it's exactly what the merge-reconcile sweeps exist to resolve), so
+      no extra GitHub call is needed to answer this half of the question.
+    * "Drive-queue entry" — a local (non-GitHub) DB read via
+      :func:`coord.state.list_drive_queue`.
+
+    Deliberately fails OPEN on a drive-queue read error: a repo we can't
+    positively confirm is idle is treated as active, never skipped.
+    """
+    for a in board.active:
+        if a.repo_name == repo_name:
+            return True
+    for a in board.completed:
+        if a.repo_name == repo_name and a.status == "done":
+            return True
+
+    from coord import state  # noqa: PLC0415 -- avoid a state<->reconcile import cycle
+
+    try:
+        if state.list_drive_queue(repo_name):
+            return True
+    except Exception:  # noqa: BLE001 -- best-effort; treat as active on doubt
+        return True
+
+    return False
+
+
+def should_skip_sweep(
+    repo_name: str, board: Board, kind: str, *, now: float | None = None
+) -> bool:
+    """True when this tick should skip *repo_name*'s *kind* GitHub sweep.
+
+    *kind* must match the tag the corresponding :func:`record_swept` call
+    uses (``"issues"`` vs. ``"prs"``) — the two sweeps are independent
+    ``gh`` call types with independent floors; see the module docstring for
+    why they must not share one clock.
+
+    Only ever True for a repo with zero activity (see
+    :func:`repo_has_activity`) that was also swept for real inside
+    :data:`DORMANT_SWEEP_FLOOR_S`. A repo with no recorded sweep at all
+    counts as due, not skippable — there is no prior sweep to protect, and a
+    freshly-registered repo should get its first real sweep immediately.
+    """
+    if repo_has_activity(repo_name, board):
+        return False
+    last = _last_swept_at(repo_name, kind)
+    if last is None:
+        return False
+    now = now if now is not None else time.time()
+    return (now - last) < DORMANT_SWEEP_FLOOR_S
+
+
+def clear() -> None:
+    """Drop all recorded sweep timestamps. Best-effort; never raises. Tests only."""
+    try:
+        _state_path().unlink()
+    except OSError:
+        pass

{code_coordinator-0.5.316 → code_coordinator-0.5.317}/coord/serve_app.py

@@ -991,7 +991,13 @@ def _reconcile_merges_tick(config: Config) -> list[str]:
     # candidate set proportional to project history — 97% of a reconcile
     # pass's `gh` calls, and the demand behind the fleet-wide secondary rate
     # limiting. A manual `coord reconcile-merges` still sweeps every time.
-    actions = reconcile_board_merges(board, config, throttle_false_merge_audit=True)
+    # #2994: same daemon-only opt-in for `skip_dormant_repos` — the stale-PR
+    # sweep (close_stale_prs, sweep c) otherwise lists open PRs for every
+    # registered repo every tick regardless of activity. A manual
+    # `coord reconcile-merges` still sweeps every repo.
+    actions = reconcile_board_merges(
+        board, config, throttle_false_merge_audit=True, skip_dormant_repos=True
+    )
     save_board(board)
     if actions:
         # #1038: one coarse operational row per tick that did something —
@@ -1035,11 +1041,24 @@ def _sync_issues_tick(config: Config) -> int:
     sample for 39 minutes straight, even though a direct ``gh`` call
     succeeded in under a second the whole time. See
     ``coord.github_ops._gh``'s docstring for exactly what the flag changes.
+
+    #2994: before spending a call on a repo, consult
+    ``coord.repo_dormancy.should_skip_sweep`` — a repo with no open
+    assignment, no drive-queue entry, and no coord-authored open PR is
+    dormant, and dormant repos are only swept once per
+    ``coord.repo_dormancy.DORMANT_SWEEP_FLOOR_S`` rather than every tick.
+    Queuing work for a dormant repo un-skips it on the very next tick (the
+    check is live against board + drive-queue state, never cached). This
+    adds a ``build_board()`` call to this tick that wasn't here before —
+    a local SQLite read, not a network call; every other slow-cadence tick
+    in this module (``_reconcile_merges_tick`` included, run moments earlier
+    in the same ``_tick_loop`` pass) already pays it once per tick, so this
+    is not new cost territory.
     """
     import logging  # noqa: PLC0415
 
-    from coord import github_ops, issues_sync_status  # noqa: PLC0415
-    from coord.state import _upsert_open_issues_local  # noqa: PLC0415
+    from coord import github_ops, issues_sync_status, repo_dormancy  # noqa: PLC0415
+    from coord.state import _upsert_open_issues_local, build_board  # noqa: PLC0415
 
     # Use the private _upsert_open_issues_local (underscore-prefixed) rather
     # than the public upsert_open_issues, because the public variant routes
@@ -1047,8 +1066,16 @@ def _sync_issues_tick(config: Config) -> int:
     # configured.  Since this function IS the daemon, we must write directly
     # to the local DB to avoid a self-referential HTTP call.
     log = logging.getLogger("coord.serve")
+    board = build_board()
     total = 0
+    skipped_dormant = 0
     for repo in config.repos:
+        if repo_dormancy.should_skip_sweep(
+            repo.name, board, repo_dormancy.KIND_ISSUES
+        ):
+            skipped_dormant += 1
+            continue
+        repo_dormancy.record_swept(repo.name, repo_dormancy.KIND_ISSUES)
         starved = issues_sync_status.is_starved(repo.name)
         issues_sync_status.record_attempt(repo.name)
         try:
@@ -1065,7 +1092,16 @@ def _sync_issues_tick(config: Config) -> int:
                 " (starvation-floor bypass already attempted)" if starved else "",
                 exc_info=True,
             )
-    log.debug("issues-sync tick: %d open issues across %d repos", total, len(config.repos))
+    if skipped_dormant:
+        log.info(
+            "issues-sync tick: skipped %d dormant repo(s) (no open assignment, "
+            "drive-queue entry, or open PR)",
+            skipped_dormant,
+        )
+    log.debug(
+        "issues-sync tick: %d open issues across %d repos (%d dormant-skipped)",
+        total, len(config.repos), skipped_dormant,
+    )
     return total
 
 

{code_coordinator-0.5.316 → code_coordinator-0.5.317}/tests/conftest.py

@@ -761,6 +761,29 @@ def _no_real_issues_sync_status_store(monkeypatch, tmp_path):
     )
 
 
+@pytest.fixture(autouse=True)
+def _no_real_repo_dormancy_store(monkeypatch, tmp_path):
+    """#2994: never let a test write the OPERATOR'S real
+    ``~/.coord/repo_dormancy_status.json``.
+
+    Same hazard as ``_no_real_issues_sync_status_store`` immediately above,
+    one file over: this one is the per-repo dormant-sweep floor timer
+    (``coord.repo_dormancy``) that both ``coord.serve_app._sync_issues_tick``
+    and ``coord.reconcile.close_stale_prs`` consult before spending a real
+    ``gh`` call on a repo. A leaked test write could plant a fake recent
+    sweep timestamp that spuriously skips a real fleet's dormant repo past
+    its floor, or clear one and force an extra sweep early.
+
+    ``coord.repo_dormancy._state_path`` reads
+    ``$COORD_REPO_DORMANCY_STATE`` first for exactly this redirect, the same
+    env-var seam ``_no_real_issues_sync_status_store`` uses, not a
+    monkeypatched private function.
+    """
+    monkeypatch.setenv(
+        "COORD_REPO_DORMANCY_STATE", str(tmp_path / "repo-dormancy-status.json")
+    )
+
+
 @pytest.fixture(autouse=True)
 def _no_real_roll_pending_store(monkeypatch, tmp_path):
     """#2587: never let a test write the OPERATOR'S real

{code_coordinator-0.5.316 → code_coordinator-0.5.317}/tests/test_reconcile_merges.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import time
+
 import pytest
 
 from coord import github_ops
@@ -907,6 +909,141 @@ def test_stale_pr_sweep_integrated_into_reconcile_board_merges(
     assert any("close PR #44" in s for s in actions)
 
 
+# ── #2994: dormant-repo skip ──────────────────────────────────────────────────
+
+
+@pytest.fixture
+def two_repo_config() -> Config:
+    return Config(
+        repos=[
+            Repo(name="api", github="acme/api", default_branch="main"),
+            Repo(name="idle", github="acme/idle", default_branch="main"),
+        ],
+        machines=[],
+    )
+
+
+def test_close_stale_prs_skips_dormant_repo_when_opted_in(
+    monkeypatch, two_repo_config
+) -> None:
+    """#2994: with skip_dormant_repos=True and a board showing activity on
+    'api' but nothing at all on 'idle', the sweep must not call
+    list_open_prs for 'idle' -- and must say so in its actions."""
+    from coord import repo_dormancy
+
+    calls: list[str] = []
+    monkeypatch.setattr(
+        github_ops,
+        "list_open_prs",
+        lambda repo: calls.append(repo) or [],
+    )
+
+    # 'idle' already had a baseline sweep, well inside the floor -- only a
+    # repo that has been swept before is even eligible to be skipped (see
+    # test_never_swept_repo_is_not_skipped in test_repo_dormancy.py).
+    repo_dormancy.record_swept("idle", repo_dormancy.KIND_PRS, now=time.time())
+
+    board = Board(
+        active=[],
+        completed=[_done_work(assignment_id="w1", branch="issue-1-x")],
+    )
+    board.completed[0].repo_name = "api"
+
+    actions = close_stale_prs(two_repo_config, board=board, skip_dormant_repos=True)
+
+    assert calls == ["acme/api"]
+    assert any("skipped 1 dormant repo" in s for s in actions)
+
+
+def test_close_stale_prs_default_does_not_skip_idle_repo(
+    monkeypatch, two_repo_config
+) -> None:
+    """Without opting in (the manual `coord reconcile-merges` path), every
+    repo is still swept even when a board is supplied and shows no
+    activity anywhere -- skip_dormant_repos defaults to False."""
+    calls: list[str] = []
+    monkeypatch.setattr(
+        github_ops,
+        "list_open_prs",
+        lambda repo: calls.append(repo) or [],
+    )
+
+    board = Board(active=[], completed=[])
+
+    actions = close_stale_prs(two_repo_config, board=board)
+
+    assert calls == ["acme/api", "acme/idle"]
+    assert not any("dormant" in s for s in actions)
+
+
+def test_close_stale_prs_dormant_repo_swept_again_past_the_floor(
+    monkeypatch, config
+) -> None:
+    """A dormant repo is only skipped inside DORMANT_SWEEP_FLOOR_S of its
+    last real sweep -- past that, the next tick sweeps it for real again so
+    out-of-band activity is still noticed eventually."""
+    from coord import repo_dormancy
+
+    calls: list[str] = []
+    monkeypatch.setattr(
+        github_ops,
+        "list_open_prs",
+        lambda repo: calls.append(repo) or [],
+    )
+
+    now = time.time()
+    repo_dormancy.record_swept(
+        "api", repo_dormancy.KIND_PRS, now=now - repo_dormancy.DORMANT_SWEEP_FLOOR_S - 1.0
+    )
+
+    board = Board(active=[], completed=[])  # no activity -- 'api' is idle
+
+    actions = close_stale_prs(config, board=board, skip_dormant_repos=True)
+
+    assert calls == ["acme/api"]
+    assert not any("dormant" in s for s in actions)
+
+
+def test_reconcile_board_merges_wakes_dormant_repo_when_work_is_queued(
+    monkeypatch, two_repo_config
+) -> None:
+    """#2994 acceptance: queuing work for a dormant repo puts it back on the
+    normal cadence on the very next tick, not after the floor expires."""
+    from coord import repo_dormancy
+
+    _patch_probes(monkeypatch, remote_branches=set(), terminal=False)
+    calls: list[str] = []
+    monkeypatch.setattr(
+        github_ops,
+        "list_open_prs",
+        lambda repo: calls.append(repo) or [],
+    )
+
+    now = time.time()
+    # Both repos need a baseline sweep before dormancy skip applies at all
+    # ('never swept' always sweeps -- see test_never_swept_repo_is_not_skipped
+    # in test_repo_dormancy.py). 'api' has real activity below so it's never
+    # skipped regardless; 'idle' was just swept -- well inside the floor.
+    repo_dormancy.record_swept("api", repo_dormancy.KIND_PRS, now=now)
+    repo_dormancy.record_swept("idle", repo_dormancy.KIND_PRS, now=now)
+
+    api_assignment = _done_work(assignment_id="w-api", status="running")
+    api_assignment.repo_name = "api"
+    board = Board(active=[api_assignment], completed=[])
+    reconcile_board_merges(board, two_repo_config, skip_dormant_repos=True)
+    assert calls == ["acme/api"]  # 'idle' skipped -- still inside the floor
+
+    # Work gets queued for 'idle' (an open assignment appears on the board).
+    calls.clear()
+    idle_assignment = _done_work(assignment_id="w-idle", status="pending")
+    idle_assignment.repo_name = "idle"
+    board.active.append(idle_assignment)
+
+    reconcile_board_merges(board, two_repo_config, skip_dormant_repos=True)
+
+    assert calls == ["acme/api", "acme/idle"]
+
+
 # ── #732 prune stale merge_queue entries ─────────────────────────────────────