alissa-tools-github-revloop 0.31.18__tar.gz → 0.31.20__tar.gz

{alissa_tools_github_revloop-0.31.18/src/main/alissa_tools_github_revloop.egg-info → alissa_tools_github_revloop-0.31.20}/PKG-INFO

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

{alissa_tools_github_revloop-0.31.18 → alissa_tools_github_revloop-0.31.20}/src/main/alissa/tools/github/revloop/config.py

@@ -211,6 +211,7 @@ CONFIG_KEYS = (
     "janitor_grace_minutes",
     "janitor_interval_minutes",
     "janitor_warn_pct",
+    "janitor_pressure_grace_minutes",
     "alissa_endpoint",
     "dry_run",
 )
@@ -245,6 +246,8 @@ JANITOR_ENABLED_ENV = "ALISSA_REVIEW_JANITOR_ENABLED"
 JANITOR_GRACE_MINUTES_ENV = "ALISSA_REVIEW_JANITOR_GRACE_MINUTES"
 JANITOR_INTERVAL_MINUTES_ENV = "ALISSA_REVIEW_JANITOR_INTERVAL_MINUTES"
 JANITOR_WARN_PCT_ENV = "ALISSA_REVIEW_JANITOR_WARN_PCT"
+# The fifth (issue #177): the grace under disk pressure.
+JANITOR_PRESSURE_GRACE_MINUTES_ENV = "ALISSA_REVIEW_JANITOR_PRESSURE_GRACE_MINUTES"
 
 # The plan directive's two allowlists (issue #148; genloop design §6.1, D12).
 # A PR gets the PLAN directive only when all four signals hold, and two of
@@ -453,6 +456,10 @@ def env_janitor(environ: "Mapping[str, str] | None" = None) -> "dict[str, Any]":
         ("janitor_grace_minutes", JANITOR_GRACE_MINUTES_ENV, "number of minutes"),
         ("janitor_interval_minutes", JANITOR_INTERVAL_MINUTES_ENV, "number of minutes"),
         ("janitor_warn_pct", JANITOR_WARN_PCT_ENV, "percentage"),
+        (
+            "janitor_pressure_grace_minutes", JANITOR_PRESSURE_GRACE_MINUTES_ENV,
+            "number of minutes",
+        ),
     ):
         value = _env_int(name, what, environ)
         if value is not None:
@@ -731,6 +738,14 @@ DEFAULT_JANITOR_INTERVAL_MINUTES = 10
 # WARNING. Devloop's threshold; 0 = never warn.
 DEFAULT_JANITOR_WARN_PCT = 80
 
+# The grace UNDER PRESSURE (issue #177): while the volume is at or above
+# `janitor_warn_pct`, a folder older than this many minutes is removable too,
+# oldest first, until the volume is back under the line. Two hours: past the
+# stale-round window (90 minutes), so a round that could still want its
+# folder has ended -- and the live-session / open-round guard holds the rest.
+# On 2026-10-18 a day's grace kept 119 dead checkouts on a full volume.
+DEFAULT_JANITOR_PRESSURE_GRACE_MINUTES = 120
+
 
 # -- the product-stability guard (issue #105) ---------------------------------
 #
@@ -1057,11 +1072,14 @@ class Config:
     # `janitor_grace_minutes` that no live session or open ledger round holds,
     # prune `.source`'s worktree records, and WARN once when the workspace
     # volume is at or above `janitor_warn_pct` (0 = never). ON by default: the
-    # disk it reclaims fills a shared volume within weeks without it.
+    # disk it reclaims fills a shared volume within weeks without it. At or
+    # above that line the grace drops to `janitor_pressure_grace_minutes`
+    # (issue #177), oldest first, until the volume is back under it.
     janitor_enabled: bool = True
     janitor_grace_minutes: int = DEFAULT_JANITOR_GRACE_MINUTES
     janitor_interval_minutes: int = DEFAULT_JANITOR_INTERVAL_MINUTES
     janitor_warn_pct: int = DEFAULT_JANITOR_WARN_PCT
+    janitor_pressure_grace_minutes: int = DEFAULT_JANITOR_PRESSURE_GRACE_MINUTES
 
     dry_run: bool = False
 
@@ -1560,6 +1578,15 @@ class Config:
                 f"janitor_warn_pct must be between 0 and 100 (0 = never warn), "
                 f"got {janitor_warn}"
             )
