@osdlc/repo-cleaner 0.17.2 → 0.19.0

package/dist/render.js

@@ -1,23 +1,18 @@
 /**
- * Rendering a sweep for a terminal, and for a program.
+ * Rendering a sweep and a run, for a terminal and for a program.
  *
  * The text report is columnar because it is read by eye across repositories:
- * the eye finds a column, and a line-per-item paragraph gives it nothing to
- * find. JSON carries everything the text report elides, including the facts
- * behind every verdict.
+ * the eye finds a column, and a line-per-row paragraph gives it nothing to
+ * find. JSON carries everything the text report leaves out, the evidence
+ * behind every verdict included.
  */
 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. */
-const CATEGORY_ORDER = ['local_branch', 'worktree', 'remote_branch'];
+import { KINDS, isPrune, isUnfetched, parseRowId, totalOf, } from "./types.js";
+import { plural } from "./util.js";
+/** Branches first, then worktrees, then remotes, whatever order they were gathered in. */
+const KIND_ORDER = ['branch', 'worktree', 'remote'];
 /** Delete first: it is what a reader is looking for. */
-const CLASSIFICATION_ORDER = ['safe-to-delete', 'needs-investigation', 'safe-to-keep'];
-const ACTION_LABEL = {
-    'safe-to-delete': 'delete',
-    'needs-investigation': 'review',
-    'safe-to-keep': 'keep',
-};
+const VERDICT_ORDER = ['delete', 'review', 'blocked', 'keep'];
 const same = (text) => text;
 /** No color. */
 export const PLAIN = {
@@ -47,22 +42,22 @@ function ellipsize(s, max) {
     return s.length <= max ? s : '…' + s.slice(s.length - (max - 1));
 }
 /**
- * A row's authorizations for a report, e.g. `requires abandon-unmerged (drops 3
- * commits), confirm-open-pr`. Empty when the row needs none.
+ * A row's risks for a report, e.g. `needs --allow abandon-unmerged (drops 3
+ * commits), confirm-open-pr`. Empty when the row carries none.
  */
-export function requiresNote(item) {
-    if (item.requires.length === 0)
+function risksNote(row) {
+    if (row.risks.length === 0)
         return '';
-    const count = item.facts['unique_commits'];
-    const names = item.requires.map((name) => name === 'abandon-unmerged' && typeof count === 'number'
+    const count = row.evidence.uniqueCommits;
+    const names = row.risks.map((name) => name === 'abandon-unmerged' && typeof count === 'number'
         ? `${name} (drops ${count} commit${count === 1 ? '' : 's'})`
         : name);
-    return `requires ${names.join(', ')}`;
+    return `needs --allow ${names.join(', ')}`;
 }
-function sortItems(items) {
-    const categoryRank = (item) => CATEGORY_ORDER.indexOf(item.category);
-    const classRank = (item) => CLASSIFICATION_ORDER.indexOf(item.classification);
-    return [...items].sort((a, b) => categoryRank(a) - categoryRank(b) || classRank(a) - classRank(b) || a.id.localeCompare(b.id));
+function sortRows(rows) {
+    const kindRank = (r) => KIND_ORDER.indexOf(r.kind);
+    const verdictRank = (r) => VERDICT_ORDER.indexOf(r.verdict);
+    return [...rows].sort((a, b) => kindRank(a) - kindRank(b) || verdictRank(a) - verdictRank(b) || a.name.localeCompare(b.name));
 }
 function repoHeader(sweep) {
     const name = sweep.repo?.root ?? sweep.path;
@@ -76,166 +71,145 @@ 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')
+/** A repository's notes on what the sweep judged without, one line each under its header. */
+function noteLines(sweep, style) {
+    return sweep.notes.map((note) => `  ${style.review('note')}: ${stripControls(note)}`);
+}
+/** The word a report shows for a row: its verdict, or `prune` for a `delete` that only prunes. */
+function verdictWord(row) {
+    return isPrune(row) ? 'prune' : row.verdict;
+}
+/** The color of a verdict word. */
+function wordStyle(style, word) {
+    if (word === 'delete')
         return style.delete;
-    if (action === 'prune')
+    if (word === 'prune')
         return style.prune;
-    if (action === 'review')
+    if (word === 'review' || word === 'blocked')
         return style.review;
     return style.keep;
 }
-/** One repository's rows, indented under its header. */
+/** One repository's rows, indented under its header. `all` shows `keep` rows too. */
 export function renderRepo(sweep, opts = {}) {
     const style = opts.style ?? PLAIN;
-    const lines = [style.strong(repoHeader(sweep))];
+    const lines = [style.strong(repoHeader(sweep)), ...noteLines(sweep, style)];
     if (sweep.error !== null) {
         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');
+    const shown = sortRows(sweep.rows).filter((r) => opts.all === true || r.verdict !== 'keep');
     if (shown.length === 0) {
         lines.push('  nothing to clean up');
         return lines.join('\n');
     }
-    const idWidth = Math.min(38, Math.max(...shown.map((item) => ellipsize(item.id, 38).length)));
-    const categoryWidth = Math.max(...shown.map((item) => item.category.length));
-    for (const item of shown) {
-        const action = isPrune(item)
-            ? 'prune'
-            : (ACTION_LABEL[item.classification] ?? item.classification);
-        const note = requiresNote(item);
-        lines.push(`  ${pad(item.category, categoryWidth)}  ${pad(ellipsize(item.id, 38), idWidth)}  ${actionStyle(style, action)(pad(action, 6))}  ${item.reason}${note ? `; ${note}` : ''}`);
+    const nameWidth = Math.min(38, Math.max(...shown.map((r) => ellipsize(r.name, 38).length)));
+    const kindWidth = Math.max(...shown.map((r) => r.kind.length));
+    for (const row of shown) {
+        const word = verdictWord(row);
+        const note = risksNote(row);
+        lines.push(`  ${pad(row.kind, kindWidth)}  ${pad(ellipsize(row.name, 38), nameWidth)}  ${wordStyle(style, word)(pad(word, 7))}  ${row.why}${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;
+        const detail = row.verdict === 'blocked' ? row.notes : row.commands;
         for (const line of detail)
-            lines.push(`  ${' '.repeat(categoryWidth)}  ${style.muted(line)}`);
+            lines.push(`  ${' '.repeat(kindWidth)}  ${style.muted(line)}`);
     }
     return lines.join('\n');
 }
-function totals(result) {
-    const out = emptyBucket();
-    for (const sweep of result.repos) {
-        for (const bucket of Object.values(summarize(sweep.items))) {
-            out.total += bucket.total;
-            out.merged += bucket.merged;
-            out['safe-to-delete'] += bucket['safe-to-delete'];
-            out.prune += bucket.prune;
-            out['safe-to-keep'] += bucket['safe-to-keep'];
-            out['needs-investigation'] += bucket['needs-investigation'];
-        }
-    }
-    return out;
-}
 /** Thousands separators, fixed to one locale so the output does not move. */
 function count(n) {
     return n.toLocaleString('en-US');
 }
+/** `1 target`, `1,204 directories`. */
+const counted = (n, one, many) => `${count(n)} ${n === 1 ? one : many}`;
 /**
- * What the search cost, or null when nothing was searched — every entry
+ * What the search cost, or null when nothing was searched — every target
  * named a checkout outright.
  *
- * Worth a line because the numbers are how a person catches an entry
+ * Worth a line because the numbers are how a person catches a target
  * pointing at the wrong directory: thousands of directories read for three
- * repositories says the entry is a home directory, not a workspace.
+ * repositories says the target is a home directory, not a workspace.
  */
-export function renderScan(result) {
-    const { scan } = result;
+export function renderScan(sweep) {
+    const { scan } = sweep;
     if (scan.containers === 0)
         return null;
-    const entries = `${scan.containers} ${scan.containers === 1 ? 'entry' : 'entries'}`;
-    const dirs = `${count(scan.directoriesScanned)} ${scan.directoriesScanned === 1 ? 'directory' : 'directories'}`;
-    const found = `${count(scan.checkoutsFound)} ${scan.checkoutsFound === 1 ? 'checkout' : 'checkouts'}`;
+    const entries = counted(scan.containers, 'target', 'targets');
+    const dirs = counted(scan.directoriesScanned, 'directory', 'directories');
+    const found = counted(scan.checkoutsFound, 'checkout', 'checkouts');
     const line = `searched ${entries}: ${dirs} read, ${found} found.`;
     if (scan.depthLimited === 0)
         return line;
     return `${line} ${count(scan.depthLimited)} left unopened at the depth limit.`;
 }
-/** The `safe-to-delete` rows that delete something, not the ones that only prune a stale link. */
-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, 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;
+export function renderTotals(sweep, style = PLAIN) {
+    const t = totalOf(sweep.counts);
+    const repos = counted(sweep.repos.length, 'repository', 'repositories');
+    const errors = sweep.repos.filter((r) => r.error !== null).length;
     const tail = [];
     if (errors > 0)
         tail.push(`${errors} unreadable`);
-    if (result.unresolved.length > 0) {
-        tail.push(`${result.unresolved.length} ${result.unresolved.length === 1 ? 'entry' : 'entries'} unresolved`);
+    if (sweep.unresolved.length > 0) {
+        tail.push(`${counted(sweep.unresolved.length, 'target', 'targets')} unresolved`);
     }
     const suffix = tail.length > 0 ? ` (${tail.join(', ')})` : '';
-    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 prune = t.prune > 0 ? `${style.prune(`${t.prune} to prune`)}, ` : '';
+    const blocked = t.blocked > 0 ? `, ${style.review(`${t.blocked} blocked`)}` : '';
+    return `${style.delete(`${t.delete} to delete`)}, ${prune}${style.review(`${t.review} to review`)}${blocked}, across ${repos}${suffix}.`;
 }
-const COUNT_LABEL = {
-    local_branch: 'local branches',
+const KIND_LABEL = {
+    branch: 'local branches',
     worktree: 'worktrees',
-    remote_branch: 'remote branches',
+    remote: 'remote branches',
 };
-/** A count table's columns. `delete` leaves out the rows `prune` counts, so each row is in one of delete, prune, review and keep. */
 const COUNT_COLUMNS = [
-    { heading: 'total', of: (b) => b.total },
-    { heading: 'merged', of: (b) => b.merged },
-    { heading: 'delete', of: deleteOnly },
-    { heading: 'prune', of: (b) => b.prune },
-    { heading: 'review', of: (b) => b['needs-investigation'] },
-    { heading: 'keep', of: (b) => b['safe-to-keep'] },
+    'total',
+    'merged',
+    'delete',
+    'prune',
+    'review',
+    'blocked',
+    'keep',
 ];
-/**
- * One repository as counts: a row per category with its total, how many are
- * merged, and how many the sweep would delete, prune, review or keep.
- */
-export function renderCounts(sweep) {
-    const lines = [repoHeader(sweep)];
-    if (sweep.error !== null) {
-        lines.push(`  error: ${sweep.error}`);
-        return lines.join('\n');
-    }
-    const buckets = summarize(sweep.items);
-    const labelWidth = Math.max(...Object.values(COUNT_LABEL).map((l) => l.length));
-    const cell = (text, heading) => text.padStart(Math.max(heading.length, 5));
-    lines.push(`  ${' '.repeat(labelWidth)}  ${COUNT_COLUMNS.map(({ heading }) => cell(heading, heading)).join('  ')}`);
-    for (const category of CATEGORY_ORDER) {
-        const bucket = buckets[category] ?? emptyBucket();
-        const cells = COUNT_COLUMNS.map(({ heading, of }) => cell(count(of(bucket)), heading));
-        lines.push(`  ${pad(COUNT_LABEL[category], labelWidth)}  ${cells.join('  ')}`);
-    }
+function renderUnresolved(sweep) {
+    if (sweep.unresolved.length === 0)
+        return null;
+    const lines = ['unresolved'];
+    const width = Math.max(...sweep.unresolved.map((row) => row.entry.length));
+    for (const row of sweep.unresolved)
+        lines.push(`  ${pad(row.entry, width)}   ${row.reason}`);
     return lines.join('\n');
 }
-/** The whole run as counts: a table per repository, then the one-line summary. */
-export function renderCountsText(result, style = PLAIN) {
-    const blocks = result.repos.map(renderCounts);
-    if (result.unresolved.length > 0) {
-        const lines = ['unresolved'];
-        const width = Math.max(...result.unresolved.map((row) => row.entry.length));
-        for (const row of result.unresolved)
-            lines.push(`  ${pad(row.entry, width)}   ${row.reason}`);
-        blocks.push(lines.join('\n'));
-    }
-    const scan = renderScan(result);
-    const summary = renderSummary(result, style);
-    blocks.push(scan === null ? summary : `${scan}\n${summary}`);
-    return blocks.join('\n\n') + '\n';
+/** `blocks`, then the unresolved targets, what the search cost and the totals, as one report. */
+function report(blocks, sweep, style) {
+    const unresolved = renderUnresolved(sweep);
+    const scan = renderScan(sweep);
+    const totals = renderTotals(sweep, style);
+    return ([
+        ...blocks,
+        ...(unresolved === null ? [] : [unresolved]),
+        scan === null ? totals : `${scan}\n${totals}`,
+    ].join('\n\n') + '\n');
 }
-/** The whole run's counts as JSON: no rows, no facts. */
-export function renderCountsJson(result) {
-    return (JSON.stringify({
-        repos: result.repos.map((sweep) => ({
-            path: sweep.path,
-            error: sweep.error,
-            repo: sweep.repo,
-            summary: summarize(sweep.items),
-        })),
-        unresolved: result.unresolved,
-        scan: result.scan,
-        summary: totals(result),
-    }, null, 2) + '\n');
+/** The sweep as counts (`--format summary`): a table per repository, then the totals line. */
+export function renderSummary(sweep, style = PLAIN) {
+    const blocks = sweep.repos.map((r) => {
+        const lines = [repoHeader(r), ...noteLines(r, style)];
+        if (r.error !== null) {
+            lines.push(`  error: ${r.error}`);
+            return lines.join('\n');
+        }
+        const labelWidth = Math.max(...Object.values(KIND_LABEL).map((l) => l.length));
+        const cell = (text, heading) => text.padStart(Math.max(heading.length, 5));
+        lines.push(`  ${' '.repeat(labelWidth)}  ${COUNT_COLUMNS.map((h) => cell(h, h)).join('  ')}`);
+        for (const kind of KIND_ORDER) {
+            const bucket = r.counts[kind];
+            const cells = COUNT_COLUMNS.map((h) => cell(count(bucket[h]), h));
+            lines.push(`  ${pad(KIND_LABEL[kind], labelWidth)}  ${cells.join('  ')}`);
+        }
+        return lines.join('\n');
+    });
+    return report(blocks, sweep, style);
 }
 /** The "Duplicate checkouts" section, or null when there are none. */
 function renderDuplicates(duplicates) {
@@ -249,83 +223,54 @@ function renderDuplicates(duplicates) {
     }
     return lines.join('\n');
 }
-/** The whole run as text: duplicate checkouts, a section per repository, then the summary. */
-export function renderText(result, opts = {}) {
-    const duplicates = renderDuplicates(result.duplicates);
+/** The sweep as text: duplicate checkouts, a section per repository, then the totals. */
+export function renderText(sweep, opts = {}) {
+    const duplicates = renderDuplicates(sweep.duplicates);
     const blocks = [
         ...(duplicates === null ? [] : [duplicates]),
-        ...result.repos.map((sweep) => renderRepo(sweep, opts)),
+        ...sweep.repos.map((r) => renderRepo(r, opts)),
     ];
-    if (result.unresolved.length > 0) {
-        const lines = ['unresolved'];
-        const width = Math.max(...result.unresolved.map((row) => row.entry.length));
-        for (const row of result.unresolved)
-            lines.push(`  ${pad(row.entry, width)}   ${row.reason}`);
-        blocks.push(lines.join('\n'));
-    }
-    const scan = renderScan(result);
-    const summary = renderSummary(result, opts.style);
-    blocks.push(scan === null ? summary : `${scan}\n${summary}`);
-    return blocks.join('\n\n') + '\n';
+    return report(blocks, sweep, opts.style ?? PLAIN);
 }
-/**
- * The whole run as JSON, facts included. `extra` adds top-level keys, such as
- * the path of a plan the run wrote.
- */
-export function renderJson(result, extra = {}) {
+/** The sweep as JSON: every row with its evidence, the counts, and what was swept. */
+export function renderJson(sweep, extra = {}) {
     return (JSON.stringify({
         ...extra,
-        repos: result.repos.map((sweep) => ({
-            path: sweep.path,
-            error: sweep.error,
-            repo: sweep.repo,
-            summary: summarize(sweep.items),
-            items: sweep.items.map((item) => ({
-                category: item.category,
-                id: item.id,
-                classification: item.classification,
-                action: item.action,
-                reason: item.reason,
-                facts: item.facts,
-                commands: item.commands,
-                requires: item.requires,
-                deletable: item.deletable,
-                investigation_prompt: item.investigationParts.length > 0 ? item.investigationParts.join(' ') : null,
-            })),
-        })),
-        unresolved: result.unresolved,
-        scan: result.scan,
-        duplicates: result.duplicates,
-        summary: totals(result),
+        options: sweep.options,
+        repos: sweep.repos,
+        unresolved: sweep.unresolved,
+        scan: sweep.scan,
+        duplicates: sweep.duplicates,
+        counts: sweep.counts,
+        totals: totalOf(sweep.counts),
     }, null, 2) + '\n');
 }
-/** Every command a `safe-to-delete` row that needs no authorization proposes, in report order. */
-export function proposedCommands(result) {
+/** Every command of a `delete` row that carries no risk, in report order (`--format commands`). */
+export function renderCommands(sweep) {
     const out = [];
-    for (const sweep of result.repos) {
-        for (const item of sortItems(sweep.items)) {
-            if (item.classification === 'safe-to-delete' && item.requires.length === 0)
-                out.push(...item.commands);
+    for (const r of sweep.repos) {
+        for (const row of sortRows(r.rows)) {
+            if (row.verdict === 'delete' && row.risks.length === 0)
+                out.push(...row.commands);
         }
     }
     return out;
 }
-/** Count a receipt's outcome. A dry run's `would-run` steps count as done. */
-export function summarizeReceipt(receipt) {
+/** Count what `steps` did and `dropped` left out. A preview's `would-run` steps count as done. */
+export function summarizeRun(r) {
     const out = {
-        deleted: { worktree: 0, local_branch: 0, remote_branch: 0 },
+        deleted: { worktree: 0, branch: 0, remote: 0 },
+        gone: 0,
         pruned: 0,
         dropped: {},
         failed: 0,
         notRun: 0,
     };
-    for (const d of receipt.dropped)
+    for (const d of r.dropped)
         out.dropped[d.reason] = (out.dropped[d.reason] ?? 0) + 1;
-    for (const s of receipt.steps) {
+    for (const s of r.steps) {
         if (s.result === 'failed')
             out.failed += 1;
-        if (s.row === null)
-            continue;
         if (s.result === 'pending') {
             // Rows not reached are rows a run would have deleted; an unlock or a
             // tip check deletes nothing.
@@ -335,73 +280,68 @@ export function summarizeReceipt(receipt) {
         }
         if (s.result !== 'ok' && s.result !== 'would-run')
             continue;
+        if (s.action === 'delete-remote' && s.gone === true) {
+            out.gone += 1;
+            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-branch')
+            out.deleted.branch += 1;
         else if (s.action === 'delete-remote')
-            out.deleted.remote_branch += 1;
+            out.deleted.remote += 1;
     }
     return out;
 }
-/** Rows a receipt deletes or prunes, which is what a person is asked to approve. */
+/** Rows a run 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;
+    return KINDS.reduce((n, k) => n + summary.deleted[k], 0) + summary.pruned;
 }
-const plural = (n, one, many) => `${n} ${n === 1 ? one : many}`;
 /**
- * How to include a skipped row next time, for the reasons a person can act
- * on. A `not-authorized` detail is `needs <risk>, <risk>` (see `recheck`).
+ * How to include a dropped row next time, for the reasons a person can act
+ * on. A `not-allowed` detail is `needs <risk>, <risk>`.
  */
-function dropHints(receipt) {
+function dropHints(dropped) {
     const risks = new Set();
-    for (const d of receipt.dropped) {
-        if (d.reason !== 'not-authorized')
+    for (const d of dropped) {
+        if (d.reason !== 'not-allowed')
             continue;
         for (const risk of d.detail.replace(/^needs /, '').split(', '))
             if (risk)
                 risks.add(risk);
     }
     return {
-        'needs-review': 'name with --row',
-        ...(risks.size > 0
-            ? { 'not-authorized': [...risks].map((r) => `--allow ${r}`).join(', ') }
-            : {}),
+        'needs-pick': 'name with --pick',
+        ...(risks.size > 0 ? { 'not-allowed': [...risks].map((r) => `--allow ${r}`).join(', ') } : {}),
     };
 }
-/** The closing lines of an apply run: what it deleted, skipped and could not finish. */
-export function renderApplySummary(receipt) {
-    const s = summarizeReceipt(receipt);
-    const dry = receipt.status === 'dry-run';
+/** The closing lines of a run or preview: what it deleted, skipped and could not finish. */
+export function renderRunSummary(r, opts = {}) {
+    const s = summarizeRun(r);
     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.deleted.branch > 0 ? plural(s.deleted.branch, 'local branch', 'local branches') : null,
+        s.deleted.remote > 0 ? plural(s.deleted.remote, 'remote branch', 'remote branches') : null,
         s.pruned > 0 ? `${plural(s.pruned, 'stale worktree', 'stale worktrees')} pruned` : null,
+        s.gone > 0 ? `${plural(s.gone, 'remote branch', 'remote branches')} already gone` : null,
     ].filter((p) => p !== null);
     const lines = [
-        `${dry ? 'would delete' : 'deleted'}: ${parts.length > 0 ? parts.join(', ') : 'nothing'}`,
+        `${opts.preview === true ? '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);
-        const hints = dropHints(receipt);
+        const hints = dropHints(r.dropped);
         const counts = dropped.map(([reason, c]) => {
             const hint = hints[reason];
             return hint === undefined ? `${c} ${reason}` : `${c} ${reason} (${hint})`;
         });
         lines.push(`skipped ${total}, not deleted: ${counts.join(', ')}`);
     }
-    if (s.failed > 0) {
+    if (s.failed > 0)
         lines.push(`stopped at a failed step; ${plural(s.notRun, 'row', 'rows')} not run`);
-    }
     return lines;
 }
 /** The word a preview shows for a step: what it does to the row. */
@@ -409,7 +349,7 @@ export const STEP_VERB = {
     'verify-remote': 'verify',
     'unlock-worktree': 'unlock',
     'remove-worktree': 'delete',
-    'delete-local': 'delete',
+    'delete-branch': 'delete',
     'delete-remote': 'delete',
     'prune-worktrees': 'prune',
 };
@@ -425,77 +365,88 @@ function resultWord(step, style) {
     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.
+ * A row id for a preview line, its name shortened from the left to fit; the
+ * kind in front always stays, so a long path still says what kind of row it is.
  */
-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)}`;
+function shownRow(id) {
+    const parsed = parseRowId(id);
+    if (parsed === null)
+        return ellipsize(stripControls(id), 70);
+    return `${parsed.kind}:${ellipsize(stripControls(parsed.name), 70 - parsed.kind.length - 1)}`;
+}
+/**
+ * What a run 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, the allows no row needed, 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(p, style = PLAIN) {
+    const repos = [...new Set([...p.steps.map((s) => s.repo), ...p.dropped.map((d) => d.repo)])];
     const blocks = [];
     for (const repo of repos) {
         const lines = [style.strong(stripControls(repo))];
-        for (const s of receipt.steps.filter((s) => s.repo === repo)) {
+        for (const s of p.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(pad(verb, 6))}  worktree records`
-                : `  ${color(pad(verb, 6))}  ${row(s.row)}`);
+            const color = wordStyle(style, verb === 'unlock' || verb === 'verify' ? 'review' : verb);
+            lines.push(`  ${color(pad(verb, 6))}  ${shownRow(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)}`);
+        for (const d of p.dropped.filter((d) => d.repo === repo)) {
+            lines.push(`  ${style.review(pad('skip', 6))}  ${shownRow(d.row)}`);
             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'));
+    const [counts = '', ...rest] = renderRunSummary(p, { preview: true });
+    const unused = (p.unusedAllows ?? []).map((a) => `unused: --allow ${a.risk}${a.row === null ? '' : `=${stripControls(a.row)}`} (no row that runs carries it)`);
+    blocks.push([style.strong(counts), ...rest.map(style.review), ...unused.map(style.muted)].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) {
+/** Rows dropped by a run's own re-check after the preview, each with why. */
+export function renderLateDrops(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`)
+        .map((d) => `  ${style.review('skip')}  ${shownRow(d.row)}\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.
+ * which the step's line 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());
+    const line = stripControls(`${pad(verb, 6)}  ${shownRow(step.row)}`);
     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. */
+/** A run as text: dropped rows, each step, a summary, then where the receipt is. */
 export function renderReceipt(receipt, receiptPath, style = PLAIN, opts = {}) {
     const lines = [];
     // 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('skipped  ')}${shown}`);
+        lines.push(`${style.review('skipped  ')}${stripControls(`${d.row} — ${d.reason} (${d.detail})`)}`);
     }
     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 what = `${s.row} — ${s.command}`;
         const tail = s.error ?? s.verification;
         lines.push(`${resultWord(s, style)} ${stripControls(`${what}${tail ? ` (${tail})` : ''}`)}`);
     }
     if (lines.length > 0)
         lines.push('');
-    const [counts = '', ...rest] = renderApplySummary(receipt);
+    const [counts = '', ...rest] = renderRunSummary(receipt, {
+        preview: receipt.status === 'dry-run',
+    });
     lines.push(style.strong(counts), ...rest.map(style.review));
     lines.push(style.muted(receiptPath === null
         ? `status: ${receipt.status}`
         : `receipt: ${stripControls(receiptPath)} (${receipt.status})`));
     return lines.join('\n') + '\n';
 }
+/** The renderers a library user needs: the CLI's own formats. */
+export const render = {
+    text: renderText,
+    json: renderJson,
+    summary: renderSummary,
+    commands: renderCommands,
+    preview: renderPreview,
+    receipt: renderReceipt,
+};