@solaqua/gji 0.7.1 → 0.8.0

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,
@@ -13074,15 +13074,21 @@ async function loadHistory(home = homedir2()) {
 async function appendHistory(path9, branch, home = homedir2()) {
   const historyPath = HISTORY_FILE_PATH(home);
   const existing = await loadHistory(home);
-  if (existing.length > 0 && existing[0].path === path9) {
-    return;
-  }
   const entry = { branch, path: path9, timestamp: Date.now() };
-  const next = [entry, ...existing].slice(0, MAX_HISTORY_ENTRIES);
+  const next = [
+    entry,
+    ...existing.filter((existingEntry) => existingEntry.path !== path9)
+  ].slice(0, MAX_HISTORY_ENTRIES);
   await mkdir2(dirname2(historyPath), { recursive: true });
   await writeFile2(historyPath, `${JSON.stringify(next, null, 2)}
 `, "utf8");
 }
+async function recordWorktreeUsage(path9, branch, home = homedir2()) {
+  try {
+    await appendHistory(path9, branch, home);
+  } catch {
+  }
+}
 function isHistoryEntry(value) {
   return typeof value === "object" && value !== null && "path" in value && typeof value.path === "string" && "timestamp" in value && typeof value.timestamp === "number";
 }
@@ -13203,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);
@@ -13236,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;
   }
@@ -13250,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;
@@ -13381,13 +13387,6 @@ async function listWorktrees(cwd) {
     };
   });
 }
-function sortByCurrentFirst(worktrees) {
-  return [...worktrees].sort((a, b3) => {
-    if (a.isCurrent && !b3.isCurrent) return -1;
-    if (!a.isCurrent && b3.isCurrent) return 1;
-    return 0;
-  });
-}
 function findPorcelainValue(block, key) {
   const value = findOptionalPorcelainValue(block, key);
   if (!value) {
@@ -13405,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
@@ -13823,41 +13822,6 @@ var dD = class extends x {
 };
 var A;
 A = /* @__PURE__ */ new WeakMap();
-var kD = Object.defineProperty;
-var $D = (e2, u2, t) => u2 in e2 ? kD(e2, u2, { enumerable: true, configurable: true, writable: true, value: t }) : e2[u2] = t;
-var H = (e2, u2, t) => ($D(e2, typeof u2 != "symbol" ? u2 + "" : u2, t), t);
-var SD = class extends x {
-  constructor(u2) {
-    super(u2, false), H(this, "options"), H(this, "cursor", 0), this.options = u2.options, this.value = [...u2.initialValues ?? []], this.cursor = Math.max(this.options.findIndex(({ value: t }) => t === u2.cursorAt), 0), this.on("key", (t) => {
-      t === "a" && this.toggleAll();
-    }), this.on("cursor", (t) => {
-      switch (t) {
-        case "left":
-        case "up":
-          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;
-          break;
-        case "space":
-          this.toggleValue();
-          break;
-      }
-    });
-  }
-  get _value() {
-    return this.options[this.cursor].value;
-  }
-  toggleAll() {
-    const u2 = this.value.length === this.options.length;
-    this.value = u2 ? [] : this.options.map((t) => t.value);
-  }
-  toggleValue() {
-    const u2 = this.value.includes(this._value);
-    this.value = u2 ? this.value.filter((t) => t !== this._value) : [...this.value, this._value];
-  }
-};
 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;
 var J = (e2, u2, t) => (PD(e2, typeof u2 != "symbol" ? u2 + "" : u2, t), t);
@@ -14026,46 +13990,6 @@ ${import_picocolors2.default.cyan(d2)}
     }
   } }).prompt();
 };
