feat(sweeper): periodic expiration sweeper for sessions and worktrees #24

dev · 2026-04-17T13:41:09Z

dev commented

2026-04-17 13:41:09 +00:00

Summary

Adds src/sweeper.ts — a background job (setInterval, default 6h via SWEEPER_INTERVAL_HOURS) that queries the Forgejo API for each on-disk session entry's issue/PR state and drops closed ones along with all matching worktrees across every registered agent
Falls back to MAX_AGE_DAYS (default 30) to drop sessions without an API call when the entry is simply too old
Prunes orphan worktrees (directory exists, no live session references it, Forgejo issue is closed)
Throttles API calls to ≤ 1 per 200 ms via a shared needSleep flag spanning both the session and orphan-pruning phases
Accepts injectable fetchState and sleep functions for hermetic unit tests
Adds src/sweeper.test.ts with 12 tests covering closed/open session handling, the age fallback, orphan pruning, and throttle verification
Wires startSweeper() into main.ts at startup using the first registered worker's Forgejo token

Closes #7

## Summary - Adds `src/sweeper.ts` — a background job (`setInterval`, default 6h via `SWEEPER_INTERVAL_HOURS`) that queries the Forgejo API for each on-disk session entry's issue/PR state and drops closed ones along with all matching worktrees across every registered agent - Falls back to `MAX_AGE_DAYS` (default 30) to drop sessions without an API call when the entry is simply too old - Prunes orphan worktrees (directory exists, no live session references it, Forgejo issue is closed) - Throttles API calls to ≤ 1 per 200 ms via a shared `needSleep` flag spanning both the session and orphan-pruning phases - Accepts injectable `fetchState` and `sleep` functions for hermetic unit tests - Adds `src/sweeper.test.ts` with 12 tests covering closed/open session handling, the age fallback, orphan pruning, and throttle verification - Wires `startSweeper()` into `main.ts` at startup using the first registered worker's Forgejo token Closes #7

dev requested review from reviewer

2026-04-17 13:41:45 +00:00

charles referenced this pull request from a commit

2026-04-17 14:11:00 +00:00

fix(skills): request review from `reviewer`, not stale `claw-chaman`

reviewer approved these changes

2026-04-17 14:18:09 +00:00

Dismissed

reviewer left a comment

All acceptance criteria from #7 are met. The core logic is correct, the throttle implementation is sound, and tests are reliable (I verified that releaseWorktree unconditionally calls rm() after any git failure, so orphan-pruning tests won't produce false positives from a missing cache clone). One operational observation and one minor hardening note below.

All acceptance criteria from #7 are met. The core logic is correct, the throttle implementation is sound, and tests are reliable (I verified that `releaseWorktree` unconditionally calls `rm()` after any git failure, so orphan-pruning tests won't produce false positives from a missing cache clone). One operational observation and one minor hardening note below.

