@osdlc/repo-cleaner 0.11.0 → 0.13.0

package/dist/render.js

@@ -6,6 +6,7 @@
  * find. JSON carries everything the text report elides, including the facts
  * behind every verdict.
  */
+import { ansiColors, paint, stripControls } from '@osdlc/ux';
 import { emptyBucket, isPrune, isUnfetched, summarize, } from "./types.js";
 import { hasBlockers } from "./worktrees.js";
 /** Order categories consistently, whatever order they were gathered in. */
@@ -17,6 +18,27 @@ const ACTION_LABEL = {
     'needs-investigation': 'review',
     'safe-to-keep': 'keep',
 };
+const same = (text) => text;
+/** No color. */
+export const PLAIN = {
+    delete: same,
+    prune: same,
+    review: same,
+    keep: same,
+    muted: same,
+    strong: same,
+};
+// The 16 basic colors, so the terminal's own theme decides the shades.
+const ANSI = ansiColors('ansi16', 'dark');
+/** The basic terminal colors: red to delete, blue to prune, yellow to review, green to keep. */
+export const TERMINAL_STYLE = {
+    delete: (t) => paint(t, ANSI['status-error']),
+    prune: (t) => paint(t, ANSI.accent),
+    review: (t) => paint(t, ANSI['status-warning']),
+    keep: (t) => paint(t, ANSI['status-success']),
+    muted: (t) => paint(t, ANSI['text-muted']),
+    strong: (t) => `\x1b[1m${t}\x1b[22m`,
+};
 function pad(s, width) {
     return s.length >= width ? s : s + ' '.repeat(width - s.length);
 }
@@ -54,11 +76,22 @@ function repoHeader(sweep) {
     ];
     return `${name}  (${bits.filter((b) => b !== null).join(', ')})`;
 }
+/** The color of a row's action word. */
+function actionStyle(style, action) {
+    if (action === 'delete')
+        return style.delete;
+    if (action === 'prune')
+        return style.prune;
+    if (action === 'review')
+        return style.review;
+    return style.keep;
+}
 /** One repository's rows, indented under its header. */
 export function renderRepo(sweep, opts = {}) {
-    const lines = [repoHeader(sweep)];
+    const style = opts.style ?? PLAIN;
+    const lines = [style.strong(repoHeader(sweep))];
     if (sweep.error !== null) {
-        lines.push(`  error: ${sweep.error}`);
+        lines.push(`  ${style.delete('error')}: ${sweep.error}`);
         return lines.join('\n');
     }
     const shown = sortItems(sweep.items).filter((item) => opts.keep === true || item.classification !== 'safe-to-keep');
@@ -73,11 +106,11 @@ export function renderRepo(sweep, opts = {}) {
             ? 'prune'
             : (ACTION_LABEL[item.classification] ?? item.classification);
         const note = requiresNote(item);
-        lines.push(`  ${pad(item.category, categoryWidth)}  ${pad(ellipsize(item.id, 38), idWidth)}  ${pad(action, 6)}  ${item.reason}${note ? `; ${note}` : ''}`);
+        lines.push(`  ${pad(item.category, categoryWidth)}  ${pad(ellipsize(item.id, 38), idWidth)}  ${actionStyle(style, action)(pad(action, 6))}  ${item.reason}${note ? `; ${note}` : ''}`);
         // A blocked row has no commands; what to do about each blocker goes there instead.
         const detail = hasBlockers(item) ? item.investigationParts : item.commands;
         for (const line of detail)
-            lines.push(`  ${' '.repeat(categoryWidth)}  ${line}`);
+            lines.push(`  ${' '.repeat(categoryWidth)}  ${style.muted(line)}`);
     }
     return lines.join('\n');
 }
@@ -124,7 +157,7 @@ function deleteOnly(bucket) {
     return bucket['safe-to-delete'] - bucket.prune;
 }
 /** The one-line verdict a person reads first, and often only. */