-var fe = (t) => {
-  const n = (r2, i) => {
-    const s = r2.label ?? String(r2.value);
-    return i === "active" ? `${import_picocolors2.default.cyan(A2)} ${s} ${r2.hint ? import_picocolors2.default.dim(`(${r2.hint})`) : ""}` : i === "selected" ? `${import_picocolors2.default.green(T)} ${import_picocolors2.default.dim(s)} ${r2.hint ? import_picocolors2.default.dim(`(${r2.hint})`) : ""}` : i === "cancelled" ? `${import_picocolors2.default.strikethrough(import_picocolors2.default.dim(s))}` : i === "active-selected" ? `${import_picocolors2.default.green(T)} ${s} ${r2.hint ? import_picocolors2.default.dim(`(${r2.hint})`) : ""}` : i === "submitted" ? `${import_picocolors2.default.dim(s)}` : `${import_picocolors2.default.dim(F)} ${import_picocolors2.default.dim(s)}`;
-  };
-  return new SD({ options: t.options, initialValues: t.initialValues, required: t.required ?? true, cursorAt: t.cursorAt, validate(r2) {
-    if (this.required && r2.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 r2 = `${import_picocolors2.default.gray(o)}
-${b2(this.state)}  ${t.message}
-`, i = (s, c) => {
-      const a = this.value.includes(s.value);
-      return c && a ? n(s, "active-selected") : a ? n(s, "selected") : n(s, c ? "active" : "inactive");
-    };
-    switch (this.state) {
-      case "submit":
-        return `${r2}${import_picocolors2.default.gray(o)}  ${this.options.filter(({ value: s }) => this.value.includes(s)).map((s) => n(s, "submitted")).join(import_picocolors2.default.dim(", ")) || import_picocolors2.default.dim("none")}`;
-      case "cancel": {
-        const s = this.options.filter(({ value: c }) => this.value.includes(c)).map((c) => n(c, "cancelled")).join(import_picocolors2.default.dim(", "));
-        return `${r2}${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 `${r2 + import_picocolors2.default.yellow(o)}  ${G2({ options: this.options, cursor: this.cursor, maxItems: t.maxItems, style: i }).join(`
-${import_picocolors2.default.yellow(o)}  `)}
-${s}
-`;
-      }
-      default:
-        return `${r2}${import_picocolors2.default.cyan(o)}  ${G2({ options: this.options, cursor: this.cursor, maxItems: t.maxItems, style: i }).join(`
-${import_picocolors2.default.cyan(o)}  `)}
-${import_picocolors2.default.cyan(d2)}
-`;
-    }
-  } }).prompt();
-};
 var Ie = (t = "") => {
   process.stdout.write(`${import_picocolors2.default.gray(ue)}  ${t}
 `);
@@ -14084,8 +14008,29 @@ function isHeadless() {
 }
 
 // src/worktree-info.ts
+var MAX_WORKTREE_INFO_READ_CONCURRENCY = 8;
 async function readWorktreeInfos(worktrees) {
-  return Promise.all(worktrees.map((worktree) => readWorktreeInfo(worktree)));
+  return mapWithConcurrency(
+    worktrees,
+    MAX_WORKTREE_INFO_READ_CONCURRENCY,
+    readWorktreeInfo
+  );
+}
+async function mapWithConcurrency(items, limit, mapper) {
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  async function readNext() {
+    for (; ; ) {
+      const index = nextIndex;
+      nextIndex += 1;
+      if (index >= items.length) return;
+      results[index] = await mapper(items[index]);
+    }
+  }
+  await Promise.all(
+    Array.from({ length: Math.min(limit, items.length) }, () => readNext())
+  );
+  return results;
 }
 async function readWorktreeInfo(worktree) {
   const [healthResult, lastCommitResult] = await Promise.allSettled([
@@ -14129,16 +14074,6 @@ function serializeWorktreeInfo(info) {
     upstream: info.upstream
   };
 }
-function formatWorktreeHint(info) {
-  const details = [
-    `status: ${info.status}`,
-    `upstream: ${formatUpstreamState(info.upstream)}`
-  ];
-  if (info.lastCommitTimestamp !== null) {
-    details.push(`last: ${formatRelativeAge(info.lastCommitTimestamp)}`);
-  }
-  return `${info.path} (${details.join(", ")})`;
-}
 function formatUpstreamState(upstream) {
   if (upstream.kind === "detached") {
     return "n/a";
@@ -14239,6 +14174,881 @@ function hasStderr(error) {
   return error instanceof Error && "stderr" in error && typeof error.stderr === "string";
 }
 
+// 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(),
+    readWorktreeInfos(sources.map((source) => source.worktree))
+  ]);
+  const historyByPath = new Map(history.map((entry) => [entry.path, entry]));
+  const entries = sources.map(
+    (source, index) => buildWorktreePromptEntry(
+      source,
+      infos[index],
+      historyByPath.get(source.worktree.path)?.timestamp ?? null,
+      Date.now()
+    )
+  );
+  return entries.sort(comparePromptEntries).map(
+    ({ lastActivityTimestamp: _lastActivityTimestamp, ...entry }) => entry
+  );
+}
+function resolveWorktreeQuery(sources, query) {
+  const normalizedQuery = normalizeQuery(query);
+  if (normalizedQuery === null) return null;
+  const matches = findWorktreePromptSourceMatches(sources, normalizedQuery);
+  if (isAmbiguousRepoOnlyQuery(matches, normalizedQuery)) return null;
+  return matches[0]?.source ?? null;
+}
+function findWorktreePromptSourceMatches(sources, normalizedQuery) {
+  return sources.flatMap((source) => {
+    const matchScore = scoreWorktreeMatch(
+      {
+        ...source.worktree,
+        repoName: source.repoName
+      },
+      normalizedQuery
+    );
+    return matchScore === null ? [] : [{ matchScore, source }];
+  }).sort(compareQueryMatches);
+}
+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, io = {}) {
+  const choice = await runSearchablePrompt({
+    entries: worktrees.map(buildSearchableWorktreeEntry),
+    input: io.input,
+    message,
+    multiple: false,
+    output: io.output
+  });
+  return typeof choice === "string" ? choice : null;
+}
+async function promptForMultipleWorktrees(message, worktrees, io = {}) {
+  const choice = await runSearchablePrompt({
+    entries: buildGroupedSearchableEntries(worktrees),
+    input: io.input,
+    message,
+    multiple: true,
+    output: io.output
+  });
+  return Array.isArray(choice) ? choice : null;
+}
+function compareQueryMatches(a, b3) {
+  if (a.matchScore !== b3.matchScore) {
+    return b3.matchScore - a.matchScore;
+  }
+  if (a.source.worktree.isCurrent && !b3.source.worktree.isCurrent) return -1;
+  if (!a.source.worktree.isCurrent && b3.source.worktree.isCurrent) return 1;
+  return a.source.repoName.localeCompare(b3.source.repoName) || (a.source.worktree.branch ?? "").localeCompare(
+    b3.source.worktree.branch ?? ""
+  ) || a.source.worktree.path.localeCompare(b3.source.worktree.path);
+}
+function groupPromptEntries(worktrees) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const worktree of worktrees) {
+    const group = worktree.group === "recent" ? "Recent worktrees" : "Other worktrees";
+    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 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;
+  const lastActivityTimestamp = lastUsedTimestamp ?? lastWorkedTimestamp;
+  const lastActivityType = lastUsedTimestamp !== null ? "used" : lastWorkedTimestamp !== null ? "worked" : null;
+  const branch = source.worktree.branch ?? "(detached)";
+  const badges = buildStatusBadges(info);
+  const recency = formatPromptRecency(
+    lastActivityTimestamp,
+    lastActivityType,
+    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),
+    metadata,
+    path9
+  ].filter((part) => part !== null && part.length > 0).join(" \xB7 ");
+  return {
+    ...source.worktree,
+    group: lastUsedTimestamp !== null ? "recent" : "other",
+    label,
+    lastActivityTimestamp,
+    metadata,
+    repoName: source.repoName
+  };
+}
+function buildStatusBadges(info) {
+  const badges = [];
+  if (info.isCurrent) {
+    badges.push("current");
+  }
+  if (info.branch === null) {
+    badges.push("detached");
+  }
+  if (info.status === "dirty") {
+    badges.push("dirty");
+  }
+  if (info.upstream.kind === "stale") {
+    badges.push("stale", "gone");
+  }
+  if (isUpToDate(info.upstream)) {
+    badges.push("up to date");
+  }
+  return badges;
+}
+function isUpToDate(upstream) {
+  return upstream.kind === "tracked" && upstream.ahead === 0 && upstream.behind === 0;
+}
+function formatPromptRecency(timestamp, type, now) {
+  if (timestamp === null || type === null) {
+    return "last used: never";
+  }
+  const label = type === "used" ? "last used" : "last worked";
+  return `${label}: ${formatPickerAge(timestamp, now)}`;
+}
+function formatPickerAge(timestamp, now) {
+  const ageSeconds = Math.max(0, Math.floor((now - timestamp) / 1e3));
+  if (ageSeconds < 60) {
+    return "now";
+  }
+  if (ageSeconds < 60 * 60) {
+    return `${Math.floor(ageSeconds / 60)}m ago`;
+  }
+  if (ageSeconds < 24 * 60 * 60) {
+    return `${Math.floor(ageSeconds / (60 * 60))}h ago`;
+  }
+  if (isYesterday(timestamp, now)) {
+    return "yesterday";
+  }
+  return new Intl.DateTimeFormat("en-US", {
+    day: "numeric",
+    month: "short"
+  }).format(new Date(timestamp));
+}
+function isYesterday(timestamp, now) {
+  const date = new Date(timestamp);
+  const yesterday = new Date(now);
+  yesterday.setDate(yesterday.getDate() - 1);
+  return date.getFullYear() === yesterday.getFullYear() && date.getMonth() === yesterday.getMonth() && date.getDate() === yesterday.getDate();
+}
+function buildSearchText(repoName, worktree) {
+  return [
+    repoName,
+    worktree.branch ?? "detached",
+    worktree.path,
+    `${repoName}/${worktree.branch ?? "detached"}`
+  ].join(" ").toLowerCase();
+}
+function normalizeQuery(query) {
+  const normalized = query?.trim().toLowerCase();
+  return normalized && normalized.length > 0 ? normalized : null;
+}
+function comparePromptEntries(a, b3) {
+  if (a.isCurrent && !b3.isCurrent) return -1;
+  if (!a.isCurrent && b3.isCurrent) return 1;
+  if (a.group !== b3.group) {
+    return groupRank(a.group) - groupRank(b3.group);
+  }
+  const aRecent = a.lastActivityTimestamp ?? 0;
+  const bRecent = b3.lastActivityTimestamp ?? 0;
+  if (aRecent !== bRecent) {
+    return bRecent - aRecent;
+  }
+  return a.repoName.localeCompare(b3.repoName) || (a.branch ?? "").localeCompare(b3.branch ?? "") || a.path.localeCompare(b3.path);
+}
+function groupRank(group) {
+  return group === "recent" ? 0 : 1;
+}
+function scoreWorktreeMatch(entry, query) {
+  const branch = entry.branch ?? "detached";
+  const exactCandidates = [
+    branch,
+    entry.path,
+    `${entry.repoName}/${branch}`
+  ].map((candidate) => candidate.toLowerCase());
+  if (exactCandidates.includes(query)) {
+    return 1e3;
+  }
+  return buildSearchText(entry.repoName, entry).includes(query) ? 1 : null;
+}
+function middleEllipsize(value, maxLength) {
+  if (terminalWidth(value) <= maxLength) {
+    return value;
+  }
+  if (maxLength <= 1) {
+    return "\u2026";
+  }
+  const keep = maxLength - 1;
+  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
 async function defaultConfirmForceRemoveWorktree(worktreePath) {
   const choice = await ye({
@@ -14299,7 +15109,14 @@ 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(cleanupCandidates);
+    const selections = shouldSelectAll ? cleanupCandidates.map((w2) => w2.path) : await promptForWorktrees(
+      await buildWorktreePromptEntries(
+        cleanupCandidates.map((worktree) => ({
+          repoName: repository.repoName,
+          worktree
+        }))
+      )
+    );
     if (!selections || selections.length === 0) {
       options.stderr("Aborted\n");
       return 1;
@@ -14534,19 +15351,7 @@ function toMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 async function defaultPromptForWorktrees(worktrees) {
-  const infos = await readWorktreeInfos(worktrees);
-  const choice = await fe({
-    message: "Choose worktrees to clean",
-    options: worktrees.map((worktree, i) => {
-      return {
-        hint: formatWorktreeHint(infos[i]),
-        label: worktree.branch ?? "(detached)",
-        value: worktree.path
-      };
-    }),
-    required: true
-  });
-  return pD(choice) ? null : choice;
+  return promptForMultipleWorktrees("Choose worktrees to clean", worktrees);
 }
 async function defaultConfirmRemoval(worktrees) {
   const branchCount = worktrees.filter(
@@ -15007,8 +15812,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)}
 `);
 }
 
@@ -15567,7 +16372,7 @@ function createNewCommand(dependencies = {}) {
       } else {
         const choice = await prompt(worktreePath);
         if (choice === "reuse") {
-          appendHistory(worktreePath, worktreeName).catch(() => void 0);
+          await recordWorktreeUsage(worktreePath, worktreeName);
           await writeOutput(worktreePath, options.stdout);
           return 0;
         }
@@ -15635,7 +16440,7 @@ function createNewCommand(dependencies = {}) {
 `
       );
     } else {
-      await appendHistory(worktreePath, worktreeName);
+      await recordWorktreeUsage(worktreePath, worktreeName);
       await writeOutput(worktreePath, options.stdout);
     }
     if (options.open) {
@@ -15672,7 +16477,32 @@ function generateBranchPlaceholder(random = Math.random) {
     "newton",
     "lovelace",
     "nietzsche",
-    "kafka"
+    "kafka",
+    "sappho",
+    "aristotle",
+    "pythagoras",
+    "artemis",
+    "apollo",
+    "minerva",
+    "persephone",
+    "icarus",
+    "odysseus",
+    "murasaki",
+    "shakespeare",
+    "frida",
+    "davinci",
+    "kepler",
+    "copernicus",
+    "faraday",
+    "noether",
+    "hopper",
+    "boole",
+    "shannon",
+    "gauss",
+    "ramanujan",
+    "austen",
+    "borges",
+    "zeno"
   ];
   const antics = [
     "borrowed-a-bike",
@@ -15689,9 +16519,50 @@ function generateBranchPlaceholder(random = Math.random) {
     "watered-the-plants",
     "washed-the-dishes",
     "folded-the-laundry",
-    "took-a-nap"
+    "took-a-nap",
+    "lost-a-sock",
+    "patched-the-boat",
+    "alphabetized-the-spoons",
+    "argued-with-the-calendar",
+    "misplaced-the-moon",
+    "painted-the-fence",
+    "overcooked-the-rice",
+    "packed-the-snacks",
+    "dropped-the-spoon",
+    "hid-the-remote",
+    "untangled-the-cables",
+    "rebooted-the-kettle",
+    "indexed-the-attic",
+    "forgot-the-password",
+    "sorted-the-buttons",
+    "mopped-the-ceiling",
+    "polished-the-doorknob",
+    "misread-the-map",
+    "reheated-the-tea",
+    "fixed-the-squeak",
+    "labeled-the-drawer",
+    "stacked-the-chairs",
+    "overslept-the-standup",
+    "claimed-the-last-bagel",
+    "debugged-the-toaster"
   ];
-  return `${pickRandom(roots, random)}-${pickRandom(antics, random)}`;
+  const root = pickRandom(roots, random);
+  const antic = pickRandom(antics, random);
+  const suffix = generateBranchPlaceholderSuffix(random);
+  return `${root}-${antic}-${suffix}`;
+}
+function pickRandom(values, random) {
+  const index = Math.floor(random() * values.length);
+  return values[Math.min(index, values.length - 1)];
+}
+function generateBranchPlaceholderSuffix(random) {
+  const characters = "abcdefghijklmnopqrstuvwxyz0123456789";
+  let suffix = "";
+  for (let index = 0; index < 3; index += 1) {
+    const characterIndex = Math.floor(random() * characters.length);
+    suffix += characters[Math.min(characterIndex, characters.length - 1)];
+  }
+  return suffix;
 }
 function applyConfiguredBranchPrefix(branch, branchPrefix) {
   if (typeof branchPrefix !== "string" || branchPrefix.length === 0) {
@@ -15732,10 +16603,6 @@ async function defaultPromptForBranch(placeholder) {
   }
   return choice.trim();
 }
-function pickRandom(values, random) {
-  const index = Math.floor(random() * values.length);
-  return values[Math.min(index, values.length - 1)];
-}
 async function localBranchExists(repoRoot, branchName) {
   try {
     await execFileAsync3(
@@ -15748,8 +16615,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);
@@ -15892,7 +16759,7 @@ async function runWarpNavigate(options) {
     );
     return 0;
   }
-  appendHistory(target.path, target.branch).catch(() => void 0);
+  await recordWorktreeUsage(target.path, target.branch);
   await writeShellOutput(WARP_OUTPUT_FILE_ENV, target.path, options.stdout);
   return 0;
 }
@@ -15975,18 +16842,6 @@ async function canonicalizeRepoPath2(repoPath) {
     return resolve5(repoPath);
   }
 }
-function findByQuery(items, query) {
-  const slashIdx = query.indexOf("/");
-  if (slashIdx !== -1) {
-    const repoQuery = query.slice(0, slashIdx);
-    const branchQuery = query.slice(slashIdx + 1);
-    const match = items.find(
-      (item) => item.repoName === repoQuery && item.worktree.branch === branchQuery
-    );
-    if (match) return match;
-  }
-  return items.find((item) => item.worktree.branch === query) ?? null;
-}
 async function resolveWarpTarget(options) {
   const cmd = options.commandName ?? "gji";
   const emitError4 = (message, hint) => {
@@ -16000,6 +16855,7 @@ async function resolveWarpTarget(options) {
     }
   };
   const registry = await loadRegistry();
+  const currentRoot = await detectRepository(options.cwd).then((repository) => repository.currentRoot).catch(() => null);
   if (registry.length === 0) {
     emitError4(
       "not in a git repository and no repos registered yet.",
@@ -16018,57 +16874,42 @@ async function resolveWarpTarget(options) {
     if (result.status === "rejected") continue;
     const { repoName, worktrees } = result.value;
     for (const worktree of worktrees) {
-      allItems.push({ repoName, worktree });
+      allItems.push({
+        repoName,
+        worktree: {
+          ...worktree,
+          isCurrent: currentRoot !== null && worktree.path === currentRoot
+        }
+      });
     }
   }
   if (allItems.length === 0) {
     emitError4("no accessible worktrees found in any registered repo.");
     return null;
   }
+  const promptSources = allItems.map((item) => ({
+    repoName: item.repoName,
+    worktree: item.worktree
+  }));
   if (options.branch) {
-    const match = findByQuery(allItems, options.branch);
+    const match = resolveWorktreeQuery(promptSources, options.branch);
     if (!match) {
       emitError4(`no worktree found matching: ${options.branch}`);
       return null;
     }
     return { branch: match.worktree.branch, path: match.worktree.path };
   }
-  const path9 = await promptForWarpTarget(allItems);
+  const promptEntries = await buildWorktreePromptEntries(promptSources);
+  const path9 = await promptForWarpTarget(promptEntries);
   if (!path9) {
     options.stderr("Aborted\n");
     return null;
   }
-  const chosen = allItems.find((item) => item.worktree.path === path9);
-  return { branch: chosen?.worktree.branch ?? null, path: path9 };
+  const chosen = promptEntries.find((item) => item.path === path9);
+  return { branch: chosen?.branch ?? null, path: path9 };
 }
 async function promptForWarpTarget(items) {
-  const healthResults = await Promise.allSettled(
-    items.map((item) => readWorktreeHealth(item.worktree.path))
-  );
-  const choice = await ve({
-    message: "Warp to a worktree",
-    options: items.map((item, i) => {
-      const health = healthResults[i].status === "fulfilled" ? healthResults[i].value : null;
-      const upstream = health ? formatHint(item.worktree.branch, health) : null;
-      const label = `${item.repoName} \u203A ${item.worktree.branch ?? "(detached)"}`;
-      const pathHint = item.worktree.isCurrent ? `${item.worktree.path} (current)` : item.worktree.path;
-      const hint = upstream ? `${upstream} \xB7 ${pathHint}` : pathHint;
-      return { hint, label, value: item.worktree.path };
-    })
-  });
-  if (pD(choice)) {
-    return null;
-  }
-  return choice;
-}
-function formatHint(branch, health) {
-  if (branch === null) return null;
-  if (!health.hasUpstream) return "no upstream";
-  if (health.upstreamGone) return "upstream gone";
-  if (health.ahead === 0 && health.behind === 0) return "up to date";
-  if (health.ahead === 0) return `behind ${health.behind}`;
-  if (health.behind === 0) return `ahead ${health.ahead}`;
-  return `ahead ${health.ahead}, behind ${health.behind}`;
+  return promptForSingleWorktree("Warp to a worktree", items);
 }
 
 // src/go.ts
@@ -16095,7 +16936,7 @@ function createGoCommand(dependencies = {}) {
         commandName: "gji go"
       });
       if (!target) return 1;
-      appendHistory(target.path, target.branch).catch(() => void 0);
+      await recordWorktreeUsage(target.path, target.branch);
       await writeShellOutput(GO_OUTPUT_FILE_ENV, target.path, options.stdout);
       return 0;
     }
@@ -16105,8 +16946,14 @@ function createGoCommand(dependencies = {}) {
       );
       return 1;
     }
-    const prompted = options.branch ? null : await prompt(sortByCurrentFirst(worktrees));
-    const resolvedPath = options.branch ? worktrees.find((entry) => entry.branch === options.branch)?.path : prompted ?? void 0;
+    const promptSources = worktrees.map((worktree) => ({
+      repoName: repository.repoName,
+      worktree
+    }));
+    const promptEntries = options.branch ? [] : await buildWorktreePromptEntries(promptSources);
+    const queried = options.branch ? resolveWorktreeQuery(promptSources, options.branch) : null;
+    const prompted = options.branch ? null : await prompt(promptEntries);
+    const resolvedPath = options.branch ? queried?.worktree.path : prompted ?? void 0;
     if (!resolvedPath) {
       if (options.branch) {
         options.stderr(`No worktree found for branch: ${options.branch}
@@ -16135,44 +16982,14 @@ function createGoCommand(dependencies = {}) {
       },
       options.stderr
     );
-    appendHistory(resolvedPath, chosenWorktree?.branch ?? null).catch(
-      () => void 0
-    );
+    await recordWorktreeUsage(resolvedPath, chosenWorktree?.branch ?? null);
     await writeShellOutput(GO_OUTPUT_FILE_ENV, resolvedPath, options.stdout);
     return 0;
   };
 }
 var runGoCommand = createGoCommand();
 async function promptForWorktree(worktrees) {
-  const healthResults = await Promise.allSettled(
-    worktrees.map((w2) => readWorktreeHealth(w2.path))
-  );
-  const choice = await ve({
-    message: "Choose a worktree",
-    options: worktrees.map((worktree, i) => {
-      const health = healthResults[i].status === "fulfilled" ? healthResults[i].value : null;
-      const pathHint = worktree.isCurrent ? `${worktree.path} (current)` : worktree.path;
-      const upstream = health ? formatUpstreamHint(worktree.branch, health) : null;
-      return {
-        value: worktree.path,
-        label: worktree.branch ?? "(detached)",
-        hint: upstream ? `${upstream} \xB7 ${pathHint}` : pathHint
-      };
-    })
-  });
-  if (pD(choice)) {
-    return null;
-  }
-  return choice;
-}
-function formatUpstreamHint(branch, health) {
-  if (branch === null) return null;
-  if (!health.hasUpstream) return "no upstream";
-  if (health.upstreamGone) return "upstream gone";
-  if (health.ahead === 0 && health.behind === 0) return "up to date";
-  if (health.ahead === 0) return `behind ${health.behind}`;
-  if (health.behind === 0) return `ahead ${health.ahead}`;
-  return `ahead ${health.ahead}, behind ${health.behind}`;
+  return promptForSingleWorktree("Choose a worktree", worktrees);
 }
 
 // src/history-command.ts
@@ -16623,27 +17440,43 @@ function createOpenCommand(dependencies = {}) {
       detectRepository(options.cwd)
     ]);
     let targetPath;
+    let targetWorktree;
     if (options.branch) {
-      const entry = worktrees.find((w2) => w2.branch === options.branch);
-      if (!entry) {
+      const match = resolveWorktreeQuery(
+        worktrees.map((worktree) => ({
+          repoName: repository.repoName,
+          worktree
+        })),
+        options.branch
+      );
+      if (!match) {
         options.stderr(
-          `gji open: no worktree found for branch: ${options.branch}
+          `gji open: no worktree found matching: ${options.branch}
 `
         );
         options.stderr(`Hint: Use 'gji ls' to see available worktrees
 `);
         return 1;
       }
-      targetPath = entry.path;
+      targetPath = match.worktree.path;
+      targetWorktree = match.worktree;
     } else if (isHeadless()) {
-      targetPath = worktrees.find((w2) => w2.isCurrent)?.path ?? options.cwd;
+      targetWorktree = worktrees.find((w2) => w2.isCurrent);
+      targetPath = targetWorktree?.path ?? options.cwd;
     } else {
-      const chosen = await promptForWorktree2(sortByCurrentFirst(worktrees));
+      const entries = await buildWorktreePromptEntries(
+        worktrees.map((worktree) => ({
+          repoName: repository.repoName,
+          worktree
+        }))
+      );
+      const chosen = await promptForWorktree2(entries);
       if (!chosen) {
         options.stderr("Aborted\n");
         return 1;
       }
       targetPath = chosen;
+      targetWorktree = worktrees.find((w2) => w2.path === chosen);
     }
     const config = await loadEffectiveConfig(
       repository.repoRoot,
@@ -16708,6 +17541,7 @@ function createOpenCommand(dependencies = {}) {
       return 1;
     }
     const displayName = editorDef?.name ?? editorCli;
+    await recordWorktreeUsage(targetPath, targetWorktree?.branch ?? null);
     options.stdout(`Opened ${targetPath} in ${displayName}
 `);
     return 0;
@@ -16732,16 +17566,7 @@ async function isCommandAvailable(command) {
   }
 }
 async function defaultPromptForWorktree(worktrees) {
-  const choice = await ve({
-    message: "Choose a worktree to open",
-    options: worktrees.map((w2) => ({
-      value: w2.path,
-      label: w2.branch ?? "(detached)",
-      hint: w2.isCurrent ? `${w2.path} (current)` : w2.path
-    }))
-  });
-  if (pD(choice)) return null;
-  return choice;
+  return promptForSingleWorktree("Choose a worktree to open", worktrees);
 }
 async function defaultPromptForEditor(editors) {
   const choice = await ve({
@@ -16835,7 +17660,7 @@ function createPrCommand(dependencies = {}) {
       }
       const choice = await prompt(worktreePath);
       if (choice === "reuse") {
-        appendHistory(worktreePath, branchName).catch(() => void 0);
+        await recordWorktreeUsage(worktreePath, branchName);
         await writeOutput2(worktreePath, options.stdout);
         return 0;
       }
@@ -16926,7 +17751,7 @@ function createPrCommand(dependencies = {}) {
 `
       );
     } else {
-      await appendHistory(worktreePath, branchName);
+      await recordWorktreeUsage(worktreePath, branchName);
       await writeOutput2(worktreePath, options.stdout);
     }
     return 0;
@@ -16994,8 +17819,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
@@ -17026,7 +17851,14 @@ function createRemoveCommand(dependencies = {}) {
       }
       return 1;
     }
-    const selection = options.branch ?? await promptForWorktree2(sortByCurrentFirst(linkedWorktrees));
+    const selection = options.branch ?? await promptForWorktree2(
+      await buildWorktreePromptEntries(
+        linkedWorktrees.map((worktree2) => ({
+          repoName: repository.repoName,
+          worktree: worktree2
+        }))
+      )
+    );
     if (!selection) {
       options.stderr("Aborted\n");
       return 1;
@@ -17140,15 +17972,7 @@ function createRemoveCommand(dependencies = {}) {
 }
 var runRemoveCommand = createRemoveCommand();
 async function defaultPromptForWorktree2(worktrees) {
-  const choice = await ve({
-    message: "Choose a worktree to finish",
-    options: worktrees.map((worktree) => ({
-      hint: worktree.isCurrent ? `${worktree.path} (current)` : worktree.path,
-      label: worktree.branch ?? "(detached)",
-      value: worktree.path
-    }))
-  });
-  return pD(choice) ? null : choice;
+  return promptForSingleWorktree("Choose a worktree to finish", worktrees);
 }
 async function defaultConfirmRemoval2(worktree) {
   const choice = await ye({
@@ -17159,8 +17983,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) {
@@ -17533,17 +18357,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) {
@@ -17633,11 +18457,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) {
@@ -17645,7 +18469,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) {