@solaqua/gji 0.13.0 → 0.14.0

package/dist/gji-bundle.mjs

@@ -12810,7 +12810,7 @@ function updateNotifier(options) {
 // package.json
 var package_default = {
   name: "@solaqua/gji",
-  version: "0.13.0",
+  version: "0.14.0",
   description: "Git worktree CLI for fast context switching.",
   license: "MIT",
   author: "sjquant",
@@ -13931,16 +13931,7 @@ async function resolveCachedRemoteDefaultBranch(cwd, remote) {
     const prefix = `${remote}/`;
     return ref.startsWith(prefix) ? ref.slice(prefix.length) : void 0;
   } catch {
-    try {
-      const refs = await runGit(cwd, [
-        "for-each-ref",
-        "--format=%(refname:strip=3)",
-        `refs/remotes/${remote}`
-      ]);
-      return refs.split("\n").find((ref) => ref !== "HEAD");
-    } catch {
-      return void 0;
-    }
+    return void 0;
   }
 }
 async function readBranchLastCommitTimestamp(cwd, branch) {
@@ -15294,11 +15285,12 @@ function toErrorMessage2(error) {
 }
 
 // src/domain/shared/concurrency.ts
-async function mapWithConcurrency(items, limit, mapper) {
+async function mapWithConcurrency(items, limit, mapper, signal) {
   const results = new Array(items.length);
   let nextIndex = 0;
   async function readNext() {
     for (; ; ) {
+      throwIfAborted(signal);
       const index = nextIndex;
       nextIndex += 1;
       if (index >= items.length) return;
@@ -15310,6 +15302,9 @@ async function mapWithConcurrency(items, limit, mapper) {
   );
   return results;
 }
+function throwIfAborted(signal) {
+  if (signal?.aborted) throw new Error("Operation cancelled");
+}
 
 // src/infrastructure/worktree/info.ts
 var MAX_WORKTREE_INFO_READ_CONCURRENCY = 8;
@@ -16401,6 +16396,90 @@ function sortPullRequests2(pullRequests) {
   );
 }
 
+// src/application/worktree/sources.ts
+var MAX_REPOSITORY_DISCOVERY_CONCURRENCY = 4;
+async function listRegisteredWorktreeSources(options) {
+  const { cwd, repositoryPort, signal } = options;
+  throwIfAborted2(signal);
+  const registry = await repositoryPort.loadRegistry();
+  const currentRoot = await repositoryPort.detectRepository(cwd).then((repository) => repository.currentRoot).catch(() => null);
+  throwIfAborted2(signal);
+  const results = await mapWithConcurrency(
+    registry,
+    MAX_REPOSITORY_DISCOVERY_CONCURRENCY,
+    async (entry) => {
+      throwIfAborted2(signal);
+      try {
+        const worktrees = await repositoryPort.listWorktrees(entry.path);
+        return { entry, skipped: false, worktrees };
+      } catch {
+        return { entry, skipped: true, worktrees: [] };
+      }
+    },
+    signal
+  );
+  const allItems = [];
+  const skipped = [];
+  for (const result of results) {
+    if (result.skipped) {
+      skipped.push(result.entry);
+      continue;
+    }
+    const { entry, worktrees } = result;
+    for (const worktree of worktrees) {
+      allItems.push({
+        repoRoot: entry.path,
+        repoName: entry.name,
+        worktree: {
+          ...worktree,
+          isCurrent: currentRoot !== null && worktree.path === currentRoot
+        }
+      });
+    }
+  }
+  return { skipped, sources: allItems };
+}
+async function listDiscoverableWorktreeSources(options) {
+  const { cwd, repositoryPort } = options;
+  const currentRepository = await repositoryPort.detectRepository(cwd).catch(() => null);
+  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) => ({
+        repoName: currentRepository.repoName,
+        repoRoot: currentRepository.repoRoot,
+        worktree
+      })
+    );
+  } catch {
+  }
+  return {
+    skipped: registered.skipped,
+    sources: deduplicateWorktreeSources([
+      ...currentSources,
+      ...registered.sources
+    ])
+  };
+}
+function deduplicateWorktreeSources(sources) {
+  const seen = /* @__PURE__ */ new Set();
+  return sources.filter((source) => {
+    if (seen.has(source.worktree.path)) return false;
+    seen.add(source.worktree.path);
+    return true;
+  });
+}
+function throwIfAborted2(signal) {
+  if (signal?.aborted) throw new Error("Operation cancelled");
+}
+
 // src/presentation/worktree/picker.ts
 import { env as env4, platform as platform2, stdin, stdout } from "node:process";
 
@@ -16501,6 +16580,7 @@ async function promptForSingleWorktree(message, worktrees, io = {}) {
     message,
     multiple: false,
     output: io.output,
+    catalog: io.catalog,
     scope: io.scope
   });
   return typeof choice === "string" ? choice : null;
