The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
"""Process-wide coordination for the cron tick's worktree prune (``cron.scheduler`` runs in here).
One process ticks every served profile (``cron/AGENTS.md``), so the per-profile throttle in
``cron.scheduler`` legitimately lets each profile decide it is due, and each due profile gets its
own ``cron-worktree-prune`` thread. Those threads used to fork ``git`` side by side, which starved a
338-profile gateway's event loop until the liveness watchdog exited 75 (#143255). Two guards:
- **One sweep at a time.** The tick is sequential, the sweeps it dispatches are not; serialising
them (discovery included) keeps the number of concurrent ``git`` children at one regardless of
profile count. A waiting sweep holds no resources, so the wait is capped rather than unbounded.
- **One prune per repo per interval.** Served profiles mostly resolve the same repos (the hermes
checkout at least), and every prune pass ends in a footprint probe of the whole ``.worktrees/``,
so the second profile to reach a shared repo within the interval has nothing to do.
"""
import logging
import os
import threading
import time
from typing import Callable, Iterable, Optional
logger = logging.getLogger(__name__)
# Bounded so a wedged sweep cannot park a profile's thread forever; a normal sweep is one git pass
# over a handful of repos.
SWEEP_WAIT_SECONDS = 120.0
_sweep_slot = threading.Semaphore(1)
_last_worktree_prune_at: dict[str, float] = {} # canonical repo path -> monotonic stamp
_lock = threading.Lock()
def claim_sweep_slot(wait_seconds: Optional[float] = None) -> bool:
"""Take the process-wide prune slot, waiting for the sweep ahead of us (bounded)."""
return _sweep_slot.acquire(timeout=SWEEP_WAIT_SECONDS if wait_seconds is None else wait_seconds)
def release_sweep_slot() -> None:
_sweep_slot.release()
def claim_due_worktree_repos(repos: Iterable[str], interval_s: float) -> list[str]:
"""The subset of *repos* no served profile pruned within *interval_s*, stamped as claimed.
Keyed on the path ``git`` resolves to, case-folded where the filesystem is (Windows).
"""
now = time.monotonic()
due = []
with _lock:
for repo in repos:
key = os.path.normcase(os.path.realpath(repo))
last = _last_worktree_prune_at.get(key)
if last is None or now - last >= interval_s:
_last_worktree_prune_at[key] = now
due.append(repo)
return due
def run_sweep(discover: Callable[[], Iterable[str]], *, interval_seconds: float,
wait_seconds: Optional[float] = None) -> None:
"""Prune the repos ``discover()`` reports that are due, from the cron tick's daemon thread.
``discover`` stays in the caller so a per-profile repo lookup (and anything a test patches) is
read where it is defined. Errors never propagate: GC is hygiene, not scheduling.
"""
if not claim_sweep_slot(wait_seconds):
logger.debug("Cron worktree maintenance skipped: another sweep is still running")
return
try:
repos = claim_due_worktree_repos(discover() or [], interval_seconds)
if not repos:
return
from hermes_cli.worktree_ops import _prune_stale_worktrees
for repo in repos:
try:
_prune_stale_worktrees(repo)
except Exception:
logger.debug("Cron worktree maintenance failed for %s", repo, exc_info=True)
except Exception:
logger.debug("Cron worktree maintenance skipped", exc_info=True)
finally:
release_sweep_slot()