@solaqua/gji 0.7.1 → 0.7.2

package/dist/gji-bundle.mjs

@@ -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";
 }
@@ -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) {
@@ -13821,43 +13820,63 @@ 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;
-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 {
+var _D = 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) {
+    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":
+        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":
+        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;
       }
     });
   }
-  get _value() {
-    return this.options[this.cursor].value;
+  getGroupItems(u2) {
+    return this.options.filter((t) => t.group === u2);
   }
-  toggleAll() {
-    const u2 = this.value.length === this.options.length;
-    this.value = u2 ? [] : this.options.map((t) => t.value);
+  isGroupSelected(u2) {
+    return this.getGroupItems(u2).every((t) => this.value.includes(t.value));
   }
   toggleValue() {
-    const u2 = this.value.includes(this._value);
-    this.value = u2 ? this.value.filter((t) => t !== this._value) : [...this.value, this._value];
+    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;
 var J = (e2, u2, t) => (PD(e2, typeof u2 != "symbol" ? u2 + "" : u2, t), t);
@@ -13920,14 +13939,14 @@ var d2 = u("\u2514", "\u2014");
 var k2 = u("\u25CF", ">");
 var P2 = u("\u25CB", " ");
 var A2 = u("\u25FB", "[\u2022]");
-var T = u("\u25FC", "[+]");
+var T2 = 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 q = u("\u25CF", "\u2022");
+var q2 = u("\u25CF", "\u2022");
 var D = u("\u25C6", "*");
 var U = u("\u25B2", "!");
 var K2 = u("\u25A0", "x");
@@ -14026,40 +14045,54 @@ ${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)}`;
+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 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.
+  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 r2 = `${import_picocolors2.default.gray(o)}
+    const i = `${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")}`;
+        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) => n(c, "cancelled")).join(import_picocolors2.default.dim(", "));
-        return `${r2}${import_picocolors2.default.gray(o)}  ${s.trim() ? `${s}
+        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 `${r2 + import_picocolors2.default.yellow(o)}  ${G2({ options: this.options, cursor: this.cursor, maxItems: t.maxItems, style: i }).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 `${r2}${import_picocolors2.default.cyan(o)}  ${G2({ options: this.options, cursor: this.cursor, maxItems: t.maxItems, style: i }).join(`
+        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)}
 `;
@@ -14084,8 +14117,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 +14183,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 +14283,225 @@ function hasStderr(error) {
   return error instanceof Error && "stderr" in error && typeof error.stderr === "string";
 }
 
+// src/worktree-picker.ts
+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) {
+  const choice = await ve({
+    message,
+    options: worktrees.map((worktree) => ({
+      label: worktree.label,
+      value: worktree.path
+    })),
+    maxItems: 12
+  });
+  return pD(choice) ? null : choice;
+}
+async function promptForMultipleWorktrees(message, worktrees) {
+  const choice = await be({
+    message,
+    options: groupPromptEntries(worktrees),
+    required: true,
+    selectableGroups: false
+  });
+  return pD(choice) ? null : choice;
+}
+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 = {};
+  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
+    });
+  }
+  return groups;
+}
+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 path9 = middleEllipsize(source.worktree.path, 76);
+  const label = [
+    middleEllipsize(source.repoName, 22),
+    middleEllipsize(branch, 34),
+    status,
+    recency,
+    path9
+  ].filter((part) => part !== null && part.length > 0).join(" \xB7 ");
+  return {
+    ...source.worktree,
+    group: lastUsedTimestamp !== null ? "recent" : "other",
+    label,
+    lastActivityTimestamp,
+    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 (value.length <= 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)}`;
+}
+
 // src/worktree-prompts.ts
 async function defaultConfirmForceRemoveWorktree(worktreePath) {
   const choice = await ye({
@@ -14299,7 +14562,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 +14804,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(
@@ -15567,7 +15825,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 +15893,7 @@ function createNewCommand(dependencies = {}) {
 `
       );
     } else {
-      await appendHistory(worktreePath, worktreeName);
+      await recordWorktreeUsage(worktreePath, worktreeName);
       await writeOutput(worktreePath, options.stdout);
     }
     if (options.open) {
@@ -15672,7 +15930,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 +15972,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 +16056,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(
@@ -15892,7 +16212,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 +16295,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 +16308,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 +16327,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 +16389,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 +16399,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 +16435,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 +16893,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 +16994,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 +17019,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 +17113,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 +17204,7 @@ function createPrCommand(dependencies = {}) {
 `
       );
     } else {
-      await appendHistory(worktreePath, branchName);
+      await recordWorktreeUsage(worktreePath, branchName);
       await writeOutput2(worktreePath, options.stdout);
     }
     return 0;
@@ -17026,7 +17304,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 +17425,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({