@@ -16511,7 +16591,9 @@ async function promptForMultipleWorktrees(message, worktrees, io = {}) {
     input: io.input,
     message,
     multiple: true,
-    output: io.output
+    output: io.output,
+    catalog: io.catalog,
+    scope: io.scope
   });
   return Array.isArray(choice) ? choice : null;
 }
@@ -16600,6 +16682,7 @@ var SearchablePrompt = class {
   scope;
   scopeTogglePending = false;
   promptClosed = false;
+  cancellation = new AbortController();
   prompt;
   run() {
     return this.prompt.prompt();
@@ -16650,9 +16733,14 @@ var SearchablePrompt = class {
     this.scopeTogglePending = true;
     renderPrompt(prompt);
     try {
-      const nextScope = await currentScope.toggle();
+      const nextScope = await currentScope.toggle(this.cancellation.signal);
       if (this.promptClosed) return;
-      this.entries = nextScope.entries.map(buildSearchableWorktreeEntry);
+      const nextEntries = await buildWorktreePromptEntries(nextScope.sources, {
+        catalog: this.options.catalog,
+        metadata: nextScope.metadata
+      });
+      this.entries = nextEntries.map(buildSearchableWorktreeEntry);
+      this.pruneHiddenSelections();
       this.scope = {
         label: nextScope.label,
         toggle: currentScope.toggle,
@@ -16683,6 +16771,7 @@ var SearchablePrompt = class {
   }
   cancel(prompt) {
     this.promptClosed = true;
+    this.cancellation.abort();
     prompt.state = "cancel";
     renderPrompt(prompt);
     closePrompt(prompt);
@@ -16773,6 +16862,14 @@ var SearchablePrompt = class {
     }
     this.selected.add(entry.value);
   }
+  pruneHiddenSelections() {
+    const visibleValues = new Set(
+      this.entries.filter(isSelectableEntry).map((entry) => entry.value)
+    );
+    for (const value of this.selected) {
+      if (!visibleValues.has(value)) this.selected.delete(value);
+    }
+  }
   render(state, error) {
     const entries = this.visibleEntries();
     const visibleEntries = windowPromptEntries(
@@ -17790,6 +17887,15 @@ function emitUndoError(options, message) {
 }
 
 // src/cli/commands/clean.ts
+function toPromptSource(candidate) {
+  return {
+    repoName: candidate.repoName,
+    repoRoot: candidate.repoRoot,
+    worktree: candidate.worktree
+  };
+}
+var MAX_CLEAN_REPOSITORY_CONCURRENCY = 4;
+var MAX_CLEAN_WORKTREE_CONCURRENCY = 8;
 function createCleanCommand(dependencies = {}) {
   const promptForWorktrees = dependencies.promptForWorktrees ?? defaultPromptForWorktrees;
   const confirmRemoval = dependencies.confirmRemoval ?? defaultConfirmRemoval;
@@ -17800,7 +17906,7 @@ function createCleanCommand(dependencies = {}) {
     const {
       readWorktreeHealth: readWorktreeHealth2,
       isBranchMergedInto: isBranchMergedInto2,
-      resolveRemoteDefaultBranch: resolveRemoteDefaultBranch2,
+      resolveRemoteBase: resolveRemoteBase2,
       runGit: runGit2
     } = runtime.git;
     const { loadEffectiveConfig: loadEffectiveConfig2 } = runtime.config;
@@ -17830,24 +17936,98 @@ function createCleanCommand(dependencies = {}) {
       options.cwd,
       sourceDependencies
     );
-    const linkedCleanupCandidates = linkedWorktrees.filter(
-      (worktree) => worktree.path !== repository.currentRoot
+    const currentSources = linkedWorktrees.filter((worktree) => worktree.path !== repository.currentRoot).map((worktree) => ({
+      repoName: repository.repoName,
+      repoRoot: repository.repoRoot,
+      worktree
+    }));
+    const cleanupDependencies = {
+      isBranchMergedInto: isBranchMergedInto2,
+      loadEffectiveConfig: loadEffectiveConfig2,
+      readWorktreeHealth: readWorktreeHealth2,
+      resolveRemoteBase: resolveRemoteBase2,
+      runGit: runGit2
+    };
+    const currentCandidates = await resolveCleanupCandidates(
+      {
+        sources: currentSources,
+        stale: options.stale,
+        stderr: options.stderr
+      },
+      cleanupDependencies
     );
-    const staleBaseRef = options.stale ? await resolveStaleBaseRef(
-      repository.repoRoot,
-      options.stderr,
-      loadEffectiveConfig2,
-      resolveRemoteDefaultBranch2,
-      runGit2
-    ) : null;
-    const cleanupCandidates = options.stale ? await filterStaleCleanupCandidates(
-      repository.repoRoot,
-      linkedCleanupCandidates,
-      staleBaseRef,
-      readWorktreeHealth2,
-      isBranchMergedInto2
-    ) : linkedCleanupCandidates;
-    if (cleanupCandidates.length === 0) {
+    let activeCandidates = currentCandidates;
+    let allCandidates = null;
+    let currentScope = true;
+    const interactiveSelection = !options.force && !options.json && !isHeadless();
+    const skippedRepositories = [];
+    const loadAllCandidates = async (signal) => {
+      throwIfAborted3(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 !== void 0 && 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];
+      throwIfAborted3(signal);
+      return allCandidates;
+    };
+    const scope = {
+      label: "current repository",
+      toggleLabel: "all repositories",
+      toggle: async (signal) => {
+        const nextCurrentScope = !currentScope;
+        const nextCandidates = nextCurrentScope ? currentCandidates : await loadAllCandidates(signal);
+        throwIfAborted3(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;
@@ -17868,27 +18048,29 @@ function createCleanCommand(dependencies = {}) {
       return 1;
     }
     const shouldSelectAll = options.force || options.dryRun && (options.stale || options.json || isHeadless());
-    const selections = shouldSelectAll ? cleanupCandidates.map((w2) => w2.path) : await promptForWorktrees(
-      await buildWorktreePromptEntries(
-        cleanupCandidates.map((worktree) => ({
-          repoName: repository.repoName,
-          worktree
-        })),
-        { catalog: runtime.worktreeCatalog }
-      )
+    const selections = shouldSelectAll ? 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,
+    const selectedCandidates = resolveSelectedCandidates(
+      activeCandidates,
       selections
     );
-    if (selectedWorktrees.length !== selections.length) {
+    if (selectedCandidates.length !== selections.length) {
       options.stderr("Selected worktree no longer exists\n");
       return 1;
     }
+    const selectedWorktrees = selectedCandidates.map(
+      ({ worktree }) => worktree
+    );
     const selectedWorktreeInfos = await readWorktreeInfos2(selectedWorktrees);
     const selectedInfoByPath = new Map(
       selectedWorktreeInfos.map((info) => [info.path, info])
@@ -17916,38 +18098,48 @@ function createCleanCommand(dependencies = {}) {
       }
       return 0;
     }
-    const removedWorktrees = [];
+    const candidatesByRepository = groupCandidatesByRepository(selectedCandidates);
+    const journals = /* @__PURE__ */ new Map();
     const failures = [];
-    let journal;
     try {
-      journal = await recordUndoOperation(
-        "clean",
-        repository.repoRoot,
-        selectedWorktrees,
-        void 0,
-        runtime
-      );
+      for (const [repoRoot, candidates] of candidatesByRepository) {
+        const journal = await recordUndoOperation(
+          "clean",
+          repoRoot,
+          candidates.map(({ worktree }) => worktree),
+          void 0,
+          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) {
-      emitError(
-        options,
-        `could not write undo journal; no worktrees were removed: ${toMessage2(error)}`
+      await discardUndoRecords(
+        journals.values(),
+        runtime.configStore.GLOBAL_CONFIG_DIRECTORY
       );
-      return 1;
-    }
-    if (!journal) {
       emitError(
         options,
-        "could not capture undo state; no worktrees were removed"
+        `could not write undo journal; no worktrees were removed: ${toMessage2(error)}`
       );
       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,
-        readWorktreeHealth2,
-        isBranchMergedInto2
+        { repoRoot, worktree, baseBranch: staleBaseRef },
+        cleanupDependencies
       )) {
         options.stderr(
           `Skipped ${worktree.path}: no longer a safe stale cleanup candidate
@@ -17956,7 +18148,7 @@ function createCleanCommand(dependencies = {}) {
         continue;
       }
       try {
-        await removeWorktree2(repository.repoRoot, worktree.path);
+        await removeWorktree2(repoRoot, worktree.path);
       } catch (error) {
         if (!isWorktreeForceRemovalError2(error)) {
           failures.push({
@@ -17982,7 +18174,7 @@ function createCleanCommand(dependencies = {}) {
           continue;
         }
         try {
-          await forceRemoveWorktree2(repository.repoRoot, worktree.path);
+          await forceRemoveWorktree2(repoRoot, worktree.path);
         } catch (forceError) {
           failures.push({
             branch: worktree.branch,
@@ -17992,10 +18184,10 @@ function createCleanCommand(dependencies = {}) {
           continue;
         }
       }
-      removedWorktrees.push(worktree);
+      removedCandidates.push(candidate);
       if (worktree.branch) {
         try {
-          await deleteBranch2(repository.repoRoot, worktree.branch);
+          await deleteBranch2(repoRoot, worktree.branch);
         } catch (error) {
           if (!isBranchUnmergedError2(error)) {
             failures.push({
@@ -18007,7 +18199,7 @@ function createCleanCommand(dependencies = {}) {
           }
           if (options.force || await confirmForceDeleteBranch(worktree.branch)) {
             try {
-              await forceDeleteBranch2(repository.repoRoot, worktree.branch);
+              await forceDeleteBranch2(repoRoot, worktree.branch);
             } catch (forceError) {
               options.stderr(
                 `Failed to delete branch ${worktree.branch}: ${toMessage2(forceError)}
@@ -18023,83 +18215,180 @@ function createCleanCommand(dependencies = {}) {
         }
       }
     }
-    await finalizeUndoOperation(
-      journal,
-      removedWorktrees,
-      void 0,
-      runtime.configStore.GLOBAL_CONFIG_DIRECTORY
+    for (const [repoRoot, journal] of journals) {
+      await finalizeUndoOperation(
+        journal,
+        removedCandidates.filter((candidate) => candidate.repoRoot === repoRoot).map(({ worktree }) => worktree),
+        void 0,
+        runtime.configStore.GLOBAL_CONFIG_DIRECTORY
+      );
+    }
+    const undoRecords = remainingUndoRecords(
+      journals.values(),
+      removedCandidates
     );
     await Promise.all(
-      removedWorktrees.map((worktree) => releaseWorktreeSlot2(worktree.path))
+      removedCandidates.map(
+        ({ worktree }) => releaseWorktreeSlot2(worktree.path)
+      )
     );
     if (options.json) {
-      const removed = removedWorktrees.map((worktree) => {
+      const removed = removedCandidates.map(({ worktree }) => {
         const info = selectedInfoByPath.get(worktree.path);
         return info === void 0 ? { branch: worktree.branch, path: worktree.path } : serializeWorktreeInfo2(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)}
 `);
     } 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}
-`);
+      emitUndoHints(undoRecords, repository.repoRoot, options.stderr);
+      options.stdout(
+        `${[...new Set(selectedCandidates.map(({ repoRoot }) => repoRoot))].join("\n")}
+`
+      );
     }
     return failures.length === 0 ? 0 : 1;
   };
 }
 var runCleanCommand = createCleanCommand();
-async function filterStaleCleanupCandidates(repoRoot, worktrees, baseBranch, readWorktreeHealth2, isBranchMergedInto2) {
-  if (baseBranch === null) {
-    return [];
+async function resolveCleanupCandidates(options, dependencies) {
+  const { sources, stale, stderr, signal } = options;
+  const grouped = /* @__PURE__ */ new Map();
+  for (const source of sources) {
+    if (source.repoRoot === void 0) continue;
+    const existing = grouped.get(source.repoRoot);
+    if (existing === void 0) {
+      grouped.set(source.repoRoot, {
+        repoName: source.repoName,
+        worktrees: [source.worktree]
+      });
+    } else {
+      existing.worktrees.push(source.worktree);
+    }
   }
-  const results = await Promise.all(
-    worktrees.map(
-      (worktree) => isStaleCleanupCandidate(
+  const results = await mapWithConcurrency(
+    [...grouped.entries()],
+    MAX_CLEAN_REPOSITORY_CONCURRENCY,
+    async ([repoRoot, group]) => {
+      throwIfAborted3(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,
-        worktree,
-        baseBranch,
-        readWorktreeHealth2,
-        isBranchMergedInto2
-      )
+        staleBaseRef,
+        worktree
+      }));
+    },
+    signal
+  );
+  return results.flat();
+}
+function resolveSelectedCandidates(candidates, selections) {
+  const selected = [];
+  const seenPaths = /* @__PURE__ */ new Set();
+  for (const selection of selections) {
+    const candidate = candidates.find(
+      (entry) => entry.worktree.path === selection || entry.worktree.branch === selection
+    );
+    if (candidate === void 0 || seenPaths.has(candidate.worktree.path)) {
+      continue;
+    }
+    selected.push(candidate);
+    seenPaths.add(candidate.worktree.path);
+  }
+  return selected;
+}
+function groupCandidatesByRepository(candidates) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const existing = grouped.get(candidate.repoRoot);
+    if (existing === void 0) 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, [], void 0, globalConfigDirectory)
     )
   );
+}
+async function filterStaleCleanupCandidates(options, dependencies) {
+  const { repoRoot, worktrees, baseBranch, signal } = options;
+  throwIfAborted3(signal);
+  if (baseBranch === null) {
+    return [];
+  }
+  const results = await mapWithConcurrency(
+    worktrees,
+    MAX_CLEAN_WORKTREE_CONCURRENCY,
+    (worktree) => isStaleCleanupCandidate({ repoRoot, worktree, baseBranch }, dependencies),
+    signal
+  );
+  throwIfAborted3(signal);
   return worktrees.filter((_3, index) => results[index]);
 }
-async function resolveStaleBaseRef(repoRoot, stderr, loadEffectiveConfig2, resolveRemoteDefaultBranch2, runGit2) {
-  const config = await loadEffectiveConfig2(repoRoot, void 0, stderr);
+async function resolveStaleBaseRef(options, dependencies) {
+  const { repoRoot, stderr } = options;
+  const config = await dependencies.loadEffectiveConfig(
+    repoRoot,
+    void 0,
+    stderr
+  );
   const remote = resolveConfiguredString(config.syncRemote) ?? "origin";
   const configuredDefaultBranch = resolveConfiguredString(
     config.syncDefaultBranch
   );
-  if (configuredDefaultBranch) {
-    return await resolveFetchedRemoteRef(
-      repoRoot,
-      remote,
-      configuredDefaultBranch,
-      runGit2
-    );
-  }
   try {
-    const remoteDefaultBranch = await resolveRemoteDefaultBranch2(
-      repoRoot,
-      remote
-    );
-    return remoteDefaultBranch === null ? null : await resolveFetchedRemoteRef(
+    const remoteBase = await dependencies.resolveRemoteBase(
       repoRoot,
       remote,
-      remoteDefaultBranch,
-      runGit2
+      configuredDefaultBranch ?? void 0
+    );
+    return remoteBase === null ? null : resolveFetchedRemoteRef(
+      { branch: remoteBase.branch, remote, repoRoot },
+      dependencies.runGit
     );
   } catch {
     return null;
   }
 }
-async function resolveFetchedRemoteRef(repoRoot, remote, branch, runGit2) {
+async function resolveFetchedRemoteRef(options, runGit2) {
+  const { repoRoot, remote, branch } = options;
   try {
     await runGit2(repoRoot, ["fetch", "--prune", remote]);
+    await runGit2(repoRoot, [
+      "rev-parse",
+      "--verify",
+      "--quiet",
+      `${remote}/${branch}`
+    ]);
     return `${remote}/${branch}`;
   } catch {
     return null;
@@ -18108,33 +18397,39 @@ async function resolveFetchedRemoteRef(repoRoot, remote, branch, runGit2) {
 function resolveConfiguredString(value) {
   return typeof value === "string" && value.length > 0 ? value : null;
 }
-async function isStaleCleanupCandidate(repoRoot, worktree, baseBranch, readWorktreeHealth2, isBranchMergedInto2) {
+async function isStaleCleanupCandidate(options, dependencies) {
+  const { repoRoot, worktree, baseBranch } = options;
   if (baseBranch === null) {
     return false;
   }
   if (worktree.branch === null) {
     return false;
   }
-  const health = await readWorktreeHealth2(worktree.path);
+  const health = await dependencies.readWorktreeHealth(worktree.path);
   if (health.status !== "clean" || !health.upstreamGone) {
     return false;
   }
-  return isBranchMergedInto2(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 = /* @__PURE__ */ 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, runGit2) {
+  const { repoRoot, worktreeBranch, baseBranch } = options;
+  try {
+    const output = await runGit2(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";
@@ -18146,6 +18441,37 @@ function reportCleanFailures(failures, stderr) {
 `);
   }
 }
+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}
+`);
+  for (const record of records) {
+    stderr(`  gji undo --id ${record.id} (${record.repoRoot})
+`);
+  }
+}
+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:
+`
+  );
+  for (const repository of repositories) {
+    stderr(`- ${repository.name} (${repository.path})
+`);
+  }
+}
+function throwIfAborted3(signal) {
+  if (signal?.aborted) throw new Error("Operation cancelled");
+}
 function formatCleanInfo(info, formatLastCommit3, formatUpstreamState3) {
   const branch = info.branch === null ? "detached" : `branch: ${info.branch}`;
   const status = `status: ${info.status}`;
@@ -18174,8 +18500,11 @@ function emitNoStaleCandidates(options) {
 function toMessage2(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(
@@ -19984,71 +20313,6 @@ function parsePrInput(input) {
   return urlMatch?.[1] ?? null;
 }
 
-// src/application/worktree/sources.ts
-var MAX_REPOSITORY_DISCOVERY_CONCURRENCY = 4;
-async function listRegisteredWorktreeSources(cwd, repositoryPort, onSkipped) {
-  const registry = await repositoryPort.loadRegistry();
-  const currentRoot = await repositoryPort.detectRepository(cwd).then((repository) => repository.currentRoot).catch(() => null);
-  const results = await mapWithConcurrency(
-    registry,
-    MAX_REPOSITORY_DISCOVERY_CONCURRENCY,
-    async (entry) => {
-      try {
-        const worktrees = await repositoryPort.listWorktrees(entry.path);
-        return { entry, worktrees };
-      } catch {
-        onSkipped?.(entry);
-        return null;
-      }
-    }
-  );
-  const allItems = [];
-  for (const result of results) {
-    if (result === null) continue;
-    const { entry, worktrees } = result;
-    for (const worktree of worktrees) {
-      allItems.push({
-        repoRoot: entry.path,
-        repoName: entry.name,
-        worktree: {
-          ...worktree,
-          isCurrent: currentRoot !== null && worktree.path === currentRoot
-        }
-      });
-    }
-  }
-  return allItems;
-}
-async function listDiscoverableWorktreeSources(cwd, repositoryPort, onSkipped) {
-  const currentRepository = await repositoryPort.detectRepository(cwd).catch(() => null);
-  const registeredSources = await listRegisteredWorktreeSources(
-    cwd,
-    repositoryPort,
-    onSkipped
-  );
-  if (currentRepository === null) return dedupeSources(registeredSources);
-  let currentSources = [];
-  try {
-    currentSources = (await repositoryPort.listWorktrees(cwd)).map(
-      (worktree) => ({
-        repoName: currentRepository.repoName,
-        repoRoot: currentRepository.repoRoot,
-        worktree
-      })
-    );
-  } catch {
-  }
-  return dedupeSources([...currentSources, ...registeredSources]);
-}
-function dedupeSources(sources) {
-  const seen = /* @__PURE__ */ new Set();
-  return sources.filter((source) => {
-    if (seen.has(source.worktree.path)) return false;
-    seen.add(source.worktree.path);
-    return true;
-  });
-}
-
 // src/application/worktree/go-resolution.ts
 async function resolveGoBranch(options) {
   const {
@@ -20115,14 +20379,12 @@ async function resolveGoBranch(options) {
       return finish({ kind: "existing", source: pullRequestMatches[0] }, false);
     }
   }
-  let skippedRegisteredRepos = 0;
-  const registeredSources = await listRegisteredWorktreeSources(
+  const registered = await listRegisteredWorktreeSources({
     cwd,
-    sourceDependencies,
-    () => {
-      skippedRegisteredRepos++;
-    }
-  );
+    repositoryPort: sourceDependencies
+  });
+  const registeredSources = registered.sources;
+  const skippedRegisteredRepos = registered.skipped.length;
   const crossRepoSources = registeredSources.filter(
     (source) => source.repoRoot !== repository?.repoRoot
   );
@@ -21705,17 +21967,16 @@ function createGoCommand(dependencies = {}) {
       let promptSources = currentSources;
       const loadAllSources = async () => {
         if (registeredSources === null) {
-          registeredSources = await listRegisteredWorktreeSources(
-            options.cwd,
-            {
+          const registered = await listRegisteredWorktreeSources({
+            cwd: options.cwd,
+            repositoryPort: {
               ...runtime.repositoryContext,
               ...runtime.repositoryRegistry,
               ...runtime.worktrees
-            },
-            () => {
-              skippedRegisteredRepos++;
             }
-          );
+          });
+          registeredSources = registered.sources;
+          skippedRegisteredRepos = registered.skipped.length;
         }
         return deduplicateSources([...currentSources, ...registeredSources]);
       };
@@ -21737,13 +21998,8 @@ function createGoCommand(dependencies = {}) {
             currentRepositoryScope = nextCurrentRepositoryScope;
             promptSources = nextSources;
             return {
-              entries: await buildWorktreePromptEntries(promptSources, {
-                metadata: currentRepositoryScope ? "full" : "fast",
-                catalog: withPullRequestQueries(
-                  runtime,
-                  dependencies.queryPullRequests
-                )
-              }),
+              sources: promptSources,
+              metadata: currentRepositoryScope ? "full" : "fast",
               label: currentRepositoryScope ? "current repository" : "all repositories",
               toggleLabel: currentRepositoryScope ? "all repositories" : "current repository"
             };
@@ -21757,7 +22013,11 @@ function createGoCommand(dependencies = {}) {
           dependencies.queryPullRequests
         )
       });
-      const selectedPath = await prompt(promptEntries, scope);
+      const selectedPath = await prompt(
+        promptEntries,
+        scope,
+        withPullRequestQueries(runtime, dependencies.queryPullRequests)
+      );
       if (!selectedPath) {
         options.stderr("Aborted\n");
         return 1;
@@ -22055,8 +22315,11 @@ async function defaultConfirmBranchCreation(branch) {
   });
   return !pD(choice) && choice;
 }
-async function promptForWorktree(worktrees, scope) {
-  return promptForSingleWorktree("Choose a worktree", worktrees, { scope });
+async function promptForWorktree(worktrees, scope, catalog) {
+  return promptForSingleWorktree("Choose a worktree", worktrees, {
+    catalog,
+    scope
+  });
 }
 
 // src/cli/commands/history-command.ts
@@ -22089,10 +22352,10 @@ async function buildHubData(cwd, dependencies = {}, runtime = defaultCliDependen
   };
   const queryRepositoryPullRequests = dependencies.queryRepositoryPullRequests ?? runtime.pullRequests.listOpenPullRequestsForRepository;
   const currentRepository = await detectRepository2(cwd).catch(() => null);
-  const sources = await listDiscoverableWorktreeSources(
+  const { sources } = await listDiscoverableWorktreeSources({
     cwd,
-    sourceDependencies
-  );
+    repositoryPort: sourceDependencies
+  });
   const groups = /* @__PURE__ */ new Map();
   for (const source of sources) {
     if (!source.repoRoot) continue;
@@ -24446,10 +24709,14 @@ async function resolveWarpTarget(options) {
     );
     return null;
   }
-  let skippedRegisteredRepos = 0;
-  const allItems = (await listRegisteredWorktreeSources(options.cwd, sourceDependencies, () => {
-    skippedRegisteredRepos++;
-  })).filter((item) => item.repoRoot !== options.excludeRepoRoot);
+  const registered = await listRegisteredWorktreeSources({
+    cwd: options.cwd,
+    repositoryPort: sourceDependencies
+  });
+  const skippedRegisteredRepos = registered.skipped.length;
+  const allItems = registered.sources.filter(
+    (item) => item.repoRoot !== options.excludeRepoRoot
+  );
   if (allItems.length === 0) {
     emitError5(
       "no accessible worktrees found in any registered repo.",