@solaqua/gji 0.13.0 → 0.14.0

package/dist/application/worktree/go-resolution.js

@@ -46,10 +46,12 @@ export async function resolveGoBranch(options) {
             return finish({ kind: "existing", source: pullRequestMatches[0] }, false);
         }
     }
-    let skippedRegisteredRepos = 0;
-    const registeredSources = await listRegisteredWorktreeSources(cwd, sourceDependencies, () => {
-        skippedRegisteredRepos++;
+    const registered = await listRegisteredWorktreeSources({
+        cwd,
+        repositoryPort: sourceDependencies,
     });
+    const registeredSources = registered.sources;
+    const skippedRegisteredRepos = registered.skipped.length;
     const crossRepoSources = registeredSources.filter((source) => source.repoRoot !== repository?.repoRoot);
     const crossMatches = await resolveExistingWorktreeMatches(crossRepoSources, branch, (!localBranch && !remoteBranch) || isPullRequestUrl(branch), repositoryPort);
     if (crossMatches.length === 1) {

package/dist/application/worktree/sources.d.ts

@@ -1,7 +1,16 @@
 import type { RepoRegistryEntry } from "../../domain/repository/registry.js";
 import type { WorktreeSource } from "../../domain/worktree/source.js";
 import type { RepositoryContextPort, RepositoryRegistryPort, WorktreePort } from "../../ports/repository.js";
-type WorktreeSourceDependencies = RepositoryContextPort & RepositoryRegistryPort & WorktreePort;
-export declare function listRegisteredWorktreeSources(cwd: string, repositoryPort: WorktreeSourceDependencies, onSkipped?: (entry: RepoRegistryEntry) => void): Promise<WorktreeSource[]>;
-export declare function listDiscoverableWorktreeSources(cwd: string, repositoryPort: WorktreeSourceDependencies, onSkipped?: (entry: RepoRegistryEntry) => void): Promise<WorktreeSource[]>;
-export {};
+export type WorktreeSourceDependencies = RepositoryContextPort & RepositoryRegistryPort & WorktreePort;
+export interface WorktreeSourceDiscovery {
+    skipped: RepoRegistryEntry[];
+    sources: WorktreeSource[];
+}
+export interface ListWorktreeSourcesOptions {
+    cwd: string;
+    repositoryPort: WorktreeSourceDependencies;
+    signal?: AbortSignal;
+}
+export declare function listRegisteredWorktreeSources(options: ListWorktreeSourcesOptions): Promise<WorktreeSourceDiscovery>;
+export declare function listDiscoverableWorktreeSources(options: ListWorktreeSourcesOptions): Promise<WorktreeSourceDiscovery>;
+export declare function deduplicateWorktreeSources(sources: WorktreeSource[]): WorktreeSource[];

package/dist/application/worktree/sources.js

@@ -1,25 +1,31 @@
 import { mapWithConcurrency } from "../../domain/shared/concurrency.js";
 const MAX_REPOSITORY_DISCOVERY_CONCURRENCY = 4;
-export async function listRegisteredWorktreeSources(cwd, repositoryPort, onSkipped) {
+export async function listRegisteredWorktreeSources(options) {
+    const { cwd, repositoryPort, signal } = options;
+    throwIfAborted(signal);
     const registry = await repositoryPort.loadRegistry();
     const currentRoot = await repositoryPort
         .detectRepository(cwd)
         .then((repository) => repository.currentRoot)
         .catch(() => null);
+    throwIfAborted(signal);
     const results = await mapWithConcurrency(registry, MAX_REPOSITORY_DISCOVERY_CONCURRENCY, async (entry) => {
+        throwIfAborted(signal);
         try {
             const worktrees = await repositoryPort.listWorktrees(entry.path);
-            return { entry, worktrees };
+            return { entry, skipped: false, worktrees };
         }
         catch {
-            onSkipped?.(entry);
-            return null;
+            return { entry, skipped: true, worktrees: [] };
         }
-    });
+    }, signal);
     const allItems = [];
+    const skipped = [];
     for (const result of results) {
-        if (result === null)
+        if (result.skipped) {
+            skipped.push(result.entry);
             continue;
+        }
         const { entry, worktrees } = result;
         for (const worktree of worktrees) {
             allItems.push({
@@ -32,15 +38,20 @@ export async function listRegisteredWorktreeSources(cwd, repositoryPort, onSkipp
             });
         }
     }
-    return allItems;
+    return { skipped, sources: allItems };
 }
-export async function listDiscoverableWorktreeSources(cwd, repositoryPort, onSkipped) {
+export async function listDiscoverableWorktreeSources(options) {
+    const { cwd, repositoryPort } = options;
     const currentRepository = await repositoryPort
         .detectRepository(cwd)
         .catch(() => null);
-    const registeredSources = await listRegisteredWorktreeSources(cwd, repositoryPort, onSkipped);
-    if (currentRepository === null)
-        return dedupeSources(registeredSources);
+    const registered = await listRegisteredWorktreeSources(options);
+    if (currentRepository === null) {
+        return {
+            skipped: registered.skipped,
+            sources: deduplicateWorktreeSources(registered.sources),
+        };
+    }
     let currentSources = [];
     try {
         currentSources = (await repositoryPort.listWorktrees(cwd)).map((worktree) => ({
@@ -52,9 +63,15 @@ export async function listDiscoverableWorktreeSources(cwd, repositoryPort, onSki
     catch {
         // Registered repositories remain discoverable when the current checkout is transiently unavailable.
     }
-    return dedupeSources([...currentSources, ...registeredSources]);
+    return {
+        skipped: registered.skipped,
+        sources: deduplicateWorktreeSources([
+            ...currentSources,
+            ...registered.sources,
+        ]),
+    };
 }
-function dedupeSources(sources) {
+export function deduplicateWorktreeSources(sources) {
     const seen = new Set();
     return sources.filter((source) => {
         if (seen.has(source.worktree.path))
@@ -63,3 +80,7 @@ function dedupeSources(sources) {
         return true;
     });
 }
+function throwIfAborted(signal) {
+    if (signal?.aborted)
+        throw new Error("Operation cancelled");
+}

package/dist/cli/commands/clean.d.ts

@@ -1,5 +1,6 @@
+import { type WorktreeCatalogDependencies } from "../../application/worktree/catalog.js";
 import type { WorktreeEntry } from "../../domain/worktree/types.js";
-import { type WorktreePromptEntry } from "../../presentation/worktree/picker.js";
+import { type WorktreePromptEntry, type WorktreePromptScope } from "../../presentation/worktree/picker.js";
 import { type CliRuntime } from "../dependencies.js";
 export interface CleanCommandOptions {
     cwd: string;
@@ -15,7 +16,7 @@ export interface CleanCommandDependencies {
     confirmForceDeleteBranch: (branch: string) => Promise<boolean>;
     confirmForceRemoveWorktree: (worktreePath: string) => Promise<boolean>;
     confirmRemoval: (worktrees: WorktreeEntry[]) => Promise<boolean>;
-    promptForWorktrees: (worktrees: WorktreePromptEntry[]) => Promise<string[] | null>;
+    promptForWorktrees: (worktrees: WorktreePromptEntry[], scope?: WorktreePromptScope, catalog?: WorktreeCatalogDependencies) => Promise<string[] | null>;
 }
 export declare function createCleanCommand(dependencies?: Partial<CleanCommandDependencies>): (options: CleanCommandOptions) => Promise<number>;
 export declare const runCleanCommand: (options: CleanCommandOptions) => Promise<number>;

package/dist/cli/commands/clean.js

@@ -1,10 +1,21 @@
 import { confirm, isCancel } from "@clack/prompts";
-import { loadLinkedWorktrees } from "../../application/worktree/catalog.js";
+import { loadLinkedWorktrees, } from "../../application/worktree/catalog.js";
+import { deduplicateWorktreeSources, listRegisteredWorktreeSources, } from "../../application/worktree/sources.js";
+import { mapWithConcurrency } from "../../domain/shared/concurrency.js";
 import { buildWorktreePromptEntries, promptForMultipleWorktrees, } from "../../presentation/worktree/picker.js";
 import { defaultConfirmForceDeleteBranch, defaultConfirmForceRemoveWorktree, } from "../../presentation/worktree/prompts.js";
 import { defaultCliDependencies, } from "../dependencies.js";
 import { isHeadless } from "../runtime/headless.js";
-import { finalizeUndoOperation, recordUndoOperation } from "./undo.js";
+import { finalizeUndoOperation, recordUndoOperation, } from "./undo.js";
+function toPromptSource(candidate) {
+    return {
+        repoName: candidate.repoName,
+        repoRoot: candidate.repoRoot,
+        worktree: candidate.worktree,
+    };
+}
+const MAX_CLEAN_REPOSITORY_CONCURRENCY = 4;
+const MAX_CLEAN_WORKTREE_CONCURRENCY = 8;
 export function createCleanCommand(dependencies = {}) {
     const promptForWorktrees = dependencies.promptForWorktrees ?? defaultPromptForWorktrees;
     const confirmRemoval = dependencies.confirmRemoval ?? defaultConfirmRemoval;
@@ -13,7 +24,7 @@ export function createCleanCommand(dependencies = {}) {
     const confirmForceDeleteBranch = dependencies.confirmForceDeleteBranch ?? defaultConfirmForceDeleteBranch;
     return async function runCleanCommand(options) {
         const runtime = options.runtime ?? defaultCliDependencies;
-        const { readWorktreeHealth, isBranchMergedInto, resolveRemoteDefaultBranch, runGit, } = runtime.git;
+        const { readWorktreeHealth, isBranchMergedInto, resolveRemoteBase, runGit, } = runtime.git;
         const { loadEffectiveConfig } = runtime.config;
         const { releaseWorktreeSlot } = runtime.slots;
         const sourceDependencies = {
@@ -24,14 +35,97 @@ export function createCleanCommand(dependencies = {}) {
         const { formatLastCommit, formatUpstreamState, readWorktreeInfos, serializeWorktreeInfo, } = runtime.worktreeInfo;
         const { deleteBranch, forceDeleteBranch, forceRemoveWorktree, isBranchUnmergedError, isSubmoduleWorktreeRemovalError, isWorktreeDeletionError, isWorktreeForceRemovalError, removeWorktree, } = runtime.worktreeLifecycle;
         const { linkedWorktrees, repository } = await loadLinkedWorktrees(options.cwd, sourceDependencies);
-        const linkedCleanupCandidates = linkedWorktrees.filter((worktree) => worktree.path !== repository.currentRoot);
-        const staleBaseRef = options.stale
-            ? await resolveStaleBaseRef(repository.repoRoot, options.stderr, loadEffectiveConfig, resolveRemoteDefaultBranch, runGit)
-            : null;
-        const cleanupCandidates = options.stale
-            ? await filterStaleCleanupCandidates(repository.repoRoot, linkedCleanupCandidates, staleBaseRef, readWorktreeHealth, isBranchMergedInto)
-            : linkedCleanupCandidates;
-        if (cleanupCandidates.length === 0) {
+        const currentSources = linkedWorktrees
+            .filter((worktree) => worktree.path !== repository.currentRoot)
+            .map((worktree) => ({
+            repoName: repository.repoName,
+            repoRoot: repository.repoRoot,
+            worktree,
+        }));
+        const cleanupDependencies = {
+            isBranchMergedInto,
+            loadEffectiveConfig,
+            readWorktreeHealth,
+            resolveRemoteBase,
+            runGit,
+        };
+        const currentCandidates = await resolveCleanupCandidates({
+            sources: currentSources,
+            stale: options.stale,
+            stderr: options.stderr,
+        }, cleanupDependencies);
+        let activeCandidates = currentCandidates;
+        let allCandidates = null;
+        let currentScope = true;
+        const interactiveSelection = !options.force && !options.json && !isHeadless();
+        const skippedRepositories = [];
+        const loadAllCandidates = async (signal) => {
+            throwIfAborted(signal);
+            if (allCandidates !== null)
+                return allCandidates;
+            const registered = await listRegisteredWorktreeSources({
+                cwd: options.cwd,
+                repositoryPort: sourceDependencies,
+                signal,
+            });
+            skippedRepositories.push(...registered.skipped);
+            if (registered.skipped.length > 0) {
+                reportSkippedRepositories(skippedRepositories, options.stderr);
+            }
+            const sources = deduplicateWorktreeSources([
+                ...currentSources,
+                ...registered.sources,
+            ]).filter((source) => source.repoRoot !== undefined &&
+                source.worktree.path !== source.repoRoot &&
+                source.worktree.path !== repository.currentRoot);
+            const otherRepositorySources = sources.filter((source) => source.repoRoot !== repository.repoRoot);
+            const otherRepositoryCandidates = await resolveCleanupCandidates({
+                sources: otherRepositorySources,
+                stale: options.stale,
+                stderr: options.stderr,
+                signal,
+            }, cleanupDependencies);
+            allCandidates = [...currentCandidates, ...otherRepositoryCandidates];
+            throwIfAborted(signal);
+            return allCandidates;
+        };
+        const scope = {
+            label: "current repository",
+            toggleLabel: "all repositories",
+            toggle: async (signal) => {
+                const nextCurrentScope = !currentScope;
+                const nextCandidates = nextCurrentScope
+                    ? currentCandidates
+                    : await loadAllCandidates(signal);
+                throwIfAborted(signal);
+                currentScope = nextCurrentScope;
+                activeCandidates = nextCandidates;
+                return {
+                    sources: nextCandidates.map(toPromptSource),
+                    metadata: nextCurrentScope ? "full" : "fast",
+                    label: nextCurrentScope ? "current repository" : "all repositories",
+                    toggleLabel: nextCurrentScope
+                        ? "all repositories"
+                        : "current repository",
+                };
+            },
+        };
+        if (currentCandidates.length === 0 && interactiveSelection) {
+            const loadedAllCandidates = await loadAllCandidates();
+            if (loadedAllCandidates.length === 0) {
+                if (options.stale) {
+                    emitNoStaleCandidates(options);
+                    return 0;
+                }
+                emitError(options, "No linked worktrees to clean");
+                return 1;
+            }
+            currentScope = false;
+            activeCandidates = loadedAllCandidates;
+            scope.label = "all repositories";
+            scope.toggleLabel = "current repository";
+        }
+        if (currentCandidates.length === 0 && !interactiveSelection) {
             if (options.stale) {
                 emitNoStaleCandidates(options);
                 return 0;
@@ -53,20 +147,21 @@ export function createCleanCommand(dependencies = {}) {
         const shouldSelectAll = options.force ||
             (options.dryRun && (options.stale || options.json || isHeadless()));
         const selections = shouldSelectAll
-            ? cleanupCandidates.map((w) => w.path)
-            : await promptForWorktrees(await buildWorktreePromptEntries(cleanupCandidates.map((worktree) => ({
-                repoName: repository.repoName,
-                worktree,
-            })), { catalog: runtime.worktreeCatalog }));
+            ? activeCandidates.map(({ worktree }) => worktree.path)
+            : await promptForWorktrees(await buildWorktreePromptEntries(activeCandidates, {
+                metadata: currentScope ? "full" : "fast",
+                catalog: runtime.worktreeCatalog,
+            }), scope, runtime.worktreeCatalog);
         if (!selections || selections.length === 0) {
             options.stderr("Aborted\n");
             return 1;
         }
-        const selectedWorktrees = resolveSelectedWorktrees(cleanupCandidates, selections);
-        if (selectedWorktrees.length !== selections.length) {
+        const selectedCandidates = resolveSelectedCandidates(activeCandidates, selections);
+        if (selectedCandidates.length !== selections.length) {
             options.stderr("Selected worktree no longer exists\n");
             return 1;
         }
+        const selectedWorktrees = selectedCandidates.map(({ worktree }) => worktree);
         const selectedWorktreeInfos = await readWorktreeInfos(selectedWorktrees);
         const selectedInfoByPath = new Map(selectedWorktreeInfos.map((info) => [info.path, info]));
         if (!options.dryRun &&
@@ -87,28 +182,35 @@ export function createCleanCommand(dependencies = {}) {
             }
             return 0;
         }
-        const removedWorktrees = [];
+        const candidatesByRepository = groupCandidatesByRepository(selectedCandidates);
+        const journals = new Map();
         const failures = [];
-        let journal;
         try {
-            journal = await recordUndoOperation("clean", repository.repoRoot, selectedWorktrees, undefined, runtime);
+            for (const [repoRoot, candidates] of candidatesByRepository) {
+                const journal = await recordUndoOperation("clean", repoRoot, candidates.map(({ worktree }) => worktree), undefined, runtime);
+                if (!journal) {
+                    await discardUndoRecords(journals.values(), runtime.configStore.GLOBAL_CONFIG_DIRECTORY);
+                    emitError(options, "could not capture undo state; no worktrees were removed");
+                    return 1;
+                }
+                journals.set(repoRoot, journal);
+            }
         }
         catch (error) {
+            await discardUndoRecords(journals.values(), runtime.configStore.GLOBAL_CONFIG_DIRECTORY);
             emitError(options, `could not write undo journal; no worktrees were removed: ${toMessage(error)}`);
             return 1;
         }
-        if (!journal) {
-            emitError(options, "could not capture undo state; no worktrees were removed");
-            return 1;
-        }
-        for (const worktree of selectedWorktrees) {
+        const removedCandidates = [];
+        for (const candidate of selectedCandidates) {
+            const { repoRoot, staleBaseRef, worktree } = candidate;
             if (options.stale &&
-                !(await isStaleCleanupCandidate(repository.repoRoot, worktree, staleBaseRef, readWorktreeHealth, isBranchMergedInto))) {
+                !(await isStaleCleanupCandidate({ repoRoot, worktree, baseBranch: staleBaseRef }, cleanupDependencies))) {
                 options.stderr(`Skipped ${worktree.path}: no longer a safe stale cleanup candidate\n`);
                 continue;
             }
             try {
-                await removeWorktree(repository.repoRoot, worktree.path);
+                await removeWorktree(repoRoot, worktree.path);
             }
             catch (error) {
                 if (!isWorktreeForceRemovalError(error)) {
@@ -135,7 +237,7 @@ export function createCleanCommand(dependencies = {}) {
                     continue;
                 }
                 try {
-                    await forceRemoveWorktree(repository.repoRoot, worktree.path);
+                    await forceRemoveWorktree(repoRoot, worktree.path);
                 }
                 catch (forceError) {
                     failures.push({
@@ -146,10 +248,10 @@ export function createCleanCommand(dependencies = {}) {
                     continue;
                 }
             }
-            removedWorktrees.push(worktree);
+            removedCandidates.push(candidate);
             if (worktree.branch) {
                 try {
-                    await deleteBranch(repository.repoRoot, worktree.branch);
+                    await deleteBranch(repoRoot, worktree.branch);
                 }
                 catch (error) {
                     if (!isBranchUnmergedError(error)) {
@@ -163,7 +265,7 @@ export function createCleanCommand(dependencies = {}) {
                     if (options.force ||
                         (await confirmForceDeleteBranch(worktree.branch))) {
                         try {
-                            await forceDeleteBranch(repository.repoRoot, worktree.branch);
+                            await forceDeleteBranch(repoRoot, worktree.branch);
                         }
                         catch (forceError) {
                             options.stderr(`Failed to delete branch ${worktree.branch}: ${toMessage(forceError)}\n`);
@@ -175,56 +277,149 @@ export function createCleanCommand(dependencies = {}) {
                 }
             }
         }
-        await finalizeUndoOperation(journal, removedWorktrees, undefined, runtime.configStore.GLOBAL_CONFIG_DIRECTORY);
-        await Promise.all(removedWorktrees.map((worktree) => releaseWorktreeSlot(worktree.path)));
+        for (const [repoRoot, journal] of journals) {
+            await finalizeUndoOperation(journal, removedCandidates
+                .filter((candidate) => candidate.repoRoot === repoRoot)
+                .map(({ worktree }) => worktree), undefined, runtime.configStore.GLOBAL_CONFIG_DIRECTORY);
+        }
+        const undoRecords = remainingUndoRecords(journals.values(), removedCandidates);
+        await Promise.all(removedCandidates.map(({ worktree }) => releaseWorktreeSlot(worktree.path)));
         if (options.json) {
-            const removed = removedWorktrees.map((worktree) => {
+            const removed = removedCandidates.map(({ worktree }) => {
                 const info = selectedInfoByPath.get(worktree.path);
                 return info === undefined
                     ? { branch: worktree.branch, path: worktree.path }
                     : serializeWorktreeInfo(info);
             });
-            const payload = failures.length === 0 ? { removed } : { removed, failed: failures };
+            const payload = {
+                removed,
+                ...(failures.length === 0 ? {} : { failed: failures }),
+                ...(needsExplicitUndoIds(undoRecords, repository.repoRoot)
+                    ? {
+                        undo: undoRecords.map(({ id, repoRoot }) => ({ id, repoRoot })),
+                    }
+                    : {}),
+            };
             options.stdout(`${JSON.stringify(payload, null, 2)}\n`);
         }
         else if (failures.length > 0) {
             reportCleanFailures(failures, options.stderr);
+            emitUndoHints(undoRecords, repository.repoRoot, options.stderr);
         }
         else {
-            options.stderr("undo: gji undo\n");
-            options.stdout(`${repository.repoRoot}\n`);
+            emitUndoHints(undoRecords, repository.repoRoot, options.stderr);
+            options.stdout(`${[...new Set(selectedCandidates.map(({ repoRoot }) => repoRoot))].join("\n")}\n`);
         }
         return failures.length === 0 ? 0 : 1;
     };
 }
 export const runCleanCommand = createCleanCommand();
-async function filterStaleCleanupCandidates(repoRoot, worktrees, baseBranch, readWorktreeHealth, isBranchMergedInto) {
+async function resolveCleanupCandidates(options, dependencies) {
+    const { sources, stale, stderr, signal } = options;
+    const grouped = new Map();
+    for (const source of sources) {
+        if (source.repoRoot === undefined)
+            continue;
+        const existing = grouped.get(source.repoRoot);
+        if (existing === undefined) {
+            grouped.set(source.repoRoot, {
+                repoName: source.repoName,
+                worktrees: [source.worktree],
+            });
+        }
+        else {
+            existing.worktrees.push(source.worktree);
+        }
+    }
+    const results = await mapWithConcurrency([...grouped.entries()], MAX_CLEAN_REPOSITORY_CONCURRENCY, async ([repoRoot, group]) => {
+        throwIfAborted(signal);
+        const staleBaseRef = stale
+            ? await resolveStaleBaseRef({ repoRoot, stderr }, dependencies)
+            : null;
+        const worktrees = stale
+            ? await filterStaleCleanupCandidates({
+                repoRoot,
+                worktrees: group.worktrees,
+                baseBranch: staleBaseRef,
+                signal,
+            }, dependencies)
+            : group.worktrees;
+        return worktrees.map((worktree) => ({
+            repoName: group.repoName,
+            repoRoot,
+            staleBaseRef,
+            worktree,
+        }));
+    }, signal);
+    return results.flat();
+}
+function resolveSelectedCandidates(candidates, selections) {
+    const selected = [];
+    const seenPaths = new Set();
+    for (const selection of selections) {
+        const candidate = candidates.find((entry) => entry.worktree.path === selection ||
+            entry.worktree.branch === selection);
+        if (candidate === undefined || seenPaths.has(candidate.worktree.path)) {
+            continue;
+        }
+        selected.push(candidate);
+        seenPaths.add(candidate.worktree.path);
+    }
+    return selected;
+}
+function groupCandidatesByRepository(candidates) {
+    const grouped = new Map();
+    for (const candidate of candidates) {
+        const existing = grouped.get(candidate.repoRoot);
+        if (existing === undefined)
+            grouped.set(candidate.repoRoot, [candidate]);
+        else
+            existing.push(candidate);
+    }
+    return grouped;
+}
+function remainingUndoRecords(records, removedCandidates) {
+    return [...records].filter((record) => removedCandidates.some((candidate) => candidate.repoRoot === record.repoRoot &&
+        record.entries.some((entry) => entry.path === candidate.worktree.path)));
+}
+async function discardUndoRecords(records, globalConfigDirectory) {
+    await Promise.all([...records].map((record) => finalizeUndoOperation(record, [], undefined, globalConfigDirectory)));
+}
+async function filterStaleCleanupCandidates(options, dependencies) {
+    const { repoRoot, worktrees, baseBranch, signal } = options;
+    throwIfAborted(signal);
     if (baseBranch === null) {
         return [];
     }
-    const results = await Promise.all(worktrees.map((worktree) => isStaleCleanupCandidate(repoRoot, worktree, baseBranch, readWorktreeHealth, isBranchMergedInto)));
+    const results = await mapWithConcurrency(worktrees, MAX_CLEAN_WORKTREE_CONCURRENCY, (worktree) => isStaleCleanupCandidate({ repoRoot, worktree, baseBranch }, dependencies), signal);
+    throwIfAborted(signal);
     return worktrees.filter((_, index) => results[index]);
 }
-async function resolveStaleBaseRef(repoRoot, stderr, loadEffectiveConfig, resolveRemoteDefaultBranch, runGit) {
-    const config = await loadEffectiveConfig(repoRoot, undefined, stderr);
+async function resolveStaleBaseRef(options, dependencies) {
+    const { repoRoot, stderr } = options;
+    const config = await dependencies.loadEffectiveConfig(repoRoot, undefined, stderr);
     const remote = resolveConfiguredString(config.syncRemote) ?? "origin";
     const configuredDefaultBranch = resolveConfiguredString(config.syncDefaultBranch);
-    if (configuredDefaultBranch) {
-        return await resolveFetchedRemoteRef(repoRoot, remote, configuredDefaultBranch, runGit);
-    }
     try {
-        const remoteDefaultBranch = await resolveRemoteDefaultBranch(repoRoot, remote);
-        return remoteDefaultBranch === null
+        const remoteBase = await dependencies.resolveRemoteBase(repoRoot, remote, configuredDefaultBranch ?? undefined);
+        return remoteBase === null
             ? null
-            : await resolveFetchedRemoteRef(repoRoot, remote, remoteDefaultBranch, runGit);
+            : resolveFetchedRemoteRef({ branch: remoteBase.branch, remote, repoRoot }, dependencies.runGit);
     }
     catch {
         return null;
     }
 }
-async function resolveFetchedRemoteRef(repoRoot, remote, branch, runGit) {
+async function resolveFetchedRemoteRef(options, runGit) {
+    const { repoRoot, remote, branch } = options;
     try {
         await runGit(repoRoot, ["fetch", "--prune", remote]);
+        await runGit(repoRoot, [
+            "rev-parse",
+            "--verify",
+            "--quiet",
+            `${remote}/${branch}`,
+        ]);
         return `${remote}/${branch}`;
     }
     catch {
@@ -234,31 +429,37 @@ async function resolveFetchedRemoteRef(repoRoot, remote, branch, runGit) {
 function resolveConfiguredString(value) {
     return typeof value === "string" && value.length > 0 ? value : null;
 }
-async function isStaleCleanupCandidate(repoRoot, worktree, baseBranch, readWorktreeHealth, isBranchMergedInto) {
+async function isStaleCleanupCandidate(options, dependencies) {
+    const { repoRoot, worktree, baseBranch } = options;
     if (baseBranch === null) {
         return false;
     }
     if (worktree.branch === null) {
         return false;
     }
-    const health = await readWorktreeHealth(worktree.path);
+    const health = await dependencies.readWorktreeHealth(worktree.path);
     if (health.status !== "clean" || !health.upstreamGone) {
         return false;
     }
-    return isBranchMergedInto(repoRoot, worktree.branch, baseBranch);
+    if (await dependencies.isBranchMergedInto(repoRoot, worktree.branch, baseBranch)) {
+        return true;
+    }
+    return isBranchPatchEquivalentInto({ baseBranch, repoRoot, worktreeBranch: worktree.branch }, dependencies.runGit);
 }
-function resolveSelectedWorktrees(worktrees, selections) {
-    const selectedWorktrees = [];
-    const seenPaths = new Set();
-    for (const selection of selections) {
-        const worktree = worktrees.find((entry) => entry.path === selection || entry.branch === selection);
-        if (!worktree || seenPaths.has(worktree.path)) {
-            continue;
-        }
-        selectedWorktrees.push(worktree);
-        seenPaths.add(worktree.path);
+async function isBranchPatchEquivalentInto(options, runGit) {
+    const { repoRoot, worktreeBranch, baseBranch } = options;
+    try {
+        const output = await runGit(repoRoot, [
+            "cherry",
+            baseBranch,
+            worktreeBranch,
+        ]);
+        const lines = output.split("\n").filter(Boolean);
+        return lines.length > 0 && lines.every((line) => line.startsWith("-"));
+    }
+    catch {
+        return false;
     }
-    return selectedWorktrees;
 }
 function reportCleanFailures(failures, stderr) {
     const noun = failures.length === 1 ? "worktree" : "worktrees";
@@ -268,6 +469,36 @@ function reportCleanFailures(failures, stderr) {
         stderr(`- ${failure.path} (${branch}): ${failure.message}\n`);
     }
 }
+function emitUndoHints(records, currentRepositoryRoot, stderr) {
+    if (records.length === 0)
+        return;
+    if (!needsExplicitUndoIds(records, currentRepositoryRoot)) {
+        stderr("undo: gji undo\n");
+        return;
+    }
+    const message = records.length === 1
+        ? "undo: restore with:"
+        : "undo: restore each repository with:";
+    stderr(`${message}\n`);
+    for (const record of records) {
+        stderr(`  gji undo --id ${record.id} (${record.repoRoot})\n`);
+    }
+}
+function needsExplicitUndoIds(records, currentRepositoryRoot) {
+    return (records.length > 1 ||
+        records.some((record) => record.repoRoot !== currentRepositoryRoot));
+}
+function reportSkippedRepositories(repositories, stderr) {
+    const noun = repositories.length === 1 ? "repository" : "repositories";
+    stderr(`Skipped ${repositories.length} registered ${noun} because worktrees could not be listed:\n`);
+    for (const repository of repositories) {
+        stderr(`- ${repository.name} (${repository.path})\n`);
+    }
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted)
+        throw new Error("Operation cancelled");
+}
 function formatCleanInfo(info, formatLastCommit, formatUpstreamState) {
     const branch = info.branch === null ? "detached" : `branch: ${info.branch}`;
     const status = `status: ${info.status}`;
@@ -296,8 +527,11 @@ function emitNoStaleCandidates(options) {
 function toMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
-async function defaultPromptForWorktrees(worktrees) {
-    return promptForMultipleWorktrees("Choose worktrees to clean", worktrees);
+async function defaultPromptForWorktrees(worktrees, scope, catalog) {
+    return promptForMultipleWorktrees("Choose worktrees to clean", worktrees, {
+        catalog,
+        scope,
+    });
 }
 async function defaultConfirmRemoval(worktrees) {
     const branchCount = worktrees.filter((worktree) => worktree.branch !== null).length;