@osdlc/repo-cleaner 0.10.0 → 0.10.1

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @osdlc/repo-cleaner
 
+## 0.10.1
+
+### Patch Changes
+
+- cde11b5: `apply` fixes:
+  
+  - The run a confirmation approves keeps the safe-to-delete guard: a row that turned into a review row between the preview and the yes is dropped as `needs-review`, not run.
+  - Two clones of one remote no longer delete its branches twice. The second row is dropped as the new reason `duplicate`, naming the clone that deletes it; before, the second push was rejected and the run stopped with exit 11. Remotes are compared by the push URLs git uses (`url.*.insteadOf` applied), a network URL in any form (`git@host:o/r`, `ssh://`, `https://`) as `host/path`, and a local path as written.
+  - A swept `apply` re-checks once before asking, from the sweep it just ran, instead of sweeping again; the run that deletes still sweeps afresh.
+  - A run that deletes without a receipt file says so on stderr.
+  - Every run ends with a summary: `deleted: 1 worktree, 3 local branches, 2 remote branches`, the dropped rows by reason, and how many rows a failed run did not reach. A preview says `would delete:`. `--output json` adds a `summary` object.
+  - The prompt's `Delete N items?` counts rows, not steps: a stale-locked worktree is one item, not two.
+  - `--repo-root` naming no repository in the plan exits 1 instead of reporting nothing to delete.
+  - An empty plan's JSON receipt says `complete`, not `dry-run`, unless the run was `--dry-run`.
+  
+  Library: `ApplyOptions.safeOnly` and `ApplyOptions.swept`, the `duplicate` drop reason, `RECEIPT_VERSION`, and `summarizeReceipt`, `renderApplySummary` and `ApplySummary`.
+
 ## 0.10.0
 
 ### Minor Changes

package/README.md

@@ -312,6 +312,20 @@ On yes it runs only the steps it showed: worktrees first, then local branches,
 remote branches and a prune, in that order. Branch deletes are
 compare-and-swap, every step is verified, and the first failure stops the run.
 
+Every run ends with what it did:
+
+```text
+deleted: 1 worktree, 3 local branches, 2 remote branches, 1 stale worktree pruned
+dropped 2: 1 needs-review, 1 duplicate
+status: complete
+```
+
+The preview says `would delete:`, and a run that stops at a failed step says
+how many rows it did not reach. `--output json` carries the same counts as
+`summary`. Two clones of one remote list the same remote branches; `apply`
+deletes each once and drops the other clone's row as `duplicate`. Remotes are
+compared by the push URL git uses, with `url.*.insteadOf` applied.
+
 A receipt records every step and is rewritten after each one. With
 `--plan plan.json` it goes beside the plan, as
 `plan.receipt-<timestamp>.json`. `--receipt <file>` puts it anywhere. A run

package/dist/apply.d.ts

@@ -18,8 +18,8 @@ import type { CommandRunner } from '@osdlc/command-seam';
 import type { HostHooks } from './hooks.ts';
 import { type ProcessProbe } from './processes.ts';
 import { type Plan } from './plan.ts';