+        janitor_pressure_grace = int(raw.get(
+            "janitor_pressure_grace_minutes", cls.janitor_pressure_grace_minutes
+        ))
+        if janitor_pressure_grace < 1:
+            # Same floor as the normal grace, for the same reason.
+            raise ValueError(
+                f"janitor_pressure_grace_minutes must be >= 1, "
+                f"got {janitor_pressure_grace}"
+            )
 
         state_path = raw.get("state_path")
         return cls(
@@ -1604,6 +1631,7 @@ class Config:
             janitor_grace_minutes=janitor_grace,
             janitor_interval_minutes=janitor_interval,
             janitor_warn_pct=janitor_warn,
+            janitor_pressure_grace_minutes=janitor_pressure_grace,
             alissa_endpoint=endpoint,
             dry_run=bool(raw.get("dry_run", False)),
         )

{alissa_tools_github_revloop-0.31.18 → alissa_tools_github_revloop-0.31.20}/src/main/alissa/tools/github/revloop/janitor.py

@@ -11,7 +11,12 @@ and nothing removed either before this module:
   shared volume held 169 of them, 27 GB of a 46 GB volume.
 * `<hub>/REVIEW-<task ref>/` -- the throwaway checkout the review skill lets a
   reviewer create beside `main/` when it must run code (`trust.
-  review_checkout_name`). Another ~5 GB on the same day.
+  review_checkout_name`). Another ~5 GB on the same day. A reviewer whose
+  shell sits in its spawn cwd makes it INSIDE `main/` instead
+  (`<hub>/main/REVIEW-<task ref>/`): on 2026-10-18 121 of those, 0.6-1.2 GB
+  apiece with their own `node_modules`, filled the fleet's 46 GB volume to
+  100% while the janitor looked only beside `main/` (issue #177). Both
+  places are swept.
 
 Modeled on devloop's janitor.py, but smaller, because what it removes is
 smaller in kind: a reviewer's folders hold no unpushed work by construction
@@ -26,15 +31,26 @@ Three properties everything here is written around:
 
 * **Only the two shapes, only where they are made.** A scratch folder is a
   `.review-scratch-*` DIRECT child of `<hub>/main`, a review checkout a
-  `REVIEW-*` direct child of the hub; symlinks are never candidates. Nothing
-  else under a hub -- `main/`'s own files, `.source`, a task worktree, an
-  operator's clone -- is ever considered, so it is never at risk.
+  `REVIEW-*` direct child of the hub or of `<hub>/main`; symlinks are never
+  candidates. Nothing else under a hub -- `main/`'s own files and its
+  `node_modules`, `.source`, a task worktree, an operator's clone -- is ever
+  considered, so it is never at risk. A review checkout that is a linked git
+  worktree is removed with `git worktree remove --force`, so its record goes
+  with it; anything else with `shutil.rmtree`.
 * **Old AND unheld.** Age is the newest mtime of the folder and its direct
   children (so a round that writes a fresh file into an old folder renews it),
   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.
 * **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.
+
+Two more bound it (issue #175). The layout is fixed: hubs are found at
+`<root>/<repo>` with the session cwd at `<hub>/main`, so under any other
+`hub_template` (`layout_supported` says no) the caller sweeps nothing rather
+than mis-key the hold. And one sweep removes at most `MAX_REMOVALS` folders in
+`MAX_SWEEP_SECONDS`; the rest wait for the next interval (`deferred`).
 """
 
 from __future__ import annotations
@@ -43,6 +59,7 @@ import logging
 import os
 import re
 import shutil
+import time
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Callable, Iterable
@@ -70,6 +87,23 @@ SOURCE_DIR = ".source"
 KIND_SCRATCH = "scratch"
 KIND_REVIEW = "review-checkout"
 
+# One sweep's bound (issue #175): at most this many removals, and no removal
+# started past this many seconds into the sweep. It runs synchronously at the
+# end of a poll pass, so a large backlog is drained over several intervals
+# instead of stalling one pass for minutes.
+MAX_REMOVALS = 25
+MAX_SWEEP_SECONDS = 120.0
+
+# The one hub layout the janitor knows: `discover_hubs` reads the root's
+# direct children and `scan_hub` reads `<hub>/main`. Named in the caller's
+# refusal WARNING.
+SUPPORTED_TEMPLATE = "{root}/{repo}/main"
+
+# What `layout_supported` probes a template with: two owners that differ, so a
+# template that puts the owner in the path resolves to two different places.
+_PROBE_OWNERS = ("janitor-probe-owner-a", "janitor-probe-owner-b")
+_PROBE_REPO = "janitor-probe-repo"
+
 Runner = Callable[..., str]
 
 
@@ -158,11 +192,44 @@ class SweepResult:
     fresh: int = 0
     failed: "list[tuple[Path, str]]" = field(default_factory=list)
     pruned: int = 0
+    # Unheld stale candidates the per-sweep bound left for the next interval.
+    deferred: int = 0
+    # Whether the volume was at or above its warn line when the sweep began,
+    # so the pressure grace applied (issue #177), and how many removals (or,
+    # in a dry run, would-be removals) only that shorter grace allowed.
+    pressure: bool = False
+    pressure_removed: int = 0
 
     @property
     def freed(self) -> int:
         return sum(size for _, size in self.removed)
 
+    @property
+    def left(self) -> int:
+        """Candidate folders still on disk after a live sweep: inside the
+        grace, held, deferred, or failed."""
+        return self.fresh + len(self.held) + self.deferred + len(self.failed)
+
+
+def layout_supported(
+    hub_for: "Callable[[str, str], Path]", workspace_root: "Path | str"
+) -> bool:
+    """Whether `hub_for` (`Config.hub_for`) places every hub at
+    `<root>/<repo>` with the session cwd at `<hub>/main` -- the one layout
+    `discover_hubs` and `scan_hub` read, and the one in which a hub's
+    directory name is the repo slug the `Guard` keys on.
+
+    Probed with two distinct owners and one repo name: both must resolve to
+    `workspace_root / repo / "main"`. A template that cannot be formatted is
+    unsupported. Pure: nothing is read off the disk."""
+    expected = Path(os.fspath(workspace_root)).expanduser() / _PROBE_REPO / "main"
+    try:
+        return all(
+            Path(hub_for(owner, _PROBE_REPO)) == expected for owner in _PROBE_OWNERS
+        )
+    except (KeyError, IndexError, ValueError, AttributeError, TypeError):
+        return False
+
 
 def discover_hubs(workspace_root: "Path | str") -> "list[Path]":
     """Every worktree hub directly under the workspace root: a non-symlink
@@ -209,8 +276,9 @@ def _dirs(parent: Path, prefix: str) -> "list[Path]":
 
 
 def scan_hub(hub: Path) -> "list[Candidate]":
-    """The janitor's candidates in one hub: `main/.review-scratch-*` and
-    `REVIEW-*`, direct children only, never a walk."""
+    """The janitor's candidates in one hub: `main/.review-scratch-*`,
+    `REVIEW-*` and `main/REVIEW-*` (issue #177), direct children only, never
+    a walk."""
     found = []
     for path in _dirs(hub / "main", SCRATCH_PREFIX):
         match = _SCRATCH_PR_RE.match(path.name[len(SCRATCH_PREFIX):])
@@ -218,7 +286,9 @@ def scan_hub(hub: Path) -> "list[Candidate]":
             path=path, hub=hub, kind=KIND_SCRATCH,
             number=int(match["number"]) if match else None,
         ))
-    for path in _dirs(hub, REVIEW_CHECKOUT_PREFIX):
+    for path in _dirs(hub, REVIEW_CHECKOUT_PREFIX) + _dirs(
+        hub / "main", REVIEW_CHECKOUT_PREFIX
+    ):
         found.append(Candidate(
             path=path, hub=hub, kind=KIND_REVIEW,
             task_ref=path.name[len(REVIEW_CHECKOUT_PREFIX):],
@@ -296,17 +366,53 @@ def disk_used_pct(path: "Path | str") -> "float | None":
 
 def _contained(candidate: Candidate) -> bool:
     """The containment rule, re-asserted at the removal site: the folder is
-    a direct child of its hub (review checkout) or of `<hub>/main` (scratch),
-    both resolved, and not a symlink."""
-    parent = candidate.hub / "main" if candidate.kind == KIND_SCRATCH else candidate.hub
+    a direct child of `<hub>/main` (scratch) or of its hub or `<hub>/main`
+    (review checkout), all resolved, and not a symlink."""
+    main = candidate.hub / "main"
+    parents = (main,) if candidate.kind == KIND_SCRATCH else (candidate.hub, main)
     try:
         if candidate.path.is_symlink():
             return False
-        return candidate.path.resolve().parent == parent.resolve()
+        parent = candidate.path.resolve().parent
+        return any(parent == allowed.resolve() for allowed in parents)
     except OSError:
         return False
 
 
+def _is_linked_worktree(path: Path) -> bool:
+    """Whether `path` is a linked git worktree: its `.git` is a FILE (the
+    `gitdir:` pointer `git worktree add` writes), not a directory."""
+    try:
+        git = path / ".git"
+        return git.is_file() and not git.is_symlink()
+    except OSError:
+        return False
+
+
+def _remove(candidate: Candidate, runner: Runner) -> None:
+    """Remove one contained candidate. A review checkout that is a linked
+    worktree goes through `git worktree remove --force` in its hub's
+    `.source` (issue #177), so the record and the folder go together; when
+    git refuses (a worktree of another repository, a locked one) or the
+    folder is anything else, `shutil.rmtree` removes it and the hub's prune
+    drops whatever record is left. Raises OSError when the folder stays."""
+    if candidate.kind == KIND_REVIEW and _is_linked_worktree(candidate.path):
+        try:
+            runner(
+                ["git", "-C", str(candidate.hub / SOURCE_DIR), "worktree",
+                 "remove", "--force", str(candidate.path)],
+                timeout=120,
+            )
+        except (CommandError, OSError) as exc:
+            log.debug(
+                "janitor: git worktree remove refused %s (%s) — removing the "
+                "folder instead", candidate.path, exc,
+            )
+        if not os.path.lexists(candidate.path):
+            return
+    shutil.rmtree(candidate.path)
+
+
 def prune_worktrees(hub: Path, runner: Runner = run) -> None:
     """`git worktree prune` in the hub's `.source`, as this process's user
     (the seat's own): drops the records of worktrees whose folders are gone
@@ -323,48 +429,100 @@ def sweep(
     now: float,
     dry_run: bool = False,
     runner: Runner = run,
+    max_removals: int = MAX_REMOVALS,
+    max_seconds: float = MAX_SWEEP_SECONDS,
+    clock: "Callable[[], float]" = time.monotonic,
+    pressure_grace_seconds: "float | None" = None,
+    under_pressure: "Callable[[], bool] | None" = None,
 ) -> SweepResult:
     """Remove every candidate under `hubs` older than `grace_seconds` that
-    `guard` does not hold, then prune each hub's worktree records.
+    `guard` does not hold, oldest first, then prune each hub's worktree
+    records.
+
+    Under pressure (issue #177): when `under_pressure` is given and answers
+    True at the start of the sweep, a candidate younger than `grace_seconds`
+    but older than `pressure_grace_seconds` is removable too -- but only
+    while `under_pressure()`, asked again before each such removal, still
+    answers True. Candidates are taken oldest first across every hub, so the
+    oldest go first and the sweep stops shrinking the grace the moment the
+    volume is back under its line. A held folder is never removed.
+
+    Bounded (issue #175): before each removal, a sweep that has already
+    removed `max_removals` folders, or has run `max_seconds` by `clock`,
+    stops removing. Every unheld stale candidate past that point is counted
+    in `deferred` and left for the next interval; every hub is still scanned
+    and pruned.
 
     Dry-run removes nothing and prunes nothing: it logs each folder it WOULD
-    remove (with its size) and reports them in `would_remove`."""
+    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)."""
     result = SweepResult()
-    for hub in hubs:
+    started = clock()
+    bounded = False
+    hub_list = list(hubs)
+    shrunk = grace_seconds
+    if pressure_grace_seconds is not None and under_pressure is not None:
+        result.pressure = under_pressure()
+        if result.pressure:
+            shrunk = min(grace_seconds, pressure_grace_seconds)
+    aged: "list[tuple[float, Candidate]]" = []
+    for hub in hub_list:
         result.hubs += 1
         for candidate in scan_hub(hub):
             mtime = newest_mtime(candidate.path)
             if mtime is None:
                 continue  # vanished mid-sweep
-            if now - mtime < grace_seconds:
-                result.fresh += 1
-                continue
-            why = guard.holds(candidate)
-            if why is not None:
-                log.debug("janitor: keeping %s — %s", candidate.path, why)
-                result.held.append((candidate.path, why))
-                continue
-            if not _contained(candidate):
-                result.failed.append((candidate.path, "not contained in its hub"))
-                continue
-            size = dir_bytes(candidate.path)
-            if dry_run:
-                log.info(
-                    "[dry-run] janitor would remove %s (%s, %.1f h old)",
-                    candidate.path, human(size), (now - mtime) / 3600,
-                )
-                result.would_remove.append((candidate.path, size))
-                continue
-            try:
-                shutil.rmtree(candidate.path)
-            except OSError as exc:
-                log.warning("janitor: could not remove %s (%s)", candidate.path, exc)
-                result.failed.append((candidate.path, str(exc)))
-                continue
-            log.debug("janitor: removed %s (%s)", candidate.path, human(size))
-            result.removed.append((candidate.path, size))
+            aged.append((mtime, candidate))
+    aged.sort(key=lambda pair: (pair[0], str(pair[1].path)))
+    for mtime, candidate in aged:
+        age = now - mtime
+        if age < shrunk:
+            result.fresh += 1
+            continue
+        why = guard.holds(candidate)
+        if why is not None:
+            log.debug("janitor: keeping %s — %s", candidate.path, why)
+            result.held.append((candidate.path, why))
+            continue
+        early = age < grace_seconds
+        if early and not dry_run and not (under_pressure and under_pressure()):
+            # Back under the line: the normal grace holds again.
+            result.fresh += 1
+            continue
+        if not bounded:
+            taken = len(result.would_remove if dry_run else result.removed)
+            bounded = taken >= max_removals or clock() - started >= max_seconds
+        if bounded:
+            result.deferred += 1
+            continue
+        if not _contained(candidate):
+            result.failed.append((candidate.path, "not contained in its hub"))
+            continue
+        size = dir_bytes(candidate.path)
         if dry_run:
+            log.info(
+                "[dry-run] janitor would remove %s (%s, %.1f h old%s)",
+                candidate.path, human(size), age / 3600,
+                ", under pressure" if early else "",
+            )
+            result.would_remove.append((candidate.path, size))
+            if early:
+                result.pressure_removed += 1
+            continue
+        try:
+            _remove(candidate, runner)
+        except OSError as exc:
+            log.warning("janitor: could not remove %s (%s)", candidate.path, exc)
+            result.failed.append((candidate.path, str(exc)))
             continue
+        log.debug("janitor: removed %s (%s)", candidate.path, human(size))
+        result.removed.append((candidate.path, size))
+        if early:
+            result.pressure_removed += 1
+    if dry_run:
+        return result
+    for hub in hub_list:
         try:
             prune_worktrees(hub, runner)
             result.pruned += 1

{alissa_tools_github_revloop-0.31.18 → alissa_tools_github_revloop-0.31.20}/src/main/alissa/tools/github/revloop/loop.py

@@ -109,6 +109,7 @@ from .loop_events import (
     round_verdict_prefix,
     ROUND_VERDICT_PREFIX,
     task_number_of,
+    volume_pressure_kind,
 )
 from .proc import CommandError
 from .state import State
@@ -1123,14 +1124,23 @@ _SHELL_RULE = (
 # checkout the review skill lets a reviewer make, and nothing a reviewer
 # writes there needs deleting. The daemon's workspace janitor (janitor.py,
 # issue #167) reclaims it: every `janitor_interval_minutes` it removes each
-# hub's `main/.review-scratch-*` and `REVIEW-*` folders older than
-# `janitor_grace_minutes` that no live session or open round holds, then
-# prunes `.source`'s worktree records. The rule's text does not name the
-# janitor: the reviewer needs only to know it must not delete, and the plan
-# directives that embed this rule are pinned by digest.
+# hub's `main/.review-scratch-*`, `REVIEW-*` and `main/REVIEW-*` folders older
+# than `janitor_grace_minutes` (`janitor_pressure_grace_minutes` while the
+# volume is at or above `janitor_warn_pct`) that no live session or open round
+# holds, then prunes `.source`'s worktree records. The rule's text does not
+# name the janitor: the reviewer needs only to know it must not delete -- and,
+# since issue #177, WHERE its checkout goes. A reviewer starts in `<hub>/main`,
+# so a bare `git worktree add REVIEW-<task>` lands INSIDE `main/`; 121 of
+# those filled the fleet's volume on 2026-10-18. The janitor reaps both
+# places, and the rule names the one beside `main/` (`../REVIEW-<task>`),
+# which is where the trust seeding, the prompt policy and the reaper look.
+# The plan directives that embed this rule are pinned by digest (re-pinned
+# for issue #177 in test_directives.py).
 _REVIEWER_RULE = (
     "You never push and never delete: a reviewer that needs scratch files "
-    "writes them under its own checkout and leaves them. "
+    "writes them under its own checkout and leaves them. A checkout you must "
+    "make to run code goes BESIDE `main/`, never inside it: from your start "
+    "directory, `git worktree add ../REVIEW-<review task ref> <the PR head>`. "
 )
 
 ROUND_1_DIRECTIVE = (
@@ -2619,6 +2629,15 @@ class ReviewWatcher:
         # When the workspace janitor last swept (monotonic), or None before the
         # first sweep -- which therefore runs at the end of the first pass.
         self._janitor_last: "float | None" = None
+        # Whether the janitor has said, once for this process, that it will
+        # not sweep under this `hub_template` (issue #175).
+        self._janitor_layout_warned = False
+        # When the open volume-pressure episode began (wall clock), or None
+        # while the volume is under `janitor_warn_pct` (issue #177): one
+        # `janitor.volume_pressure` event per episode, and a reading back
+        # 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
         # 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
@@ -7946,8 +7965,9 @@ class ReviewWatcher:
         One INFO line per sweep (folders removed and bytes freed, or what a
         dry run WOULD remove), and one WARNING when the workspace volume is
         at or above `janitor_warn_pct`. The disk read runs even when the
-        roster cannot be listed and the removal half is skipped: a full
-        volume is worth saying whatever else went wrong."""
+        roster cannot be listed, or the hub layout is not the one the janitor
+        reads, and the removal half is skipped: a full volume is worth saying
+        whatever else went wrong."""
         if not self.config.janitor_enabled:
             return None
         mono = time.monotonic()
@@ -7956,8 +7976,10 @@ class ReviewWatcher:
             return None
         self._janitor_last = mono
         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
         try:
-            result = self._sweep_workspace(stamp)
+            result = self._sweep_workspace(stamp, pressed=pressed)
         except Exception as exc:
             log.warning(
                 "janitor: sweep failed unexpectedly (%s: %s) — nothing more is "
@@ -7965,10 +7987,43 @@ class ReviewWatcher:
                 type(exc).__name__, exc, exc_info=True,
             )
             result = None
-        self._warn_disk()
+        self._note_volume(pct, result, stamp)
         return result
 
-    def _sweep_workspace(self, now: float) -> "janitor_mod.SweepResult | None":
+    def _volume_used_pct(self) -> "float | None":
+        """The workspace volume's used percentage, or None when
+        `janitor_warn_pct` is 0 (never warn, never pressed) or the volume
+        cannot be read."""
+        if not self.config.janitor_warn_pct:
+            return None
+        return janitor_mod.disk_used_pct(self.config.workspace_root)
+
+    def _volume_pressed(self) -> bool:
+        """Whether the workspace volume is, right now, at or above
+        `janitor_warn_pct` -- asked by the sweep before each removal only
+        the pressure grace allows (issue #177)."""
+        pct = self._volume_used_pct()
+        return pct is not None and pct >= self.config.janitor_warn_pct
+
+    def _sweep_workspace(
+        self, now: float, *, pressed: bool = False
+    ) -> "janitor_mod.SweepResult | None":
+        if not janitor_mod.layout_supported(
+            self.config.hub_for, self.config.workspace_root
+        ):
+            # Fail closed (issue #175): under another layout the hubs on disk
+            # are not keyed by the slug the Guard holds (or are not found at
+            # all), so a sweep could remove a live round's folders. Nothing is
+            # removed or pruned; said once per process, not once per interval.
+            if not self._janitor_layout_warned:
+                self._janitor_layout_warned = True
+                log.warning(
+                    "janitor: hub_template %r is not supported — the janitor "
+                    "supports only %s, so it removes and prunes nothing in "
+                    "this process",
+                    self.config.hub_template, janitor_mod.SUPPORTED_TEMPLATE,
+                )
+            return None
         guard = self._janitor_guard(now)
         if guard is None:
             log.warning(
@@ -7982,21 +8037,37 @@ class ReviewWatcher:
             grace_seconds=self.config.janitor_grace_minutes * 60,
             now=now,
             dry_run=self.config.dry_run,
+            pressure_grace_seconds=(
+                self.config.janitor_pressure_grace_minutes * 60 if pressed else None
+            ),
+            under_pressure=self._volume_pressed if pressed else None,
         )
+        if result.pressure:
+            log.info(
+                "janitor: volume at or above %d%% — the grace dropped to %d "
+                "minute(s) this sweep; %d folder(s) %s only under it",
+                self.config.janitor_warn_pct,
+                self.config.janitor_pressure_grace_minutes,
+                result.pressure_removed,
+                "would go" if self.config.dry_run else "went",
+            )
         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",
+                "hub(s); %d held by a live round, %d inside the grace, %d "
+                "deferred to the next interval",
                 len(result.would_remove),
                 janitor_mod.human(sum(size for _, size in result.would_remove)),
-                result.hubs, len(result.held), result.fresh,
+                result.hubs, len(result.held), result.fresh, result.deferred,
             )
         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 held by a live round, %d inside the grace, %d failed, %d "
+                "deferred to the next interval",
                 len(result.removed), janitor_mod.human(result.freed),
                 result.hubs, len(result.held), result.fresh, len(result.failed),
+                result.deferred,
             )
         return result
 
@@ -8047,18 +8118,62 @@ class ReviewWatcher:
                 )
         return guard
 
-    def _warn_disk(self) -> None:
+    def _note_volume(
+        self,
+        pct: "float | None",
+        result: "janitor_mod.SweepResult | None",
+        stamp: float,
+    ) -> None:
         """One WARNING when the workspace volume is at or above
-        `janitor_warn_pct` (0 = never)."""
+        `janitor_warn_pct` (0 = never), and the pressure EPISODE (issue
+        #177): the first sweep at or above the line records ONE
+        `volume-pressure:` ping -- what the sweep freed and left folded in --
+        which loop_events derives into one `janitor.volume_pressure` event;
+        the first reading back under the line (after this sweep, or at a
+        later one) closes the episode. Dry-run records nothing: it shares the
+        ledger with production, so it only says what it would record. Never
+        raises."""
         threshold = self.config.janitor_warn_pct
-        if not threshold:
+        if not threshold or pct is None:
             return
-        pct = janitor_mod.disk_used_pct(self.config.workspace_root)
-        if pct is not None and pct >= threshold:
-            log.warning(
-                "janitor: workspace volume %s is %.1f%% used (warn at %d%%)",
-                self.config.workspace_root, pct, threshold,
+        if pct < threshold:
+            self._close_pressure_episode(pct)
+            return
+        log.warning(
+            "janitor: workspace volume %s is %.1f%% used (warn at %d%%)",
+            self.config.workspace_root, pct, threshold,
+        )
+        if self._janitor_pressure_since is None:
+            kind = volume_pressure_kind(
+                stamp, pct, threshold,
+                result.freed if result is not None else 0,
+                result.left if result is not None else None,
             )
+            if self.config.dry_run:
+                log.info("[dry-run] janitor: would record %s", kind)
+                self._janitor_pressure_since = stamp
+            else:
+                try:
+                    self.state.record_ping("", 0, kind)
+                    self._janitor_pressure_since = stamp
+                except Exception as exc:
+                    # The episode stays unopened, so the next sweep retries.
+                    log.warning(
+                        "janitor: could not record the volume-pressure episode "
+                        "(%s: %s)", type(exc).__name__, exc,
+                    )
+        after = self._volume_used_pct()
+        if after is not None and after < threshold:
+            self._close_pressure_episode(after)
+
+    def _close_pressure_episode(self, pct: float) -> None:
+        if self._janitor_pressure_since is None:
+            return
+        self._janitor_pressure_since = None
+        log.info(
+            "janitor: volume-pressure episode closed — the workspace is %.1f%% "
+            "used, under the %d%% line", pct, self.config.janitor_warn_pct,
+        )
 
     def _vitals_config(self) -> dict:
         """The snapshot's `config` block (issue #159), read off what this

{alissa_tools_github_revloop-0.31.18 → alissa_tools_github_revloop-0.31.20}/src/main/alissa/tools/github/revloop/loop_events.py

@@ -102,6 +102,17 @@ loop's `pr_origin_task_ref`). Both are read once, at spawn, onto the round's
 PR's newest spawn row (a pre-spawn `checks.held`, a `round.capped` no spawn
 explains). Each field is omitted when unknown -- never null -- so a PR whose
 body names neither emits the same payload as before, byte for byte.
+
+``janitor.volume_pressure`` (issue #177) is the workspace volume at or above
+`janitor_warn_pct` -- until then a WARNING line nobody saw while 119 dead
+review checkouts filled a 46 GB volume. Again a ledger ROW: the watcher
+records ONE `volume-pressure:` ping per pressure EPISODE (the first sweep at
+or above the line opens it; the first reading back under the line closes it),
+under the anchor-less `('', 0)` an `auth-rejected:` row without a PR uses,
+with what that sweep saw folded into the kind: `data: { usedPct, warnPct,
+freedBytes, foldersLeft }` (`foldersLeft` null when the sweep did not run).
+Keyed on the episode's start second, so a backfill re-derives the same one
+event. No repo and no PR: the volume is the seat's, not a PR's.
 """
 
 from __future__ import annotations
@@ -205,6 +216,33 @@ _AUTH_REJECTED_RE = re.compile(
     r"(?P<matched>[a-z0-9_]+):(?P<env>[A-Z_]*):(?P<suffix>.{0,4})$"
 )
 
+# The `janitor.volume_pressure` row (issue #177): one per pressure EPISODE,
+# `volume-pressure:<started>:<usedPct>:<warnPct>:<freedBytes>:<foldersLeft>`.
+# `started` (epoch seconds) is the episode's identity and its dedupe key;
+# `foldersLeft` is empty when the sweep did not run (roster unlistable,
+# unsupported layout).
+VOLUME_PRESSURE_PREFIX = "volume-pressure:"
+VOLUME_PRESSURE_EVENT = "janitor.volume_pressure"
+_VOLUME_PRESSURE_RE = re.compile(
+    r"^volume-pressure:(?P<started>\d+):(?P<pct>\d+(?:\.\d+)?):(?P<warn>\d+):"
+    r"(?P<freed>\d+):(?P<left>\d*)$"
+)
+
+
+def volume_pressure_kind(
+    started: "int | float",
+    used_pct: float,
+    warn_pct: int,
+    freed: int,
+    left: "int | None",
+) -> str:
+    """The ledger kind of ONE pressure episode (see VOLUME_PRESSURE_PREFIX)."""
+    return (
+        f"{VOLUME_PRESSURE_PREFIX}{int(started)}:{round(float(used_pct), 1)}:"
+        f"{int(warn_pct)}:{max(0, int(freed))}:{'' if left is None else int(left)}"
+    )
+
+
 # The credential variables a container may carry, in Claude Code's own
 # precedence order (design §1.4: `ANTHROPIC_API_KEY` outranks
 # `CLAUDE_CODE_OAUTH_TOKEN`; both outrank the persisted login). Read by NAME
@@ -578,7 +616,8 @@ def _ping_events(
     rows: "list[dict]", notices: "dict[tuple[str, int], dict]"
 ) -> "list[tuple[int, dict]]":
     """`stalled`, `stability.hold`, `checks.held`, the prompt responder's
-    two families and `auth.rejected` out of the ping ledger.
+    two families, `auth.rejected` and `janitor.volume_pressure` out of the
+    ping ledger.
 
     `kind` is free-form text carrying the episode identity, so it is parsed
     by prefix; kinds this module does not report (`activity-deferred:`,
@@ -693,6 +732,25 @@ def _ping_events(
                     ),
                 },
             ))
+        elif kind.startswith(VOLUME_PRESSURE_PREFIX):
+            match = _VOLUME_PRESSURE_RE.match(kind)
+            if match is None:
+                continue
+            pct, warn = float(match.group("pct")), int(match.group("warn"))
+            out.append(_event(
+                VOLUME_PRESSURE_EVENT,
+                at,
+                f"{SEAT}:{VOLUME_PRESSURE_EVENT}:{match.group('started')}",
+                reason=f"workspace volume {pct:.1f}% used (warn at {warn}%)",
+                data={
+                    "usedPct": pct,
+                    "warnPct": warn,
+                    "freedBytes": int(match.group("freed")),
+                    "foldersLeft": (
+                        int(match.group("left")) if match.group("left") else None
+                    ),
+                },
+            ))
         elif kind.startswith(PROMPT_PREFIX):
             match = _PROMPT_RE.match(kind)
             if match is None:

{alissa_tools_github_revloop-0.31.18 → alissa_tools_github_revloop-0.31.20}/src/main/alissa/tools/github/revloop/prompts.py

@@ -16,8 +16,11 @@ developer's `<hub>/TASK-*` worktree; here `SessionContext.worktree` is the
 reviewer's own REVIEW CHECKOUT -- the throwaway `<hub>/REVIEW-<task>`
 worktree the alissa-code-review skill lets a reviewer that must run code
 make beside `main/`. A `dangerous_rm` target inside it is `accept`; anything
-else -- `main/`, the hub, another round's checkout, `/tmp`, an unresolvable
-target, a session whose checkout the loop could not name -- is `decline`.
+else -- `main/` (a `main/REVIEW-*` checkout included: the reviewer rule
+places the checkout beside `main/`, and the janitor, not the reviewer, reaps
+one made inside it -- issue #177), the hub, another round's checkout, `/tmp`,
+an unresolvable target, a session whose checkout the loop could not name --
+is `decline`.
 The reason strings are devloop's verbatim ("target inside worktree", "lane
 worktree unknown") so the sentinel reads one vocabulary across the seats.
 

{alissa_tools_github_revloop-0.31.18 → alissa_tools_github_revloop-0.31.20}/src/main/alissa/tools/github/revloop/trust.py

@@ -90,6 +90,7 @@ TRUST_KEY = "hasTrustDialogAccepted"
 # The throwaway worktree the alissa-code-review skill tells a reviewer to
 # create beside `main/` when it must run code: `REVIEW-TASK-<id>`. Listed by
 # prefix so a checkout already on disk is trusted whatever task it was for.
+# The janitor also reaps one made inside `main/` (issue #177).
 REVIEW_CHECKOUT_PREFIX = "REVIEW-"
 
 # What a pane PARKED on one of Claude Code's first-run gates shows -- and
@@ -195,7 +196,15 @@ def hub_root(cwd: "Path | str") -> Path:
 def review_checkout_name(task_ref: "str | None") -> "str | None":
     """The throwaway worktree the review skill creates for a round that must
     run code: `REVIEW-<task ref>` (`REVIEW-TASK-<id>`), or None without a
-    review task to name it after."""
+    review task to name it after.
+
+    Its place is BESIDE `main/` -- `<hub>/REVIEW-<task ref>`, which the
+    reviewer rule in loop.py tells the session to make with `git worktree
+    add ../REVIEW-<task ref>` from its `<hub>/main` start directory, and
+    where this module seeds trust. One made INSIDE `main/` by a bare
+    `git worktree add REVIEW-<task ref>` (issue #177: 121 of them on
+    2026-10-18) is not trusted or policed as the round's checkout, but the
+    janitor reaps it exactly like one beside `main/`."""
     ref = (task_ref or "").strip()
     return f"{REVIEW_CHECKOUT_PREFIX}{ref}" if ref else None
 

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

@@ -0,0 +1 @@
+0.31.20

{alissa_tools_github_revloop-0.31.18 → alissa_tools_github_revloop-0.31.20/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.18
+Version: 0.31.20
 Summary: ALISSA-TOOLS-GITHUB-REVLOOP
 Home-page: https://alissa.app
 Author: Fahera

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

@@ -1 +0,0 @@
-0.31.18