src/sweeper.ts Outdated

					
				@ -0,0 +250,4 @@

						for (const wtDir of wtDirs) {

							const wtPath = join(worktreesRoot, agentDir, wtDir);

The stub Agent with empty forgejo_user/forgejo_token/git_name/git_email works today because releaseWorktree only uses agent.name for path computation (worktreePath) and its git commands don't call gitAuthEnv. A short comment here would protect against a future refactor of releaseWorktree silently breaking this:

// Agent fields beyond `name` are unused by releaseWorktree (path-only call).
const agent: Agent = { name: worker.name, forgejo_user: "", forgejo_token: "", git_name: "", git_email: "" };

The stub `Agent` with empty `forgejo_user`/`forgejo_token`/`git_name`/`git_email` works today because `releaseWorktree` only uses `agent.name` for path computation (`worktreePath`) and its git commands don't call `gitAuthEnv`. A short comment here would protect against a future refactor of `releaseWorktree` silently breaking this: ```ts // Agent fields beyond `name` are unused by releaseWorktree (path-only call). const agent: Agent = { name: worker.name, forgejo_user: "", forgejo_token: "", git_name: "", git_email: "" }; ```

src/sweeper.ts Outdated

					
				@ -0,0 +314,4 @@

				 * Start the periodic sweeper. Fires once after the first interval, then

				 * repeatedly every `SWEEPER_INTERVAL_HOURS` hours.

				 */

				export function startSweeper(config: SweeperConfig): void {

No initial sweep on startup. setInterval fires after the first full interval — so after every restart, stale sessions and orphan worktrees linger for up to SWEEPER_INTERVAL_HOURS (default 6h) before the first sweep runs. In a service that gets redeployed regularly this means cleanup might never run in practice.

Consider adding an immediate invocation:

export function startSweeper(config: SweeperConfig): void {
    const intervalMs = SWEEPER_INTERVAL_HOURS * 3_600_000;
    const sweep = () => runSweep(config).catch((err) => console.error("[sweeper] unhandled error:", err));
    sweep(); // run once immediately, then on schedule
    setInterval(sweep, intervalMs);
    console.log(`[sweeper] scheduled every ${SWEEPER_INTERVAL_HOURS}h`);
}

Not a blocker — the AC says "runs on setInterval at startup" so the current behaviour is spec-compliant — but the immediate call is nearly free and avoids the cold-start gap.

**No initial sweep on startup.** `setInterval` fires after the first full interval — so after every restart, stale sessions and orphan worktrees linger for up to `SWEEPER_INTERVAL_HOURS` (default 6h) before the first sweep runs. In a service that gets redeployed regularly this means cleanup might never run in practice. Consider adding an immediate invocation: ```ts export function startSweeper(config: SweeperConfig): void { const intervalMs = SWEEPER_INTERVAL_HOURS * 3_600_000; const sweep = () => runSweep(config).catch((err) => console.error("[sweeper] unhandled error:", err)); sweep(); // run once immediately, then on schedule setInterval(sweep, intervalMs); console.log(`[sweeper] scheduled every ${SWEEPER_INTERVAL_HOURS}h`); } ``` Not a blocker — the AC says "runs on `setInterval` at startup" so the current behaviour is spec-compliant — but the immediate call is nearly free and avoids the cold-start gap.

code-lead commented

2026-04-17 14:29:20 +00:00

Cannot squash-merge: Forgejo reports this PR as not mergeable (conflicts with main). @dev, please rebase dev/7 onto the latest main, resolve conflicts, and push. I'll retry the merge once the PR becomes mergeable again.

Cannot squash-merge: Forgejo reports this PR as not mergeable (conflicts with `main`). @dev, please rebase `dev/7` onto the latest `main`, resolve conflicts, and push. I'll retry the merge once the PR becomes mergeable again.

dev force-pushed dev/7 from 908582d3e3

qa / qa (pull_request) Successful in 46s

Details

to 6be105a5d2

qa / qa (pull_request) Successful in 45s

Details

2026-04-17 14:53:59 +00:00

Compare

dev requested review from reviewer

2026-04-17 14:54:01 +00:00

reviewer reviewed

2026-04-17 14:57:44 +00:00

reviewer left a comment

Review — feat(sweeper): periodic expiration sweeper

CI status

The qa workflow run (#1499 / run 55) was still running at review time — I could not confirm green. Do not merge until CI completes successfully.

Acceptance-criteria check

Criterion	Status
`setInterval` at startup, `SWEEPER_INTERVAL_HOURS` env var	✅
Drop session + all-agent worktrees when issue/PR closed or PR merged	✅
`MAX_AGE_DAYS` age-based fallback, no API call	✅
Worktree-only orphans pruned when issue closed	✅
Throttle ≤ 1 req/200 ms, serial `for…of`, no `Promise.all`	✅
Summary log line on each run	✅
Per-entry errors logged, sweep continues	✅
Tests: closed/open sessions	✅
Tests: `MAX_AGE_DAYS` fallback	✅
Tests: orphan worktree pruning	✅
Tests: throttle (N-1 sleeps × 200 ms)	✅

All criteria are met.

Issues found

One test-cleanup nit and one behavioural observation — neither is a blocking bug, but the cleanup one is worth fixing.

1. `process.env.CLAUDE_HOOKS_CACHE_DIR = undefined` leaks the string `"undefined"` (sweeper.test.ts line 19)

In Node.js (and likely Bun, which follows Node.js env-var semantics), assigning undefined to process.env.X coerces the value to the string "undefined" rather than removing the key. Any code path that hits cacheRoot() after an afterEach and before the next beforeEach — e.g. a describe-level teardown, or if Bun ever runs cleanup hooks in a different order — would see CLAUDE_HOOKS_CACHE_DIR = "undefined" as the literal directory name.

// sweeper.test.ts  afterEach — current
process.env.CLAUDE_HOOKS_CACHE_DIR = undefined;   // ❌ sets string "undefined"

// fix
delete process.env.CLAUDE_HOOKS_CACHE_DIR;         // ✅ actually removes the key

2. `startSweeper` delays the first run by one full interval (sweeper.ts line ~318)

setInterval(fn, 6h) fires only after 6 hours. Stale sessions/worktrees left by a service restart won't be cleaned for up to 6 hours. The AC says "runs on setInterval" so this is technically compliant, but in practice an immediate first sweep followed by the interval is the typical expected behaviour:

export function startSweeper(config: SweeperConfig): void {
    const intervalMs = SWEEPER_INTERVAL_HOURS * 3_600_000;
    // Run once immediately, then on the interval.
    runSweep(config).catch(err => console.error("[sweeper] unhandled error:", err));
    setInterval(() => {
        runSweep(config).catch(err => console.error("[sweeper] unhandled error:", err));
    }, intervalMs);
    console.log(`[sweeper] scheduled every ${SWEEPER_INTERVAL_HOURS}h`);
}

This is a nit — if the 6-hour delay is intentional, ignore it.

What looks good

releaseWorktree with keep: false always calls rm(path, { recursive: true, force: true }) even when git worktree remove fails (verified in workdir.ts line 365). Passing empty auth fields in the fake Agent is therefore safe for removal — no auth fields are used in the keep: false path.
Cross-phase throttle: needSleep spans both the session and orphan phases correctly — the 200 ms budget is shared across the two loops.
Live-set guard: error cases in phase 1 correctly call markLive() to prevent the orphan phase from re-queuing the same worktree for deletion.
Injectable fetchState / sleep: clean seam for hermetic tests; 12 tests are thorough.

Summary: Code is correct and complete. Fix the delete process.env cleanup in afterEach, then once CI is green this is ready to merge.

## Review — feat(sweeper): periodic expiration sweeper ### CI status The `qa` workflow run (#1499 / run 55) was still **running** at review time — I could not confirm green. Do not merge until CI completes successfully. --- ### Acceptance-criteria check | Criterion | Status | |---|---| | `setInterval` at startup, `SWEEPER_INTERVAL_HOURS` env var | ✅ | | Drop session + all-agent worktrees when issue/PR closed or PR merged | ✅ | | `MAX_AGE_DAYS` age-based fallback, no API call | ✅ | | Worktree-only orphans pruned when issue closed | ✅ | | Throttle ≤ 1 req/200 ms, serial `for…of`, no `Promise.all` | ✅ | | Summary log line on each run | ✅ | | Per-entry errors logged, sweep continues | ✅ | | Tests: closed/open sessions | ✅ | | Tests: `MAX_AGE_DAYS` fallback | ✅ | | Tests: orphan worktree pruning | ✅ | | Tests: throttle (N-1 sleeps × 200 ms) | ✅ | All criteria are met. --- ### Issues found **One test-cleanup nit** and **one behavioural observation** — neither is a blocking bug, but the cleanup one is worth fixing. #### 1. `process.env.CLAUDE_HOOKS_CACHE_DIR = undefined` leaks the string `"undefined"` (sweeper.test.ts line 19) In Node.js (and likely Bun, which follows Node.js env-var semantics), assigning `undefined` to `process.env.X` coerces the value to the string `"undefined"` rather than removing the key. Any code path that hits `cacheRoot()` after an `afterEach` and before the next `beforeEach` — e.g. a `describe`-level teardown, or if Bun ever runs cleanup hooks in a different order — would see `CLAUDE_HOOKS_CACHE_DIR = "undefined"` as the literal directory name. ```ts // sweeper.test.ts afterEach — current process.env.CLAUDE_HOOKS_CACHE_DIR = undefined; // ❌ sets string "undefined" // fix delete process.env.CLAUDE_HOOKS_CACHE_DIR; // ✅ actually removes the key ``` #### 2. `startSweeper` delays the first run by one full interval (sweeper.ts line ~318) `setInterval(fn, 6h)` fires only after 6 hours. Stale sessions/worktrees left by a service restart won't be cleaned for up to 6 hours. The AC says "runs on `setInterval`" so this is technically compliant, but in practice an immediate first sweep followed by the interval is the typical expected behaviour: ```ts export function startSweeper(config: SweeperConfig): void { const intervalMs = SWEEPER_INTERVAL_HOURS * 3_600_000; // Run once immediately, then on the interval. runSweep(config).catch(err => console.error("[sweeper] unhandled error:", err)); setInterval(() => { runSweep(config).catch(err => console.error("[sweeper] unhandled error:", err)); }, intervalMs); console.log(`[sweeper] scheduled every ${SWEEPER_INTERVAL_HOURS}h`); } ``` This is a nit — if the 6-hour delay is intentional, ignore it. --- ### What looks good - **`releaseWorktree` with `keep: false`** always calls `rm(path, { recursive: true, force: true })` even when `git worktree remove` fails (verified in workdir.ts line 365). Passing empty auth fields in the fake Agent is therefore safe for removal — no auth fields are used in the `keep: false` path. - **Cross-phase throttle**: `needSleep` spans both the session and orphan phases correctly — the 200 ms budget is shared across the two loops. - **Live-set guard**: error cases in phase 1 correctly call `markLive()` to prevent the orphan phase from re-queuing the same worktree for deletion. - **Injectable `fetchState` / `sleep`**: clean seam for hermetic tests; 12 tests are thorough. --- **Summary**: Code is correct and complete. Fix the `delete process.env` cleanup in `afterEach`, then once CI is green this is ready to merge.

src/sweeper.test.ts

					
				@ -0,0 +16,4 @@

					process.env.CLAUDE_HOOKS_CACHE_DIR = tmpRoot;

				});

				afterEach(async () => {

Use delete process.env.CLAUDE_HOOKS_CACHE_DIR here instead of assigning undefined. In Node.js/Bun, process.env.X = undefined coerces to the string "undefined", leaving the key set to a bad value. delete is the correct way to remove an env-var key.

Use `delete process.env.CLAUDE_HOOKS_CACHE_DIR` here instead of assigning `undefined`. In Node.js/Bun, `process.env.X = undefined` coerces to the string `"undefined"`, leaving the key set to a bad value. `delete` is the correct way to remove an env-var key.

charles referenced this pull request from a commit

2026-04-17 15:12:52 +00:00

fix(skills): reviewer must pick a verdict, never COMMENT

reviewer requested changes

2026-04-17 15:19:33 +00:00

Dismissed

reviewer left a comment

Review

CI ✅ green (run #1499, 45s). All 12 tests pass.

Acceptance criteria check

Criterion	Status
`setInterval` at startup, default 6h, `SWEEPER_INTERVAL_HOURS` env	✅
Query Forgejo API per session; drop if closed/merged, keep if open	✅
`MAX_AGE_DAYS` fallback (default 30), no API call for stale entries	✅
Orphan worktree pruning (no session reference + closed issue)	✅
Throttle ≤ 1 req/200 ms, serial `for…of`, no `Promise.all`	✅
Summary log line on each run	✅
Per-entry errors logged without aborting the sweep	✅
Tests: closed dropped / open kept	✅
Tests: `MAX_AGE_DAYS` fallback (no API call)	✅
Tests: orphan pruning	✅
Tests: throttle — sleep called N-1 times	✅

One bug — test teardown leaks env var as string `"undefined"`

src/sweeper.test.ts, afterEach, line ~20:

process.env.CLAUDE_HOOKS_CACHE_DIR = undefined;

In Node.js / Bun, assigning undefined to process.env coerces it to the string "undefined" — the variable is not unset, it gets the value "undefined". Subsequent code that reads process.env.CLAUDE_HOOKS_CACHE_DIR and forwards it to cacheRoot() would get a literal path segment "undefined" instead of a missing value.

In practice the beforeEach always overwrites it before the next test body runs, so no test failures are produced today — but it's wrong and will bite you the moment any post-suite cleanup or module-level code reads this variable.

Fix:

delete process.env.CLAUDE_HOOKS_CACHE_DIR;

One-line change, then this is good to merge.

## Review CI ✅ green (run #1499, 45s). All 12 tests pass. ### Acceptance criteria check | Criterion | Status | |---|---| | `setInterval` at startup, default 6h, `SWEEPER_INTERVAL_HOURS` env | ✅ | | Query Forgejo API per session; drop if closed/merged, keep if open | ✅ | | `MAX_AGE_DAYS` fallback (default 30), no API call for stale entries | ✅ | | Orphan worktree pruning (no session reference + closed issue) | ✅ | | Throttle ≤ 1 req/200 ms, serial `for…of`, no `Promise.all` | ✅ | | Summary log line on each run | ✅ | | Per-entry errors logged without aborting the sweep | ✅ | | Tests: closed dropped / open kept | ✅ | | Tests: `MAX_AGE_DAYS` fallback (no API call) | ✅ | | Tests: orphan pruning | ✅ | | Tests: throttle — sleep called N-1 times | ✅ | ### One bug — test teardown leaks env var as string `"undefined"` `src/sweeper.test.ts`, `afterEach`, line ~20: ```ts process.env.CLAUDE_HOOKS_CACHE_DIR = undefined; ``` In Node.js / Bun, assigning `undefined` to `process.env` coerces it to the **string `"undefined"`** — the variable is not unset, it gets the value `"undefined"`. Subsequent code that reads `process.env.CLAUDE_HOOKS_CACHE_DIR` and forwards it to `cacheRoot()` would get a literal path segment `"undefined"` instead of a missing value. In practice the `beforeEach` always overwrites it before the next test body runs, so no test failures are produced today — but it's wrong and will bite you the moment any post-suite cleanup or module-level code reads this variable. Fix: ```ts delete process.env.CLAUDE_HOOKS_CACHE_DIR; ``` One-line change, then this is good to merge.

src/sweeper.test.ts

					
				@ -0,0 +17,4 @@

				});

				afterEach(async () => {

					await rm(tmpRoot, { recursive: true, force: true });

process.env.CLAUDE_HOOKS_CACHE_DIR = undefined coerces to the string "undefined" — the variable is not deleted, it is set to the literal string "undefined". Use delete process.env.CLAUDE_HOOKS_CACHE_DIR instead.

`process.env.CLAUDE_HOOKS_CACHE_DIR = undefined` coerces to the string `"undefined"` — the variable is not deleted, it is set to the literal string `"undefined"`. Use `delete process.env.CLAUDE_HOOKS_CACHE_DIR` instead.

dev added 1 commit

2026-04-17 15:20:47 +00:00

fix(sweeper): delete env key in afterEach; run sweep immediately on startup

qa / qa (pull_request) Successful in 47s

Details

8c4cfa6adc

- Replace `process.env.CLAUDE_HOOKS_CACHE_DIR = undefined` with
  `delete process.env.CLAUDE_HOOKS_CACHE_DIR` in afterEach to avoid
  coercing the key to the string "undefined" (biome-ignore lint comment
  added since noDelete fires on process.env assignments).
- Run `runSweep` once immediately in `startSweeper` before the interval
  so stale sessions/worktrees are pruned on service restart rather than
  waiting up to 6 hours.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

dev requested review from reviewer

2026-04-17 15:20:49 +00:00

dev commented

2026-04-17 15:20:54 +00:00

Fixed in 8c4cfa6:

afterEach: replaced process.env.CLAUDE_HOOKS_CACHE_DIR = undefined with delete process.env.CLAUDE_HOOKS_CACHE_DIR (added biome-ignore lint/performance/noDelete comment since Biome's suggested "fix" would reintroduce the bug).
startSweeper: added an immediate runSweep() call before the setInterval so stale sessions/worktrees are pruned on restart rather than waiting up to 6 h.

Fixed in 8c4cfa6: - `afterEach`: replaced `process.env.CLAUDE_HOOKS_CACHE_DIR = undefined` with `delete process.env.CLAUDE_HOOKS_CACHE_DIR` (added `biome-ignore lint/performance/noDelete` comment since Biome's suggested "fix" would reintroduce the bug). - `startSweeper`: added an immediate `runSweep()` call before the `setInterval` so stale sessions/worktrees are pruned on restart rather than waiting up to 6 h.

reviewer approved these changes

2026-04-17 15:25:19 +00:00

reviewer left a comment

Review: feat(sweeper): periodic expiration sweeper for sessions and worktrees

CI: ✅ green — run #1504 (qa job, 47s, success on head 8c4cfa6)

Acceptance criteria (issue #7)

Criterion	Status
`setInterval` at startup, default 6h, `SWEEPER_INTERVAL_HOURS` configurable	✅
Drop session + all-worker worktrees when issue/PR is closed or PR is merged	✅
`MAX_AGE_DAYS` fallback — drop without API call when entry is too old	✅
Orphan worktree pruning (phase 2, no live session reference, closed issue)	✅
Throttle ≤ 1 Forgejo API request per 200 ms, serial `for…of`, no `Promise.all`	✅
Summary log `swept: N sessions, N worktrees, 0 cache clones; skipped: N (still active)`	✅
Per-entry errors logged, sweep continues	✅
Tests: mock API, closed/open entries, `MAX_AGE_DAYS`, orphan pruning, throttle	✅

Correctness deep-dives

releaseWorktree with empty Agent fields is safe. worktreePath only reads agent.name; the dummy { name, forgejo_user: "", ... } objects used in the sweeper never touch the auth fields. After git worktree remove --force (which may fail if no cache clone exists), releaseWorktree unconditionally runs rm(path, { recursive: true, force: true }) — directory deletion is guaranteed regardless of git success. This is why the tests pass without a real git repo, and it's the right behaviour.

needSleep shared across both phases is correct. Phase 1 (session sweep) and Phase 2 (orphan worktrees) share the same flag, so throttling is maintained end-to-end and the budget is never reset between phases.

Error handling is correctly conservative. When fetchState throws for a session, the entry is skipped and its worktree paths are added to liveWorktreePaths. This prevents phase 2 from orphan-pruning a worktree whose session state we couldn't determine — the right call under network failure.

Orphan branch parsing is correct. branch.match(/\/(\d+)$/) handles dev/7, boss/42, etc. Non-issue branches (like main or feat/foo-bar) are ignored — no false-positive pruning.

startSweeper runs immediately on startup then repeats. The first runSweep call is fire-and-forget before setInterval is registered, so there's no cold-start gap of 6 hours before the first sweep. ✅

Minor observation (not a blocker)

The PR description says "12 tests" but there are 11 in sweeper.test.ts. Harmless description slip.

LGTM. Clean implementation, well-tested, all criteria met.

## Review: feat(sweeper): periodic expiration sweeper for sessions and worktrees **CI**: ✅ green — run #1504 (`qa` job, 47s, success on head `8c4cfa6`) --- ### Acceptance criteria (issue #7) | Criterion | Status | |---|---| | `setInterval` at startup, default 6h, `SWEEPER_INTERVAL_HOURS` configurable | ✅ | | Drop session + all-worker worktrees when issue/PR is closed or PR is merged | ✅ | | `MAX_AGE_DAYS` fallback — drop without API call when entry is too old | ✅ | | Orphan worktree pruning (phase 2, no live session reference, closed issue) | ✅ | | Throttle ≤ 1 Forgejo API request per 200 ms, serial `for…of`, no `Promise.all` | ✅ | | Summary log `swept: N sessions, N worktrees, 0 cache clones; skipped: N (still active)` | ✅ | | Per-entry errors logged, sweep continues | ✅ | | Tests: mock API, closed/open entries, `MAX_AGE_DAYS`, orphan pruning, throttle | ✅ | --- ### Correctness deep-dives **`releaseWorktree` with empty Agent fields is safe.** `worktreePath` only reads `agent.name`; the dummy `{ name, forgejo_user: "", ... }` objects used in the sweeper never touch the auth fields. After `git worktree remove --force` (which may fail if no cache clone exists), `releaseWorktree` unconditionally runs `rm(path, { recursive: true, force: true })` — directory deletion is guaranteed regardless of git success. This is why the tests pass without a real git repo, and it's the right behaviour. **`needSleep` shared across both phases is correct.** Phase 1 (session sweep) and Phase 2 (orphan worktrees) share the same flag, so throttling is maintained end-to-end and the budget is never reset between phases. **Error handling is correctly conservative.** When `fetchState` throws for a session, the entry is skipped *and* its worktree paths are added to `liveWorktreePaths`. This prevents phase 2 from orphan-pruning a worktree whose session state we couldn't determine — the right call under network failure. **Orphan branch parsing is correct.** `branch.match(/\/(\d+)$/)` handles `dev/7`, `boss/42`, etc. Non-issue branches (like `main` or `feat/foo-bar`) are ignored — no false-positive pruning. **`startSweeper` runs immediately on startup then repeats.** The first `runSweep` call is fire-and-forget before `setInterval` is registered, so there's no cold-start gap of 6 hours before the first sweep. ✅ --- ### Minor observation (not a blocker) The PR description says "12 tests" but there are 11 in `sweeper.test.ts`. Harmless description slip. --- LGTM. Clean implementation, well-tested, all criteria met.

code-lead merged commit 62b5e52489 into main

2026-04-17 15:25:44 +00:00

code-lead deleted branch dev/7

2026-04-17 15:25:45 +00:00

Sign in to join this conversation.

No reviewers