-import type { Dropped, Receipt, RowRef, Step } from './receipt.ts';
-import { type Authorization, type SweepProgress } from './types.ts';
+import { type Dropped, type Receipt, type RowRef, type Step } from './receipt.ts';
+import { type Authorization, type SweepItem, type SweepProgress } from './types.ts';
 /** An authorization the caller gave, for one row or (`row: null`) for all. */
 export interface Grant {
     name: Authorization;
@@ -45,6 +45,20 @@ export interface ApplyOptions extends HostHooks {
     /** Limit the run to the plan repository rooted here. */
     repoRoot?: string | undefined;
     now?: () => Date;
+    /**
+     * Drop each selected row the re-check does not judge `safe-to-delete`.
+     * Defaults to true when no rows are requested, so a row to review runs only
+     * when it is named. Pass it to keep that guard on a run whose rows came
+     * from such a selection, such as the run a preview confirmed.
+     */
+    safeOnly?: boolean | undefined;
+    /**
+     * Items to re-check against instead of sweeping again, keyed by repository
+     * root, already annotated: the hook is not applied to them again. For a
+     * preview straight after a sweep; the run that deletes should always sweep
+     * again.
+     */
+    swept?: ReadonlyMap<string, readonly SweepItem[]> | undefined;
     /** Rows dropped before this run, such as by a preview; recorded first in the receipt. */
     dropped?: readonly Dropped[] | undefined;
     /** Passed to the re-sweep's `onProgress`, for a status line. */
@@ -66,6 +80,13 @@ export declare function parseGrant(text: string): Grant;
 export type RowSelection = RowRef & {
     repo?: string;
 };
+/**
+ * A network URL as `host[:port]/path`, the same for `git@host:o/r.git`,
+ * `ssh://git@host/o/r` and `https://host/o/r/`; the whole path is kept, so
+ * nested groups stay apart. Null for a path on this machine, including
+ * `file://` and a Windows drive path.
+ */
+export declare function networkRemoteKey(url: string): string | null;
 /**
  * Apply the `requested` rows of `plan` under `grants`. An empty `requested`
  * selects every row of the plan (of `repoRoot`'s repository, when given) and

package/dist/apply.js

@@ -20,6 +20,7 @@ import { CommandFailed, Git, PUSH_REJECTIONS } from '@osdlc/typed-git';
 import { localDeleteCommand, remoteDeleteCommand } from "./branches.js";
 import { busyHolders, defaultProcessProbe, parseLockOwner } from "./processes.js";
 import { PLAN_CATEGORIES, fingerprint, isPlanCategory, sameFingerprint, } from "./plan.js";
+import { RECEIPT_VERSION } from "./receipt.js";
 import { sweepRepo } from "./sweep.js";
 import { AUTHORIZATIONS } from "./types.js";
 import { worktreePruneCommand, worktreeRemoveCommand, worktreeUnlockCommand } from "./worktrees.js";
@@ -78,6 +79,10 @@ function granted(grants, ref, name) {
 }
 /** The plan repository's rows as they stand now, with the host's overlay applied. */
 function resweep(repo, opts) {
+    const given = opts.swept?.get(repo.root);
+    if (given !== undefined) {
+        return [...given];
+    }
     const sweep = sweepRepo(repo.root, {
         remote: repo.remote,
         noGh: repo.no_gh,
@@ -257,6 +262,73 @@ function execute(step, row, git, probe) {
         }
     }
 }
+/**
+ * A network URL as `host[:port]/path`, the same for `git@host:o/r.git`,
+ * `ssh://git@host/o/r` and `https://host/o/r/`; the whole path is kept, so
+ * nested groups stay apart. Null for a path on this machine, including
+ * `file://` and a Windows drive path.
+ */
+export function networkRemoteKey(url) {
+    const u = url.trim();
+    if (/^[a-z]:[\\/]/i.test(u) || /^file:/i.test(u))
+        return null;
+    const uri = /^[a-z][a-z0-9+.-]*:\/\/(?:[^@/]+@)?([^/:]+)(?::(\d+))?(\/.*)?$/i.exec(u);
+    const scp = uri === null ? /^(?:[^@/:]+@)?([^/:]+):(?!\/\/)(.+)$/.exec(u) : null;
+    const host = uri?.[1] ?? scp?.[1];
+    if (host === undefined)
+        return null;
+    const port = uri?.[2] === undefined ? '' : `:${uri[2]}`;
+    const path = (uri?.[3] ?? scp?.[2] ?? '').replace(/^\/+|\/+$/g, '').replace(/\.git$/, '');
+    return `${host.toLowerCase()}${port}/${path}`;
+}
+/**
+ * One string per remote repository, so two clones that push to the same one
+ * agree. Built from the push URLs git would use (`remote get-url --push
+ * --all`, which applies `url.*.insteadOf` and `pushInsteadOf`): a network URL
+ * by {@link networkRemoteKey}, a local path resolved against the repository
+ * and kept as written, `.git` and all. Null when git reports no URL; such a
+ * row is never treated as a duplicate.
+ */
+function remoteKey(git, repo, remote) {
+    const urls = git.at(repo).try.remoteGetUrls(remote, { push: true });
+    if (!urls.ok || urls.value === null || urls.value.length === 0)
+        return null;
+    const keys = urls.value.map((url) => networkRemoteKey(url) ?? resolve(repo, url.trim().replace(/^file:\/\/(localhost)?/i, '')));
+    return [...new Set(keys)].sort().join('\n');
+}
+/**
+ * Keep the first row for each remote branch. Two clones of one remote each
+ * list its branches; deleting one twice fails the second push and stops the
+ * run, so the later row is dropped as `duplicate`.
+ */
+function onePerRemoteBranch({ accepted, dropped }, git) {
+    const seen = new Map();
+    const kept = [];
+    const extra = [];
+    for (const row of accepted) {
+        if (row.item.category !== 'remote_branch') {
+            kept.push(row);
+            continue;
+        }
+        const remote = remoteKey(git, row.repo, String(row.item.facts['remote']));
+        const key = remote === null ? null : `${remote}\0${String(row.item.facts['branch'])}`;
+        const first = key === null ? undefined : seen.get(key);
+        if (first !== undefined) {
+            extra.push({
+                repo: row.repo,
+                category: row.item.category,
+                id: row.item.id,
+                reason: 'duplicate',
+                detail: `the same remote branch is deleted from ${first}`,
+            });
+            continue;
+        }
+        if (key !== null)
+            seen.set(key, row.repo);
+        kept.push(row);
+    }
+    return { accepted: kept, dropped: [...dropped, ...extra] };
+}
 /**
  * Apply the `requested` rows of `plan` under `grants`. An empty `requested`
  * selects every row of the plan (of `repoRoot`'s repository, when given) and
@@ -286,7 +358,7 @@ export function applyPlan(plan, requested, grants, opts) {
         }
     }
     const receipt = {
-        version: 1,
+        version: RECEIPT_VERSION,
         plan: opts.planPath,
         status: opts.dryRun ? 'dry-run' : 'applying',
         started_at: now().toISOString(),
@@ -294,7 +366,8 @@ export function applyPlan(plan, requested, grants, opts) {
         dropped: [],
         steps: [],
     };
-    const { accepted, dropped } = recheck(selected, grants, requested.length === 0, opts);
+    const rechecked = recheck(selected, grants, opts.safeOnly ?? requested.length === 0, opts);
+    const { accepted, dropped } = onePerRemoteBranch(rechecked, new Git(opts.callerCwd, { runner: opts.git }));
     receipt.dropped = [...(opts.dropped ?? []), ...dropped];
     const ordered = PLAN_CATEGORIES.flatMap((category) => accepted.filter((row) => row.item.category === category));
     const plannedSteps = ordered.flatMap((row) => stepsFor(row).map((step) => [step, row]));

package/dist/branches.d.ts

@@ -27,6 +27,16 @@ export declare function recordPr(facts: Record<string, unknown>, pr: PRInfo | un
 };
 /** One sentence on why a merged PR did not count, for `investigationParts`. */
 export declare function gapSentence(pr: PRInfo, gap: PrEvidenceGap, repo: RepoInfo): string;
+/**
+ * `facts.merged`: the work is on the default branch, by an exact-head merged
+ * PR, by ancestry or by a patch match. Every category records it this way, so
+ * `summary` counts one definition.
+ */
+export declare function mergedFact(e: {
+    landed: boolean;
+    ancestor: boolean;
+    patchLanded: boolean;
+}): boolean;
 /** `HEAD` as the branch checked out at `git`'s directory; any other name as given. */
 export declare function resolveBranch(value: string, git: Git): string;
 /**

package/dist/branches.js

@@ -59,6 +59,14 @@ export function gapSentence(pr, gap, repo) {
         ? `PR #${pr.number} merged into \`${pr.baseRef}\`, not \`${repo.mainBranch}\`, so it is not landing proof (other-base).`
         : `PR #${pr.number} merged at head ${pr.headOid ?? '(unknown)'}, which is not this tip, so it is not landing proof (head-moved).`;
 }
+/**
+ * `facts.merged`: the work is on the default branch, by an exact-head merged
+ * PR, by ancestry or by a patch match. Every category records it this way, so
+ * `summary` counts one definition.
+ */
+export function mergedFact(e) {
+    return e.landed || e.ancestor || e.patchLanded;
+}
 /** What deleting a branch needs: its unlanded commits, and its open PR. */
 function branchRequires(unmerged, pr) {
     return authorizationsFor({
@@ -152,7 +160,11 @@ export function classifyLocalBranch(opts) {
         // `soft`: a missing default ref reads as not merged.
         const pr = prs.get(name);
         const { landed } = recordPr(facts, pr, sha, repo);
-        facts['merged'] = landed || git.at(repo.root).soft.isAncestor(sha, landedRef(repo));
+        facts['merged'] = mergedFact({
+            landed,
+            ancestor: git.at(repo.root).soft.isAncestor(sha, landedRef(repo)),
+            patchLanded: false,
+        });
         return pinned(held);
     }
     // Work merged only into an unpushed local default has not landed. A missing
@@ -172,8 +184,7 @@ export function classifyLocalBranch(opts) {
         recordLanding(facts, patch);
     const patchLanded = patch !== null && patch.check !== null;
     const unmerged = !landed && !isAncestor && !landingConfirmed(patch);
-    // Merged: the work is on the default branch, by ancestry, an exact-head merged PR or a patch match.
-    facts['merged'] = landed || isAncestor || patchLanded;
+    facts['merged'] = mergedFact({ landed, ancestor: isAncestor, patchLanded });
     if (!landed && !isAncestor) {
         facts['unique_commits'] = git.at(repo.root).aheadBehind(repo.mainBranch, sha).ahead;
     }
@@ -297,8 +308,7 @@ export function classifyRemoteBranch(opts) {
         recordLanding(facts, patch);
     const patchLanded = patch !== null && patch.check !== null;
     const unmerged = !landed && !isAncestor && !landingConfirmed(patch);
-    // Merged: the work is on the default branch, by ancestry, an exact-head merged PR or a patch match.
-    facts['merged'] = landed || isAncestor || patchLanded;
+    facts['merged'] = mergedFact({ landed, ancestor: isAncestor, patchLanded });
     if (!landed && !isAncestor) {
         // Unknown (null) when the clone lacks `sha` or `remoteMain`, as above.
         const counted = git.at(repo.root).try.aheadBehind(remoteMain, sha);

package/dist/cli.js

@@ -29,7 +29,8 @@ import { Git } from '@osdlc/typed-git';
 import { resolveBranch } from "./branches.js";
 import { ApplyArgumentError, applyPlan, parseGrant, parseRowRef } from "./apply.js";
 import { PLAN_VERSION, fileStamp, parsePlan, planRepo, readPlan, writePlan, } from "./plan.js";
-import { proposedCommands, renderCountsJson, renderCountsText, renderJson, renderReceipt, renderSummary, renderText, } from "./render.js";
+import { RECEIPT_VERSION } from "./receipt.js";
+import { proposedCommands, renderCountsJson, renderCountsText, renderJson, renderReceipt, renderSummary, renderText, rowsActedOn, summarizeReceipt, } from "./render.js";
 import { NO_STATUS_LINE, describeStep, describeSweep, statusLine, } from "./status-line.js";
 import { sweepRepos } from "./sweep.js";
 const EXIT_NOTHING_TO_SWEEP = 10;
@@ -160,7 +161,7 @@ const applyCli = () => defineCli({
         repoRoot: {
             kind: 'string',
             valueName: 'path',
-            help: 'apply only the plan repository rooted here',
+            help: 'with a plan of several repositories: apply only the one rooted here',
         },
         receipt: {
             kind: 'string',
@@ -209,27 +210,23 @@ function failure(ctx, err) {
     return EXIT.error;
 }
 /** Validate the sweep flags and run the sweep, or answer with the exit code. */
-function sweep(name, v, paths, ctx, render, status) {
+function sweep(name, v, paths, ctx, status) {
     const only = v.only?.filter((s) => s !== '');
     const unknown = (only ?? []).filter((s) => !(s in ONLY));
     if (unknown.length > 0) {
-        return {
-            ok: false,
-            code: usageError(ctx, name, `unknown --only value(s): ${unknown.join(', ')}`),
-        };
+        const message = `unknown --only value(s): ${unknown.join(', ')}`;
+        return { kind: 'exit', code: usageError(ctx, name, message) };
     }
     if (v.branch !== undefined && paths.length > 0) {
-        return {
-            ok: false,
-            code: usageError(ctx, name, '--branch sweeps this repository only; drop the paths'),
-        };
+        const message = '--branch sweeps this repository only; drop the paths';
+        return { kind: 'exit', code: usageError(ctx, name, message) };
     }
     let branch;
     try {
         branch = v.branch === undefined ? undefined : resolveBranch(v.branch, new Git(ctx.cwd));
     }
     catch (err) {
-        return { ok: false, code: failure(ctx, err) };
+        return { kind: 'exit', code: failure(ctx, err) };
     }
     const options = {
         baseDir: ctx.cwd,
@@ -250,16 +247,14 @@ function sweep(name, v, paths, ctx, render, status) {
     status.clear();
     if (branch !== undefined && result.repos.length > 1) {
         const err = new Error(`--branch sweeps one repository; ${result.repos.length} found under ${ctx.cwd}`);
-        return { ok: false, code: failure(ctx, err) };
+        return { kind: 'exit', code: failure(ctx, err) };
     }
     const refused = branch === undefined ? null : (result.repos[0]?.error ?? null);
     if (refused !== null)
-        return { ok: false, code: failure(ctx, new Error(refused)) };
-    if (result.repos.length === 0) {
-        ctx.io.stdout(render(result));
-        return { ok: false, code: EXIT_NOTHING_TO_SWEEP };
-    }
-    return { ok: true, result, branch, values: v };
+        return { kind: 'exit', code: failure(ctx, new Error(refused)) };
+    if (result.repos.length === 0)
+        return { kind: 'nothing', result };
+    return { kind: 'ok', result, branch, values: v };
 }
 /**
  * Name each repository the sweep could not read, on stderr. True when there
@@ -292,9 +287,13 @@ function runStatus(argv, ctx, status) {
         return usageError(ctx, NAME, parsed.message);
     const v = parsed.values;
     const render = (r) => v.output === 'json' ? renderJson(r) : renderText(r, { keep: v.keep });
-    const swept = sweep(NAME, v, parsed.positionals, ctx, render, status);
-    if (!swept.ok)
+    const swept = sweep(NAME, v, parsed.positionals, ctx, status);
+    if (swept.kind === 'exit')
         return swept.code;
+    if (swept.kind === 'nothing') {
+        ctx.io.stdout(render(swept.result));
+        return EXIT_NOTHING_TO_SWEEP;
+    }
     if (v.commands) {
         const commands = proposedCommands(swept.result);
         if (commands.length > 0)
@@ -314,11 +313,11 @@ function runSummary(argv, ctx, status) {
         return usageError(ctx, name, parsed.message);
     const v = parsed.values;
     const render = (r) => v.output === 'json' ? renderCountsJson(r) : renderCountsText(r);
-    const swept = sweep(name, v, parsed.positionals, ctx, render, status);
-    if (!swept.ok)
+    const swept = sweep(name, v, parsed.positionals, ctx, status);
+    if (swept.kind === 'exit')
         return swept.code;
     ctx.io.stdout(render(swept.result));
-    return EXIT.ok;
+    return swept.kind === 'nothing' ? EXIT_NOTHING_TO_SWEEP : EXIT.ok;
 }
 function runPlan(argv, ctx, status) {
     const name = `${NAME} plan`;
@@ -328,12 +327,14 @@ function runPlan(argv, ctx, status) {
     if (parsed.status === 'error')
         return usageError(ctx, name, parsed.message);
     const v = parsed.values;
-    const swept = sweep(name, v, parsed.positionals, ctx, (r) => {
-        ctx.io.stderr(renderSummary(r) + '\n');
-        return '';
-    }, status);
-    if (!swept.ok)
+    const swept = sweep(name, v, parsed.positionals, ctx, status);
+    if (swept.kind === 'exit')
         return swept.code;
+    // stdout carries only the plan, so the summary goes to stderr either way.
+    if (swept.kind === 'nothing') {
+        ctx.io.stderr(renderSummary(swept.result) + '\n');
+        return EXIT_NOTHING_TO_SWEEP;
+    }
     const plan = planOf(swept, new Date());
     const unreadable = reportUnreadable(ctx, name, swept.result);
     ctx.io.stderr(renderSummary(swept.result) + '\n');
@@ -352,8 +353,68 @@ function receiptBeside(planPath, now) {
     const stem = basename(planPath).replace(/\.json$/i, '');
     return join(dirname(planPath), `${stem}.receipt-${fileStamp(now)}.json`);
 }
+/** Rows the run would delete or prune: one each, however many steps (an unlock, a remove) it takes. */
 function wouldRun(receipt) {
-    return receipt.steps.filter((s) => s.row !== null).length;
+    return rowsActedOn(summarizeReceipt(receipt));
+}
+/** Sweep and plan in memory, or read `--plan`; or answer with the exit code. */
+function loadPlan(name, v, paths, ctx, deps, status, now) {
+    const receiptPath = v.receipt === undefined ? null : resolve(ctx.cwd, v.receipt);
+    if (v.plan === undefined) {
+        const swept = sweep(name, v, paths, ctx, status);
+        if (swept.kind === 'exit')
+            return swept.code;
+        if (swept.kind === 'nothing') {
+            ctx.io.stdout(v.output === 'json' ? renderJson(swept.result) : renderText(swept.result));
+            return EXIT_NOTHING_TO_SWEEP;
+        }
+        const items = new Map();
+        for (const r of swept.result.repos)
+            if (r.repo !== null)
+                items.set(r.repo.root, r.items);
+        return {
+            plan: planOf(swept, now),
+            source: '(swept)',
+            receiptPath,
+            unreadable: reportUnreadable(ctx, name, swept.result),
+            swept: items,
+        };
+    }
+    try {
+        if (v.plan === '-') {
+            const plan = parsePlan((deps.readStdin ?? readAllStdin)(), 'stdin');
+            return { plan, source: '(stdin)', receiptPath, unreadable: false, swept: undefined };
+        }
+        const source = resolve(ctx.cwd, v.plan);
+        const plan = readPlan(source);
+        return {
+            plan,
+            source,
+            receiptPath: receiptPath ?? receiptBeside(source, now),
+            unreadable: false,
+            swept: undefined,
+        };
+    }
+    catch (err) {
+        return failure(ctx, err);
+    }
+}
+/** The run's flags that contradict each other, as a usage message, or null. */
+function applyConflict(v, paths) {
+    if (v.plan !== undefined) {
+        const sweepFlags = [
+            paths.length > 0 ? 'paths' : null,
+            v.only !== undefined ? '--only' : null,
+            v.branch !== undefined ? '--branch' : null,
+            v.remote !== undefined ? '--remote' : null,
+        ].filter((f) => f !== null);
+        if (sweepFlags.length > 0)
+            return `--plan fixes what is swept; drop ${sweepFlags.join(', ')}`;
+    }
+    if (v.plan === '-' && !v.yes && !v.dryRun) {
+        return '--plan - reads the plan from stdin, so it cannot ask; pass --yes or --dry-run';
+    }
+    return null;
 }
 function runApply(argv, ctx, deps, status) {
     const name = `${NAME} apply`;
@@ -375,57 +436,39 @@ function runApply(argv, ctx, deps, status) {
             return usageError(ctx, name, err.message);
         throw err;
     }
-    const fromStdin = v.plan === '-';
-    if (v.plan !== undefined) {
-        const sweepFlags = [
-            paths.length > 0 ? 'paths' : null,
-            v.only !== undefined ? '--only' : null,
-            v.branch !== undefined ? '--branch' : null,
-            v.remote !== undefined ? '--remote' : null,
-        ].filter((f) => f !== null);
-        if (sweepFlags.length > 0) {
-            return usageError(ctx, name, `--plan fixes what is swept; drop ${sweepFlags.join(', ')}`);
-        }
-    }
-    if (fromStdin && !v.yes && !v.dryRun) {
-        return usageError(ctx, name, '--plan - reads the plan from stdin, so it cannot ask; pass --yes or --dry-run');
-    }
+    const conflict = applyConflict(v, paths);
+    if (conflict !== null)
+        return usageError(ctx, name, conflict);
     const now = new Date();
-    let plan;
-    let planSource;
-    // A repository the sweep could not read contributes no rows; the run says so and exits 1.
-    let unreadable = false;
-    const ok = () => (unreadable ? EXIT.error : EXIT.ok);
-    let receiptPath = v.receipt === undefined ? null : resolve(ctx.cwd, v.receipt);
-    if (v.plan === undefined) {
-        const swept = sweep(name, v, paths, ctx, (r) => (v.output === 'json' ? renderJson(r) : renderText(r)), status);
-        if (!swept.ok)
-            return swept.code;
-        unreadable = reportUnreadable(ctx, name, swept.result);
-        plan = planOf(swept, now);
-        planSource = '(swept)';
+    const loaded = loadPlan(name, v, paths, ctx, deps, status, now);
+    if (typeof loaded === 'number')
+        return loaded;
+    const { plan, source, receiptPath } = loaded;
+    const ok = () => (loaded.unreadable ? EXIT.error : EXIT.ok);
+    const repoRoot = v.repoRoot === undefined ? undefined : resolve(ctx.cwd, v.repoRoot);
+    const print = (receipt, shownPath) => {
+        ctx.io.stdout(v.output === 'json'
+            ? `${JSON.stringify({ receiptPath: shownPath, summary: summarizeReceipt(receipt), receipt }, null, 2)}\n`
+            : renderReceipt(receipt, shownPath));
+    };
+    const planned = plan.repos.filter((r) => repoRoot === undefined || resolve(r.root) === resolve(repoRoot));
+    if (repoRoot !== undefined && planned.length === 0) {
+        return failure(ctx, new Error(`no plan repository at ${repoRoot}`));
     }
-    else {
-        try {
-            if (fromStdin) {
-                plan = parsePlan((deps.readStdin ?? readAllStdin)(), 'stdin');
-                planSource = '(stdin)';
-            }
-            else {
-                planSource = resolve(ctx.cwd, v.plan);
-                plan = readPlan(planSource);
-                receiptPath ??= receiptBeside(planSource, now);
-            }
-        }
-        catch (err) {
-            return failure(ctx, err);
-        }
+    if (rows.length === 0 && planned.every((r) => r.rows.length === 0)) {
+        if (v.output === 'json')
+            print(emptyReceipt(source, now, v.dryRun), null);
+        else
+            ctx.io.stdout('nothing to delete\n');
+        return ok();
     }
-    const repoRoot = v.repoRoot === undefined ? undefined : resolve(ctx.cwd, v.repoRoot);
     const base = {
         callerCwd: ctx.cwd,
-        planPath: planSource,
+        planPath: source,
         repoRoot,
+        // An implicit selection runs only safe-to-delete rows, in the preview and
+        // in the run it confirms, whose rows are passed explicitly.
+        safeOnly: rows.length === 0,
         ...(v.progress
             ? {
                 onSweepProgress: (p) => status.update(`re-checking ${describeSweep(p)}`),
@@ -433,25 +476,17 @@ function runApply(argv, ctx, deps, status) {
             }
             : {}),
     };
-    const print = (receipt, shownPath) => {
-        ctx.io.stdout(v.output === 'json'
-            ? `${JSON.stringify({ receiptPath: shownPath, receipt }, null, 2)}\n`
-            : renderReceipt(receipt, shownPath));
-    };
     let preview;
     try {
-        preview = applyPlan(plan, rows, grants, { ...base, dryRun: true, receiptPath: null });
+        // A sweep that just ran is the preview's re-check; the run that deletes sweeps again.
+        preview = applyPlan(plan, rows, grants, {
+            ...base,
+            dryRun: true,
+            receiptPath: null,
+            swept: loaded.swept,
+        });
     }
     catch (err) {
-        if (err instanceof ApplyArgumentError) {
-            if (rows.length === 0 && plan.repos.every((r) => r.rows.length === 0)) {
-                if (v.output === 'json')
-                    print(emptyReceipt(planSource, now), null);
-                else
-                    ctx.io.stdout('nothing to delete\n');
-                return ok();
-            }
-        }
         return failure(ctx, err);
     }
     const count = wouldRun(preview);
@@ -460,17 +495,9 @@ function runApply(argv, ctx, deps, status) {
         return ok();
     }
     if (!v.yes) {
-        // The preview is for the person answering, so it goes where the question does.
-        const show = v.output === 'json' ? ctx.io.stderr : ctx.io.stdout;
-        show(renderReceipt(preview, null));
-        const answer = (deps.confirm ?? terminalConfirm)(`Delete ${count} item${count === 1 ? '' : 's'}?`);
-        if (answer === null) {
-            return usageError(ctx, name, 'refusing to delete without a terminal to ask; pass --yes');
-        }
-        if (!answer) {
-            ctx.io.stderr('nothing deleted\n');
-            return EXIT.ok;
-        }
+        const declined = confirm(ctx, name, preview, count, v.output === 'json', deps);
+        if (declined !== null)
+            return declined;
     }
     // Only what the preview showed: rows it dropped stay dropped.
     // Pinned to their repositories: a branch name two repositories share stays two rows.
@@ -489,14 +516,35 @@ function runApply(argv, ctx, deps, status) {
         return failure(ctx, err);
     }
     print(receipt, receiptPath);
+    if (receiptPath === null) {
+        ctx.io.stderr(`${name}: no receipt written; pass --receipt <file> to keep one\n`);
+    }
     return receipt.status === 'failed' ? EXIT_STEP_FAILED : ok();
 }
-function emptyReceipt(plan, now) {
+/**
+ * Show the preview and ask. Null to go ahead; otherwise the exit code: 0 for
+ * a no, 2 when there is no one to ask.
+ */
+function confirm(ctx, name, preview, count, json, deps) {
+    // The preview is for the person answering, so it goes where the question does.
+    const show = json ? ctx.io.stderr : ctx.io.stdout;
+    show(renderReceipt(preview, null));
+    const answer = (deps.confirm ?? terminalConfirm)(`Delete ${count} item${count === 1 ? '' : 's'}?`);
+    if (answer === null) {
+        return usageError(ctx, name, 'refusing to delete without a terminal to ask; pass --yes');
+    }
+    if (!answer) {
+        ctx.io.stderr('nothing deleted\n');
+        return EXIT.ok;
+    }
+    return null;
+}
+function emptyReceipt(plan, now, dryRun) {
     const at = now.toISOString();
     return {
-        version: 1,
+        version: RECEIPT_VERSION,
         plan,
-        status: 'dry-run',
+        status: dryRun ? 'dry-run' : 'complete',
         started_at: at,
         finished_at: at,
         dropped: [],

package/dist/index.d.ts

@@ -21,10 +21,10 @@ export { assessLanding, patchEquivalent, type Landing, type LandingCheck } from
 export { ApplyArgumentError, applyPlan, type RowSelection, parseGrant, parseRowRef, type ApplyOptions, type Grant, } from './apply.ts';
 export type { Annotate, HostHooks } from './hooks.ts';
 export { PLAN_VERSION, PlanReadError, planRepo, parsePlan, readPlan, writePlan, type Plan, type PlanRepo, type PlannableRow, } from './plan.ts';
-export { ReceiptSchema, type Dropped, type Receipt, type RowRef, type Step } from './receipt.ts';
+export { RECEIPT_VERSION, ReceiptSchema, type Dropped, type Receipt, type RowRef, type Step, } from './receipt.ts';
 export { defaultProcessProbe, isIdleShell, parseLockOwner, parseLsofCwd, type DefaultProbeOptions, type LockOwner, type ProcessHolder, type ProcessProbe, } from './processes.ts';
 export { fetchPrs } from './prs.ts';
 export { expandTilde, isCheckoutRoot, resolveEntries, type Resolution, type ResolveOptions, } from './resolve.ts';
 export { sweepRepo, sweepRepos, type SweepOptions, type SweepReposOptions } from './sweep.ts';
-export { proposedCommands, renderJson, renderReceipt, renderRepo, renderScan, renderSummary, renderText, requiresNote, } from './render.ts';
+export { proposedCommands, renderJson, renderApplySummary, renderReceipt, summarizeReceipt, type ApplySummary, renderRepo, renderScan, renderSummary, renderText, requiresNote, } from './render.ts';
 export { ALL_SCOPES, AUTHORIZATIONS, authorizationsFor, emptyBucket, emptyScan, findDuplicateCheckouts, isUnfetched, makeItem, summarize, type Authorization, type Category, type Classification, type DuplicateCheckout, type PRInfo, type RepoInfo, type RepoSweep, type ScanStats, type Scope, type SummaryBucket, type SweepItem, type SweepProgress, type SweepResult, type UnresolvedEntry, } from './types.ts';

package/dist/index.js

@@ -20,10 +20,10 @@ export { DiscoveryFailed, discoverRepo } from "./discover.js";
 export { assessLanding, patchEquivalent } from "./landing.js";
 export { ApplyArgumentError, applyPlan, parseGrant, parseRowRef, } from "./apply.js";
 export { PLAN_VERSION, PlanReadError, planRepo, parsePlan, readPlan, writePlan, } from "./plan.js";
-export { ReceiptSchema } from "./receipt.js";
+export { RECEIPT_VERSION, ReceiptSchema, } from "./receipt.js";
 export { defaultProcessProbe, isIdleShell, parseLockOwner, parseLsofCwd, } from "./processes.js";
 export { fetchPrs } from "./prs.js";
 export { expandTilde, isCheckoutRoot, resolveEntries, } from "./resolve.js";
 export { sweepRepo, sweepRepos } from "./sweep.js";
-export { proposedCommands, renderJson, renderReceipt, renderRepo, renderScan, renderSummary, renderText, requiresNote, } from "./render.js";
+export { proposedCommands, renderJson, renderApplySummary, renderReceipt, summarizeReceipt, renderRepo, renderScan, renderSummary, renderText, requiresNote, } from "./render.js";
 export { ALL_SCOPES, AUTHORIZATIONS, authorizationsFor, emptyBucket, emptyScan, findDuplicateCheckouts, isUnfetched, makeItem, summarize, } from "./types.js";

package/dist/receipt.d.ts

@@ -1,5 +1,7 @@
 /** What `applyPlan` did, step by step, rewritten after every step. */
 import { z } from 'zod';
+/** The receipt format's version, written into every receipt. */
+export declare const RECEIPT_VERSION = 1;
 export declare const RowRefSchema: z.ZodObject<{
     category: z.ZodEnum<{
         local_branch: "local_branch";
@@ -23,6 +25,7 @@ export declare const DroppedSchema: z.ZodObject<{
         "needs-review": "needs-review";
         "facts-changed": "facts-changed";
         "not-authorized": "not-authorized";
+        duplicate: "duplicate";
     }>;
     detail: z.ZodString;
 }, z.core.$strip>;
@@ -81,6 +84,7 @@ export declare const ReceiptSchema: z.ZodObject<{
             "needs-review": "needs-review";
             "facts-changed": "facts-changed";
             "not-authorized": "not-authorized";
+            duplicate: "duplicate";
         }>;
         detail: z.ZodString;
     }, z.core.$strip>>;

package/dist/receipt.js

@@ -1,10 +1,19 @@
 /** What `applyPlan` did, step by step, rewritten after every step. */
 import { z } from 'zod';
 import { PLAN_CATEGORIES } from "./plan.js";
+/** The receipt format's version, written into every receipt. */
+export const RECEIPT_VERSION = 1;
 export const RowRefSchema = z.object({ category: z.enum(PLAN_CATEGORIES), id: z.string() });
 export const DroppedSchema = RowRefSchema.extend({
     repo: z.string(),
-    reason: z.enum(['gone', 'not-deletable', 'needs-review', 'facts-changed', 'not-authorized']),
+    reason: z.enum([
+        'gone',
+        'not-deletable',
+        'needs-review',
+        'facts-changed',
+        'not-authorized',
+        'duplicate',
+    ]),
     detail: z.string(),
 });
 export const StepSchema = z.object({
@@ -25,7 +34,7 @@ export const StepSchema = z.object({
     verification: z.string().nullable(),
 });
 export const ReceiptSchema = z.object({
-    version: z.literal(1),
+    version: z.literal(RECEIPT_VERSION),
     plan: z.string(),
     status: z.enum(['dry-run', 'applying', 'complete', 'failed']),
     started_at: z.string(),

package/dist/render.d.ts

@@ -48,5 +48,28 @@ export declare function renderText(result: SweepResult, opts?: {
 export declare function renderJson(result: SweepResult, extra?: Record<string, unknown>): string;
 /** Every command a `safe-to-delete` row that needs no authorization proposes, in report order. */
 export declare function proposedCommands(result: SweepResult): string[];
-/** An apply run as text: dropped rows, each step, then where the receipt is. */
+/** What an apply run did, or would do, counted by kind. */
+export interface ApplySummary {
+    /** Rows deleted (or, in a dry run, that would be), by category. Pruned worktrees are not counted here. */
+    deleted: {
+        worktree: number;
+        local_branch: number;
+        remote_branch: number;
+    };
+    /** Worktrees whose stale registration was pruned; their directories were gone or left alone. */
+    pruned: number;
+    /** Dropped rows by reason. */
+    dropped: Record<string, number>;
+    /** Steps that failed: 0 or 1, since the first failure stops the run. */
+    failed: number;
+    /** Row steps never reached because a step failed. */
+    notRun: number;
+}
+/** Count a receipt's outcome. A dry run's `would-run` steps count as done. */
+export declare function summarizeReceipt(receipt: Receipt): ApplySummary;
+/** Rows a receipt deletes or prunes, which is what a person is asked to approve. */
+export declare function rowsActedOn(summary: ApplySummary): number;
+/** The closing lines of an apply run: what it deleted, dropped and could not finish. */
+export declare function renderApplySummary(receipt: Receipt): string[];
+/** An apply run as text: dropped rows, each step, a summary, then where the receipt is. */
 export declare function renderReceipt(receipt: Receipt, receiptPath: string | null): string;

package/dist/render.js

@@ -264,7 +264,74 @@ export function proposedCommands(result) {
     }
     return out;
 }
-/** An apply run as text: dropped rows, each step, then where the receipt is. */
+/** Count a receipt's outcome. A dry run's `would-run` steps count as done. */
+export function summarizeReceipt(receipt) {
+    const out = {
+        deleted: { worktree: 0, local_branch: 0, remote_branch: 0 },
+        pruned: 0,
+        dropped: {},
+        failed: 0,
+        notRun: 0,
+    };
+    for (const d of receipt.dropped)
+        out.dropped[d.reason] = (out.dropped[d.reason] ?? 0) + 1;
+    for (const s of receipt.steps) {
+        if (s.result === 'failed')
+            out.failed += 1;
+        if (s.row === null)
+            continue;
+        if (s.result === 'pending') {
+            if (s.action !== 'unlock-worktree')
+                out.notRun += 1;
+            continue;
+        }
+        if (s.result !== 'ok' && s.result !== 'would-run')
+            continue;
+        if (s.action === 'remove-worktree')
+            out.deleted.worktree += 1;
+        else if (s.action === 'prune-worktrees')
+            out.pruned += 1;
+        else if (s.action === 'delete-local')
+            out.deleted.local_branch += 1;
+        else if (s.action === 'delete-remote')
+            out.deleted.remote_branch += 1;
+    }
+    return out;
+}
+/** Rows a receipt deletes or prunes, which is what a person is asked to approve. */
+export function rowsActedOn(summary) {
+    const d = summary.deleted;
+    return d.worktree + d.local_branch + d.remote_branch + summary.pruned;
+}
+const plural = (n, one, many) => `${n} ${n === 1 ? one : many}`;
+/** The closing lines of an apply run: what it deleted, dropped and could not finish. */
+export function renderApplySummary(receipt) {
+    const s = summarizeReceipt(receipt);
+    const dry = receipt.status === 'dry-run';
+    const parts = [
+        s.deleted.worktree > 0 ? plural(s.deleted.worktree, 'worktree', 'worktrees') : null,
+        s.deleted.local_branch > 0
+            ? plural(s.deleted.local_branch, 'local branch', 'local branches')
+            : null,
+        s.deleted.remote_branch > 0
+            ? plural(s.deleted.remote_branch, 'remote branch', 'remote branches')
+            : null,
+        s.pruned > 0 ? `${plural(s.pruned, 'stale worktree', 'stale worktrees')} pruned` : null,
+    ].filter((p) => p !== null);
+    const lines = [
+        `${dry ? 'would delete' : 'deleted'}: ${parts.length > 0 ? parts.join(', ') : 'nothing'}`,
+    ];
+    const dropped = Object.entries(s.dropped);
+    if (dropped.length > 0) {
+        const total = dropped.reduce((n, [, c]) => n + c, 0);
+        lines.push(`dropped ${total}: ${dropped.map(([reason, c]) => `${c} ${reason}`).join(', ')}`);
+    }
+    if (s.failed > 0) {
+        lines.push(`stopped at a failed step; ${plural(s.notRun, 'row', 'rows')} not run`);
+    }
+    return lines;
+}
+/** An apply run as text: dropped rows, each step, a summary, then where the receipt is. */
 export function renderReceipt(receipt, receiptPath) {
     const lines = [];
     for (const d of receipt.dropped) {
@@ -275,6 +342,9 @@ export function renderReceipt(receipt, receiptPath) {
         const tail = s.error ?? s.verification;
         lines.push(`${s.result.padEnd(8)} ${what}${tail ? ` (${tail})` : ''}`);
     }
+    if (lines.length > 0)
+        lines.push('');
+    lines.push(...renderApplySummary(receipt));
     lines.push(receiptPath === null
         ? `status: ${receipt.status}`
         : `receipt: ${receiptPath} (${receipt.status})`);

package/dist/version.generated.d.ts

@@ -1,2 +1,2 @@
 /** This package's version, from its package.json when it was built. */
-export declare const VERSION = "0.10.0";
+export declare const VERSION = "0.10.1";

package/dist/version.generated.js

@@ -1,3 +1,3 @@
 // Generated by cli-tool-stamp-version from package.json. Do not edit.
 /** This package's version, from its package.json when it was built. */
-export const VERSION = '0.10.0';
+export const VERSION = '0.10.1';

package/dist/worktrees.js

@@ -9,7 +9,7 @@ import { existsSync, statSync } from 'node:fs';
 import { isAbsolute, join, sep } from 'node:path';
 import { shellJoin } from '@osdlc/command-seam';
 import { nodeGuard } from '@osdlc/path-guard/node';
-import { gapSentence, recordPr } from "./branches.js";
+import { gapSentence, mergedFact, recordPr } from "./branches.js";
 import { confirmationNote, judgeLanding, landingConfirmed, recordLanding, unmatchedSentence, } from "./landing.js";
 import { busyHolders, isIdleHolder, parseLockOwner } from "./processes.js";
 import { authorizationsFor, landedRef, makeItem, } from "./types.js";
@@ -251,10 +251,12 @@ export function classifyWorktree(opts) {
     const patchLanded = patch !== null && patch.check !== null;
     const unlanded = unpushed.length > 0 && !landed && !landingConfirmed(patch);
     if (onDisk && head !== null) {
-        // Merged: HEAD's work is on the default branch. `soft`: a missing default
-        // ref reads as not merged.
-        facts['merged'] =
-            landed || patchLanded || git.at(repo.root).soft.isAncestor(head, landedRef(repo));
+        // `soft`: a missing default ref reads as not merged.
+        facts['merged'] = mergedFact({
+            landed,
+            patchLanded,
+            ancestor: git.at(repo.root).soft.isAncestor(head, landedRef(repo)),
+        });
     }
     const requires = authorizationsFor({
         'abandon-unmerged': unlanded,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@osdlc/repo-cleaner",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "description": "What has been merged into the default branch, and what can go away. Inventories local branches, worktrees and remote branches across one repository or many, classifying each with the evidence behind the verdict and the command that would act on it. Plans and applies approved deletes, compare-and-swap.",
   "license": "MIT OR Apache-2.0",
   "author": "sksizer",
@@ -50,10 +50,10 @@
   "dependencies": {
     "zod": "4.4.3",
     "@osdlc/cli-tool": "^0.12.0",
-    "@osdlc/command-seam": "^0.14.0",
     "@osdlc/path-guard": "^0.3.1",
-    "@osdlc/typed-gh": "^0.14.1",
+    "@osdlc/command-seam": "^0.14.0",
     "@osdlc/typed-git": "^0.12.0",
+    "@osdlc/typed-gh": "^0.14.1",
     "@osdlc/ux": "^0.1.1"
   },
   "devDependencies": {
@@ -63,8 +63,8 @@
     "prettier": "3.9.6",
     "typescript": "~6.0.3",
     "vitest": "^5.0.5",
-    "@osdlc/prettier-config": "^0.3.1",
-    "@osdlc/tsconfig": "^0.4.1"
+    "@osdlc/tsconfig": "^0.4.1",
+    "@osdlc/prettier-config": "^0.3.1"
   },
   "scripts": {
     "build": "cli-tool-stamp-version && tsc -p tsconfig.build.json",