@solaqua/gji 0.7.2 → 0.8.1

package/dist/gji-bundle.mjs

@@ -3465,7 +3465,7 @@ var require_polyfills = __commonJS({
     var constants2 = __require("constants");
     var origCwd = process.cwd;
     var cwd = null;
-    var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
+    var platform2 = process.env.GRACEFUL_FS_PLATFORM || process.platform;
     process.cwd = function() {
       if (!cwd)
         cwd = origCwd.call(process);
@@ -3524,7 +3524,7 @@ var require_polyfills = __commonJS({
         fs5.lchownSync = function() {
         };
       }
-      if (platform === "win32") {
+      if (platform2 === "win32") {
         fs5.rename = typeof fs5.rename !== "function" ? fs5.rename : (function(fs$rename) {
           function rename(from, to, cb) {
             var start = Date.now();
@@ -5036,11 +5036,11 @@ var require_utils = __commonJS({
       var content = file.apply(null, arguments);
       return content ? parse(content) : null;
     };
-    var env4 = exports.env = function(prefix, env5) {
-      env5 = env5 || process.env;
+    var env5 = exports.env = function(prefix, env6) {
+      env6 = env6 || process.env;
       var obj = {};
       var l2 = prefix.length;
-      for (var k3 in env5) {
+      for (var k3 in env6) {
         if (k3.toLowerCase().indexOf(prefix.toLowerCase()) === 0) {
           var keypath = k3.substring(l2).split("__");
           var _emptyStringIndex;
@@ -5052,7 +5052,7 @@ var require_utils = __commonJS({
             if (!_subkey || typeof cursor !== "object")
               return;
             if (i === keypath.length - 1)
-              cursor[_subkey] = env5[k3];
+              cursor[_subkey] = env6[k3];
             if (cursor[_subkey] === void 0)
               cursor[_subkey] = {};
             cursor = cursor[_subkey];
@@ -5398,7 +5398,7 @@ var require_rc = __commonJS({
         argv = require_minimist()(process.argv.slice(2));
       defaults = ("string" === typeof defaults ? cc.json(defaults) : defaults) || {};
       parse = parse || cc.parse;
-      var env4 = cc.env(name + "_");
+      var env5 = cc.env(name + "_");
       var configs = [defaults];
       var configFiles = [];
       function addConfigFile(file) {
@@ -5422,10 +5422,10 @@ var require_rc = __commonJS({
           join10(home, "." + name + "rc")
         ].forEach(addConfigFile);
       addConfigFile(cc.find("." + name + "rc"));
-      if (env4.config) addConfigFile(env4.config);
+      if (env5.config) addConfigFile(env5.config);
       if (argv.config) addConfigFile(argv.config);
       return deepExtend.apply(null, configs.concat([
-        env4,
+        env5,
         argv,
         configFiles.length ? { configs: configFiles, config: configFiles[configFiles.length - 1] } : void 0
       ]));
@@ -5439,7 +5439,7 @@ var require_polyfills2 = __commonJS({
     var constants2 = __require("constants");
     var origCwd = process.cwd;
     var cwd = null;
-    var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
+    var platform2 = process.env.GRACEFUL_FS_PLATFORM || process.platform;
     process.cwd = function() {
       if (!cwd)
         cwd = origCwd.call(process);
@@ -5498,7 +5498,7 @@ var require_polyfills2 = __commonJS({
         fs5.lchownSync = function() {
         };
       }
-      if (platform === "win32") {
+      if (platform2 === "win32") {
         fs5.rename = typeof fs5.rename !== "function" ? fs5.rename : (function(fs$rename) {
           function rename(from, to, cb) {
             var start = Date.now();
@@ -6423,13 +6423,13 @@ var require_config_chain = __commonJS({
       }
       return parse(content, file, "json");
     };
-    var env4 = exports.env = function(prefix, env5) {
-      env5 = env5 || process.env;
+    var env5 = exports.env = function(prefix, env6) {
+      env6 = env6 || process.env;
       var obj = {};
       var l2 = prefix.length;
-      for (var k3 in env5) {
+      for (var k3 in env6) {
         if (k3.indexOf(prefix) === 0)
-          obj[k3.substring(l2)] = env5[k3];
+          obj[k3.substring(l2)] = env6[k3];
       }
       return obj;
     };
@@ -6535,10 +6535,10 @@ var require_config_chain = __commonJS({
       }.bind(this));
       return this;
     };
-    ConfigChain.prototype.addEnv = function(prefix, env5, name) {
+    ConfigChain.prototype.addEnv = function(prefix, env6, name) {
       name = name || "env";
-      var data = exports.env(prefix, env5);
-      this.sources[name] = { data, source: env5, prefix };
+      var data = exports.env(prefix, env6);
+      this.sources[name] = { data, source: env6, prefix };
       return this.add(data, name);
     };
     ConfigChain.prototype.addUrl = function(req, type, name) {
@@ -6630,28 +6630,28 @@ var require_env_replace = __commonJS({
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.envReplace = void 0;
     var ENV_EXPR = /(?<!\\)(\\*)\$\{([^${}]+)\}/g;
-    function envReplace(settingValue, env4) {
-      return settingValue.replace(ENV_EXPR, replaceEnvMatch.bind(null, env4));
+    function envReplace(settingValue, env5) {
+      return settingValue.replace(ENV_EXPR, replaceEnvMatch.bind(null, env5));
     }
     exports.envReplace = envReplace;
-    function replaceEnvMatch(env4, orig, escape, name) {
+    function replaceEnvMatch(env5, orig, escape, name) {
       if (escape.length % 2) {
         return orig.slice((escape.length + 1) / 2);
       }
-      const envValue = getEnvValue(env4, name);
+      const envValue = getEnvValue(env5, name);
       if (envValue === void 0) {
         throw new Error(`Failed to replace env in config: ${orig}`);
       }
       return `${escape.slice(escape.length / 2)}${envValue}`;
     }
     var ENV_VALUE = /([^:-]+)(:?)-(.+)/;
-    function getEnvValue(env4, name) {
+    function getEnvValue(env5, name) {
       const matched = name.match(ENV_VALUE);
       if (!matched)
-        return env4[name];
+        return env5[name];
       const [, variableName, colon, fallback] = matched;
-      if (Object.prototype.hasOwnProperty.call(env4, variableName)) {
-        return !env4[variableName] && colon ? fallback : env4[variableName];
+      if (Object.prototype.hasOwnProperty.call(env5, variableName)) {
+        return !env5[variableName] && colon ? fallback : env5[variableName];
       }
       return fallback;
     }
@@ -6971,15 +6971,15 @@ var require_conf = __commonJS({
         }
       }
       // https://github.com/npm/cli/blob/latest/lib/config/core.js#L341-L357
-      addEnv(env4) {
-        env4 = env4 || process.env;
+      addEnv(env5) {
+        env5 = env5 || process.env;
         const conf = {};
-        Object.keys(env4).filter((x2) => /^npm_config_/i.test(x2)).forEach((x2) => {
-          if (!env4[x2]) {
+        Object.keys(env5).filter((x2) => /^npm_config_/i.test(x2)).forEach((x2) => {
+          if (!env5[x2]) {
             return;
           }
           const key = envKeyToSetting(x2.substr(11));
-          const rawVal = env4[x2];
+          const rawVal = env5[x2];
           conf[key] = deserializeEnvVal(key, rawVal);
         });
         return super.addEnv("", conf, "env");
@@ -9354,8 +9354,8 @@ var require_picocolors = __commonJS({
   "node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js"(exports, module) {
     var p2 = process || {};
     var argv = p2.argv || [];
-    var env4 = p2.env || {};
-    var isColorSupported = !(!!env4.NO_COLOR || argv.includes("--no-color")) && (!!env4.FORCE_COLOR || argv.includes("--color") || p2.platform === "win32" || (p2.stdout || {}).isTTY && env4.TERM !== "dumb" || !!env4.CI);
+    var env5 = p2.env || {};
+    var isColorSupported = !(!!env5.NO_COLOR || argv.includes("--no-color")) && (!!env5.FORCE_COLOR || argv.includes("--color") || p2.platform === "win32" || (p2.stdout || {}).isTTY && env5.TERM !== "dumb" || !!env5.CI);
     var formatter = (open, close, replace = open) => (input) => {
       let string = "" + input, index = string.indexOf(close, open.length);
       return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
@@ -10178,7 +10178,7 @@ var Configstore = class {
 var ANSI_BACKGROUND_OFFSET = 10;
 var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
 var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
-var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+var wrapAnsi16m = (offset = 0) => (red2, green2, blue) => `\x1B[${38 + offset};2;${red2};${green2};${blue}m`;
 var styles = {
   modifier: {
     reset: [0, 0],
@@ -10273,17 +10273,17 @@ function assembleStyles() {
   styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
   Object.defineProperties(styles, {
     rgbToAnsi256: {
-      value(red, green, blue) {
-        if (red === green && green === blue) {
-          if (red < 8) {
+      value(red2, green2, blue) {
+        if (red2 === green2 && green2 === blue) {
+          if (red2 < 8) {
             return 16;
           }
-          if (red > 248) {
+          if (red2 > 248) {
             return 231;
           }
-          return Math.round((red - 8) / 247 * 24) + 232;
+          return Math.round((red2 - 8) / 247 * 24) + 232;
         }
-        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+        return 16 + 36 * Math.round(red2 / 255 * 5) + 6 * Math.round(green2 / 255 * 5) + Math.round(blue / 255 * 5);
       },
       enumerable: false
     },
@@ -10320,25 +10320,25 @@ function assembleStyles() {
         if (code < 16) {
           return 90 + (code - 8);
         }
-        let red;
-        let green;
+        let red2;
+        let green2;
         let blue;
         if (code >= 232) {
-          red = ((code - 232) * 10 + 8) / 255;
-          green = red;
-          blue = red;
+          red2 = ((code - 232) * 10 + 8) / 255;
+          green2 = red2;
+          blue = red2;
         } else {
           code -= 16;
           const remainder = code % 36;
-          red = Math.floor(code / 36) / 5;
-          green = Math.floor(remainder / 6) / 5;
+          red2 = Math.floor(code / 36) / 5;
+          green2 = Math.floor(remainder / 6) / 5;
           blue = remainder % 6 / 5;
         }
-        const value = Math.max(red, green, blue) * 2;
+        const value = Math.max(red2, green2, blue) * 2;
         if (value === 0) {
           return 30;
         }
-        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green2) << 1 | Math.round(red2));
         if (value === 2) {
           result += 60;
         }
@@ -10347,7 +10347,7 @@ function assembleStyles() {
       enumerable: false
     },
     rgbToAnsi: {
-      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+      value: (red2, green2, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red2, green2, blue)),
       enumerable: false
     },
     hexToAnsi: {
@@ -11976,7 +11976,7 @@ var import_ansi_align = __toESM(require_ansi_align(), 1);
 var ANSI_BACKGROUND_OFFSET2 = 10;
 var wrapAnsi162 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
 var wrapAnsi2562 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
-var wrapAnsi16m2 = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+var wrapAnsi16m2 = (offset = 0) => (red2, green2, blue) => `\x1B[${38 + offset};2;${red2};${green2};${blue}m`;
 var styles3 = {
   modifier: {
     reset: [0, 0],
@@ -12071,17 +12071,17 @@ function assembleStyles2() {
   styles3.bgColor.ansi16m = wrapAnsi16m2(ANSI_BACKGROUND_OFFSET2);
   Object.defineProperties(styles3, {
     rgbToAnsi256: {
-      value(red, green, blue) {
-        if (red === green && green === blue) {
-          if (red < 8) {
+      value(red2, green2, blue) {
+        if (red2 === green2 && green2 === blue) {
+          if (red2 < 8) {
             return 16;
           }
-          if (red > 248) {
+          if (red2 > 248) {
             return 231;
           }
-          return Math.round((red - 8) / 247 * 24) + 232;
+          return Math.round((red2 - 8) / 247 * 24) + 232;
         }
-        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+        return 16 + 36 * Math.round(red2 / 255 * 5) + 6 * Math.round(green2 / 255 * 5) + Math.round(blue / 255 * 5);
       },
       enumerable: false
     },
@@ -12118,25 +12118,25 @@ function assembleStyles2() {
         if (code < 16) {
           return 90 + (code - 8);
         }
-        let red;
-        let green;
+        let red2;
+        let green2;
         let blue;
         if (code >= 232) {
-          red = ((code - 232) * 10 + 8) / 255;
-          green = red;
-          blue = red;
+          red2 = ((code - 232) * 10 + 8) / 255;
+          green2 = red2;
+          blue = red2;
         } else {
           code -= 16;
           const remainder = code % 36;
-          red = Math.floor(code / 36) / 5;
-          green = Math.floor(remainder / 6) / 5;
+          red2 = Math.floor(code / 36) / 5;
+          green2 = Math.floor(remainder / 6) / 5;
           blue = remainder % 6 / 5;
         }
-        const value = Math.max(red, green, blue) * 2;
+        const value = Math.max(red2, green2, blue) * 2;
         if (value === 0) {
           return 30;
         }
-        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green2) << 1 | Math.round(red2));
         if (value === 2) {
           result += 60;
         }
@@ -12145,7 +12145,7 @@ function assembleStyles2() {
       enumerable: false
     },
     rgbToAnsi: {
-      value: (red, green, blue) => styles3.ansi256ToAnsi(styles3.rgbToAnsi256(red, green, blue)),
+      value: (red2, green2, blue) => styles3.ansi256ToAnsi(styles3.rgbToAnsi256(red2, green2, blue)),
       enumerable: false
     },
     hexToAnsi: {
@@ -12319,15 +12319,15 @@ var NEWLINE = "\n";
 var PAD = " ";
 var NONE = "none";
 var terminalColumns = () => {
-  const { env: env4, stdout, stderr } = process9;
-  if (stdout?.columns) {
-    return stdout.columns;
+  const { env: env5, stdout: stdout2, stderr } = process9;
+  if (stdout2?.columns) {
+    return stdout2.columns;
   }
   if (stderr?.columns) {
     return stderr.columns;
   }
-  if (env4.COLUMNS) {
-    return Number.parseInt(env4.COLUMNS, 10);
+  if (env5.COLUMNS) {
+    return Number.parseInt(env5.COLUMNS, 10);
   }
   return 80;
 };
@@ -12554,10 +12554,10 @@ var determineDimensions = (text, options) => {
   }
   return options;
 };
-var isHex = (color) => color.match(/^#(?:[0-f]{3}){1,2}$/i);
-var isColorValid = (color) => typeof color === "string" && (source_default[color] ?? isHex(color));
-var getColorFunction = (color) => isHex(color) ? source_default.hex(color) : source_default[color];
-var getBGColorFunction = (color) => isHex(color) ? source_default.bgHex(color) : source_default[camelCase(["bg", color])];
+var isHex = (color2) => color2.match(/^#(?:[0-f]{3}){1,2}$/i);
+var isColorValid = (color2) => typeof color2 === "string" && (source_default[color2] ?? isHex(color2));
+var getColorFunction = (color2) => isHex(color2) ? source_default.hex(color2) : source_default[color2];
+var getBGColorFunction = (color2) => isHex(color2) ? source_default.bgHex(color2) : source_default[camelCase(["bg", color2])];
 function boxen(text, options) {
   options = {
     padding: 0,
@@ -13209,20 +13209,20 @@ import { promisify as promisify2 } from "node:util";
 var execFileAsync = promisify2(execFile);
 async function runGit(cwd, args) {
   try {
-    const { stdout } = await execFileAsync("git", args, { cwd });
-    return stdout.trim();
+    const { stdout: stdout2 } = await execFileAsync("git", args, { cwd });
+    return stdout2.trim();
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`Git command failed in '${cwd}': ${message}`);
   }
 }
 async function readWorktreeHealth(cwd) {
-  const { stdout } = await execFileAsync(
+  const { stdout: stdout2 } = await execFileAsync(
     "git",
     ["status", "--porcelain=v2", "--branch"],
     { cwd }
   );
-  return parseWorktreeHealth(stdout);
+  return parseWorktreeHealth(stdout2);
 }
 async function isDirtyWorktree(cwd) {
   const health = await readWorktreeHealth(cwd);
@@ -13242,12 +13242,12 @@ async function isBranchMergedInto(cwd, branch, base = "HEAD") {
   }
 }
 async function resolveRemoteDefaultBranch(cwd, remote) {
-  const { stdout } = await execFileAsync(
+  const { stdout: stdout2 } = await execFileAsync(
     "git",
     ["ls-remote", "--symref", remote, "HEAD"],
     { cwd }
   );
-  const refLine = stdout.split("\n").find((line) => line.startsWith("ref: refs/heads/"));
+  const refLine = stdout2.split("\n").find((line) => line.startsWith("ref: refs/heads/"));
   if (!refLine) {
     return null;
   }
@@ -13256,12 +13256,12 @@ async function resolveRemoteDefaultBranch(cwd, remote) {
 }
 async function readBranchLastCommitTimestamp(cwd, branch) {
   try {
-    const { stdout } = await execFileAsync(
+    const { stdout: stdout2 } = await execFileAsync(
       "git",
       ["log", "-1", "--format=%ct", branch],
       { cwd }
     );
-    const timestamp = Number(stdout.trim());
+    const timestamp = Number(stdout2.trim());
     return Number.isFinite(timestamp) ? timestamp : null;
   } catch {
     return null;
@@ -13404,14 +13404,14 @@ function findOptionalPorcelainValue(block, key) {
 
 // src/shell-handoff.ts
 import { writeFile as writeFile3 } from "node:fs/promises";
-async function writeShellOutput(envVar, value, stdout) {
+async function writeShellOutput(envVar, value, stdout2) {
   const output = `${value}
 `;
   if (process.env[envVar]) {
     await writeFile3(process.env[envVar], output, "utf8");
     return;
   }
-  stdout(output);
+  stdout2(output);
 }
 
 // src/back.ts
@@ -13820,62 +13820,7 @@ var dD = class extends x {
     });
   }
 };
-var mD = Object.defineProperty;
-var bD = (e2, u2, t) => u2 in e2 ? mD(e2, u2, { enumerable: true, configurable: true, writable: true, value: t }) : e2[u2] = t;
-var Z = (e2, u2, t) => (bD(e2, typeof u2 != "symbol" ? u2 + "" : u2, t), t);
-var q = (e2, u2, t) => {
-  if (!u2.has(e2)) throw TypeError("Cannot " + t);
-};
-var T = (e2, u2, t) => (q(e2, u2, "read from private field"), t ? t.call(e2) : u2.get(e2));
-var wD = (e2, u2, t) => {
-  if (u2.has(e2)) throw TypeError("Cannot add the same private member more than once");
-  u2 instanceof WeakSet ? u2.add(e2) : u2.set(e2, t);
-};
-var yD = (e2, u2, t, F2) => (q(e2, u2, "write to private field"), F2 ? F2.call(e2, t) : u2.set(e2, t), t);
 var A;
-var _D = class extends x {
-  constructor(u2) {
-    super(u2, false), Z(this, "options"), Z(this, "cursor", 0), wD(this, A, void 0);
-    const { options: t } = u2;
-    yD(this, A, u2.selectableGroups !== false), this.options = Object.entries(t).flatMap(([F2, s]) => [{ value: F2, group: true, label: F2 }, ...s.map((i) => ({ ...i, group: F2 }))]), this.value = [...u2.initialValues ?? []], this.cursor = Math.max(this.options.findIndex(({ value: F2 }) => F2 === u2.cursorAt), T(this, A) ? 0 : 1), this.on("cursor", (F2) => {
-      switch (F2) {
-        case "left":
-        case "up": {
-          this.cursor = this.cursor === 0 ? this.options.length - 1 : this.cursor - 1;
-          const s = this.options[this.cursor]?.group === true;
-          !T(this, A) && s && (this.cursor = this.cursor === 0 ? this.options.length - 1 : this.cursor - 1);
-          break;
-        }
-        case "down":
-        case "right": {
-          this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1;
-          const s = this.options[this.cursor]?.group === true;
-          !T(this, A) && s && (this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1);
-          break;
-        }
-        case "space":
-          this.toggleValue();
-          break;
-      }
-    });
-  }
-  getGroupItems(u2) {
-    return this.options.filter((t) => t.group === u2);
-  }
-  isGroupSelected(u2) {
-    return this.getGroupItems(u2).every((t) => this.value.includes(t.value));
-  }
-  toggleValue() {
-    const u2 = this.options[this.cursor];
-    if (u2.group === true) {
-      const t = u2.value, F2 = this.getGroupItems(t);
-      this.isGroupSelected(t) ? this.value = this.value.filter((s) => F2.findIndex((i) => i.value === s) === -1) : this.value = [...this.value, ...F2.map((s) => s.value)], this.value = Array.from(new Set(this.value));
-    } else {
-      const t = this.value.includes(u2.value);
-      this.value = t ? this.value.filter((F2) => F2 !== u2.value) : [...this.value, u2.value];
-    }
-  }
-};
 A = /* @__PURE__ */ new WeakMap();
 var OD = Object.defineProperty;
 var PD = (e2, u2, t) => u2 in e2 ? OD(e2, u2, { enumerable: true, configurable: true, writable: true, value: t }) : e2[u2] = t;
@@ -13939,14 +13884,14 @@ var d2 = u("\u2514", "\u2014");
 var k2 = u("\u25CF", ">");
 var P2 = u("\u25CB", " ");
 var A2 = u("\u25FB", "[\u2022]");
-var T2 = u("\u25FC", "[+]");
+var T = u("\u25FC", "[+]");
 var F = u("\u25FB", "[ ]");
 var $e = u("\u25AA", "\u2022");
 var _2 = u("\u2500", "-");
 var me = u("\u256E", "+");
 var de = u("\u251C", "+");
 var pe = u("\u256F", "+");
-var q2 = u("\u25CF", "\u2022");
+var q = u("\u25CF", "\u2022");
 var D = u("\u25C6", "*");
 var U = u("\u25B2", "!");
 var K2 = u("\u25A0", "x");
@@ -14045,60 +13990,6 @@ ${import_picocolors2.default.cyan(d2)}
     }
   } }).prompt();
 };
-var be = (t) => {
-  const { selectableGroups: n = true } = t, r2 = (i, s, c = []) => {
-    const a = i.label ?? String(i.value), l2 = typeof i.group == "string", $2 = l2 && (c[c.indexOf(i) + 1] ?? { group: true }), g = l2 && $2.group === true, p2 = l2 ? n ? `${g ? d2 : o} ` : "  " : "";
-    if (s === "active") return `${import_picocolors2.default.dim(p2)}${import_picocolors2.default.cyan(A2)} ${a} ${i.hint ? import_picocolors2.default.dim(`(${i.hint})`) : ""}`;
-    if (s === "group-active") return `${p2}${import_picocolors2.default.cyan(A2)} ${import_picocolors2.default.dim(a)}`;
-    if (s === "group-active-selected") return `${p2}${import_picocolors2.default.green(T2)} ${import_picocolors2.default.dim(a)}`;
-    if (s === "selected") {
-      const f = l2 || n ? import_picocolors2.default.green(T2) : "";
-      return `${import_picocolors2.default.dim(p2)}${f} ${import_picocolors2.default.dim(a)} ${i.hint ? import_picocolors2.default.dim(`(${i.hint})`) : ""}`;
-    }
-    if (s === "cancelled") return `${import_picocolors2.default.strikethrough(import_picocolors2.default.dim(a))}`;
-    if (s === "active-selected") return `${import_picocolors2.default.dim(p2)}${import_picocolors2.default.green(T2)} ${a} ${i.hint ? import_picocolors2.default.dim(`(${i.hint})`) : ""}`;
-    if (s === "submitted") return `${import_picocolors2.default.dim(a)}`;
-    const v2 = l2 || n ? import_picocolors2.default.dim(F) : "";
-    return `${import_picocolors2.default.dim(p2)}${v2} ${import_picocolors2.default.dim(a)}`;
-  };
-  return new _D({ options: t.options, initialValues: t.initialValues, required: t.required ?? true, cursorAt: t.cursorAt, selectableGroups: n, validate(i) {
-    if (this.required && i.length === 0) return `Please select at least one option.
-${import_picocolors2.default.reset(import_picocolors2.default.dim(`Press ${import_picocolors2.default.gray(import_picocolors2.default.bgWhite(import_picocolors2.default.inverse(" space ")))} to select, ${import_picocolors2.default.gray(import_picocolors2.default.bgWhite(import_picocolors2.default.inverse(" enter ")))} to submit`))}`;
-  }, render() {
-    const i = `${import_picocolors2.default.gray(o)}
-${b2(this.state)}  ${t.message}
-`;
-    switch (this.state) {
-      case "submit":
-        return `${i}${import_picocolors2.default.gray(o)}  ${this.options.filter(({ value: s }) => this.value.includes(s)).map((s) => r2(s, "submitted")).join(import_picocolors2.default.dim(", "))}`;
-      case "cancel": {
-        const s = this.options.filter(({ value: c }) => this.value.includes(c)).map((c) => r2(c, "cancelled")).join(import_picocolors2.default.dim(", "));
-        return `${i}${import_picocolors2.default.gray(o)}  ${s.trim() ? `${s}
-${import_picocolors2.default.gray(o)}` : ""}`;
-      }
-      case "error": {
-        const s = this.error.split(`
-`).map((c, a) => a === 0 ? `${import_picocolors2.default.yellow(d2)}  ${import_picocolors2.default.yellow(c)}` : `   ${c}`).join(`
-`);
-        return `${i}${import_picocolors2.default.yellow(o)}  ${this.options.map((c, a, l2) => {
-          const $2 = this.value.includes(c.value) || c.group === true && this.isGroupSelected(`${c.value}`), g = a === this.cursor;
-          return !g && typeof c.group == "string" && this.options[this.cursor].value === c.group ? r2(c, $2 ? "group-active-selected" : "group-active", l2) : g && $2 ? r2(c, "active-selected", l2) : $2 ? r2(c, "selected", l2) : r2(c, g ? "active" : "inactive", l2);
-        }).join(`
-${import_picocolors2.default.yellow(o)}  `)}
-${s}
-`;
-      }
-      default:
-        return `${i}${import_picocolors2.default.cyan(o)}  ${this.options.map((s, c, a) => {
-          const l2 = this.value.includes(s.value) || s.group === true && this.isGroupSelected(`${s.value}`), $2 = c === this.cursor;
-          return !$2 && typeof s.group == "string" && this.options[this.cursor].value === s.group ? r2(s, l2 ? "group-active-selected" : "group-active", a) : $2 && l2 ? r2(s, "active-selected", a) : l2 ? r2(s, "selected", a) : r2(s, $2 ? "active" : "inactive", a);
-        }).join(`
-${import_picocolors2.default.cyan(o)}  `)}
-${import_picocolors2.default.cyan(d2)}
-`;
-    }
-  } }).prompt();
-};
 var Ie = (t = "") => {
   process.stdout.write(`${import_picocolors2.default.gray(ue)}  ${t}
 `);
@@ -14236,6 +14127,7 @@ function formatRelativeAge(timestampSeconds) {
 
 // src/worktree-management.ts
 import { execFile as execFile2 } from "node:child_process";
+import { rm } from "node:fs/promises";
 import { promisify as promisify3 } from "node:util";
 var execFileAsync2 = promisify3(execFile2);
 var GIT_ENV = { ...process.env, LC_ALL: "C" };
@@ -14256,10 +14148,24 @@ async function removeWorktree(repoRoot, worktreePath) {
   });
 }
 async function forceRemoveWorktree(repoRoot, worktreePath) {
-  await execFileAsync2("git", ["worktree", "remove", "--force", worktreePath], {
-    cwd: repoRoot,
-    env: GIT_ENV
-  });
+  try {
+    await execFileAsync2(
+      "git",
+      ["worktree", "remove", "--force", worktreePath],
+      {
+        cwd: repoRoot,
+        env: GIT_ENV
+      }
+    );
+  } catch (error) {
+    const worktreeIsStillRegistered = (await listWorktrees(repoRoot)).some(
+      (worktree) => worktree.path === worktreePath
+    );
+    if (worktreeIsStillRegistered) {
+      throw error;
+    }
+    await rm(worktreePath, { force: true, recursive: true });
+  }
 }
 async function deleteBranch(repoRoot, branch) {
   await execFileAsync2("git", ["branch", "-d", branch], {
@@ -14273,8 +14179,14 @@ async function forceDeleteBranch(repoRoot, branch) {
     env: GIT_ENV
   });
 }
-function isWorktreeDirtyError(error) {
-  return hasStderr(error) && error.stderr.includes("contains modified or untracked files");
+function isWorktreeForceRemovalError(error) {
+  if (!hasStderr(error)) {
+    return false;
+  }
+  return error.stderr.includes("contains modified or untracked files") || isWorktreeDeletionError(error);
+}
+function isWorktreeDeletionError(error) {
+  return hasStderr(error) && error.stderr.includes("failed to delete");
 }
 function isBranchUnmergedError(error) {
   return hasStderr(error) && error.stderr.includes("is not fully merged");
@@ -14284,6 +14196,7 @@ function hasStderr(error) {
 }
 
 // src/worktree-picker.ts
+import { env as env4, platform, stdin, stdout } from "node:process";
 async function buildWorktreePromptEntries(sources) {
   const [history, infos] = await Promise.all([
     loadHistory(),
@@ -14325,25 +14238,25 @@ function isAmbiguousRepoOnlyQuery(matches, query) {
   if (matches[0]?.matchScore === 1e3) return false;
   return matches.filter((match) => match.source.repoName.toLowerCase() === query).length > 1;
 }
-async function promptForSingleWorktree(message, worktrees) {
-  const choice = await ve({
+async function promptForSingleWorktree(message, worktrees, io = {}) {
+  const choice = await runSearchablePrompt({
+    entries: worktrees.map(buildSearchableWorktreeEntry),
+    input: io.input,
     message,
-    options: worktrees.map((worktree) => ({
-      label: worktree.label,
-      value: worktree.path
-    })),
-    maxItems: 12
+    multiple: false,
+    output: io.output
   });
-  return pD(choice) ? null : choice;
+  return typeof choice === "string" ? choice : null;
 }
-async function promptForMultipleWorktrees(message, worktrees) {
-  const choice = await be({
+async function promptForMultipleWorktrees(message, worktrees, io = {}) {
+  const choice = await runSearchablePrompt({
+    entries: buildGroupedSearchableEntries(worktrees),
+    input: io.input,
     message,
-    options: groupPromptEntries(worktrees),
-    required: true,
-    selectableGroups: false
+    multiple: true,
+    output: io.output
   });
-  return pD(choice) ? null : choice;
+  return Array.isArray(choice) ? choice : null;
 }
 function compareQueryMatches(a, b3) {
   if (a.matchScore !== b3.matchScore) {
@@ -14356,16 +14269,625 @@ function compareQueryMatches(a, b3) {
   ) || a.source.worktree.path.localeCompare(b3.source.worktree.path);
 }
 function groupPromptEntries(worktrees) {
-  const groups = {};
+  const groups = /* @__PURE__ */ new Map();
   for (const worktree of worktrees) {
     const group = worktree.group === "recent" ? "Recent worktrees" : "Other worktrees";
-    groups[group] ??= [];
-    groups[group].push({
-      label: worktree.label,
-      value: worktree.path
+    const groupWorktrees = groups.get(group);
+    if (groupWorktrees === void 0) {
+      groups.set(group, [worktree]);
+    } else {
+      groupWorktrees.push(worktree);
+    }
+  }
+  return [...groups.entries()];
+}
+function buildGroupedSearchableEntries(worktrees) {
+  const entries = [];
+  for (const [group, groupWorktrees] of groupPromptEntries(worktrees)) {
+    entries.push({
+      label: group,
+      searchText: group.toLowerCase(),
+      selectable: false
+    });
+    for (const worktree of groupWorktrees) {
+      entries.push(buildSearchableWorktreeEntry(worktree));
+    }
+  }
+  return entries;
+}
+function buildSearchableWorktreeEntry(worktree) {
+  const metadata = worktree.metadata ?? null;
+  const branch = worktree.branch ?? "(detached)";
+  return {
+    detail: [worktree.repoName, branch, metadata, worktree.path].filter((part) => part !== null && part.length > 0).join(" \xB7 "),
+    label: worktree.label,
+    searchText: buildPromptSearchText(worktree),
+    value: worktree.path,
+    worktree: {
+      branch,
+      metadata,
+      path: worktree.path,
+      repoName: worktree.repoName
+    }
+  };
+}
+async function runSearchablePrompt(options) {
+  const input = options.input ?? stdin;
+  const output = options.output ?? stdout;
+  if (!input.isTTY) {
+    return null;
+  }
+  const prompt = new SearchablePrompt(options, input, output);
+  const value = await prompt.run();
+  return pD(value) ? null : value;
+}
+var SearchablePrompt = class {
+  constructor(options, input, output) {
+    this.options = options;
+    this.output = output;
+    this.cursor = this.firstSelectableIndex();
+    const owner = this;
+    this.prompt = new WorktreeCorePrompt(this, {
+      input,
+      output,
+      render: function renderWorktreePrompt() {
+        return owner.render(this.state, this.error);
+      }
     });
+    this.syncValue();
+  }
+  cursor = 0;
+  query = "";
+  searchActive = false;
+  selected = /* @__PURE__ */ new Set();
+  prompt;
+  run() {
+    return this.prompt.prompt();
+  }
+  handleKeypress(prompt, character, key) {
+    if (prompt.state === "error") {
+      prompt.state = "active";
+      prompt.error = "";
+    }
+    const action = resolvePromptAction(character, key);
+    if (action === "cancel") {
+      this.cancel(prompt);
+      return;
+    }
+    if (action === "escape") {
+      this.handleEscapeKey(prompt);
+      return;
+    }
+    if (action === "enter") {
+      this.submit(prompt);
+      return;
+    }
+    if (this.searchActive && this.handleSearchKey(character, key?.name)) {
+      this.syncValue();
+      renderPrompt(prompt);
+      return;
+    }
+    if (character === "/" && !this.searchActive) {
+      this.searchActive = true;
+      this.query = "";
+      this.cursor = this.firstSelectableIndex();
+      this.syncValue();
+      renderPrompt(prompt);
+      return;
+    }
+    this.handleNavigationKey(character, action);
+    this.syncValue();
+    renderPrompt(prompt);
+  }
+  handleEscapeKey(prompt) {
+    if (this.searchActive) {
+      this.searchActive = false;
+      this.query = "";
+      this.cursor = this.firstSelectableIndex();
+      this.syncValue();
+      renderPrompt(prompt);
+      return;
+    }
+    this.cancel(prompt);
+  }
+  cancel(prompt) {
+    prompt.state = "cancel";
+    renderPrompt(prompt);
+    closePrompt(prompt);
+  }
+  handleSearchKey(character, keyName) {
+    if (keyName === "space" || character === " ") {
+      return false;
+    }
+    if (keyName === "backspace" || keyName === "delete") {
+      this.query = this.query.slice(0, -1);
+      this.cursor = this.firstSelectableIndex();
+      return true;
+    }
+    if (isPrintableSearchCharacter(character)) {
+      this.query += character;
+      this.cursor = this.firstSelectableIndex();
+      return true;
+    }
+    return false;
+  }
+  handleNavigationKey(character, action) {
+    switch (action) {
+      case "up":
+        this.moveCursor(-1);
+        return;
+      case "down":
+        this.moveCursor(1);
+        return;
+      case "space":
+        this.toggleSelection();
+        return;
+    }
+    switch (character) {
+      case "k":
+        this.moveCursor(-1);
+        return;
+      case "j":
+        this.moveCursor(1);
+        return;
+      case " ":
+        this.toggleSelection();
+        return;
+    }
+  }
+  moveCursor(direction) {
+    const entries = this.visibleEntries();
+    if (entries.length === 0) return;
+    let nextCursor = this.cursor;
+    for (let index = 0; index < entries.length; index += 1) {
+      nextCursor = wrapIndex(nextCursor + direction, entries.length);
+      if (isSelectableEntry(entries[nextCursor])) {
+        this.cursor = nextCursor;
+        return;
+      }
+    }
+  }
+  submit(prompt) {
+    const entry = this.visibleEntries()[this.cursor];
+    if (!this.options.multiple) {
+      prompt.value = isSelectableEntry(entry) ? entry.value : null;
+      prompt.state = "submit";
+      renderPrompt(prompt);
+      closePrompt(prompt);
+      return;
+    }
+    if (this.selected.size === 0) {
+      prompt.error = "Please select at least one option.";
+      prompt.state = "error";
+      renderPrompt(prompt);
+      return;
+    }
+    prompt.value = [...this.selected];
+    prompt.state = "submit";
+    renderPrompt(prompt);
+    closePrompt(prompt);
+  }
+  toggleSelection() {
+    if (!this.options.multiple) return;
+    const entry = this.visibleEntries()[this.cursor];
+    if (!isSelectableEntry(entry)) return;
+    if (this.selected.has(entry.value)) {
+      this.selected.delete(entry.value);
+      return;
+    }
+    this.selected.add(entry.value);
+  }
+  render(state, error) {
+    const entries = this.visibleEntries();
+    const visibleEntries = windowPromptEntries(
+      entries,
+      this.cursor,
+      this.maxItems()
+    );
+    const glyphs = promptGlyphs();
+    const colors = promptColors();
+    const frame = promptFrameColor(state, colors);
+    const lines = [
+      colors.bar(glyphs.bar),
+      this.renderTitle(state, glyphs, colors),
+      `${frame(glyphs.bar)}  ${this.renderSearchHint(colors)}`,
+      frame(glyphs.bar)
+    ];
+    if (state === "error" && error.length > 0) {
+      lines.push(`${colors.errorBar(glyphs.bar)}  ${colors.error(error)}`);
+      lines.push(frame(glyphs.bar));
+    }
+    lines.push(
+      ...this.renderEntries(entries, visibleEntries, glyphs, colors, frame)
+    );
+    lines.push(frame(glyphs.bar));
+    const preview = this.activePreview(entries, colors);
+    if (preview !== null) {
+      lines.push(`${frame(glyphs.bar)}  ${preview}`);
+      lines.push(frame(glyphs.bar));
+    }
+    const visibleWorktreeCount = entries.filter(isSelectableEntry).length;
+    const footer = this.footerText(visibleWorktreeCount, colors);
+    if (footer.length > 0) {
+      lines.push(`${frame(glyphs.corner)}  ${footer}`);
+    }
+    return `${lines.join("\n")}
+`;
+  }
+  renderTitle(state, glyphs, colors) {
+    const symbol = colors.symbol(promptSymbol(state, glyphs), state);
+    const maxTitleLength = Math.max(8, this.columns() - 3);
+    if (!this.searchActive) {
+      return `${symbol}  ${middleEllipsize(this.options.message, maxTitleLength)}`;
+    }
+    const search = ` /${this.query}`;
+    const maxSearchLength = Math.min(
+      terminalWidth(search),
+      Math.floor(maxTitleLength / 2)
+    );
+    const message = middleEllipsize(
+      this.options.message,
+      Math.max(1, maxTitleLength - maxSearchLength)
+    );
+    const visibleSearch = middleEllipsize(
+      search,
+      Math.max(1, maxTitleLength - terminalWidth(message))
+    );
+    return `${symbol}  ${message}${colors.search(visibleSearch)}`;
+  }
+  renderSearchHint(colors) {
+    if (this.searchActive) {
+      return `${colors.hint("type to filter")} ${colors.hint("\xB7")} ${colors.key("esc")} ${colors.hint("clears")}`;
+    }
+    return `${colors.hint("press ")}${colors.key("/")}${colors.hint(" to search")}`;
+  }
+  renderEntries(entries, visibleEntries, glyphs, colors, frame) {
+    if (entries.length === 0) {
+      return [`${frame(glyphs.bar)}  ${colors.hint("No matching worktrees")}`];
+    }
+    return visibleEntries.map(
+      (entry) => entry === "ellipsis" ? `${frame(glyphs.bar)}  ${colors.hint("...")}` : this.renderEntry(entries, entry, glyphs, colors, frame)
+    );
+  }
+  renderEntry(entries, entry, glyphs, colors, frame) {
+    const active = entries[this.cursor] === entry;
+    const selected = isSelectableEntry(entry) && this.selected.has(entry.value);
+    const prefix = this.entryPrefix(entry, active, selected, glyphs);
+    const label = this.entryLabel(entry, prefix);
+    const line = isSelectableEntry(entry) ? active ? label : colors.hint(label) : colors.hint(label);
+    const marker = selected ? colors.selected(prefix) : active ? this.options.multiple ? colors.option(prefix) : colors.selected(prefix) : colors.hint(prefix);
+    return `${frame(glyphs.bar)}  ${marker} ${line}`;
+  }
+  activePreview(entries, colors) {
+    const entry = entries[this.cursor];
+    if (!isSelectableEntry(entry) || entry.detail === void 0) return null;
+    const label = "current";
+    const separator = " ";
+    const width = this.previewWidth();
+    const prefixWidth = terminalWidth(label) + terminalWidth(separator);
+    if (width <= prefixWidth) return colors.key(middleEllipsize(label, width));
+    const detail = middleEllipsize(entry.detail, width - prefixWidth);
+    return `${colors.key(label)}${colors.hint(separator)}${colors.hint(detail)}`;
+  }
+  entryLabel(entry, prefix) {
+    const width = this.labelWidth(prefix);
+    if (entry.worktree === void 0) {
+      return middleEllipsize(entry.label, width);
+    }
+    return fitPromptPieces(
+      [
+        {
+          ellipsize: middleEllipsize,
+          max: 18,
+          min: 6,
+          value: entry.worktree.repoName
+        },
+        {
+          ellipsize: middleEllipsize,
+          max: 32,
+          min: 8,
+          value: entry.worktree.branch
+        },
+        ...entry.worktree.metadata === null ? [] : [
+          {
+            ellipsize: middleEllipsize,
+            max: 30,
+            min: 10,
+            value: entry.worktree.metadata
+          }
+        ],
+        {
+          ellipsize: startEllipsize,
+          max: 36,
+          min: 12,
+          value: entry.worktree.path
+        }
+      ],
+      width
+    );
+  }
+  labelWidth(prefix) {
+    return Math.max(8, this.columns() - terminalWidth(prefix) - 4);
+  }
+  previewWidth() {
+    return Math.max(8, this.columns() - 3);
+  }
+  entryPrefix(entry, active, selected, glyphs) {
+    if (!isSelectableEntry(entry)) {
+      return active ? glyphs.active : " ";
+    }
+    if (!this.options.multiple) {
+      return active ? glyphs.active : glyphs.inactive;
+    }
+    if (active && selected) return glyphs.checked;
+    if (active) return glyphs.uncheckedActive;
+    return selected ? glyphs.checked : glyphs.unchecked;
+  }
+  footerText(visibleCount, colors) {
+    if (!this.options.multiple) return "";
+    return [
+      `${colors.key("space")} ${colors.hint("select")}`,
+      `${colors.selected(String(this.selected.size))} ${colors.hint("selected")}`,
+      colors.hint(`${visibleCount} shown`)
+    ].join(colors.hint(" \xB7 "));
+  }
+  firstSelectableIndex() {
+    const index = this.visibleEntries().findIndex(isSelectableEntry);
+    return index === -1 ? 0 : index;
+  }
+  visibleEntries() {
+    const query = normalizeQuery(this.query);
+    if (query === null) {
+      return this.options.entries;
+    }
+    return filterSearchablePromptEntries(this.options.entries, query);
+  }
+  maxItems() {
+    const rows = this.output.rows ?? 16;
+    return Math.max(5, Math.min(12, rows - 8));
+  }
+  columns() {
+    return Math.max(20, this.output.columns ?? 80);
+  }
+  syncValue() {
+    if (this.options.multiple) {
+      this.prompt.value = [...this.selected];
+      return;
+    }
+    const entry = this.visibleEntries()[this.cursor];
+    this.prompt.value = isSelectableEntry(entry) ? entry.value : null;
+  }
+};
+var WorktreeCorePrompt = class extends x {
+  constructor(worktreePrompt, options) {
+    super(options, false);
+    this.worktreePrompt = worktreePrompt;
+  }
+};
+Object.defineProperty(WorktreeCorePrompt.prototype, "onKeypress", {
+  value: onWorktreeKeypress,
+  writable: true
+});
+function renderPrompt(prompt) {
+  prompt.render();
+}
+function closePrompt(prompt) {
+  prompt.close();
+}
+function onWorktreeKeypress(character, key) {
+  this.worktreePrompt.handleKeypress(this, character, key);
+}
+function resolvePromptAction(character, key) {
+  if (key?.ctrl && key.name === "c" || character === "") {
+    return "cancel";
+  }
+  switch (key?.name) {
+    case "escape":
+      return "escape";
+    case "return":
+      return "enter";
+    case "space":
+      return "space";
+    case "up":
+    case "left":
+      return "up";
+    case "down":
+    case "right":
+      return "down";
+  }
+  switch (character) {
+    case " ":
+      return "space";
+    case "k":
+    case "h":
+      return "up";
+    case "j":
+    case "l":
+      return "down";
+  }
+  return void 0;
+}
+function promptGlyphs() {
+  return supportsUnicode() ? {
+    active: "\u25CF",
+    bar: "\u2502",
+    checked: "\u25FC",
+    corner: "\u2514",
+    inactive: "\u25CB",
+    pending: "\u25C6",
+    submitted: "\u25C7",
+    unchecked: "\u25FB",
+    uncheckedActive: "\u25FB"
+  } : {
+    active: ">",
+    bar: "|",
+    checked: "[x]",
+    corner: "-",
+    inactive: " ",
+    pending: "*",
+    submitted: "o",
+    unchecked: "[ ]",
+    uncheckedActive: "[ ]"
+  };
+}
+function promptColors() {
+  return {
+    activeBar: cyan,
+    bar: gray,
+    error: yellow,
+    errorBar: yellow,
+    hint: dim,
+    key: cyan,
+    option: cyan,
+    search: cyan,
+    selected: green,
+    symbol: (value, state) => {
+      if (state === "submit") return green(value);
+      if (state === "error") return yellow(value);
+      if (state === "cancel") return red(value);
+      return cyan(value);
+    }
+  };
+}
+function promptFrameColor(state, colors) {
+  if (state === "error") return colors.errorBar;
+  if (state === "active" || state === "initial") return colors.activeBar;
+  return colors.bar;
+}
+function promptSymbol(state, glyphs) {
+  return state === "submit" ? glyphs.submitted : glyphs.pending;
+}
+function cyan(value) {
+  return color("\x1B[36m", "\x1B[39m", value);
+}
+function dim(value) {
+  return color("\x1B[2m", "\x1B[22m", value);
+}
+function gray(value) {
+  return color("\x1B[90m", "\x1B[39m", value);
+}
+function green(value) {
+  return color("\x1B[32m", "\x1B[39m", value);
+}
+function red(value) {
+  return color("\x1B[31m", "\x1B[39m", value);
+}
+function yellow(value) {
+  return color("\x1B[33m", "\x1B[39m", value);
+}
+function color(open, close, value) {
+  if (env4.NO_COLOR !== void 0) return value;
+  return `${open}${value}${close}`;
+}
+function supportsUnicode() {
+  if (platform !== "win32") {
+    return env4.TERM !== "linux";
+  }
+  return Boolean(
+    env4.CI || env4.WT_SESSION || env4.TERMINUS_SUBLIME || env4.ConEmuTask === "{cmd::Cmder}" || env4.TERM_PROGRAM === "Terminus-Sublime" || env4.TERM_PROGRAM === "vscode" || env4.TERM === "xterm-256color" || env4.TERM === "alacritty" || env4.TERMINAL_EMULATOR === "JetBrains-JediTerm"
+  );
+}
+function isPrintableSearchCharacter(character) {
+  return typeof character === "string" && character.length === 1 && character >= " " && character !== "\x7F";
+}
+function wrapIndex(index, length) {
+  return (index + length) % length;
+}
+function windowPromptEntries(entries, cursor, maxItems) {
+  if (entries.length <= maxItems) {
+    return entries;
+  }
+  const activeIndex = Math.min(Math.max(cursor, 0), entries.length - 1);
+  const start = Math.max(
+    0,
+    Math.min(activeIndex - 2, entries.length - maxItems)
+  );
+  const window = entries.slice(start, start + maxItems);
+  if (start > 0) {
+    window[0] = "ellipsis";
+  }
+  if (start + maxItems < entries.length) {
+    window[window.length - 1] = "ellipsis";
+  }
+  return window;
+}
+function fitPromptPieces(pieces, width) {
+  const separator = " \xB7 ";
+  let visiblePieces = pieces.filter((piece) => piece.value.length > 0);
+  let available = width - terminalWidth(separator) * Math.max(0, visiblePieces.length - 1);
+  while (visiblePieces.length > 1 && available < minimumPieceLength(visiblePieces)) {
+    const removableIndex = visiblePieces.length === 4 ? 2 : visiblePieces.length - 2;
+    visiblePieces = visiblePieces.filter(
+      (_3, index) => index !== removableIndex
+    );
+    available = width - terminalWidth(separator) * Math.max(0, visiblePieces.length - 1);
+  }
+  if (available <= 0 || available < minimumPieceLength(visiblePieces)) {
+    return middleEllipsize(
+      visiblePieces.map((piece) => piece.value).join(separator),
+      width
+    );
+  }
+  const lengths = visiblePieces.map(
+    (piece) => Math.min(terminalWidth(piece.value), piece.max)
+  );
+  while (sum(lengths) > available) {
+    const index = largestShrinkablePieceIndex(visiblePieces, lengths);
+    if (index === -1) break;
+    lengths[index] -= 1;
+  }
+  return visiblePieces.map((piece, index) => piece.ellipsize(piece.value, lengths[index])).join(separator);
+}
+function minimumPieceLength(pieces) {
+  return sum(
+    pieces.map((piece) => Math.min(terminalWidth(piece.value), piece.min))
+  );
+}
+function largestShrinkablePieceIndex(pieces, lengths) {
+  let candidate = -1;
+  for (let index = 0; index < pieces.length; index += 1) {
+    if (lengths[index] <= Math.min(terminalWidth(pieces[index].value), pieces[index].min)) {
+      continue;
+    }
+    if (candidate === -1 || lengths[index] > lengths[candidate]) {
+      candidate = index;
+    }
   }
-  return groups;
+  return candidate;
+}
+function sum(values) {
+  return values.reduce((total, value) => total + value, 0);
+}
+function filterSearchablePromptEntries(entries, query) {
+  const filtered = [];
+  let pendingGroup = null;
+  for (const entry of entries) {
+    if (!isSelectableEntry(entry)) {
+      pendingGroup = entry;
+      continue;
+    }
+    if (!entry.searchText.includes(query)) {
+      continue;
+    }
+    if (pendingGroup !== null) {
+      filtered.push(pendingGroup);
+      pendingGroup = null;
+    }
+    filtered.push(entry);
+  }
+  return filtered;
+}
+function isSelectableEntry(entry) {
+  return entry !== void 0 && entry.selectable !== false && typeof entry.value === "string";
+}
+function buildPromptSearchText(worktree) {
+  return [
+    worktree.repoName,
+    worktree.branch ?? "detached",
+    worktree.path,
+    worktree.label,
+    `${worktree.repoName}/${worktree.branch ?? "detached"}`
+  ].join(" ").toLowerCase();
 }
 function buildWorktreePromptEntry(source, info, lastUsedTimestamp, now) {
   const lastWorkedTimestamp = info.lastCommitTimestamp === null ? null : info.lastCommitTimestamp * 1e3;
@@ -14379,12 +14901,15 @@ function buildWorktreePromptEntry(source, info, lastUsedTimestamp, now) {
     now
   );
   const status = badges.length > 0 ? badges.map((badge) => `[${badge}]`).join(" ") : null;
+  const metadataParts = [status, recency].filter(
+    (part) => part !== null && part.length > 0
+  );
+  const metadata = metadataParts.length === 0 ? null : metadataParts.join(" \xB7 ");
   const path9 = middleEllipsize(source.worktree.path, 76);
   const label = [
     middleEllipsize(source.repoName, 22),
     middleEllipsize(branch, 34),
-    status,
-    recency,
+    metadata,
     path9
   ].filter((part) => part !== null && part.length > 0).join(" \xB7 ");
   return {
@@ -14392,6 +14917,7 @@ function buildWorktreePromptEntry(source, info, lastUsedTimestamp, now) {
     group: lastUsedTimestamp !== null ? "recent" : "other",
     label,
     lastActivityTimestamp,
+    metadata,
     repoName: source.repoName
   };
 }
@@ -14490,16 +15016,58 @@ function scoreWorktreeMatch(entry, query) {
   return buildSearchText(entry.repoName, entry).includes(query) ? 1 : null;
 }
 function middleEllipsize(value, maxLength) {
-  if (value.length <= maxLength) {
+  if (terminalWidth(value) <= maxLength) {
     return value;
   }
   if (maxLength <= 1) {
     return "\u2026";
   }
   const keep = maxLength - 1;
-  const start = Math.ceil(keep / 2);
-  const end = Math.floor(keep / 2);
-  return `${value.slice(0, start)}\u2026${value.slice(value.length - end)}`;
+  const start = takeTerminalColumns(value, Math.ceil(keep / 2), "start");
+  const end = takeTerminalColumns(value, Math.floor(keep / 2), "end");
+  return `${start}\u2026${end}`;
+}
+function startEllipsize(value, maxLength) {
+  if (terminalWidth(value) <= maxLength) {
+    return value;
+  }
+  if (maxLength <= 1) {
+    return "\u2026";
+  }
+  return `\u2026${takeTerminalColumns(value, maxLength - 1, "end")}`;
+}
+function takeTerminalColumns(value, maxWidth, direction) {
+  const characters = direction === "start" ? Array.from(value) : Array.from(value).reverse();
+  const kept = [];
+  let width = 0;
+  for (const character of characters) {
+    const characterWidth = terminalWidth(character);
+    if (width + characterWidth > maxWidth) break;
+    kept.push(character);
+    width += characterWidth;
+  }
+  return direction === "start" ? kept.join("") : kept.reverse().join("");
+}
+function terminalWidth(value) {
+  let width = 0;
+  for (const character of Array.from(value)) {
+    width += characterTerminalWidth(character);
+  }
+  return width;
+}
+function characterTerminalWidth(character) {
+  const codePoint = character.codePointAt(0);
+  if (codePoint === void 0) return 0;
+  if (isZeroWidthCodePoint(codePoint) || new RegExp("\\p{Mark}", "u").test(character)) {
+    return 0;
+  }
+  return isWideCodePoint(codePoint) ? 2 : 1;
+}
+function isZeroWidthCodePoint(codePoint) {
+  return codePoint === 0 || codePoint === 8205 || codePoint >= 65024 && codePoint <= 65039;
+}
+function isWideCodePoint(codePoint) {
+  return codePoint >= 4352 && codePoint <= 4447 || codePoint === 9001 || codePoint === 9002 || codePoint >= 11904 && codePoint <= 42191 || codePoint >= 44032 && codePoint <= 55203 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65040 && codePoint <= 65049 || codePoint >= 65072 && codePoint <= 65135 || codePoint >= 65280 && codePoint <= 65376 || codePoint >= 65504 && codePoint <= 65510 || codePoint >= 127744 && codePoint <= 129791 || codePoint >= 131072 && codePoint <= 262141;
 }
 
 // src/worktree-prompts.ts
@@ -14609,8 +15177,8 @@ function createCleanCommand(dependencies = {}) {
       }
       return 0;
     }
-    const removedPaths = [];
     const removedWorktrees = [];
+    const failures = [];
     for (const worktree of selectedWorktrees) {
       if (options.stale && !await isStaleCleanupCandidate(
         repository.repoRoot,
@@ -14626,10 +15194,15 @@ function createCleanCommand(dependencies = {}) {
       try {
         await removeWorktree(repository.repoRoot, worktree.path);
       } catch (error) {
-        if (!isWorktreeDirtyError(error)) {
-          throw error;
+        if (!isWorktreeForceRemovalError(error)) {
+          failures.push({
+            branch: worktree.branch,
+            message: toMessage(error),
+            path: worktree.path
+          });
+          continue;
         }
-        if (options.stale) {
+        if (options.stale && !isWorktreeDeletionError(error)) {
           options.stderr(
             `Skipped ${worktree.path}: no longer a safe stale cleanup candidate
 `
@@ -14637,24 +15210,24 @@ function createCleanCommand(dependencies = {}) {
           continue;
         }
         if (!options.force && !await confirmForceRemoveWorktree(worktree.path)) {
-          reportRemovedPaths(removedPaths, options.stderr);
-          options.stderr("Aborted\n");
-          return 1;
+          failures.push({
+            branch: worktree.branch,
+            message: "force removal declined",
+            path: worktree.path
+          });
+          continue;
         }
         try {
           await forceRemoveWorktree(repository.repoRoot, worktree.path);
         } catch (forceError) {
-          if (!options.json) {
-            reportRemovedPaths(removedPaths, options.stderr);
-          }
-          emitError(
-            options,
-            `Failed to remove worktree at ${worktree.path}: ${toMessage(forceError)}`
-          );
-          return 1;
+          failures.push({
+            branch: worktree.branch,
+            message: toMessage(forceError),
+            path: worktree.path
+          });
+          continue;
         }
       }
-      removedPaths.push(worktree.path);
       removedWorktrees.push(worktree);
       if (worktree.branch) {
         try {
@@ -14686,13 +15259,16 @@ function createCleanCommand(dependencies = {}) {
         const info = selectedInfoByPath.get(worktree.path);
         return info === void 0 ? { branch: worktree.branch, path: worktree.path } : serializeWorktreeInfo(info);
       });
-      options.stdout(`${JSON.stringify({ removed }, null, 2)}
+      const payload = failures.length === 0 ? { removed } : { removed, failed: failures };
+      options.stdout(`${JSON.stringify(payload, null, 2)}
 `);
+    } else if (failures.length > 0) {
+      reportCleanFailures(failures, options.stderr);
     } else {
       options.stdout(`${repository.repoRoot}
 `);
     }
-    return 0;
+    return failures.length === 0 ? 0 : 1;
   };
 }
 var runCleanCommand = createCleanCommand();
@@ -14769,9 +15345,13 @@ function resolveSelectedWorktrees(worktrees, selections) {
   }
   return selectedWorktrees;
 }
-function reportRemovedPaths(paths, stderr) {
-  if (paths.length > 0) {
-    stderr(`Already removed: ${paths.join(", ")}
+function reportCleanFailures(failures, stderr) {
+  const noun = failures.length === 1 ? "worktree" : "worktrees";
+  stderr(`Failed to clean ${failures.length} ${noun}:
+`);
+  for (const failure of failures) {
+    const branch = failure.branch === null ? "detached" : failure.branch;
+    stderr(`- ${failure.path} (${branch}): ${failure.message}
 `);
   }
 }
@@ -15265,8 +15845,8 @@ async function runConfigCommand(options) {
     `Invalid config arguments: ${[options.action, options.key, options.value].filter(Boolean).join(" ")}`
   );
 }
-function writeJson(stdout, value) {
-  stdout(`${JSON.stringify(value, null, 2)}
+function writeJson(stdout2, value) {
+  stdout2(`${JSON.stringify(value, null, 2)}
 `);
 }
 
@@ -16068,8 +16648,8 @@ async function localBranchExists(repoRoot, branchName) {
     return false;
   }
 }
-async function writeOutput(worktreePath, stdout) {
-  await writeShellOutput(NEW_OUTPUT_FILE_ENV, worktreePath, stdout);
+async function writeOutput(worktreePath, stdout2) {
+  await writeShellOutput(NEW_OUTPUT_FILE_ENV, worktreePath, stdout2);
 }
 function isNotRegisteredWorktreeError(error) {
   const stderr = hasExecStderr(error) ? error.stderr : String(error);
@@ -17272,8 +17852,8 @@ function sourceRefForForge(forge, prNumber) {
       return `refs/merge-requests/${prNumber}/head`;
   }
 }
-async function writeOutput2(worktreePath, stdout) {
-  await writeShellOutput(PR_OUTPUT_FILE_ENV, worktreePath, stdout);
+async function writeOutput2(worktreePath, stdout2) {
+  await writeShellOutput(PR_OUTPUT_FILE_ENV, worktreePath, stdout2);
 }
 
 // src/remove.ts
@@ -17371,7 +17951,7 @@ function createRemoveCommand(dependencies = {}) {
     try {
       await removeWorktree(repository.repoRoot, worktree.path);
     } catch (error) {
-      if (!isWorktreeDirtyError(error)) {
+      if (!isWorktreeForceRemovalError(error)) {
         throw error;
       }
       if (!options.force && !await confirmForceRemoveWorktree(worktree.path)) {
@@ -17436,8 +18016,8 @@ async function defaultConfirmRemoval2(worktree) {
   });
   return !pD(choice) && choice;
 }
-async function writeOutput3(repoRoot, stdout) {
-  await writeShellOutput(REMOVE_OUTPUT_FILE_ENV, repoRoot, stdout);
+async function writeOutput3(repoRoot, stdout2) {
+  await writeShellOutput(REMOVE_OUTPUT_FILE_ENV, repoRoot, stdout2);
 }
 function emitError2(options, message) {
   if (options.json) {
@@ -17810,17 +18390,17 @@ function readSyncFiles(config) {
   if (!Array.isArray(syncFiles2)) return [];
   return syncFiles2.filter((item) => typeof item === "string");
 }
-function writeSyncFiles(stdout, files, json) {
+function writeSyncFiles(stdout2, files, json) {
   if (json) {
-    stdout(`${JSON.stringify(files, null, 2)}
+    stdout2(`${JSON.stringify(files, null, 2)}
 `);
     return;
   }
   if (files.length === 0) {
-    stdout("No sync files configured for this repo.\n");
+    stdout2("No sync files configured for this repo.\n");
     return;
   }
-  stdout(`${files.join("\n")}
+  stdout2(`${files.join("\n")}
 `);
 }
 function validatePaths(paths, options) {
@@ -17910,11 +18490,11 @@ async function runCli(argv, options = {}) {
   maybeRegisterCurrentRepo(options.cwd ?? process.cwd());
   const program2 = createProgram();
   const cwd = options.cwd ?? process.cwd();
-  const stdout = options.stdout ?? (() => void 0);
+  const stdout2 = options.stdout ?? (() => void 0);
   const stderr = options.stderr ?? (() => void 0);
   program2.configureOutput({
     writeErr: stderr,
-    writeOut: stdout
+    writeOut: stdout2
   });
   program2.exitOverride();
   if (argv.length === 0) {
@@ -17922,7 +18502,7 @@ async function runCli(argv, options = {}) {
     return { exitCode: 0 };
   }
   try {
-    attachCommandActions(program2, { cwd, stderr, stdout });
+    attachCommandActions(program2, { cwd, stderr, stdout: stdout2 });
     await program2.parseAsync(["node", "gji", ...argv], { from: "node" });
     return { exitCode: 0 };
   } catch (error) {