@solaqua/gji 0.13.0 → 0.15.0

package/dist/gji-bundle.mjs

@@ -5386,7 +5386,7 @@ var require_minimist = __commonJS({
 var require_rc = __commonJS({
   "node_modules/.pnpm/rc@1.2.8/node_modules/rc/index.js"(exports, module) {
     var cc = require_utils();
-    var join16 = __require("path").join;
+    var join17 = __require("path").join;
     var deepExtend = require_deep_extend();
     var etc = "/etc";
     var win = process.platform === "win32";
@@ -5411,15 +5411,15 @@ var require_rc = __commonJS({
       }
       if (!win)
         [
-          join16(etc, name, "config"),
-          join16(etc, name + "rc")
+          join17(etc, name, "config"),
+          join17(etc, name + "rc")
         ].forEach(addConfigFile);
       if (home)
         [
-          join16(home, ".config", name, "config"),
-          join16(home, ".config", name),
-          join16(home, "." + name, "config"),
-          join16(home, "." + name + "rc")
+          join17(home, ".config", name, "config"),
+          join17(home, ".config", name),
+          join17(home, "." + name, "config"),
+          join17(home, "." + name + "rc")
         ].forEach(addConfigFile);
       addConfigFile(cc.find("." + name + "rc"));
       if (env5.config) addConfigFile(env5.config);
@@ -6757,11 +6757,11 @@ var require_util = __commonJS({
           if (files.includes("node_modules") || files.includes("package.json") || files.includes("package.json5") || files.includes("package.yaml") || files.includes("pnpm-workspace.yaml")) {
             return name2;
           }
-          const dirname14 = path9.dirname(name2);
-          if (dirname14 === name2) {
+          const dirname15 = path9.dirname(name2);
+          if (dirname15 === name2) {
             return original;
           }
-          return find(dirname14, original);
+          return find(dirname15, original);
         } catch (error) {
           if (name2 === original) {
             if (error.code === "ENOENT") {
@@ -9519,7 +9519,7 @@ var retryifyAsync = (fn, options) => {
           throw error;
         const delay2 = Math.round(interval * Math.random());
         if (delay2 > 0) {
-          const delayPromise = new Promise((resolve12) => setTimeout(resolve12, delay2));
+          const delayPromise = new Promise((resolve13) => setTimeout(resolve13, delay2));
           return delayPromise.then(() => attempt.apply(void 0, args));
         } else {
           return attempt.apply(void 0, args);
@@ -9778,14 +9778,14 @@ var Temp = {
     }
   },
   truncate: (filePath) => {
-    const basename13 = path2.basename(filePath);
-    if (basename13.length <= LIMIT_BASENAME_LENGTH)
+    const basename14 = path2.basename(filePath);
+    if (basename14.length <= LIMIT_BASENAME_LENGTH)
       return filePath;
-    const truncable = /^(\.?)(.*?)((?:\.[^.]+)?(?:\.tmp-\d{10}[a-f0-9]{6})?)$/.exec(basename13);
+    const truncable = /^(\.?)(.*?)((?:\.[^.]+)?(?:\.tmp-\d{10}[a-f0-9]{6})?)$/.exec(basename14);
     if (!truncable)
       return filePath;
-    const truncationLength = basename13.length - LIMIT_BASENAME_LENGTH;
-    return `${filePath.slice(0, -basename13.length)}${truncable[1]}${truncable[2].slice(0, -truncationLength)}${truncable[3]}`;
+    const truncationLength = basename14.length - LIMIT_BASENAME_LENGTH;
+    return `${filePath.slice(0, -basename14.length)}${truncable[1]}${truncable[2].slice(0, -truncationLength)}${truncable[3]}`;
   }
 };
 node_default(Temp.purgeSyncAll);
@@ -11085,14 +11085,14 @@ var TimeoutError = class extends Error {
 
 // node_modules/.pnpm/ky@1.14.3/node_modules/ky/distribution/utils/timeout.js
 async function timeout(request, init, abortController, options) {
-  return new Promise((resolve12, reject) => {
+  return new Promise((resolve13, reject) => {
     const timeoutId = setTimeout(() => {
       if (abortController) {
         abortController.abort();
       }
       reject(new TimeoutError(request));
     }, options.timeout);
-    void options.fetch(request, init).then(resolve12).catch(reject).then(() => {
+    void options.fetch(request, init).then(resolve13).catch(reject).then(() => {
       clearTimeout(timeoutId);
     });
   });
@@ -11100,7 +11100,7 @@ async function timeout(request, init, abortController, options) {
 
 // node_modules/.pnpm/ky@1.14.3/node_modules/ky/distribution/utils/delay.js
 async function delay(ms, { signal }) {
-  return new Promise((resolve12, reject) => {
+  return new Promise((resolve13, reject) => {
     if (signal) {
       signal.throwIfAborted();
       signal.addEventListener("abort", abortHandler, { once: true });
@@ -11111,7 +11111,7 @@ async function delay(ms, { signal }) {
     }
     const timeoutId = setTimeout(() => {
       signal?.removeEventListener("abort", abortHandler);
-      resolve12();
+      resolve13();
     }, ms);
   });
 }
@@ -12810,7 +12810,7 @@ function updateNotifier(options) {
 // package.json
 var package_default = {
   name: "@solaqua/gji",
-  version: "0.13.0",
+  version: "0.15.0",
   description: "Git worktree CLI for fast context switching.",
   license: "MIT",
   author: "sjquant",
@@ -13093,7 +13093,7 @@ async function ensureDestinationDirectory(root, path9) {
 // src/infrastructure/process/command-runner.ts
 import { spawn as spawn2 } from "node:child_process";
 var runCommand = async (command, cwd, stderr, stdout3 = (chunk) => process.stdout.write(chunk), options) => {
-  await new Promise((resolve12, reject) => {
+  await new Promise((resolve13, reject) => {
     const shell = options?.shell ?? true;
     const [executable, args] = shell ? [command, []] : splitCommand(command);
     const child = spawn2(executable, args, {
@@ -13112,7 +13112,7 @@ var runCommand = async (command, cwd, stderr, stdout3 = (chunk) => process.stdou
       if (code !== 0) {
         reject(new Error(`exited with code ${code}`));
       } else {
-        resolve12();
+        resolve13();
       }
     });
     child.on("error", reject);
@@ -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) {
@@ -14028,9 +14019,9 @@ var EDITORS = [
 ];
 async function defaultSpawnEditor(cli, args) {
   const child = spawn3(cli, args, { detached: true, stdio: "ignore" });
-  await new Promise((resolve12, reject) => {
+  await new Promise((resolve13, reject) => {
     child.once("error", reject);
-    child.once("spawn", resolve12);
+    child.once("spawn", resolve13);
   });
   child.unref();
 }
@@ -14872,7 +14863,7 @@ async function runArgvHook(hookCmd, cwd, context, stderr, stdout3) {
     stderr("gji: hook argv command must include a non-empty command\n");
     return;
   }
-  await new Promise((resolve12) => {
+  await new Promise((resolve13) => {
     const child = spawn4(command, args, {
       cwd,
       shell: false,
@@ -14892,18 +14883,18 @@ async function runArgvHook(hookCmd, cwd, context, stderr, stdout3) {
 `
         );
       }
-      resolve12();
+      resolve13();
     });
     child.on("error", (err) => {
       stderr(`gji: hook failed to start: ${err.message}
 `);
-      resolve12();
+      resolve13();
     });
   });
 }
 async function runShellHook(hookCmd, cwd, context, stderr, stdout3) {
   const interpolated = interpolate(hookCmd, context);
-  await new Promise((resolve12) => {
+  await new Promise((resolve13) => {
     const child = spawn4(interpolated, {
       cwd,
       shell: true,
@@ -14921,12 +14912,12 @@ async function runShellHook(hookCmd, cwd, context, stderr, stdout3) {
         stderr(`gji: hook exited with code ${code}: ${interpolated}
 `);
       }
-      resolve12();
+      resolve13();
     });
     child.on("error", (err) => {
       stderr(`gji: hook failed to start: ${err.message}
 `);
-      resolve12();
+      resolve13();
     });
   });
 }
@@ -15091,8 +15082,8 @@ async function removeMissingRegistryEntries(paths, home = homedir4()) {
 async function withRegistryLock(registryPath, operation) {
   const previous = registryLocks.get(registryPath);
   let release;
-  const current = new Promise((resolve12) => {
-    release = resolve12;
+  const current = new Promise((resolve13) => {
+    release = resolve13;
   });
   registryLocks.set(registryPath, current);
   if (previous) await previous;
@@ -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;
@@ -15695,6 +15690,10 @@ function formatAge(timestamp) {
   return `${days}d ago`;
 }
 
+// src/cli/commands/clean.ts
+import { realpath as realpath5 } from "node:fs/promises";
+import { basename as basename8, dirname as dirname10, join as join12, resolve as resolve11 } from "node:path";
+
 // node_modules/.pnpm/@clack+core@0.5.0/node_modules/@clack/core/dist/index.mjs
 var import_sisteransi = __toESM(require_src(), 1);
 var import_picocolors = __toESM(require_picocolors(), 1);
@@ -16401,6 +16400,205 @@ 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/domain/worktree/path-filter.ts
+function createWorktreePathFilter(patterns) {
+  const matchers = patterns.map(createPathMatcher);
+  if (matchers.length === 0) return () => true;
+  return (worktreePath) => matchers.some((matches) => matches(worktreePath));
+}
+function findGlobIndex(pattern) {
+  for (let index = 0; index < pattern.length; index += 1) {
+    const character = pattern[index];
+    if (character === "\\") index += 1;
+    else if (character === "*" || character === "?") return index;
+  }
+  return -1;
+}
+function escapePathPattern(path9) {
+  return path9.replace(/[\\*?]/g, "\\$&");
+}
+function unescapePathPattern(pattern) {
+  return pattern.replace(/\\(.)/g, "$1");
+}
+function createPathMatcher(pattern) {
+  if (findGlobIndex(pattern) !== -1) {
+    const regExp = globToRegExp(pattern);
+    return (path9) => regExp.test(path9);
+  }
+  const literal = unescapePathPattern(pattern);
+  const prefix = literal === "/" ? "/" : `${literal}/`;
+  return (path9) => path9 === literal || path9.startsWith(prefix);
+}
+function globToRegExp(pattern) {
+  let source = "";
+  for (let index = 0; index < pattern.length; index += 1) {
+    let character = pattern[index];
+    if (character === "*") {
+      if (pattern[index + 1] === "*") {
+        index += 1;
+        if (pattern[index + 1] === "/") {
+          index += 1;
+          source += "(?:.*/)?";
+        } else {
+          source += ".*";
+        }
+      } else {
+        source += "[^/]*";
+      }
+    } else if (character === "?") {
+      source += "[^/]";
+    } else {
+      if (character === "\\" && index + 1 < pattern.length) {
+        index += 1;
+        character = pattern[index];
+      }
+      source += character.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+  }
+  return new RegExp(`^${source}$`);
+}
+
+// src/domain/worktree/policy.ts
+import { homedir as homedir5 } from "node:os";
+import { basename as basename7, dirname as dirname8, join as join10 } from "node:path";
+function resolveWorktreePath(repoRoot, branch, basePath) {
+  const segments = branch.split("/").filter(Boolean);
+  if (segments.length === 0) {
+    throw new Error("Branch name must not be empty.");
+  }
+  if (segments.some((segment) => segment === "." || segment === "..")) {
+    throw new Error(
+      `Branch name '${branch}' contains an invalid path segment.`
+    );
+  }
+  const base = basePath ? expandTildeInPath(basePath) : join10(dirname8(repoRoot), "worktrees", basename7(repoRoot));
+  return join10(base, ...segments);
+}
+function validateBranchName(name) {
+  if (name.length === 0) {
+    return "Branch name must not be empty.";
+  }
+  if (/[\x00-\x1f\x7f ~^:?*[\\\s]/.test(name)) {
+    return `Branch name '${name}' contains an invalid character.`;
+  }
+  if (name.startsWith("-")) {
+    return `Branch name '${name}' must not start with a dash.`;
+  }
+  if (name.startsWith("/") || name.endsWith("/") || name.includes("//")) {
+    return `Branch name '${name}' has invalid slash placement.`;
+  }
+  if (name.includes("..")) {
+    return `Branch name '${name}' must not contain '..'.`;
+  }
+  if (name.endsWith(".")) {
+    return `Branch name '${name}' must not end with '.'.`;
+  }
+  if (name.includes("@{")) {
+    return `Branch name '${name}' must not contain '@{'.`;
+  }
+  if (name === "@") {
+    return "Branch name cannot be '@'.";
+  }
+  for (const segment of name.split("/")) {
+    if (segment.startsWith(".")) {
+      return `Branch name '${name}' contains a path component starting with '.'.`;
+    }
+    if (segment.endsWith(".lock")) {
+      return `Branch name '${name}' contains a path component ending with '.lock'.`;
+    }
+  }
+  return null;
+}
+function expandTildeInPath(path9) {
+  if (path9 === "~") return homedir5();
+  if (path9.startsWith("~/")) return join10(homedir5(), path9.slice(2));
+  return path9;
+}
+
 // src/presentation/worktree/picker.ts
 import { env as env4, platform as platform2, stdin, stdout } from "node:process";
 
@@ -16501,6 +16699,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 +16710,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 +16801,7 @@ var SearchablePrompt = class {
   scope;
   scopeTogglePending = false;
   promptClosed = false;
+  cancellation = new AbortController();
   prompt;
   run() {
     return this.prompt.prompt();
@@ -16650,9 +16852,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 +16890,7 @@ var SearchablePrompt = class {
   }
   cancel(prompt) {
     this.promptClosed = true;
+    this.cancellation.abort();
     prompt.state = "cancel";
     renderPrompt(prompt);
     closePrompt(prompt);
@@ -16773,6 +16981,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(
@@ -17392,21 +17608,21 @@ import {
   unlink as unlink2,
   writeFile as writeFile7
 } from "node:fs/promises";
-import { homedir as homedir5 } from "node:os";
-import { dirname as dirname8, join as join10, resolve as resolve10 } from "node:path";
+import { homedir as homedir6 } from "node:os";
+import { dirname as dirname9, join as join11, resolve as resolve10 } from "node:path";
 var MAX_UNDO_RECORDS = 20;
 var UNDO_LOCK_STALE_AFTER_MS = 6e4;
 var UNDO_LOCK_RETRY_DELAY_MS = 5;
 var UNDO_LOCK_WAIT_TIMEOUT_MS = UNDO_LOCK_STALE_AFTER_MS + UNDO_LOCK_RETRY_DELAY_MS;
 var undoLogQueues = /* @__PURE__ */ new Map();
-function undoLogPath(home = homedir5(), globalConfigDirectory = defaultCliDependencies.configStore.GLOBAL_CONFIG_DIRECTORY) {
+function undoLogPath(home = homedir6(), globalConfigDirectory = defaultCliDependencies.configStore.GLOBAL_CONFIG_DIRECTORY) {
   const configured = process.env.GJI_CONFIG_DIR;
-  return join10(
-    configured ? resolve10(configured) : join10(home, globalConfigDirectory),
+  return join11(
+    configured ? resolve10(configured) : join11(home, globalConfigDirectory),
     "undo-log.json"
   );
 }
-async function loadUndoRecords(home = homedir5(), globalConfigDirectory = defaultCliDependencies.configStore.GLOBAL_CONFIG_DIRECTORY) {
+async function loadUndoRecords(home = homedir6(), globalConfigDirectory = defaultCliDependencies.configStore.GLOBAL_CONFIG_DIRECTORY) {
   try {
     const parsed = JSON.parse(
       await readFile7(undoLogPath(home, globalConfigDirectory), "utf8")
@@ -17416,7 +17632,7 @@ async function loadUndoRecords(home = homedir5(), globalConfigDirectory = defaul
     return [];
   }
 }
-async function recordUndoOperation(op, repoRoot, worktrees, home = homedir5(), runtime = defaultCliDependencies) {
+async function recordUndoOperation(op, repoRoot, worktrees, home = homedir6(), runtime = defaultCliDependencies) {
   const globalConfigDirectory = runtime.configStore.GLOBAL_CONFIG_DIRECTORY;
   const { isDirtyWorktree: isDirtyWorktree2, runGit: runGit2 } = runtime.git;
   const entries = [];
@@ -17466,7 +17682,7 @@ async function recordUndoOperation(op, repoRoot, worktrees, home = homedir5(), r
     globalConfigDirectory
   );
 }
-async function finalizeUndoOperation(record, removedWorktrees, home = homedir5(), globalConfigDirectory = defaultCliDependencies.configStore.GLOBAL_CONFIG_DIRECTORY) {
+async function finalizeUndoOperation(record, removedWorktrees, home = homedir6(), globalConfigDirectory = defaultCliDependencies.configStore.GLOBAL_CONFIG_DIRECTORY) {
   const removedPaths = new Set(
     removedWorktrees.map((worktree) => worktree.path)
   );
@@ -17486,7 +17702,7 @@ async function finalizeUndoOperation(record, removedWorktrees, home = homedir5()
     globalConfigDirectory
   );
 }
-async function restoreUndoRecord(record, home = homedir5(), runtime = defaultCliDependencies) {
+async function restoreUndoRecord(record, home = homedir6(), runtime = defaultCliDependencies) {
   const globalConfigDirectory = runtime.configStore.GLOBAL_CONFIG_DIRECTORY;
   const restored = [];
   const failed = [];
@@ -17531,7 +17747,7 @@ async function runUndoCommand(options) {
     options.stderr(
       "Warning: undo journal is invalid; starting with an empty journal\n"
     );
-  const records = await loadUndoRecords(homedir5(), globalConfigDirectory);
+  const records = await loadUndoRecords(homedir6(), globalConfigDirectory);
   if (options.list) {
     if (options.json) options.stdout(`${JSON.stringify(records, null, 2)}
 `);
@@ -17578,7 +17794,7 @@ async function runUndoCommand(options) {
   }
   if (!record)
     return emitUndoError(options, `undo record not found: ${options.id}`);
-  const result = await restoreUndoRecord(record, homedir5(), runtime);
+  const result = await restoreUndoRecord(record, homedir6(), runtime);
   if (options.json)
     options.stdout(
       `${JSON.stringify({ restored: result.restored.map((entry) => ({ branch: entry.branch, path: entry.path })), failed: result.failed.map((entry) => ({ branch: entry.branch, path: entry.path, error: entry.message })) }, null, 2)}
@@ -17606,7 +17822,7 @@ async function runUndoCommand(options) {
 async function hasMalformedUndoLog(globalConfigDirectory = defaultCliDependencies.configStore.GLOBAL_CONFIG_DIRECTORY) {
   try {
     const parsed = JSON.parse(
-      await readFile7(undoLogPath(homedir5(), globalConfigDirectory), "utf8")
+      await readFile7(undoLogPath(homedir6(), globalConfigDirectory), "utf8")
     );
     return !Array.isArray(parsed) || parsed.some((entry) => !isUndoRecord(entry));
   } catch (error) {
@@ -17698,7 +17914,7 @@ async function assertCommitExists(repoRoot, headSha, runGit2) {
 }
 async function enqueueUndoLogWrite(home, operation, globalConfigDirectory = defaultCliDependencies.configStore.GLOBAL_CONFIG_DIRECTORY) {
   const path9 = undoLogPath(home, globalConfigDirectory);
-  await mkdir6(dirname8(path9), { recursive: true });
+  await mkdir6(dirname9(path9), { recursive: true });
   const previous = undoLogQueues.get(path9) ?? Promise.resolve();
   const runLocked = async () => {
     const release = await acquireUndoLogLock(path9);
@@ -17739,7 +17955,7 @@ async function acquireUndoLogLock(path9) {
       const remainingMs = deadline - Date.now();
       if (remainingMs > 0)
         await new Promise(
-          (resolve12) => setTimeout(resolve12, Math.min(UNDO_LOCK_RETRY_DELAY_MS, remainingMs))
+          (resolve13) => setTimeout(resolve13, Math.min(UNDO_LOCK_RETRY_DELAY_MS, remainingMs))
         );
     }
   }
@@ -17747,7 +17963,7 @@ async function acquireUndoLogLock(path9) {
 }
 async function writeUndoRecords(home, records, globalConfigDirectory = defaultCliDependencies.configStore.GLOBAL_CONFIG_DIRECTORY) {
   const path9 = undoLogPath(home, globalConfigDirectory);
-  await mkdir6(dirname8(path9), { recursive: true });
+  await mkdir6(dirname9(path9), { recursive: true });
   const temporaryPath = `${path9}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
     await writeFile7(temporaryPath, `${JSON.stringify(records, null, 2)}
@@ -17790,6 +18006,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 +18025,7 @@ function createCleanCommand(dependencies = {}) {
     const {
       readWorktreeHealth: readWorktreeHealth2,
       isBranchMergedInto: isBranchMergedInto2,
-      resolveRemoteDefaultBranch: resolveRemoteDefaultBranch2,
+      resolveRemoteBase: resolveRemoteBase2,
       runGit: runGit2
     } = runtime.git;
     const { loadEffectiveConfig: loadEffectiveConfig2 } = runtime.config;
@@ -17830,30 +18055,115 @@ function createCleanCommand(dependencies = {}) {
       options.cwd,
       sourceDependencies
     );
-    const linkedCleanupCandidates = linkedWorktrees.filter(
-      (worktree) => worktree.path !== repository.currentRoot
+    const pathPatterns = await canonicalizePathPatterns(
+      options.cwd,
+      options.paths ?? []
     );
-    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) {
+    const matchesPathFilter = createWorktreePathFilter(pathPatterns);
+    const searchAllRepositories = pathPatterns.length > 0;
+    let allSourceCount = 0;
+    const emitNoCandidates = (sourceCount) => {
+      if (pathPatterns.length > 0 && sourceCount === 0) {
+        emitError(options, "No linked worktrees match --path");
+        return 1;
+      }
       if (options.stale) {
         emitNoStaleCandidates(options);
         return 0;
       }
       emitError(options, "No linked worktrees to clean");
       return 1;
+    };
+    const currentSources = linkedWorktrees.filter(
+      (worktree) => worktree.path !== repository.currentRoot && matchesPathFilter(worktree.path)
+    ).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
+    );
+    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 && matchesPathFilter(source.worktree.path)
+      );
+      allSourceCount = sources.length;
+      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 (searchAllRepositories || interactiveSelection && currentCandidates.length === 0) {
+      const loadedAllCandidates = await loadAllCandidates();
+      if (loadedAllCandidates.length === 0) {
+        return emitNoCandidates(allSourceCount);
+      }
+      currentScope = false;
+      activeCandidates = loadedAllCandidates;
+      scope.label = "all repositories";
+      scope.toggleLabel = "current repository";
+    } else if (currentCandidates.length === 0) {
+      return emitNoCandidates(currentSources.length);
     }
     if (!options.dryRun && !options.force && (options.json || isHeadless())) {
       const message = "--force is required";
@@ -17868,27 +18178,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 +18228,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 +18278,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 +18304,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 +18314,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 +18329,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 +18345,205 @@ 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 canonicalizePathPatterns(cwd, patterns) {
+  return Promise.all(
+    patterns.map(
+      (pattern) => canonicalizeLiteralPrefix(resolve11(cwd, expandTildeInPath(pattern)))
+    )
+  );
+}
+async function canonicalizeLiteralPrefix(pattern) {
+  const globIndex = findGlobIndex(pattern);
+  let prefix = globIndex === -1 ? pattern : dirname10(`${pattern.slice(0, globIndex)}x`);
+  let suffix = pattern.slice(prefix.length);
+  for (; ; ) {
+    try {
+      const canonicalPrefix = escapePathPattern(
+        await realpath5(unescapePathPattern(prefix))
+      );
+      return `${canonicalPrefix}${suffix}`.replace(/^\/\//, "/");
+    } catch {
+      const parent = dirname10(prefix);
+      if (parent === prefix) return pattern;
+      suffix = join12("/", basename8(prefix), suffix);
+      prefix = parent;
+    }
   }
-  const results = await Promise.all(
-    worktrees.map(
-      (worktree) => isStaleCleanupCandidate(
+}
+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 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 +18552,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 +18596,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 +18655,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(
@@ -18432,7 +18916,11 @@ _gji_completion() {
       COMPREPLY=( $(compgen -W "--compact --json --help" -- "$cur") )
       ;;
     clean)
-      COMPREPLY=( $(compgen -W "-f --force --stale --dry-run --json --help" -- "$cur") )
+      if [ "\${COMP_WORDS[COMP_CWORD-1]}" = "--path" ]; then
+        COMPREPLY=( $(compgen -d -- "$cur") )
+      else
+        COMPREPLY=( $(compgen -W "-f --force --stale --path --dry-run --json --help" -- "$cur") )
+      fi
       ;;
     remove|rm)
       COMPREPLY=( $(compgen -W "$(__gji_worktree_branches) -f --force --dry-run --json --help" -- "$cur") )
@@ -18675,6 +19163,7 @@ complete -c gji -n '__fish_seen_subcommand_from ls' -l json -d 'print active wor
 
 complete -c gji -n '__fish_seen_subcommand_from clean' -s f -l force -d 'bypass prompts, force-remove dirty worktrees, and force-delete unmerged branches'
 complete -c gji -n '__fish_seen_subcommand_from clean' -l stale -d 'only target clean worktrees whose upstream is gone and branch is merged into the default branch'
+complete -c gji -n '__fish_seen_subcommand_from clean' -l path -r -F -d 'only target worktrees under a directory or matching a path glob (repeatable)'
 complete -c gji -n '__fish_seen_subcommand_from clean' -l dry-run -d 'show what would be deleted without removing anything'
 complete -c gji -n '__fish_seen_subcommand_from clean' -l json -d 'emit JSON on success or error instead of human-readable output'
 
@@ -18835,7 +19324,7 @@ case "\${words[2]}" in
     _arguments '--compact[show only branch and path columns]' '--json[print active worktrees as JSON]'
     ;;
   clean)
-    _arguments '(-f --force)'{-f,--force}'[bypass prompts, force-remove dirty worktrees, and force-delete unmerged branches]' '--stale[only target clean worktrees whose upstream is gone and branch is merged into the default branch]' '--dry-run[show what would be deleted without removing anything]' '--json[emit JSON on success or error instead of human-readable output]'
+    _arguments '(-f --force)'{-f,--force}'[bypass prompts, force-remove dirty worktrees, and force-delete unmerged branches]' '--stale[only target clean worktrees whose upstream is gone and branch is merged into the default branch]' '*--path[only target worktrees under a directory or matching a path glob]:pattern:_files' '--dry-run[show what would be deleted without removing anything]' '--json[emit JSON on success or error instead of human-readable output]'
     ;;
   remove|rm)
     _arguments '(-f --force)'{-f,--force}'[bypass prompts, force-remove a dirty worktree, and force-delete an unmerged branch]' '--dry-run[show what would be deleted without removing anything]' '--json[emit JSON on success or error instead of human-readable output]' '2:branch:->worktrees'
@@ -18972,20 +19461,20 @@ function writeJson(stdout3, value) {
 import { execFile as execFile8 } from "node:child_process";
 import { constants as constants6 } from "node:fs";
 import { access as access6, readFile as readFile8 } from "node:fs/promises";
-import { homedir as homedir6 } from "node:os";
-import { basename as basename7, dirname as dirname9, join as join12 } from "node:path";
+import { homedir as homedir7 } from "node:os";
+import { basename as basename9, dirname as dirname11, join as join14 } from "node:path";
 import { promisify as promisify9 } from "node:util";
 
 // src/presentation/shell/setup.ts
 import { constants as constants5 } from "node:fs";
 import { access as access5 } from "node:fs/promises";
-import { delimiter, join as join11 } from "node:path";
+import { delimiter, join as join13 } from "node:path";
 var SHELL_INTEGRATION_START_MARKER = "# >>> gji init >>>";
 var SHELL_INTEGRATION_END_MARKER = "# <<< gji init <<<";
 var ONBOARDING_SHELL_INTEGRATION_START_MARKER = "# >>> gji shell integration >>>";
 var ONBOARDING_SHELL_INTEGRATION_END_MARKER = "# <<< gji shell integration <<<";
 async function executableExists(command) {
-  const candidates = command.includes("/") ? [command] : (process.env.PATH ?? "").split(delimiter).filter(Boolean).map((directory) => join11(directory, command));
+  const candidates = command.includes("/") ? [command] : (process.env.PATH ?? "").split(delimiter).filter(Boolean).map((directory) => join13(directory, command));
   for (const path9 of candidates) {
     try {
       await access5(path9, constants5.X_OK);
@@ -18998,17 +19487,17 @@ async function executableExists(command) {
 function resolveShellConfigPath(shell, home) {
   switch (shell) {
     case "bash":
-      return join11(home, ".bashrc");
+      return join13(home, ".bashrc");
     case "fish":
-      return join11(home, ".config", "fish", "config.fish");
+      return join13(home, ".config", "fish", "config.fish");
     case "zsh":
-      return join11(home, ".zshrc");
+      return join13(home, ".zshrc");
   }
 }
 function resolveCompletionPath(shell, home) {
   switch (shell) {
     case "bash":
-      return join11(
+      return join13(
         home,
         ".local",
         "share",
@@ -19017,9 +19506,9 @@ function resolveCompletionPath(shell, home) {
         "gji"
       );
     case "fish":
-      return join11(home, ".config", "fish", "completions", "gji.fish");
+      return join13(home, ".config", "fish", "completions", "gji.fish");
     case "zsh":
-      return join11(home, ".zsh", "completions", "_gji");
+      return join13(home, ".zsh", "completions", "_gji");
   }
 }
 function hasShellIntegration(config, shell) {
@@ -19051,7 +19540,7 @@ async function runDoctorCommand(options) {
     }
     return 1;
   }
-  const home = options.home ?? homedir6();
+  const home = options.home ?? homedir7();
   const shell = resolveSupportedShell(
     void 0,
     options.shell ?? process.env.SHELL
@@ -19116,7 +19605,7 @@ async function collectDoctorInspection(cwd, home, shell, runtime) {
     KNOWN_GLOBAL_CONFIG_KEYS2
   );
   const localConfig = repository ? await inspectConfig(
-    join12(repository.repoRoot, CONFIG_FILE_NAME2),
+    join14(repository.repoRoot, CONFIG_FILE_NAME2),
     "local",
     KNOWN_CONFIG_KEYS2
   ) : null;
@@ -19295,7 +19784,7 @@ function resolvePerRepoConfig(repos, repoRoot, home) {
 }
 function expandTilde2(path9, home) {
   if (path9 === "~") return home;
-  if (path9.startsWith("~/")) return join12(home, path9.slice(2));
+  if (path9.startsWith("~/")) return join14(home, path9.slice(2));
   return path9;
 }
 async function checkGitVersion() {
@@ -19422,7 +19911,7 @@ function resolveWorktreeBase(repoRoot, config, home) {
   if (typeof configuredPath === "string" && (configuredPath.startsWith("/") || configuredPath.startsWith("~"))) {
     return expandTilde2(configuredPath, home);
   }
-  return join12(dirname9(repoRoot), "worktrees", basename7(repoRoot));
+  return join14(dirname11(repoRoot), "worktrees", basename9(repoRoot));
 }
 async function findNearestExistingPath(path9) {
   let candidate = path9;
@@ -19431,7 +19920,7 @@ async function findNearestExistingPath(path9) {
       await access6(candidate, constants6.F_OK);
       return candidate;
     } catch {
-      const parent = dirname9(candidate);
+      const parent = dirname11(candidate);
       if (parent === candidate) return null;
       candidate = parent;
     }
@@ -19582,7 +20071,7 @@ function statusSymbol(status) {
 }
 
 // src/cli/commands/done.ts
-import { basename as basename8 } from "node:path";
+import { basename as basename10 } from "node:path";
 var DONE_OUTPUT_FILE_ENV = "GJI_DONE_OUTPUT_FILE";
 async function runDoneCommand(options) {
   const runtime = options.runtime ?? defaultCliDependencies;
@@ -19690,7 +20179,7 @@ async function runDoneCommand(options) {
     {
       branch: target.branch ?? void 0,
       path: target.path,
-      repo: basename8(repository.repoRoot)
+      repo: basename10(repository.repoRoot)
     },
     options.stderr
   );
@@ -19881,7 +20370,7 @@ function toMessage3(error) {
 }
 
 // src/cli/commands/go.ts
-import { basename as basename10 } from "node:path";
+import { basename as basename11 } from "node:path";
 
 // src/application/worktree/context-card.ts
 async function loadContextCardModel(worktreePath, dependencies) {
@@ -19984,71 +20473,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 +20539,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
   );
@@ -20279,64 +20701,7 @@ function formatLastCommit2(info) {
 
 // src/cli/commands/new.ts
 import { access as access8, mkdir as mkdir7 } from "node:fs/promises";
-import { dirname as dirname11, resolve as resolve11 } from "node:path";
-
-// src/domain/worktree/policy.ts
-import { homedir as homedir7 } from "node:os";
-import { basename as basename9, dirname as dirname10, join as join13 } from "node:path";
-function resolveWorktreePath(repoRoot, branch, basePath) {
-  const segments = branch.split("/").filter(Boolean);
-  if (segments.length === 0) {
-    throw new Error("Branch name must not be empty.");
-  }
-  if (segments.some((segment) => segment === "." || segment === "..")) {
-    throw new Error(
-      `Branch name '${branch}' contains an invalid path segment.`
-    );
-  }
-  const base = basePath ? expandTildeInPath(basePath) : join13(dirname10(repoRoot), "worktrees", basename9(repoRoot));
-  return join13(base, ...segments);
-}
-function validateBranchName(name) {
-  if (name.length === 0) {
-    return "Branch name must not be empty.";
-  }
-  if (/[\x00-\x1f\x7f ~^:?*[\\\s]/.test(name)) {
-    return `Branch name '${name}' contains an invalid character.`;
-  }
-  if (name.startsWith("-")) {
-    return `Branch name '${name}' must not start with a dash.`;
-  }
-  if (name.startsWith("/") || name.endsWith("/") || name.includes("//")) {
-    return `Branch name '${name}' has invalid slash placement.`;
-  }
-  if (name.includes("..")) {
-    return `Branch name '${name}' must not contain '..'.`;
-  }
-  if (name.endsWith(".")) {
-    return `Branch name '${name}' must not end with '.'.`;
-  }
-  if (name.includes("@{")) {
-    return `Branch name '${name}' must not contain '@{'.`;
-  }
-  if (name === "@") {
-    return "Branch name cannot be '@'.";
-  }
-  for (const segment of name.split("/")) {
-    if (segment.startsWith(".")) {
-      return `Branch name '${name}' contains a path component starting with '.'.`;
-    }
-    if (segment.endsWith(".lock")) {
-      return `Branch name '${name}' contains a path component ending with '.lock'.`;
-    }
-  }
-  return null;
-}
-function expandTildeInPath(path9) {
-  if (path9 === "~") return homedir7();
-  if (path9.startsWith("~/")) return join13(homedir7(), path9.slice(2));
-  return path9;
-}
+import { dirname as dirname12, resolve as resolve12 } from "node:path";
 
 // src/presentation/bootstrap/output.ts
 function createBootstrapReporter(write, json) {
@@ -20646,7 +21011,7 @@ ${formatDependencyBootstrapPreview(dryRunDependencyBootstrap)}`
       }
       return 0;
     }
-    await mkdir7(dirname11(worktreePath), { recursive: true });
+    await mkdir7(dirname12(worktreePath), { recursive: true });
     const startPoint = options.fromCurrent && !options.detached ? await resolveCurrentWorktreeHead(options.cwd, runtime.git.runGit) : void 0;
     const takeStartPoint = options.take ? await resolveCurrentWorktreeHead(options.cwd, runtime.git.runGit) : void 0;
     const changedTakeFiles = options.take ? await listTakeFiles(options.cwd, runtime.git.runGitRaw) : [];
@@ -21238,7 +21603,7 @@ async function detectInProgressGitState(cwd, runGit2) {
   for (const [marker, name] of markers) {
     try {
       const gitPath = await runGit2(cwd, ["rev-parse", "--git-path", marker]);
-      await access8(resolve11(cwd, gitPath));
+      await access8(resolve12(cwd, gitPath));
       return name;
     } catch {
     }
@@ -21390,7 +21755,7 @@ function emitNewError(options, message, details) {
 
 // src/cli/commands/pr.ts
 import { mkdir as mkdir8 } from "node:fs/promises";
-import { dirname as dirname12 } from "node:path";
+import { dirname as dirname13 } from "node:path";
 var PR_OUTPUT_FILE_ENV = "GJI_PR_OUTPUT_FILE";
 function createPrCommand(dependencies = {}) {
   const prompt = dependencies.promptForPathConflict ?? promptForPathConflict;
@@ -21529,7 +21894,7 @@ ${formatDependencyBootstrapPreview(dryRunDependencyBootstrap)}`
       }
       return 1;
     }
-    await mkdir8(dirname12(worktreePath), { recursive: true });
+    await mkdir8(dirname13(worktreePath), { recursive: true });
     const branchAlreadyExists = await localBranchExists2(
       repository.repoRoot,
       branchName,
@@ -21705,17 +22070,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 +22101,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 +22116,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;
@@ -21940,7 +22303,7 @@ async function navigateToExistingWorktree(options, path9, worktree, runtime) {
     {
       branch: worktree?.branch ?? void 0,
       path: path9,
-      repo: basename10(repository.repoRoot),
+      repo: basename11(repository.repoRoot),
       slot: await runtime.slots.getWorktreeSlot(path9)
     },
     options.stderr
@@ -22055,8 +22418,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
@@ -22077,7 +22443,7 @@ async function runHistoryCommand(options) {
 }
 
 // src/cli/commands/hub.ts
-import { basename as basename11 } from "node:path";
+import { basename as basename12 } from "node:path";
 import { stdin as stdin2, stdout as stdout2 } from "node:process";
 var MAX_HUB_REPOSITORY_CONCURRENCY = 4;
 async function buildHubData(cwd, dependencies = {}, runtime = defaultCliDependencies) {
@@ -22089,10 +22455,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;
@@ -22102,7 +22468,7 @@ async function buildHubData(cwd, dependencies = {}, runtime = defaultCliDependen
       existing.sources.push(source);
     } else {
       groups.set(repoRoot, {
-        name: source.repoName || basename11(repoRoot),
+        name: source.repoName || basename12(repoRoot),
         sources: [source]
       });
     }
@@ -22353,7 +22719,7 @@ function formatHumanText(value, maxLength) {
 import { constants as constants8 } from "node:fs";
 import { access as access9, mkdir as mkdir9, readFile as readFile9, writeFile as writeFile8 } from "node:fs/promises";
 import { homedir as homedir8 } from "node:os";
-import { dirname as dirname13 } from "node:path";
+import { dirname as dirname14 } from "node:path";
 var ZSH_COMPLETION_PATH_LINE = "fpath=(~/.zsh/completions $fpath)";
 var SHELL_WRAPPED_COMMANDS = [
   {
@@ -22478,7 +22844,7 @@ async function runDefaultOnboarding(context, runtime) {
   const installCompletion = await promptForCompletion(shell, completionPath);
   if (installCompletion === null) return abortDefaultOnboarding();
   if (installCompletion) {
-    await mkdir9(dirname13(completionPath), { recursive: true });
+    await mkdir9(dirname14(completionPath), { recursive: true });
     await writeFile8(completionPath, renderShellCompletion(shell), "utf8");
   }
   if (shell === "zsh" && (completionAlreadyInstalled || installCompletion)) {
@@ -22584,7 +22950,7 @@ async function applyOnboardingResult(result, home, runtime) {
     runtime
   );
   if (result.installCompletion) {
-    await mkdir9(dirname13(completionPath), { recursive: true });
+    await mkdir9(dirname14(completionPath), { recursive: true });
     await writeFile8(
       completionPath,
       renderShellCompletion(result.shell),
@@ -22604,7 +22970,7 @@ async function applyOnboardingResult(result, home, runtime) {
 }
 async function installOnboardingShellIntegration(shell, home) {
   const rcPath = resolveShellConfigPath(shell, home);
-  await mkdir9(dirname13(rcPath), { recursive: true });
+  await mkdir9(dirname14(rcPath), { recursive: true });
   const current = await readExistingConfig(rcPath);
   if (shell === "fish") {
     await writeFile8(
@@ -22692,7 +23058,7 @@ async function runLegacyInitCommand(options, runtime) {
     return 0;
   }
   const rcPath = resolveShellConfigPath(shell, home);
-  await mkdir9(dirname13(rcPath), { recursive: true });
+  await mkdir9(dirname14(rcPath), { recursive: true });
   const current = await readExistingConfig(rcPath);
   const next = upsertShellIntegration(current, script);
   await writeFile8(rcPath, next, "utf8");
@@ -23050,7 +23416,7 @@ function sortWorktrees(worktrees) {
 // src/cli/commands/open.ts
 import { execFile as execFile9 } from "node:child_process";
 import { access as access10, writeFile as writeFile9 } from "node:fs/promises";
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 import { promisify as promisify10 } from "node:util";
 var execFileAsync9 = promisify10(execFile9);
 function createOpenCommand(dependencies = {}) {
@@ -23229,7 +23595,7 @@ async function defaultPromptForEditor(editors) {
   return choice;
 }
 async function ensureWorkspaceFile(worktreePath, repoName) {
-  const workspacePath = join14(worktreePath, `${repoName}.code-workspace`);
+  const workspacePath = join15(worktreePath, `${repoName}.code-workspace`);
   try {
     await access10(workspacePath);
     return workspacePath;
@@ -23616,7 +23982,7 @@ function formatError(error) {
 }
 
 // src/cli/commands/remove.ts
-import { basename as basename12 } from "node:path";
+import { basename as basename13 } from "node:path";
 var REMOVE_OUTPUT_FILE_ENV = "GJI_REMOVE_OUTPUT_FILE";
 function createRemoveCommand(dependencies = {}) {
   const promptForWorktree2 = dependencies.promptForWorktree ?? defaultPromptForWorktree3;
@@ -23745,7 +24111,7 @@ function createRemoveCommand(dependencies = {}) {
       {
         branch: worktree.branch ?? void 0,
         path: worktree.path,
-        repo: basename12(repository.repoRoot)
+        repo: basename13(repository.repoRoot)
       },
       options.stderr
     );
@@ -24184,7 +24550,7 @@ function resolveConfiguredString2(value) {
 
 // src/cli/commands/sync-files-command.ts
 import { homedir as homedir9 } from "node:os";
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 async function runSyncFilesCommand(options) {
   const runtime = options.runtime ?? defaultCliDependencies;
   const { validateSyncFilePattern: validateSyncFilePattern2 } = runtime.filesystem;
@@ -24338,7 +24704,7 @@ function writeError(options, message) {
 }
 function expandTilde3(value, home) {
   if (value === "~") return home;
-  if (value.startsWith("~/")) return join15(home, value.slice(2));
+  if (value.startsWith("~/")) return join16(home, value.slice(2));
   return value;
 }
 
@@ -24446,10 +24812,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.",
@@ -24702,6 +25072,10 @@ function registerCommands(program2) {
   ).option(
     "--stale",
     "only target clean worktrees whose upstream is gone and branch is merged into the default branch"
+  ).option(
+    "--path <pattern>",
+    "only target worktrees under a directory or matching a path glob (repeatable)",
+    collectOption
   ).option("--dry-run", "show what would be deleted without removing anything").option(
     "--json",
     "emit JSON on success or error instead of human-readable output"
@@ -25069,6 +25443,7 @@ function attachCommandActions(program2, options) {
         dryRun: commandOptions2.dryRun,
         force: commandOptions2.force,
         json: commandOptions2.json,
+        paths: commandOptions2.path,
         stale: commandOptions2.stale,
         runtime: options.dependencies,
         stderr: options.stderr,
@@ -25196,6 +25571,9 @@ function requireCommand(parent, name) {
   }
   return command;
 }
+function collectOption(value, previous = []) {
+  return [...previous, value];
+}
 function notImplemented(commandName) {
   return () => {
     throw new Error(`'${commandName}' is not implemented yet.`);