alissa-tools-github-revloop 0.31.23__tar.gz → 0.31.25__tar.gz

{alissa_tools_github_revloop-0.31.23/src/main/alissa_tools_github_revloop.egg-info → alissa_tools_github_revloop-0.31.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alissa-tools-github-revloop
-Version: 0.31.23
+Version: 0.31.25
 Summary: ALISSA-TOOLS-GITHUB-REVLOOP
 Home-page: https://alissa.app
 Author: Fahera

{alissa_tools_github_revloop-0.31.23 → alissa_tools_github_revloop-0.31.25}/src/main/alissa/tools/github/revloop/janitor.py

@@ -42,6 +42,9 @@ Three properties everything here is written around:
   and the grace is a day by default. A held folder is kept whatever its age.
   Under disk PRESSURE (issue #177) the grace drops -- to two hours by default
   -- oldest first, only while the volume is still at or above its warn line.
+  A round that names no review task yet holds only its hub's checkouts made
+  since it spawned (issue #185), and at or above `BACKSTOP_PCT` no such
+  hub-wide hold reaches a checkout older than the stale-round window.
 * **Nothing raises past its own concern.** A folder that vanishes mid-sweep,
   an unreadable hub, a failed removal: logged and skipped, because this runs
   at the end of a poll pass that must complete.
@@ -104,6 +107,31 @@ SUPPORTED_TEMPLATE = "{root}/{repo}/main"
 _PROBE_OWNERS = ("janitor-probe-owner-a", "janitor-probe-owner-b")
 _PROBE_REPO = "janitor-probe-repo"
 
+# How far before a round's spawn time a checkout may be stamped and still
+# be held by that round when its review-task ref is unknown (issue #185):
+# clock skew between the ledger's stamp and the filesystem's.
+HOLD_SKEW_SECONDS = 5 * 60
+
+# The volume used percentage at or above which the pressure backstop applies
+# (issue #185): a hub-wide hold is void for checkouts older than the stale-
+# round window, and one WARNING names what holds the most bytes.
+BACKSTOP_PCT = 95.0
+
+# How long a held folder's cached size is trusted (issue #187). The cache is
+# keyed on the folder's newest mtime, which only sees the folder and its
+# direct children: a write deeper down (an `npm ci` filling `node_modules`)
+# leaves it unchanged. So an entry is re-walked once it is this old, mtime
+# or not.
+SIZE_CACHE_SECONDS = 60 * 60
+
+# One held folder's cached size: (newest mtime, bytes, the sweep `now` it
+# was walked at).
+SizeCache = dict[Path, tuple[float, int, float]]
+
+# The two reasons a hub-wide hold gives, so the sweep summary groups them.
+HUB_HOLD_BOUNDED = "a live round in this hub names no review task and spawned before this checkout"
+HUB_HOLD_UNBOUNDED = "a live round in this hub names no review task or spawn time"
+
 Runner = Callable[..., str]
 
 
@@ -138,25 +166,43 @@ class Guard:
     `review-pr-<n>` session names no repo, and holds its PR number anywhere.
 
     A round whose review-task ref is unknown cannot be mapped to a single
-    REVIEW- checkout, so it holds every checkout in its hub (`all_checkouts`).
+    REVIEW- checkout -- every fresh round starts that way, since the reviewer
+    creates its review task after it spawns. Such a round holds the checkouts
+    in its hub that are NEWER than its spawn time less `HOLD_SKEW_SECONDS`
+    (issue #185): a checkout older than every unknown-ref round in the hub
+    cannot belong to any of them. `all_checkouts` keeps, per hub, the
+    earliest such bound; None there means a round whose spawn time is not
+    known either, and holds every checkout in the hub, as before issue #185
+    -- the hold that, with studio reviews running near-continuously, kept 78
+    dead checkouts (~44 GB) and filled the fleet's volume on 2026-10-21.
     """
 
     numbers: "dict[str | None, set[int]]" = field(default_factory=dict)
     tasks: "dict[str | None, set[str]]" = field(default_factory=dict)
-    all_checkouts: "set[str | None]" = field(default_factory=set)
+    all_checkouts: "dict[str | None, float | None]" = field(default_factory=dict)
 
     def hold(
-        self, repo: "str | None", number: int, task_ref: "str | None" = None
+        self,
+        repo: "str | None",
+        number: int,
+        task_ref: "str | None" = None,
+        since: "float | None" = None,
     ) -> None:
         """Hold PR `number` of `repo` (`owner/name`, a bare name, or a
-        session-name slug; None = any hub) and the checkout its task names."""
+        session-name slug; None = any hub) and the checkout its task names.
+        With no task ref, `since` (the round's spawn time, epoch seconds)
+        bounds the checkouts held in the hub; without it, every one is."""
         slug = None if repo is None else session_repo_slug(repo.rpartition("/")[2])
         self.numbers.setdefault(slug, set()).add(int(number))
         ref = (task_ref or "").strip()
         if ref:
             self.tasks.setdefault(slug, set()).add(ref)
-        else:
-            self.all_checkouts.add(slug)
+            return
+        bound = None if since is None else float(since) - HOLD_SKEW_SECONDS
+        if slug in self.all_checkouts:
+            prev = self.all_checkouts[slug]
+            bound = None if prev is None or bound is None else min(prev, bound)
+        self.all_checkouts[slug] = bound
 
     def _in(self, table: "dict[str | None, set]", slug: str, value: object) -> bool:
         return value in table.get(slug, ()) or value in table.get(None, ())
@@ -164,8 +210,19 @@ class Guard:
     def _any(self, slug: str) -> bool:
         return bool(self.numbers.get(slug) or self.numbers.get(None))
 
-    def holds(self, candidate: Candidate) -> "str | None":
-        """Why `candidate` must stay, or None when nothing holds it."""
+    def holds(
+        self,
+        candidate: Candidate,
+        mtime: "float | None" = None,
+        void_before: "float | None" = None,
+    ) -> "str | None":
+        """Why `candidate` must stay, or None when nothing holds it.
+
+        `mtime` is the candidate's age stamp (`newest_mtime`); a review
+        checkout with none is held by every hub-wide hold, bounded or not.
+        `void_before` is the pressure backstop (issue #185): a hub-wide hold
+        does not reach a checkout whose stamp is older than it. A known task
+        ref's hold and a scratch folder's are never voided."""
         slug = candidate.hub_slug
         if candidate.kind == KIND_SCRATCH:
             if candidate.number is None:
@@ -173,10 +230,18 @@ class Guard:
             if self._in(self.numbers, slug, candidate.number):
                 return f"PR #{candidate.number} has a live session or open round"
             return None
-        if slug in self.all_checkouts or None in self.all_checkouts:
-            return "a live round in this hub names no review task"
         if candidate.task_ref and self._in(self.tasks, slug, candidate.task_ref):
             return f"{candidate.task_ref} has a live session or open round"
+        if mtime is not None and void_before is not None and mtime < void_before:
+            return None
+        for key in (slug, None):
+            if key not in self.all_checkouts:
+                continue
+            bound = self.all_checkouts[key]
+            if bound is None:
+                return HUB_HOLD_UNBOUNDED
+            if mtime is None or mtime >= bound:
+                return HUB_HOLD_BOUNDED
         return None
 
 
@@ -199,11 +264,31 @@ class SweepResult:
     # in a dry run, would-be removals) only that shorter grace allowed.
     pressure: bool = False
     pressure_removed: int = 0
+    # Issue #185: bytes held per "<hub slug>: <reason>", so held growth is
+    # visible before it fills the disk; held folders not sized because the
+    # sweep's time budget ran out; and, when the backstop applied, how many
+    # checkouts only it released from a hub-wide hold.
+    held_bytes: "dict[str, int]" = field(default_factory=dict)
+    held_unsized: int = 0
+    # Issue #187: held folders whose size came from the cache, not a walk
+    # this sweep, so the summary can say its figure may be up to
+    # SIZE_CACHE_SECONDS old.
+    held_cached: int = 0
+    backstop: bool = False
+    backstop_released: int = 0
 
     @property
     def freed(self) -> int:
         return sum(size for _, size in self.removed)
 
+    @property
+    def held_total(self) -> int:
+        return sum(self.held_bytes.values())
+
+    def top_held(self, limit: int = 5) -> "list[tuple[str, int]]":
+        """The reasons holding the most bytes, largest first."""
+        return sorted(self.held_bytes.items(), key=lambda kv: (-kv[1], kv[0]))[:limit]
+
     @property
     def left(self) -> int:
         """Candidate folders still on disk after a live sweep: inside the
@@ -211,6 +296,34 @@ class SweepResult:
         return self.fresh + len(self.held) + self.deferred + len(self.failed)
 
 
+def held_reasons(pairs: "Iterable[tuple[str, int]]") -> str:
+    """`; <hub>: <reason> = <size>, ...` for the log lines, or '' when none."""
+    parts = [f"{key} = {human(size)}" for key, size in pairs]
+    return ("; " + ", ".join(parts)) if parts else ""
+
+
+# How many held reasons the sweep summary names before folding the rest.
+HELD_REASONS_LOGGED = 10
+
+
+def held_summary(result: SweepResult) -> str:
+    """The sweep summary's held-bytes tail (issue #185): every hub/reason
+    holding bytes, largest first, at most HELD_REASONS_LOGGED of them, and
+    how many held folders were sized from the cache or went unsized."""
+    tail = held_reasons(result.top_held(HELD_REASONS_LOGGED))
+    rest = len(result.held_bytes) - HELD_REASONS_LOGGED
+    if rest > 0:
+        tail += f", +{rest} more reason(s)"
+    if result.held_cached:
+        tail += (
+            f"; {result.held_cached} held size(s) cached, up to "
+            f"{SIZE_CACHE_SECONDS // 60} min old"
+        )
+    if result.held_unsized:
+        tail += f"; {result.held_unsized} held folder(s) not sized this sweep"
+    return tail
+
+
 def layout_supported(
     hub_for: "Callable[[str, str], Path]", workspace_root: "Path | str"
 ) -> bool:
@@ -322,9 +435,23 @@ def dir_bytes(path: "Path | str") -> int:
     """Bytes allocated under `path` (st_blocks, the figure `du` reports and a
     removal frees), following no symlinks. Iterative, and every per-entry
     error is skipped -- devloop's `dir_size` walk, counting blocks."""
+    return _walk_bytes(path, None) or 0
+
+
+def held_bytes_of(path: "Path | str", stop: "Callable[[], bool]") -> "int | None":
+    """`dir_bytes` for a held folder (issue #187): `stop` is asked before
+    each directory is read, and the walk gives up -- None, never a partial
+    figure -- the moment it answers True, so one large tree cannot run the
+    sweep past its time budget."""
+    return _walk_bytes(path, stop)
+
+
+def _walk_bytes(path: "Path | str", stop: "Callable[[], bool] | None") -> "int | None":
     total = 0
     stack = [os.fspath(path)]
     while stack:
+        if stop is not None and stop():
+            return None
         current = stack.pop()
         try:
             with os.scandir(current) as entries:
@@ -434,6 +561,8 @@ def sweep(
     clock: "Callable[[], float]" = time.monotonic,
     pressure_grace_seconds: "float | None" = None,
     under_pressure: "Callable[[], bool] | None" = None,
+    stale_round_seconds: "float | None" = None,
+    sizes: "SizeCache | None" = None,
 ) -> SweepResult:
     """Remove every candidate under `hubs` older than `grace_seconds` that
     `guard` does not hold, oldest first, then prune each hub's worktree
@@ -456,7 +585,22 @@ def sweep(
     Dry-run removes nothing and prunes nothing: it logs each folder it WOULD
     remove (with its size) and reports them in `would_remove`, under the
     same bound -- so it reports what one live sweep would do (a dry run frees
-    nothing, so under pressure it reports every pressure-eligible folder)."""
+    nothing, so under pressure it reports every pressure-eligible folder).
+
+    The pressure backstop (issue #185): when `stale_round_seconds` is given
+    (the caller passes STALE_ROUND_SECONDS at or above `BACKSTOP_PCT`), a
+    hub-wide hold -- a round with no review-task ref -- is void for a
+    checkout older than that window: no live round can own a checkout older
+    than the stale window. `backstop_released` counts what only it freed.
+
+    Every held folder is sized into `held_bytes` per hub and reason, AFTER
+    the removal loop and on whatever is left of the time budget (issue
+    #187): removal never pays for observability. A walk that reaches the
+    budget mid-tree is abandoned, and every folder left unsized is counted in
+    `held_unsized`. `sizes` (a `SizeCache`), when given, caches those walks
+    across sweeps and is re-keyed to this sweep's held folders; an entry is
+    reused while the folder's mtime is unchanged AND it is younger than
+    SIZE_CACHE_SECONDS by `now`, and each reuse is counted in `held_cached`."""
     result = SweepResult()
     started = clock()
     bounded = False
@@ -466,6 +610,11 @@ def sweep(
         result.pressure = under_pressure()
         if result.pressure:
             shrunk = min(grace_seconds, pressure_grace_seconds)
+    void_before = None
+    if stale_round_seconds is not None:
+        result.backstop = True
+        void_before = now - stale_round_seconds
+    held_queue: "list[tuple[float, Candidate, str]]" = []
     aged: "list[tuple[float, Candidate]]" = []
     for hub in hub_list:
         result.hubs += 1
@@ -480,10 +629,19 @@ def sweep(
         if age < shrunk:
             result.fresh += 1
             continue
-        why = guard.holds(candidate)
+        why = guard.holds(candidate, mtime)
+        if why is not None and void_before is not None:
+            if guard.holds(candidate, mtime, void_before) is None:
+                result.backstop_released += 1
+                log.info(
+                    "janitor: backstop releases %s (%.1f h old) from a hub-wide "
+                    "hold — %s", candidate.path, age / 3600, why,
+                )
+                why = None
         if why is not None:
             log.debug("janitor: keeping %s — %s", candidate.path, why)
             result.held.append((candidate.path, why))
+            held_queue.append((mtime, candidate, f"{candidate.hub_slug}: {why}"))
             continue
         early = age < grace_seconds
         if early and not dry_run and not (under_pressure and under_pressure()):
@@ -520,6 +678,8 @@ def sweep(
         result.removed.append((candidate.path, size))
         if early:
             result.pressure_removed += 1
+    _size_held(held_queue, result, sizes, now=now,
+               out_of_time=lambda: clock() - started >= max_seconds)
     if dry_run:
         return result
     for hub in hub_list:
@@ -529,3 +689,37 @@ def sweep(
         except (CommandError, OSError) as exc:
             log.warning("janitor: git worktree prune failed in %s (%s)", hub, exc)
     return result
+
+
+def _size_held(
+    queue: "list[tuple[float, Candidate, str]]",
+    result: SweepResult,
+    sizes: "SizeCache | None",
+    *,
+    now: float,
+    out_of_time: "Callable[[], bool]",
+) -> None:
+    """Size the sweep's held folders into `result.held_bytes`, after the
+    removals (issue #187). A fresh cache entry costs nothing and is always
+    used; anything else is walked only while `out_of_time()` answers False,
+    and a walk is abandoned the moment it does. `sizes` is then re-keyed to
+    what this sweep sized, so entries for gone or unsized folders drop out."""
+    seen: SizeCache = {}
+    for mtime, candidate, key in queue:
+        cached = (sizes or {}).get(candidate.path)
+        if (cached is not None and cached[0] == mtime
+                and now - cached[2] < SIZE_CACHE_SECONDS):
+            size = cached[1]
+            seen[candidate.path] = cached
+            result.held_cached += 1
+        else:
+            walked = None if out_of_time() else held_bytes_of(candidate.path, out_of_time)
+            if walked is None:
+                result.held_unsized += 1
+                continue
+            size = walked
+            seen[candidate.path] = (mtime, size, now)
+        result.held_bytes[key] = result.held_bytes.get(key, 0) + size
+    if sizes is not None:
+        sizes.clear()
+        sizes.update(seen)

{alissa_tools_github_revloop-0.31.23 → alissa_tools_github_revloop-0.31.25}/src/main/alissa/tools/github/revloop/loop.py

@@ -2847,6 +2847,10 @@ class ReviewWatcher:
         # under the line closes it. In memory, so a restart under pressure
         # opens (and reports) a new episode.
         self._janitor_pressure_since: "float | None" = None
+        # Held folders' sizes from the last sweep, path -> (mtime, bytes,
+        # sized at) (issues #185, #187): the held-bytes summary re-walks only
+        # what changed or is older than janitor_mod.SIZE_CACHE_SECONDS.
+        self._janitor_sizes: "janitor_mod.SizeCache" = {}
         # The (repo, number, round) whose alive session the stale-round probe
         # just killed as `wedged:first-run-dialog` (issue #136), so the
         # respawn site logs its re-enqueue at INFO instead of a second
@@ -8363,8 +8367,9 @@ class ReviewWatcher:
         stamp = time.time() if now is None else now
         pct = self._volume_used_pct()
         pressed = pct is not None and pct >= self.config.janitor_warn_pct
+        backstop = pct is not None and pct >= janitor_mod.BACKSTOP_PCT
         try:
-            result = self._sweep_workspace(stamp, pressed=pressed)
+            result = self._sweep_workspace(stamp, pressed=pressed, backstop=backstop)
         except Exception as exc:
             log.warning(
                 "janitor: sweep failed unexpectedly (%s: %s) — nothing more is "
@@ -8391,7 +8396,7 @@ class ReviewWatcher:
         return pct is not None and pct >= self.config.janitor_warn_pct
 
     def _sweep_workspace(
-        self, now: float, *, pressed: bool = False
+        self, now: float, *, pressed: bool = False, backstop: bool = False
     ) -> "janitor_mod.SweepResult | None":
         if not janitor_mod.layout_supported(
             self.config.hub_for, self.config.workspace_root
@@ -8426,7 +8431,17 @@ class ReviewWatcher:
                 self.config.janitor_pressure_grace_minutes * 60 if pressed else None
             ),
             under_pressure=self._volume_pressed if pressed else None,
+            stale_round_seconds=STALE_ROUND_SECONDS if backstop else None,
+            sizes=self._janitor_sizes,
         )
+        if result.backstop:
+            log.warning(
+                "janitor: volume at or above %d%% — hub-wide holds are void for "
+                "checkouts older than %d minute(s); %d released; %s held%s",
+                int(janitor_mod.BACKSTOP_PCT), STALE_ROUND_SECONDS // 60,
+                result.backstop_released, janitor_mod.human(result.held_total),
+                janitor_mod.held_reasons(result.top_held()),
+            )
         if result.pressure:
             log.info(
                 "janitor: volume at or above %d%% — the grace dropped to %d "
@@ -8439,20 +8454,22 @@ class ReviewWatcher:
         if self.config.dry_run:
             log.info(
                 "[dry-run] janitor: would remove %d folder(s) (%s) across %d "
-                "hub(s); %d held by a live round, %d inside the grace, %d "
-                "deferred to the next interval",
+                "hub(s); %d held by a live round (%s), %d inside the grace, %d "
+                "deferred to the next interval%s",
                 len(result.would_remove),
                 janitor_mod.human(sum(size for _, size in result.would_remove)),
-                result.hubs, len(result.held), result.fresh, result.deferred,
+                result.hubs, len(result.held), janitor_mod.human(result.held_total),
+                result.fresh, result.deferred, janitor_mod.held_summary(result),
             )
         else:
             log.info(
                 "janitor: removed %d folder(s), freed %s across %d hub(s); "
-                "%d held by a live round, %d inside the grace, %d failed, %d "
-                "deferred to the next interval",
+                "%d held by a live round (%s), %d inside the grace, %d failed, %d "
+                "deferred to the next interval%s",
                 len(result.removed), janitor_mod.human(result.freed),
-                result.hubs, len(result.held), result.fresh, len(result.failed),
-                result.deferred,
+                result.hubs, len(result.held), janitor_mod.human(result.held_total),
+                result.fresh, len(result.failed), result.deferred,
+                janitor_mod.held_summary(result),
             )
         return result
 
@@ -8465,7 +8482,11 @@ class ReviewWatcher:
         Open rounds are the ledger's own definition (`in_flight_repos`): a
         spawn younger than the stale-round window whose session was not
         reaped, and a verdict post still owed. The roster is the pass's
-        post-reap listing when the sweep produced one."""
+        post-reap listing when the sweep produced one.
+
+        Every hold carries its round's spawn time (issue #185), so a round
+        whose review-task ref is not known yet holds only the checkouts in
+        its hub made since it spawned."""
         sessions = self._pass_roster
         if sessions is None:
             try:
@@ -8480,17 +8501,22 @@ class ReviewWatcher:
                 continue
             row = self.state.find_spawn_by_session(ses.name)
             if row is not None:
-                guard.hold(str(row["repo"]), int(row["number"]), row["task_ref"])
+                guard.hold(
+                    str(row["repo"]), int(row["number"]), row["task_ref"],
+                    since=row["spawned_at"],
+                )
             else:
                 # No ledger row (a skill-shaped `review-pr-<n>`): the name is
                 # the only evidence, and a name without a repo holds its PR
-                # number in every hub.
+                # number in every hub. The roster reports no start time, so
+                # its hold on the hub's checkouts stays unbounded (issue
+                # #185); the >=95% backstop is what reaches past it.
                 guard.hold(ref.repo, ref.number)
         for spawn_row in self.state.read_spawns(since=now - STALE_ROUND_SECONDS):
             if not self.state.is_reaped(str(spawn_row["session"])):
                 guard.hold(
                     str(spawn_row["repo"]), int(spawn_row["number"]),
-                    spawn_row["task_ref"],
+                    spawn_row["task_ref"], since=spawn_row["spawned_at"],
                 )
         for post in self.state.read_verdict_posts():
             if post["posted_at"] is None and post["abandoned_at"] is None:
@@ -8500,6 +8526,7 @@ class ReviewWatcher:
                 guard.hold(
                     str(post["repo"]), int(post["number"]),
                     spawn["task_ref"] if spawn is not None else None,
+                    since=spawn["spawned_at"] if spawn is not None else None,
                 )
         return guard
 

alissa_tools_github_revloop-0.31.25/src/main/alissa/tools/github/revloop/version

@@ -0,0 +1 @@
+0.31.25

{alissa_tools_github_revloop-0.31.23 → alissa_tools_github_revloop-0.31.25/src/main/alissa_tools_github_revloop.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alissa-tools-github-revloop
-Version: 0.31.23
+Version: 0.31.25
 Summary: ALISSA-TOOLS-GITHUB-REVLOOP
 Home-page: https://alissa.app
 Author: Fahera

alissa_tools_github_revloop-0.31.23/src/main/alissa/tools/github/revloop/version

@@ -1 +0,0 @@
-0.31.23