-export function renderSummary(result) {
+export function renderSummary(result, style = PLAIN) {
     const counts = totals(result);
     const repos = `${result.repos.length} ${result.repos.length === 1 ? 'repository' : 'repositories'}`;
     const errors = result.repos.filter((sweep) => sweep.error !== null).length;
@@ -135,8 +168,10 @@ export function renderSummary(result) {
         tail.push(`${result.unresolved.length} ${result.unresolved.length === 1 ? 'entry' : 'entries'} unresolved`);
     }
     const suffix = tail.length > 0 ? ` (${tail.join(', ')})` : '';
-    const prune = counts.prune > 0 ? `${counts.prune} to prune, ` : '';
-    return `${deleteOnly(counts)} to delete, ${prune}${counts['needs-investigation']} to review, across ${repos}${suffix}.`;
+    const prune = counts.prune > 0 ? `${style.prune(`${counts.prune} to prune`)}, ` : '';
+    const del = style.delete(`${deleteOnly(counts)} to delete`);
+    const review = style.review(`${counts['needs-investigation']} to review`);
+    return `${del}, ${prune}${review}, across ${repos}${suffix}.`;
 }
 const COUNT_LABEL = {
     local_branch: 'local branches',
@@ -174,7 +209,7 @@ export function renderCounts(sweep) {
     return lines.join('\n');
 }
 /** The whole run as counts: a table per repository, then the one-line summary. */
-export function renderCountsText(result) {
+export function renderCountsText(result, style = PLAIN) {
     const blocks = result.repos.map(renderCounts);
     if (result.unresolved.length > 0) {
         const lines = ['unresolved'];
@@ -184,7 +219,8 @@ export function renderCountsText(result) {
         blocks.push(lines.join('\n'));
     }
     const scan = renderScan(result);
-    blocks.push(scan === null ? renderSummary(result) : `${scan}\n${renderSummary(result)}`);
+    const summary = renderSummary(result, style);
+    blocks.push(scan === null ? summary : `${scan}\n${summary}`);
     return blocks.join('\n\n') + '\n';
 }
 /** The whole run's counts as JSON: no rows, no facts. */
@@ -228,7 +264,8 @@ export function renderText(result, opts = {}) {
         blocks.push(lines.join('\n'));
     }
     const scan = renderScan(result);
-    blocks.push(scan === null ? renderSummary(result) : `${scan}\n${renderSummary(result)}`);
+    const summary = renderSummary(result, opts.style);
+    blocks.push(scan === null ? summary : `${scan}\n${summary}`);
     return blocks.join('\n\n') + '\n';
 }
 /**
@@ -290,7 +327,9 @@ export function summarizeReceipt(receipt) {
         if (s.row === null)
             continue;
         if (s.result === 'pending') {
-            if (s.action !== 'unlock-worktree')
+            // Rows not reached are rows a run would have deleted; an unlock or a
+            // tip check deletes nothing.
+            if (s.action !== 'unlock-worktree' && s.action !== 'verify-remote')
                 out.notRun += 1;
             continue;
         }
@@ -340,22 +379,96 @@ export function renderApplySummary(receipt) {
     }
     return lines;
 }
+/** The word a preview shows for a step: what it does to the row. */
+export const STEP_VERB = {
+    'verify-remote': 'verify',
+    'unlock-worktree': 'unlock',
+    'remove-worktree': 'delete',
+    'delete-local': 'delete',
+    'delete-remote': 'delete',
+    'prune-worktrees': 'prune',
+};
+/** A step's result word, colored by what it says about the run. */
+function resultWord(step, style) {
+    const word = step.result.padEnd(8);
+    if (step.result === 'failed')
+        return style.delete(word);
+    if (step.result === 'ok')
+        return style.keep(word);
+    if (step.result === 'pending')
+        return style.muted(word);
+    return step.action === 'prune-worktrees' ? style.prune(word) : style.delete(word);
+}
+/**
+ * What `apply` is about to do, for the person asked to approve it: per
+ * repository, each row and the command that deletes it, the rows it will
+ * skip and why, then the counts. Terminal controls are stripped from what it
+ * shows, so a path or name cannot hide part of what is approved.
+ */
+export function renderPreview(receipt, style = PLAIN) {
+    const repos = [
+        ...new Set([...receipt.steps.map((s) => s.repo), ...receipt.dropped.map((d) => d.repo)]),
+    ];
+    const rows = [
+        ...receipt.steps.flatMap((s) => (s.row === null ? [] : [s.row])),
+        ...receipt.dropped,
+    ];
+    const categoryWidth = Math.max(0, ...rows.map((r) => r.category.length));
+    const row = (r) => r === null ? '' : `${pad(r.category, categoryWidth)}  ${ellipsize(stripControls(r.id), 60)}`;
+    const blocks = [];
+    for (const repo of repos) {
+        const lines = [style.strong(stripControls(repo))];
+        for (const s of receipt.steps.filter((s) => s.repo === repo)) {
+            const verb = STEP_VERB[s.action];
+            const color = actionStyle(style, verb === 'unlock' ? 'review' : verb);
+            lines.push(s.row === null ? `  ${color(verb)}` : `  ${color(pad(verb, 6))}  ${row(s.row)}`);
+            lines.push(`          ${style.muted(stripControls(s.command))}`);
+        }
+        for (const d of receipt.dropped.filter((d) => d.repo === repo)) {
+            lines.push(`  ${style.review(pad('skip', 6))}  ${row(d)}`);
+            lines.push(`          ${d.reason}: ${stripControls(d.detail)}`);
+        }
+        blocks.push(lines.join('\n'));
+    }
+    const [counts = '', ...rest] = renderApplySummary(receipt);
+    blocks.push([style.strong(counts), ...rest.map(style.review)].join('\n'));
+    return blocks.join('\n\n') + '\n';
+}
+/** Rows dropped by a live run's own re-check, after the preview: each with why. */
+export function renderPreviewDrops(dropped, style = PLAIN) {
+    return dropped
+        .map((d) => `  ${style.review('skip')}  ${stripControls(`${d.category}  ${ellipsize(d.id, 60)}`)}\n      ${style.review(stripControls(`${d.reason}: ${d.detail}`))}\n`)
+        .join('');
+}
+/**
+ * A failed step for a run shown live: `✗`, the row, and the error in full,
+ * which the step's row on the board is too narrow to hold.
+ */
+export function renderStepFailure(step, style = PLAIN) {
+    const verb = STEP_VERB[step.action];
+    const row = step.row === null ? '' : `${step.row.category}  ${ellipsize(step.row.id, 60)}`;
+    const line = stripControls(`${pad(verb, 6)}  ${row}`.trimEnd());
+    return `  ${style.delete('✗')} ${line}\n      ${style.delete(stripControls(step.error ?? 'failed'))}`;
+}
 /** An apply run as text: dropped rows, each step, a summary, then where the receipt is. */
-export function renderReceipt(receipt, receiptPath) {
+export function renderReceipt(receipt, receiptPath, style = PLAIN, opts = {}) {
     const lines = [];
-    for (const d of receipt.dropped) {
-        lines.push(`dropped  ${d.category}:${d.id} — ${d.reason} (${d.detail})`);
+    // A run shown live has printed its dropped rows and steps already.
+    for (const d of opts.steps === false ? [] : receipt.dropped) {
+        const shown = stripControls(`${d.category}:${d.id} — ${d.reason} (${d.detail})`);
+        lines.push(`${style.review('dropped  ')}${shown}`);
     }
-    for (const s of receipt.steps) {
+    for (const s of opts.steps === false ? [] : receipt.steps) {
         const what = s.row === null ? s.command : `${s.row.category}:${s.row.id} — ${s.command}`;
         const tail = s.error ?? s.verification;
-        lines.push(`${s.result.padEnd(8)} ${what}${tail ? ` (${tail})` : ''}`);
+        lines.push(`${resultWord(s, style)} ${stripControls(`${what}${tail ? ` (${tail})` : ''}`)}`);
     }
     if (lines.length > 0)
         lines.push('');
-    lines.push(...renderApplySummary(receipt));
-    lines.push(receiptPath === null
+    const [counts = '', ...rest] = renderApplySummary(receipt);
+    lines.push(style.strong(counts), ...rest.map(style.review));
+    lines.push(style.muted(receiptPath === null
         ? `status: ${receipt.status}`
-        : `receipt: ${receiptPath} (${receipt.status})`);
+        : `receipt: ${stripControls(receiptPath)} (${receipt.status})`));
     return lines.join('\n') + '\n';
 }

package/dist/status-line.d.ts

@@ -5,12 +5,14 @@
  */
 import type { Step } from './receipt.ts';
 import type { SweepProgress } from './types.ts';
+/** A bar `width` cells wide, filled for `done` of `total`, e.g. `█████░░░░░`. */
+export declare function progressBar(done: number, total: number, width?: number): string;
 /**
- * A sweep step as one line, e.g. `[2/5] checking remote branches 37/427 · ~/work/api`.
+ * A sweep step as one line, e.g. `[2/5] checking remote branches ████░░░░ 37/427 · ~/work/api`.
  * The path goes last, so a line cut to the terminal's width loses its tail first.
  */
 export declare function describeSweep(p: SweepProgress, home?: string): string;
-/** An apply step as one line, e.g. `deleting 3/7: delete-remote origin/feat/x`. */
+/** An apply step as one line, e.g. `deleting ██████░░░░ 3/7: delete-remote origin/feat/x`. */
 export declare function describeStep(index: number, total: number, step: Step): string;
 export interface StatusLine {
     /** Replace the line with `text`. */

package/dist/status-line.js

@@ -17,19 +17,26 @@ const STEP_TEXT = {
 function tilde(path, home) {
     return path === home ? '~' : path.startsWith(`${home}/`) ? `~${path.slice(home.length)}` : path;
 }
+/** A bar `width` cells wide, filled for `done` of `total`, e.g. `█████░░░░░`. */
+export function progressBar(done, total, width = 20) {
+    const filled = total <= 0 ? width : Math.min(width, Math.round((done / total) * width));
+    return '█'.repeat(filled) + '░'.repeat(width - filled);
+}
 /**
- * A sweep step as one line, e.g. `[2/5] checking remote branches 37/427 · ~/work/api`.
+ * A sweep step as one line, e.g. `[2/5] checking remote branches ████░░░░ 37/427 · ~/work/api`.
  * The path goes last, so a line cut to the terminal's width loses its tail first.
  */
 export function describeSweep(p, home = homedir()) {
     const where = p.of > 1 ? `[${p.index}/${p.of}] ` : '';
-    const count = p.done === undefined ? '' : ` ${p.done + 1}/${p.total}`;
+    const count = p.done === undefined || p.total === undefined
+        ? ''
+        : ` ${progressBar(p.done, p.total)} ${p.done + 1}/${p.total}`;
     return `${where}${STEP_TEXT[p.step]}${count} · ${tilde(p.repo, home)}`;
 }
-/** An apply step as one line, e.g. `deleting 3/7: delete-remote origin/feat/x`. */
+/** An apply step as one line, e.g. `deleting ██████░░░░ 3/7: delete-remote origin/feat/x`. */
 export function describeStep(index, total, step) {
     const what = step.row === null ? step.repo : step.row.id;
-    return `deleting ${index + 1}/${total}: ${step.action} ${what}`;
+    return `deleting ${progressBar(index, total)} ${index + 1}/${total}: ${step.action} ${what}`;
 }
 /** A line drawn with `\r` and erase-line, controls stripped, cut to `columns() - 1` display columns so it never wraps. */
 export function statusLine(write, columns) {

package/dist/step-board.d.ts

@@ -0,0 +1,34 @@
+/**
+ * `apply`'s steps as a vertical list redrawn in place on a terminal: one row
+ * per step with its own bar, empty while it waits, half full while it runs,
+ * full and ticked when it is done, and a bar for the whole run under the
+ * list. The run is synchronous, so the board moves between steps, not on a
+ * timer.
+ */
+import type { Step } from './receipt.ts';
+import { type Style } from './render.ts';
+/**
+ * The board's lines, each at most `width` columns, and at most `height - 1`
+ * of them: the cursor sits on the row under the last line, which must stay
+ * on screen. That is the run's bar under the rows that fit; a list longer
+ * than that shows a window that keeps the running step in view, with a line
+ * for the rows above and below it when there is room for one.
+ */
+export declare function boardLines(steps: readonly Step[], running: number | null, size: {
+    width: number;
+    height: number;
+}, style?: Style): string[];
+export interface StepBoard {
+    /** Draw with `running` as the step under way, or null between steps. */
+    draw(running: number | null): void;
+}
+/**
+ * A board on `write`. The first draw prints its lines; each later one moves
+ * the cursor back to the board's first line and rewrites them, erasing any
+ * line an earlier, taller frame left below. Lines are cut to one column
+ * short of the width, so none wraps and the line count stays right.
+ */
+export declare function stepBoard(write: (text: string) => void, steps: readonly Step[], size: () => {
+    width: number;
+    height: number;
+}, style?: Style): StepBoard;

package/dist/step-board.js

@@ -0,0 +1,101 @@
+/**
+ * `apply`'s steps as a vertical list redrawn in place on a terminal: one row
+ * per step with its own bar, empty while it waits, half full while it runs,
+ * full and ticked when it is done, and a bar for the whole run under the
+ * list. The run is synchronous, so the board moves between steps, not on a
+ * timer.
+ */
+import { fitWidth, stripControls } from '@osdlc/ux';
+import { PLAIN, STEP_VERB } from "./render.js";
+import { progressBar } from "./status-line.js";
+/** A step bar's cells, and the run bar's at most. */
+const BAR = 10;
+const TOTAL_BAR = 30;
+function label(step) {
+    const verb = STEP_VERB[step.action];
+    if (step.row === null)
+        return verb;
+    return stripControls(`${verb.padEnd(6)}  ${step.row.category}  ${step.row.id}`);
+}
+/**
+ * One step's row, cut to `width` columns before it is colored, so the color
+ * codes never count against the width and the row never wraps.
+ */
+function stepRow(step, running, width, style) {
+    const [bar, mark, color, text] = step.result === 'ok'
+        ? ['█'.repeat(BAR), '✓', style.keep, (t) => t]
+        : step.result === 'failed'
+            ? ['█'.repeat(BAR), '✗', style.delete, (t) => t]
+            : running
+                ? ['█'.repeat(BAR / 2) + '░'.repeat(BAR / 2), '›', style.review, style.strong]
+                : ['░'.repeat(BAR), ' ', style.muted, style.muted];
+    const head = `  ${bar} ${mark} `;
+    if (width <= head.length)
+        return color(fitWidth(head, width));
+    return `  ${color(bar)} ${color(mark)} ${text(fitWidth(label(step), width - head.length))}`;
+}
+/** The run's bar and count, shrunk to fit `width` columns. */
+function totalRow(done, total, failed, width, style) {
+    const count = ` ${done}/${total}`;
+    const cells = Math.min(TOTAL_BAR, width - 2 - count.length);
+    const line = cells > 0
+        ? `  ${progressBar(done, total, cells)}${count}`
+        : fitWidth(`  ${count.trim()}`, width);
+    return failed ? style.delete(line) : style.strong(line);
+}
+/**
+ * The board's lines, each at most `width` columns, and at most `height - 1`
+ * of them: the cursor sits on the row under the last line, which must stay
+ * on screen. That is the run's bar under the rows that fit; a list longer
+ * than that shows a window that keeps the running step in view, with a line
+ * for the rows above and below it when there is room for one.
+ */
+export function boardLines(steps, running, size, style = PLAIN) {
+    const width = Math.max(1, size.width);
+    const room = Math.max(1, size.height - 2);
+    let first = 0;
+    let last = steps.length;
+    const windowed = steps.length > room;
+    // The above and below notes need a row each, and a row for a step besides.
+    const notes = windowed && room >= 3;
+    if (windowed) {
+        const at = running ?? steps.findIndex((s) => s.result === 'pending');
+        const focus = at < 0 ? steps.length - 1 : at;
+        const shown = notes ? room - 2 : room;
+        first = Math.min(Math.max(0, focus - Math.floor(shown / 3)), steps.length - shown);
+        last = first + shown;
+    }
+    const note = (text) => style.muted(fitWidth(text, width));
+    const lines = [];
+    if (notes)
+        lines.push(note(`  … ${first} above`));
+    for (let i = first; i < last; i++)
+        lines.push(stepRow(steps[i], i === running, width, style));
+    if (notes)
+        lines.push(note(`  … ${steps.length - last} below`));
+    const done = steps.filter((s) => s.result === 'ok' || s.result === 'failed').length;
+    const failed = steps.some((s) => s.result === 'failed');
+    lines.push(totalRow(done, steps.length, failed, width, style));
+    return lines;
+}
+/**
+ * A board on `write`. The first draw prints its lines; each later one moves
+ * the cursor back to the board's first line and rewrites them, erasing any
+ * line an earlier, taller frame left below. Lines are cut to one column
+ * short of the width, so none wraps and the line count stays right.
+ */
+export function stepBoard(write, steps, size, style = PLAIN) {
+    let drawn = 0;
+    return {
+        draw(running) {
+            const { width, height } = size();
+            const lines = boardLines(steps, running, { width: width - 1, height }, style);
+            // A frame shorter than the last one blanks the rows the last one used.
+            while (lines.length < drawn)
+                lines.push('');
+            const up = drawn > 0 ? `\x1b[${drawn}A` : '';
+            write(up + lines.map((l) => `\r\x1b[2K${l}\n`).join(''));
+            drawn = lines.length;
+        },
+    };
+}

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.11.0";
+export declare const VERSION = "0.13.0";

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.11.0';
+export const VERSION = '0.13.0';

package/dist/worktrees.d.ts

@@ -46,3 +46,15 @@ export declare function classifyWorktree(opts: {
     /** Answers lock-owner and working-directory questions. One per sweep: it caches the process table. */
     probe: ProcessProbe;
 }): SweepItem;
+/** How a branch shows it was worked on, for a worktree merged by ancestry alone. */
+export type BranchUse = 'commits' | 'upstream';
+/**
+ * The sign that `branch` was worked on, or null for a branch that looks
+ * freshly made. `commits`: its reflog records work (see {@link isWorkEntry}). `upstream`: it tracks a branch on a remote, and not
+ * the default branch (`mainBranch`) of any remote, so someone pushed it as
+ * its own branch. A branch with neither, such as one `git worktree add -b`
+ * just made from the default branch, with or without `--track`, reads as
+ * null: removing its worktree could lose ignored files from work about to
+ * start.
+ */
+export declare function branchUse(git: Git, branch: string, mainBranch: string): BranchUse | null;

package/dist/worktrees.js

@@ -360,6 +360,24 @@ export function classifyWorktree(opts) {
     }
     if (pr && pr.state === 'OPEN')
         return keep(`open PR #${pr.number}`, { requires });
+    // Merged by ancestry alone: a worktree just made from the default branch is
+    // merged that way too, so ancestry needs a sign the branch was worked on.
+    if (facts['merged'] === true && branch && head !== null) {
+        const used = branchUse(git.at(repo.root), branch, repo.mainBranch);
+        facts['branch_used'] = used;
+        if (used !== null) {
+            return makeItem({
+                category: 'worktree',
+                id: path,
+                classification: 'safe-to-delete',
+                action: 'remove',
+                reason: `clean; merged into ${landedRef(repo)}, and ${USE_REASON[used]}`,
+                facts,
+                commands: safeRemove,
+                requires,
+            });
+        }
+    }
     const parts = [`Worktree \`${path}\` is clean.`];
     if (branch)
         parts.push(`Branch: \`${branch}\`.`);
@@ -380,3 +398,42 @@ export function classifyWorktree(opts) {
         requires,
     });
 }
+const USE_REASON = {
+    commits: 'the branch has commits made on it',
+    upstream: 'the branch was pushed to its own upstream',
+};
+/**
+ * Reflog entries that put work on a branch: a commit, a cherry-pick, an `am`,
+ * or a merge or pull that made a merge commit. A fast-forward merge or pull,
+ * a rebase, a reset or a rename only moves a branch, which a fresh branch
+ * tracking the default branch does on its first `git pull`.
+ */
+function isWorkEntry(entry) {
+    if (/^(commit|cherry-pick|am)\b/.test(entry))
+        return true;
+    return /^(merge|pull)\b/.test(entry) && !/Fast-forward/.test(entry);
+}
+/**
+ * The sign that `branch` was worked on, or null for a branch that looks
+ * freshly made. `commits`: its reflog records work (see {@link isWorkEntry}). `upstream`: it tracks a branch on a remote, and not
+ * the default branch (`mainBranch`) of any remote, so someone pushed it as
+ * its own branch. A branch with neither, such as one `git worktree add -b`
+ * just made from the default branch, with or without `--track`, reads as
+ * null: removing its worktree could lose ignored files from work about to
+ * start.
+ */
+export function branchUse(git, branch, mainBranch) {
+    // `raw`: a branch with no reflog (core.logAllRefUpdates off) exits non-zero.
+    const reflog = git.raw(['reflog', 'show', '--format=%gs', `refs/heads/${branch}`, '--']);
+    if (reflog.exitCode === 0 && reflog.stdout.split('\n').some(isWorkEntry)) {
+        return 'commits';
+    }
+    // From the branch's own config, not the resolved name: a branch tracking a
+    // local branch has remote `.`, and one tracking `upstream/main` merges the
+    // default branch however its remote is spelled.
+    const remote = git.configGet(`branch.${branch}.remote`);
+    const merge = git.configGet(`branch.${branch}.merge`);
+    if (remote && remote !== '.' && merge && merge !== `refs/heads/${mainBranch}`)
+        return 'upstream';
+    return null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@osdlc/repo-cleaner",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "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",
@@ -48,13 +48,13 @@
     "node": "^22.22.2 || ^24.15.0 || >=26.0.0"
   },
   "dependencies": {
-    "zod": "4.4.3",
-    "@osdlc/cli-tool": "^0.13.0",
+    "zod": "^4.6.6",
+    "@osdlc/cli-tool": "^0.14.0",
     "@osdlc/command-seam": "^0.14.0",
     "@osdlc/path-guard": "^0.3.1",
     "@osdlc/typed-gh": "^0.14.1",
-    "@osdlc/typed-git": "^0.12.0",
-    "@osdlc/ux": "^0.1.1"
+    "@osdlc/ux": "^0.1.1",
+    "@osdlc/typed-git": "^0.12.0"
   },
   "devDependencies": {
     "@types/node": "^26.1.0",