@webpieces/rules-config 0.4.507 → 0.4.509

package/src/merged-branches.d.ts

@@ -1,116 +1,30 @@
 import { WorktreeService } from './worktrees';
-export declare class MergedBranch {
-    branch: string;
-    pr: number;
-    constructor(branch: string, pr: number);
-}
-/**
- * WHY a branch is dead, or why it was spared — as a STABLE token, alongside the English prose.
- *
- * `sha`/`commits`/`prState` (below) let a human SEE a spared branch. This adds the other half: a token
- * saying WHICH KIND of spared it is. Every spared branch used to report the identical string
- * `no merged PR found — a human must decide`, and in one observed repo that one string covered three
- * genuinely different situations — a PR CLOSED UNMERGED whose work landed under a later number, a
- * branch that NEVER had a PR and holds the only copy of its commits, and content already in main.
- * Reporting all three identically is why nobody ever decided, and why the pile grew to 6 branches
- * against a cap of 5. A token lets wp-cleanup GROUP them and ask a question that can be answered.
- */
-export declare const CLASSIFICATION_MERGED_PR = "merged-pr";
-export declare const CLASSIFICATION_BACKUP_OF_MERGED = "backup-of-merged";
-export declare const CLASSIFICATION_NO_COMMITS = "no-commits";
-export declare const CLASSIFICATION_SUPERSEDED = "superseded";
-export declare const CLASSIFICATION_CONTENT_IN_MAIN = "content-already-in-main";
-export declare const CLASSIFICATION_NEVER_PROPOSED = "never-proposed";
-export declare const CLASSIFICATION_IN_USE = "in-use";
-/**
- * WORKTREE-only classifications. A worktree verdict borrows every token above (its branch is what is
- * being judged), but three of its outcomes have no branch analogue at all, and lumping them under
- * `in-use` would tell wp-cleanup to shut up about exactly the ones a human might want to act on.
- *
- *  - PRUNABLE   — the directory is already gone; `git worktree prune` is the reap, not `remove`.
- *  - LOCKED     — a human ran `git worktree lock`. Explicitly "do not touch"; never promptable.
- *  - CURRENT    — the worktree the command is running IN. Removing your own cwd is a self-destruct.
- *  - DETACHED   — detached HEAD, so there is no branch to judge and no branch to archive.
- */
-export declare const CLASSIFICATION_PRUNABLE = "prunable-worktree";
-export declare const CLASSIFICATION_LOCKED = "locked-worktree";
-export declare const CLASSIFICATION_CURRENT = "current-worktree";
-export declare const CLASSIFICATION_DETACHED = "detached-worktree";
-export declare const PROMPTABLE_CLASSIFICATIONS: readonly string[];
-/**
- * A local branch and the verdict on it. `pr` is 0 when no merged PR backs the verdict (a `keep`).
- *
- * `sha`, `commits` and `prState` exist for the SPARED branches specifically. When nothing is
- * auto-reapable the branch cap has nothing safe to offer, and its only remaining advice was "raise
- * maxLocalBranches" / "set turnOffRuleUntilEpoch" — both of which loosen the rule. An agent with no
- * human present took the config edit, which is the exact failure the cap exists to prevent. To ask a
- * human "may I delete these?" instead, the guard has to be able to SHOW what it would delete: tip SHA
- * (so the delete is recoverable), PR state (closed? never opened?) and how much unique work is on it.
- *
- * All three are computed in the DETACHED refresher and read straight off merged-branches.json — the
- * blocking hook path never recomputes them. Defaulted so a cache written by an older release (and
- * every existing call site) revives without them.
- */
-export declare class DeletableBranch {
-    branch: string;
-    reason: string;
-    pr: number;
-    /** Short tip SHA — what makes the delete undoable (`git branch <name> <sha>`). '' when unknown. */
-    sha: string;
-    /** Commits on this branch that are not on origin/main. -1 when it could not be established. */
-    commits: number;
-    /** GitHub's state for the PR whose head is this branch: MERGED / CLOSED / OPEN, or '' for none. */
-    prState: string;
-    /**
-     * One of the CLASSIFICATION_* tokens. Defaulted like the fields above so every pre-existing call
-     * site — and every cache written by an older release — still constructs; an unclassified revived
-     * entry reads as 'never-proposed', the most conservative of the spared verdicts.
-     */
-    classification: string;
-    constructor(branch: string, reason: string, pr: number, sha?: string, commits?: number, prState?: string, classification?: string);
-}
-/**
- * A worktree and the verdict on it. Carries `path` (what `git worktree remove` takes) AND `branch`
- * (what `git branch -D` takes afterwards) because reaping a worktree is always those two steps, in
- * that order — git refuses to delete a branch that is still checked out somewhere.
- *
- * `classification` is the same STABLE token the branch verdicts carry, plus the four worktree-only
- * ones above. It exists for the same reason it does on DeletableBranch: `deletable` answers "may the
- * tooling reap this unattended?", and everything false used to collapse into one undifferentiated
- * "spared" that a human could not rule on. With a token, WorktreeReaper knows whether the reap is a
- * `prune` or a `remove`, and wp-cleanup knows which spared worktrees are worth ASKING about.
- * Defaulted so every pre-existing call site and every cache written by an older release still builds;
- * an unclassified revived entry reads as 'never-proposed', the most conservative spared verdict.
- */
-export declare class DeletableWorktree {
-    path: string;
-    branch: string;
-    reason: string;
-    pr: number;
-    deletable: boolean;
-    classification: string;
-    constructor(path: string, branch: string, reason: string, pr: number, deletable: boolean, classification?: string);
-}
-/**
- * `deletable` is PRECOMPUTED so the consumer just deletes the list — no re-deriving, no judgement
- * call at block time. `keep` carries the branches we refuse to touch (no merged PR found), each with
- * its reason, so a human can see what was spared and why.
- *
- * `worktrees` is the parallel verdict list for the SECOND budget (see worktrees.ts): every linked
- * worktree, each flagged deletable or not. Both budgets are reaped from this one cache file.
- */
-export declare class MergedBranchesCache {
-    timestamp: string;
-    deletable: DeletableBranch[];
-    keep: DeletableBranch[];
-    worktrees: DeletableWorktree[];
-    constructor(timestamp: string, deletable: DeletableBranch[], keep: DeletableBranch[], worktrees?: DeletableWorktree[]);
-}
+import { CacheFreshness, MergedBranchesCache } from './merged-branch-verdicts';
+export { MergedBranch, DeletableBranch, DeletableWorktree, MergedBranchesCache, CacheFreshness, CACHE_STALE_AFTER_MS, CLASSIFICATION_MERGED_PR, CLASSIFICATION_BACKUP_OF_MERGED, CLASSIFICATION_NO_COMMITS, CLASSIFICATION_SUPERSEDED, CLASSIFICATION_CONTENT_IN_MAIN, CLASSIFICATION_NEVER_PROPOSED, CLASSIFICATION_IN_USE, CLASSIFICATION_PRUNABLE, CLASSIFICATION_LOCKED, CLASSIFICATION_CURRENT, CLASSIFICATION_DETACHED, PROMPTABLE_CLASSIFICATIONS, } from './merged-branch-verdicts';
 export declare class MergedBranchesService {
     private readonly worktrees;
     constructor(worktrees?: WorktreeService);
     mergedBranchesPath(repoRoot: string): string;
     readMergedBranches(repoRoot: string): MergedBranchesCache | null;
+    /**
+     * How old is this cache, and may its numbers be quoted as fact?
+     *
+     * `now` is a parameter purely so the specs can pin it; every caller passes nothing.
+     */
+    freshness(cache: MergedBranchesCache, now?: number): CacheFreshness;
+    /**
+     * Drop every cached verdict whose subject no longer exists, using only LOCAL, instant git reads.
+     *
+     * The verdicts themselves are NOT re-derived here — that is the detached refresher's job and it
+     * needs the network. This answers a different and much cheaper question: does this branch / this
+     * worktree still exist at all? A cache written before a `git branch -D` or a `git worktree remove`
+     * keeps naming things that are gone, and a reader that counts those entries reports a repo that
+     * does not exist (observed: 8 parked branches asserted against an actual 1) and then blocks on it.
+     *
+     * Fails toward the cache: if git cannot answer (empty branch list), the cache is returned untouched
+     * rather than emptied, since "git failed" must never read as "everything was deleted".
+     */
+    reconcile(repoRoot: string, cache: MergedBranchesCache): MergedBranchesCache;
     writeMergedBranches(repoRoot: string, cache: MergedBranchesCache): void;
     /**
      * Every local branch except `main`. Uses `git for-each-ref`, NOT `git branch` — the latter is a
@@ -128,10 +42,11 @@ export declare class MergedBranchesService {
      * clone and is not a thing you can remove.
      *
      * A worktree is deletable when its directory is already gone (`prunable`), or when its branch is
-     * dead by the very same proofs the branch cap uses (merged PR, backup-of-merged, or zero commits of
-     * its own). It is spared when it is LOCKED (a human said "do not touch"), when it is the worktree we
-     * are standing in right now (removing your own cwd is not a thing to suggest to an agent), or when
-     * its branch still holds unmerged work.
+     * dead by the very same proof the branch cap uses — a MERGED PR, its own or that of the branch it
+     * snapshots. Nothing else. It is spared when it is LOCKED (a human said "do not touch"), when it is
+     * the worktree we are standing in right now (removing your own cwd is not a thing to suggest to an
+     * agent), or when its branch is anything short of provably merged — INCLUDING a branch with no
+     * commits yet, which is what every worktree looks like while an agent is working in it.
      */
     private classifyWorktrees;
     /**

package/src/merged-branches.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MergedBranchesService = exports.MergedBranchesCache = exports.DeletableWorktree = exports.DeletableBranch = exports.PROMPTABLE_CLASSIFICATIONS = exports.CLASSIFICATION_DETACHED = exports.CLASSIFICATION_CURRENT = exports.CLASSIFICATION_LOCKED = exports.CLASSIFICATION_PRUNABLE = exports.CLASSIFICATION_IN_USE = exports.CLASSIFICATION_NEVER_PROPOSED = exports.CLASSIFICATION_CONTENT_IN_MAIN = exports.CLASSIFICATION_SUPERSEDED = exports.CLASSIFICATION_NO_COMMITS = exports.CLASSIFICATION_BACKUP_OF_MERGED = exports.CLASSIFICATION_MERGED_PR = exports.MergedBranch = void 0;
+exports.MergedBranchesService = exports.PROMPTABLE_CLASSIFICATIONS = exports.CLASSIFICATION_DETACHED = exports.CLASSIFICATION_CURRENT = exports.CLASSIFICATION_LOCKED = exports.CLASSIFICATION_PRUNABLE = exports.CLASSIFICATION_IN_USE = exports.CLASSIFICATION_NEVER_PROPOSED = exports.CLASSIFICATION_CONTENT_IN_MAIN = exports.CLASSIFICATION_SUPERSEDED = exports.CLASSIFICATION_NO_COMMITS = exports.CLASSIFICATION_BACKUP_OF_MERGED = exports.CLASSIFICATION_MERGED_PR = exports.CACHE_STALE_AFTER_MS = exports.CacheFreshness = exports.MergedBranchesCache = exports.DeletableWorktree = exports.DeletableBranch = exports.MergedBranch = void 0;
 const tslib_1 = require("tslib");
 const child_process_1 = require("child_process");
 const fs = tslib_1.__importStar(require("fs"));
@@ -9,6 +9,26 @@ const inversify_1 = require("inversify");
 const constants_1 = require("./constants");
 const to_error_1 = require("./to-error");
 const worktrees_1 = require("./worktrees");
+const merged_branch_verdicts_1 = require("./merged-branch-verdicts");
+var merged_branch_verdicts_2 = require("./merged-branch-verdicts");
+Object.defineProperty(exports, "MergedBranch", { enumerable: true, get: function () { return merged_branch_verdicts_2.MergedBranch; } });
+Object.defineProperty(exports, "DeletableBranch", { enumerable: true, get: function () { return merged_branch_verdicts_2.DeletableBranch; } });
+Object.defineProperty(exports, "DeletableWorktree", { enumerable: true, get: function () { return merged_branch_verdicts_2.DeletableWorktree; } });
+Object.defineProperty(exports, "MergedBranchesCache", { enumerable: true, get: function () { return merged_branch_verdicts_2.MergedBranchesCache; } });
+Object.defineProperty(exports, "CacheFreshness", { enumerable: true, get: function () { return merged_branch_verdicts_2.CacheFreshness; } });
+Object.defineProperty(exports, "CACHE_STALE_AFTER_MS", { enumerable: true, get: function () { return merged_branch_verdicts_2.CACHE_STALE_AFTER_MS; } });
+Object.defineProperty(exports, "CLASSIFICATION_MERGED_PR", { enumerable: true, get: function () { return merged_branch_verdicts_2.CLASSIFICATION_MERGED_PR; } });
+Object.defineProperty(exports, "CLASSIFICATION_BACKUP_OF_MERGED", { enumerable: true, get: function () { return merged_branch_verdicts_2.CLASSIFICATION_BACKUP_OF_MERGED; } });
+Object.defineProperty(exports, "CLASSIFICATION_NO_COMMITS", { enumerable: true, get: function () { return merged_branch_verdicts_2.CLASSIFICATION_NO_COMMITS; } });
+Object.defineProperty(exports, "CLASSIFICATION_SUPERSEDED", { enumerable: true, get: function () { return merged_branch_verdicts_2.CLASSIFICATION_SUPERSEDED; } });
+Object.defineProperty(exports, "CLASSIFICATION_CONTENT_IN_MAIN", { enumerable: true, get: function () { return merged_branch_verdicts_2.CLASSIFICATION_CONTENT_IN_MAIN; } });
+Object.defineProperty(exports, "CLASSIFICATION_NEVER_PROPOSED", { enumerable: true, get: function () { return merged_branch_verdicts_2.CLASSIFICATION_NEVER_PROPOSED; } });
+Object.defineProperty(exports, "CLASSIFICATION_IN_USE", { enumerable: true, get: function () { return merged_branch_verdicts_2.CLASSIFICATION_IN_USE; } });
+Object.defineProperty(exports, "CLASSIFICATION_PRUNABLE", { enumerable: true, get: function () { return merged_branch_verdicts_2.CLASSIFICATION_PRUNABLE; } });
+Object.defineProperty(exports, "CLASSIFICATION_LOCKED", { enumerable: true, get: function () { return merged_branch_verdicts_2.CLASSIFICATION_LOCKED; } });
+Object.defineProperty(exports, "CLASSIFICATION_CURRENT", { enumerable: true, get: function () { return merged_branch_verdicts_2.CLASSIFICATION_CURRENT; } });
+Object.defineProperty(exports, "CLASSIFICATION_DETACHED", { enumerable: true, get: function () { return merged_branch_verdicts_2.CLASSIFICATION_DETACHED; } });
+Object.defineProperty(exports, "PROMPTABLE_CLASSIFICATIONS", { enumerable: true, get: function () { return merged_branch_verdicts_2.PROMPTABLE_CLASSIFICATIONS; } });
 /**
  * The "which local branches are dead?" cache.
  *
@@ -31,152 +51,6 @@ const MERGED_PR_LOOKUP_LIMIT = 100;
 // (base → baseSquash / basewp2 / basePreMerge3). GitHub has never seen these SHAs, so no PR will ever
 // name them — they can only be reaped by stripping back to the base branch they were cloned from.
 const BACKUP_SUFFIX = /(?:Squash|PreMerge\d*|wp\d+)$/;
-// Data-only (per CLAUDE.md, classes for data).
-class MergedBranch {
-    branch;
-    pr;
-    constructor(branch, pr) {
-        this.branch = branch;
-        this.pr = pr;
-    }
-}
-exports.MergedBranch = MergedBranch;
-/**
- * WHY a branch is dead, or why it was spared — as a STABLE token, alongside the English prose.
- *
- * `sha`/`commits`/`prState` (below) let a human SEE a spared branch. This adds the other half: a token
- * saying WHICH KIND of spared it is. Every spared branch used to report the identical string
- * `no merged PR found — a human must decide`, and in one observed repo that one string covered three
- * genuinely different situations — a PR CLOSED UNMERGED whose work landed under a later number, a
- * branch that NEVER had a PR and holds the only copy of its commits, and content already in main.
- * Reporting all three identically is why nobody ever decided, and why the pile grew to 6 branches
- * against a cap of 5. A token lets wp-cleanup GROUP them and ask a question that can be answered.
- */
-// Dead by proof — these are auto-deletable.
-exports.CLASSIFICATION_MERGED_PR = 'merged-pr';
-exports.CLASSIFICATION_BACKUP_OF_MERGED = 'backup-of-merged';
-exports.CLASSIFICATION_NO_COMMITS = 'no-commits';
-// Spared, but a human should be ASKED — in descending order of "obviously fine to delete".
-exports.CLASSIFICATION_SUPERSEDED = 'superseded';
-exports.CLASSIFICATION_CONTENT_IN_MAIN = 'content-already-in-main';
-exports.CLASSIFICATION_NEVER_PROPOSED = 'never-proposed';
-// Spared for a mechanical reason, not a judgement call (checked out somewhere).
-exports.CLASSIFICATION_IN_USE = 'in-use';
-/**
- * WORKTREE-only classifications. A worktree verdict borrows every token above (its branch is what is
- * being judged), but three of its outcomes have no branch analogue at all, and lumping them under
- * `in-use` would tell wp-cleanup to shut up about exactly the ones a human might want to act on.
- *
- *  - PRUNABLE   — the directory is already gone; `git worktree prune` is the reap, not `remove`.
- *  - LOCKED     — a human ran `git worktree lock`. Explicitly "do not touch"; never promptable.
- *  - CURRENT    — the worktree the command is running IN. Removing your own cwd is a self-destruct.
- *  - DETACHED   — detached HEAD, so there is no branch to judge and no branch to archive.
- */
-exports.CLASSIFICATION_PRUNABLE = 'prunable-worktree';
-exports.CLASSIFICATION_LOCKED = 'locked-worktree';
-exports.CLASSIFICATION_CURRENT = 'current-worktree';
-exports.CLASSIFICATION_DETACHED = 'detached-worktree';
-// Spared classifications a human can meaningfully rule on, most-safe first. wp-cleanup prompts in
-// exactly this order so the easy yeses come before the ones that need thought.
-exports.PROMPTABLE_CLASSIFICATIONS = [
-    exports.CLASSIFICATION_SUPERSEDED,
-    exports.CLASSIFICATION_CONTENT_IN_MAIN,
-    exports.CLASSIFICATION_NEVER_PROPOSED,
-];
-/**
- * A local branch and the verdict on it. `pr` is 0 when no merged PR backs the verdict (a `keep`).
- *
- * `sha`, `commits` and `prState` exist for the SPARED branches specifically. When nothing is
- * auto-reapable the branch cap has nothing safe to offer, and its only remaining advice was "raise
- * maxLocalBranches" / "set turnOffRuleUntilEpoch" — both of which loosen the rule. An agent with no
- * human present took the config edit, which is the exact failure the cap exists to prevent. To ask a
- * human "may I delete these?" instead, the guard has to be able to SHOW what it would delete: tip SHA
- * (so the delete is recoverable), PR state (closed? never opened?) and how much unique work is on it.
- *
- * All three are computed in the DETACHED refresher and read straight off merged-branches.json — the
- * blocking hook path never recomputes them. Defaulted so a cache written by an older release (and
- * every existing call site) revives without them.
- */
-class DeletableBranch {
-    branch;
-    reason;
-    pr;
-    /** Short tip SHA — what makes the delete undoable (`git branch <name> <sha>`). '' when unknown. */
-    sha;
-    /** Commits on this branch that are not on origin/main. -1 when it could not be established. */
-    commits;
-    /** GitHub's state for the PR whose head is this branch: MERGED / CLOSED / OPEN, or '' for none. */
-    prState;
-    /**
-     * One of the CLASSIFICATION_* tokens. Defaulted like the fields above so every pre-existing call
-     * site — and every cache written by an older release — still constructs; an unclassified revived
-     * entry reads as 'never-proposed', the most conservative of the spared verdicts.
-     */
-    classification;
-    // eslint-disable-next-line @typescript-eslint/max-params
-    constructor(branch, reason, pr, sha = '', commits = -1, prState = '', classification = exports.CLASSIFICATION_NEVER_PROPOSED) {
-        this.branch = branch;
-        this.reason = reason;
-        this.pr = pr;
-        this.sha = sha;
-        this.commits = commits;
-        this.prState = prState;
-        this.classification = classification;
-    }
-}
-exports.DeletableBranch = DeletableBranch;
-/**
- * A worktree and the verdict on it. Carries `path` (what `git worktree remove` takes) AND `branch`
- * (what `git branch -D` takes afterwards) because reaping a worktree is always those two steps, in
- * that order — git refuses to delete a branch that is still checked out somewhere.
- *
- * `classification` is the same STABLE token the branch verdicts carry, plus the four worktree-only
- * ones above. It exists for the same reason it does on DeletableBranch: `deletable` answers "may the
- * tooling reap this unattended?", and everything false used to collapse into one undifferentiated
- * "spared" that a human could not rule on. With a token, WorktreeReaper knows whether the reap is a
- * `prune` or a `remove`, and wp-cleanup knows which spared worktrees are worth ASKING about.
- * Defaulted so every pre-existing call site and every cache written by an older release still builds;
- * an unclassified revived entry reads as 'never-proposed', the most conservative spared verdict.
- */
-class DeletableWorktree {
-    path;
-    branch;
-    reason;
-    pr;
-    deletable;
-    classification;
-    // eslint-disable-next-line @typescript-eslint/max-params
-    constructor(path, branch, reason, pr, deletable, classification = exports.CLASSIFICATION_NEVER_PROPOSED) {
-        this.path = path;
-        this.branch = branch;
-        this.reason = reason;
-        this.pr = pr;
-        this.deletable = deletable;
-        this.classification = classification;
-    }
-}
-exports.DeletableWorktree = DeletableWorktree;
-/**
- * `deletable` is PRECOMPUTED so the consumer just deletes the list — no re-deriving, no judgement
- * call at block time. `keep` carries the branches we refuse to touch (no merged PR found), each with
- * its reason, so a human can see what was spared and why.
- *
- * `worktrees` is the parallel verdict list for the SECOND budget (see worktrees.ts): every linked
- * worktree, each flagged deletable or not. Both budgets are reaped from this one cache file.
- */
-class MergedBranchesCache {
-    timestamp;
-    deletable;
-    keep;
-    worktrees;
-    constructor(timestamp, deletable, keep, worktrees = []) {
-        this.timestamp = timestamp;
-        this.deletable = deletable;
-        this.keep = keep;
-        this.worktrees = worktrees;
-    }
-}
-exports.MergedBranchesCache = MergedBranchesCache;
 /**
  * Internal: the bulk PR lookup, indexed.
  *
@@ -236,7 +110,7 @@ let MergedBranchesService = class MergedBranchesService {
             if (!fs.existsSync(cachePath))
                 return null;
             const raw = JSON.parse(fs.readFileSync(cachePath, 'utf8'));
-            return new MergedBranchesCache(raw.timestamp ?? '', this.reviveList(raw.deletable), this.reviveList(raw.keep), this.reviveWorktrees(raw.worktrees));
+            return new merged_branch_verdicts_1.MergedBranchesCache(raw.timestamp ?? '', this.reviveList(raw.deletable), this.reviveList(raw.keep), this.reviveWorktrees(raw.worktrees));
         }
         catch (err) {
             const error = (0, to_error_1.toError)(err);
@@ -244,6 +118,39 @@ let MergedBranchesService = class MergedBranchesService {
             return null;
         }
     }
+    /**
+     * How old is this cache, and may its numbers be quoted as fact?
+     *
+     * `now` is a parameter purely so the specs can pin it; every caller passes nothing.
+     */
+    freshness(cache, now = Date.now()) {
+        const written = Date.parse(cache.timestamp);
+        if (Number.isNaN(written))
+            return new merged_branch_verdicts_1.CacheFreshness(true, -1, cache.timestamp);
+        const ageMs = Math.max(0, now - written);
+        const ageMinutes = Math.floor(ageMs / 60000);
+        return new merged_branch_verdicts_1.CacheFreshness(ageMs > merged_branch_verdicts_1.CACHE_STALE_AFTER_MS, ageMinutes, cache.timestamp);
+    }
+    /**
+     * Drop every cached verdict whose subject no longer exists, using only LOCAL, instant git reads.
+     *
+     * The verdicts themselves are NOT re-derived here — that is the detached refresher's job and it
+     * needs the network. This answers a different and much cheaper question: does this branch / this
+     * worktree still exist at all? A cache written before a `git branch -D` or a `git worktree remove`
+     * keeps naming things that are gone, and a reader that counts those entries reports a repo that
+     * does not exist (observed: 8 parked branches asserted against an actual 1) and then blocks on it.
+     *
+     * Fails toward the cache: if git cannot answer (empty branch list), the cache is returned untouched
+     * rather than emptied, since "git failed" must never read as "everything was deleted".
+     */
+    reconcile(repoRoot, cache) {
+        const live = new Set(this.localBranches(repoRoot));
+        const trees = this.worktrees.listWorktrees(repoRoot);
+        const livePaths = new Set(trees.map((tree) => tree.path));
+        const keepBranch = (entry) => live.size === 0 || live.has(entry.branch);
+        const keepTree = (entry) => trees.length === 0 || livePaths.has(entry.path);
+        return new merged_branch_verdicts_1.MergedBranchesCache(cache.timestamp, cache.deletable.filter(keepBranch), cache.keep.filter(keepBranch), cache.worktrees.filter(keepTree));
+    }
     writeMergedBranches(repoRoot, cache) {
         const cachePath = this.mergedBranchesPath(repoRoot);
         fs.mkdirSync(path.dirname(cachePath), { recursive: true });
@@ -295,7 +202,7 @@ let MergedBranchesService = class MergedBranchesService {
             // worktree list below is what actually reaps it, and a human should see the connection.
             const heldAt = holder.get(branch);
             if (heldAt !== undefined) {
-                keep.push(new DeletableBranch(branch, `checked out in worktree '${heldAt}' — remove that worktree before deleting the branch`, verdict.entry.pr, verdict.entry.sha, verdict.entry.commits, verdict.entry.prState, exports.CLASSIFICATION_IN_USE));
+                keep.push(new merged_branch_verdicts_1.DeletableBranch(branch, `checked out in worktree '${heldAt}' — remove that worktree before deleting the branch`, verdict.entry.pr, verdict.entry.sha, verdict.entry.commits, verdict.entry.prState, merged_branch_verdicts_1.CLASSIFICATION_IN_USE));
                 continue;
             }
             if (verdict.deletable)
@@ -304,17 +211,18 @@ let MergedBranchesService = class MergedBranchesService {
                 keep.push(verdict.entry);
         }
         const worktrees = this.classifyWorktrees(repoRoot, trees, prs);
-        return new MergedBranchesCache(new Date().toISOString(), deletable, keep, worktrees);
+        return new merged_branch_verdicts_1.MergedBranchesCache(new Date().toISOString(), deletable, keep, worktrees);
     }
     /**
      * Verdicts for the worktree budget. The main worktree is excluded outright — it is the primary
      * clone and is not a thing you can remove.
      *
      * A worktree is deletable when its directory is already gone (`prunable`), or when its branch is
-     * dead by the very same proofs the branch cap uses (merged PR, backup-of-merged, or zero commits of
-     * its own). It is spared when it is LOCKED (a human said "do not touch"), when it is the worktree we
-     * are standing in right now (removing your own cwd is not a thing to suggest to an agent), or when
-     * its branch still holds unmerged work.
+     * dead by the very same proof the branch cap uses — a MERGED PR, its own or that of the branch it
+     * snapshots. Nothing else. It is spared when it is LOCKED (a human said "do not touch"), when it is
+     * the worktree we are standing in right now (removing your own cwd is not a thing to suggest to an
+     * agent), or when its branch is anything short of provably merged — INCLUDING a branch with no
+     * commits yet, which is what every worktree looks like while an agent is working in it.
      */
     classifyWorktrees(repoRoot, trees, prs) {
         const out = [];
@@ -322,26 +230,26 @@ let MergedBranchesService = class MergedBranchesService {
             if (tree.isMain)
                 continue;
             if (tree.prunable) {
-                out.push(new DeletableWorktree(tree.path, tree.branch, 'its directory is gone — `git worktree prune` clears it', 0, true, exports.CLASSIFICATION_PRUNABLE));
+                out.push(new merged_branch_verdicts_1.DeletableWorktree(tree.path, tree.branch, 'its directory is gone — `git worktree prune` clears it', 0, true, merged_branch_verdicts_1.CLASSIFICATION_PRUNABLE));
                 continue;
             }
             if (tree.locked) {
-                out.push(new DeletableWorktree(tree.path, tree.branch, 'locked by a human — do not touch', 0, false, exports.CLASSIFICATION_LOCKED));
+                out.push(new merged_branch_verdicts_1.DeletableWorktree(tree.path, tree.branch, 'locked by a human — do not touch', 0, false, merged_branch_verdicts_1.CLASSIFICATION_LOCKED));
                 continue;
             }
             if (tree.path === repoRoot) {
-                out.push(new DeletableWorktree(tree.path, tree.branch, 'you are standing in it', 0, false, exports.CLASSIFICATION_CURRENT));
+                out.push(new merged_branch_verdicts_1.DeletableWorktree(tree.path, tree.branch, 'you are standing in it', 0, false, merged_branch_verdicts_1.CLASSIFICATION_CURRENT));
                 continue;
             }
             if (tree.branch === '') {
-                out.push(new DeletableWorktree(tree.path, '', 'detached HEAD — no branch to check, so a human must decide', 0, false, exports.CLASSIFICATION_DETACHED));
+                out.push(new merged_branch_verdicts_1.DeletableWorktree(tree.path, '', 'detached HEAD — no branch to check, so a human must decide', 0, false, merged_branch_verdicts_1.CLASSIFICATION_DETACHED));
                 continue;
             }
             // The branch's OWN classification token rides along unchanged. That is what lets wp-cleanup
             // group probably-dead worktrees exactly the way it groups probably-dead branches, instead of
             // inventing a second, parallel notion of "how dead is this".
             const verdict = this.classify(repoRoot, tree.branch, prs);
-            out.push(new DeletableWorktree(tree.path, tree.branch, verdict.entry.reason, verdict.entry.pr, verdict.deletable, verdict.entry.classification));
+            out.push(new merged_branch_verdicts_1.DeletableWorktree(tree.path, tree.branch, verdict.entry.reason, verdict.entry.pr, verdict.deletable, verdict.entry.classification));
         }
         return out;
     }
@@ -360,21 +268,24 @@ let MergedBranchesService = class MergedBranchesService {
         const prState = known ? known.state : '';
         const own = prs.merged.get(branch);
         if (own !== undefined) {
-            return new Verdict(true, new DeletableBranch(branch, `PR #${String(own)} merged`, own, sha, commits, prState || 'MERGED', exports.CLASSIFICATION_MERGED_PR));
+            return new Verdict(true, new merged_branch_verdicts_1.DeletableBranch(branch, `PR #${String(own)} merged`, own, sha, commits, prState || 'MERGED', merged_branch_verdicts_1.CLASSIFICATION_MERGED_PR));
         }
         const base = branch.replace(BACKUP_SUFFIX, '');
         if (base !== branch && base.length > 0) {
             const basePr = prs.merged.get(base);
             if (basePr !== undefined) {
-                return new Verdict(true, new DeletableBranch(branch, `squash-merge backup of '${base}' (PR #${String(basePr)} merged) — its job is done`, basePr, sha, commits, prState, exports.CLASSIFICATION_BACKUP_OF_MERGED));
+                return new Verdict(true, new merged_branch_verdicts_1.DeletableBranch(branch, `squash-merge backup of '${base}' (PR #${String(basePr)} merged) — its job is done`, basePr, sha, commits, prState, merged_branch_verdicts_1.CLASSIFICATION_BACKUP_OF_MERGED));
             }
         }
-        // The one git-local signal that squash-merge CANNOT corrupt: a branch with zero commits of its
-        // own holds no work, so deleting it can lose nothing. (Squash breaks patch-id and ancestry, so
-        // "are these commits in main?" is unanswerable from git — but "are there any commits at all?"
-        // is exact.) These are the husks left behind by branching and then never committing.
+        // Zero commits of its own. This is SPARED, not deletable — see CLASSIFICATION_NO_COMMITS for
+        // why. It is a real signal (the branch is identical to origin/main), but it is equally the
+        // signature of a worktree an agent created thirty seconds ago and has not committed in yet,
+        // and there is no git-local way to tell those two apart. So it becomes a question for a human
+        // (wp-cleanup prompts on it) instead of an unattended delete.
         if (commits === 0) {
-            return new Verdict(true, new DeletableBranch(branch, 'no commits of its own — identical to origin/main', 0, sha, 0, prState, exports.CLASSIFICATION_NO_COMMITS));
+            return new Verdict(false, new merged_branch_verdicts_1.DeletableBranch(branch, 'no commits of its own — identical to origin/main. That is either an abandoned husk OR a '
+                + 'worktree/branch someone is working in right now and has not committed to yet, so it is '
+                + 'never reaped unattended', 0, sha, 0, prState, merged_branch_verdicts_1.CLASSIFICATION_NO_COMMITS));
         }
         return new Verdict(false, this.classifySpared(repoRoot, branch, prs, sha, commits, prState));
     }
@@ -391,20 +302,20 @@ let MergedBranchesService = class MergedBranchesService {
         // A PR that CLOSED without merging, in a repo that has merged later PRs, is near-certainly the
         // abandoned first attempt at work that landed under a different number.
         if (known !== undefined && known.state === 'CLOSED' && prs.latestMergedPr > known.number) {
-            return new DeletableBranch(branch, `PR #${String(known.number)} was CLOSED UNMERGED and later PRs (through ` +
-                `#${String(prs.latestMergedPr)}) have merged — near-certainly superseded`, known.number, sha, commits, prState, exports.CLASSIFICATION_SUPERSEDED);
+            return new merged_branch_verdicts_1.DeletableBranch(branch, `PR #${String(known.number)} was CLOSED UNMERGED and later PRs (through ` +
+                `#${String(prs.latestMergedPr)}) have merged — near-certainly superseded`, known.number, sha, commits, prState, merged_branch_verdicts_1.CLASSIFICATION_SUPERSEDED);
         }
         // `git cherry` compares by PATCH-ID, so it survives cherry-picks and rebases. It does NOT
         // survive a squash — which is exactly why this is a spared verdict and not a deletable proof.
         if (this.contentAlreadyInMain(repoRoot, branch)) {
-            return new DeletableBranch(branch, `all ${String(commits)} commit(s) already have an equivalent in origin/main ` +
-                `(git cherry) — content is not unique`, known ? known.number : 0, sha, commits, prState, exports.CLASSIFICATION_CONTENT_IN_MAIN);
+            return new merged_branch_verdicts_1.DeletableBranch(branch, `all ${String(commits)} commit(s) already have an equivalent in origin/main ` +
+                `(git cherry) — content is not unique`, known ? known.number : 0, sha, commits, prState, merged_branch_verdicts_1.CLASSIFICATION_CONTENT_IN_MAIN);
         }
         const why = known
             ? `PR #${String(known.number)} is ${known.state} (not merged); holds ` +
                 `${String(commits)} unique commit(s) — a human must decide`
             : `never had a PR; holds ${String(commits)} unique commit(s) that may be the only copy in existence`;
-        return new DeletableBranch(branch, why, 0, sha, commits, prState, exports.CLASSIFICATION_NEVER_PROPOSED);
+        return new merged_branch_verdicts_1.DeletableBranch(branch, why, 0, sha, commits, prState, merged_branch_verdicts_1.CLASSIFICATION_NEVER_PROPOSED);
     }
     /**
      * True when EVERY commit on the branch has a patch-equivalent already in origin/main.
@@ -463,7 +374,7 @@ let MergedBranchesService = class MergedBranchesService {
                 const branch = entry.headRefName ?? '';
                 const pr = entry.number ?? 0;
                 if (branch !== '' && pr > 0)
-                    out.push(new MergedBranch(branch, pr));
+                    out.push(new merged_branch_verdicts_1.MergedBranch(branch, pr));
             }
             return out;
         }
@@ -512,12 +423,12 @@ let MergedBranchesService = class MergedBranchesService {
     reviveList(raw) {
         if (!raw)
             return [];
-        return raw.map((entry) => new DeletableBranch(entry.branch ?? '', entry.reason ?? '', entry.pr ?? 0, entry.sha ?? '', entry.commits ?? -1, entry.prState ?? '', entry.classification ?? exports.CLASSIFICATION_NEVER_PROPOSED));
+        return raw.map((entry) => new merged_branch_verdicts_1.DeletableBranch(entry.branch ?? '', entry.reason ?? '', entry.pr ?? 0, entry.sha ?? '', entry.commits ?? -1, entry.prState ?? '', entry.classification ?? merged_branch_verdicts_1.CLASSIFICATION_NEVER_PROPOSED));
     }
     reviveWorktrees(raw) {
         if (!raw)
             return [];
-        return raw.map((entry) => new DeletableWorktree(entry.path ?? '', entry.branch ?? '', entry.reason ?? '', entry.pr ?? 0, entry.deletable ?? false, entry.classification ?? exports.CLASSIFICATION_NEVER_PROPOSED));
+        return raw.map((entry) => new merged_branch_verdicts_1.DeletableWorktree(entry.path ?? '', entry.branch ?? '', entry.reason ?? '', entry.pr ?? 0, entry.deletable ?? false, entry.classification ?? merged_branch_verdicts_1.CLASSIFICATION_NEVER_PROPOSED));
     }
     // Run a command capturing trimmed stdout; ok=false on spawn failure or non-zero exit.
     capture(repoRoot, cmd, args) {