@solaqua/gji 0.7.0 → 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";
 }
@@ -13176,9 +13182,13 @@ function extractHooks(config) {
   }
   const hooks = raw;
   return {
-    afterCreate: parseHookCommand(hooks.afterCreate),
-    afterEnter: parseHookCommand(hooks.afterEnter),
-    beforeRemove: parseHookCommand(hooks.beforeRemove)
+    "after-create": parseHookCommand(
+      hooks["after-create"] ?? hooks.afterCreate
+    ),
+    "after-enter": parseHookCommand(hooks["after-enter"] ?? hooks.afterEnter),
+    "before-remove": parseHookCommand(
+      hooks["before-remove"] ?? hooks.beforeRemove
+    )
   };
 }
 function parseHookCommand(value) {
@@ -13377,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) {
@@ -13450,7 +13453,7 @@ async function runBackCommand(options) {
     );
     const hooks = extractHooks(config);
     await runHook(
-      hooks.afterEnter,
+      hooks["after-enter"],
       target.path,
       {
         branch: target.branch ?? void 0,
@@ -13817,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);
@@ -13916,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");
@@ -14022,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)}
 `;
@@ -14080,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([
@@ -14125,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";
@@ -14235,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({
@@ -14295,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;
@@ -14530,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(
@@ -14623,14 +14885,14 @@ var TOP_LEVEL_COMMANDS = [
   },
   { name: "rm", description: "alias of remove" },
   {
-    name: "trigger-hook",
+    name: "run-hook",
     description: "run a named hook in the current worktree"
   },
   { name: "warp", description: "jump to any worktree across all known repos" },
   { name: "config", description: "manage global config defaults" }
 ];
 var SHELL_NAMES = ["bash", "fish", "zsh"];
-var HOOK_NAMES = ["afterCreate", "afterEnter", "beforeRemove"];
+var HOOK_NAMES = ["after-create", "after-enter", "before-remove"];
 var CONFIG_KEYS = Array.from(KNOWN_GLOBAL_CONFIG_KEYS);
 function renderShellCompletion(shell) {
   switch (shell) {
@@ -14714,7 +14976,7 @@ _gji_completion() {
     remove|rm)
       COMPREPLY=( $(compgen -W "$(__gji_worktree_branches) -f --force --dry-run --json --help" -- "$cur") )
       ;;
-    trigger-hook)
+    run-hook)
       COMPREPLY=( $(compgen -W "${hooks} --help" -- "$cur") )
       ;;
     warp)
@@ -14752,7 +15014,7 @@ function renderFishCompletion() {
     (shell) => `complete -c gji -n '__fish_seen_subcommand_from init' -a '${shell}' -d 'shell'`
   ).join("\n");
   const hookLines = HOOK_NAMES.map(
-    (hook) => `complete -c gji -n '__fish_seen_subcommand_from trigger-hook' -a '${hook}' -d 'hook'`
+    (hook) => `complete -c gji -n '__fish_seen_subcommand_from run-hook' -a '${hook}' -d 'hook'`
   ).join("\n");
   const configKeyLines = CONFIG_KEYS.map(
     (key) => `complete -c gji -n '__gji_should_complete_config_key' -a '${key}' -d 'config key'`
@@ -14917,7 +15179,7 @@ case "\${words[2]}" in
   remove|rm)
     _arguments '(-f --force)'{-f,--force}'[bypass prompts, force-remove a dirty worktree, and force-delete an unmerged branch]' '--dry-run[show what would be deleted without removing anything]' '--json[emit JSON on success or error instead of human-readable output]' '2:branch:->worktrees'
     ;;
-  trigger-hook)
+  run-hook)
     _arguments "2:hook:(${hooks})"
     ;;
   warp)
@@ -15303,8 +15565,7 @@ async function maybeRunInstallPrompt(worktreePath, repoRoot, config, stderr, dep
   if (isHeadless() || nonInteractive) {
     return;
   }
-  const hooks = isPlainObject2(config.hooks) ? config.hooks : null;
-  if (isConfiguredHookCommand(hooks?.afterCreate)) {
+  if (extractHooks(config)["after-create"]) {
     return;
   }
   if (config.skipInstallPrompt === true) {
@@ -15337,17 +15598,28 @@ async function maybeRunInstallPrompt(worktreePath, repoRoot, config, stderr, dep
   if (choice === "always") {
     try {
       if (saveGlobal) {
-        const existingHooks = await loadExistingGlobalRepoHooks(repoRoot);
+        const existingRaw = await loadExistingGlobalRepoHooks(repoRoot);
+        const existing = extractHooks({ hooks: existingRaw });
         await writeGlobalKey(repoRoot, "hooks", {
-          ...existingHooks,
-          afterCreate: pm.installCommand
+          ...existing["after-enter"] !== void 0 && {
+            "after-enter": existing["after-enter"]
+          },
+          ...existing["before-remove"] !== void 0 && {
+            "before-remove": existing["before-remove"]
+          },
+          "after-create": pm.installCommand
         });
       } else {
         const { config: localConfig } = await loadConfig(repoRoot);
-        const existingLocalHooks = isPlainObject2(localConfig.hooks) ? localConfig.hooks : {};
+        const existing = extractHooks(localConfig);
         await writeKey(repoRoot, "hooks", {
-          ...existingLocalHooks,
-          afterCreate: pm.installCommand
+          ...existing["after-enter"] !== void 0 && {
+            "after-enter": existing["after-enter"]
+          },
+          ...existing["before-remove"] !== void 0 && {
+            "before-remove": existing["before-remove"]
+          },
+          "after-create": pm.installCommand
         });
       }
     } catch (error) {
@@ -15412,7 +15684,7 @@ async function defaultPromptForInstallChoice(pm) {
     options: [
       { value: "yes", label: "Yes", hint: "run once" },
       { value: "no", label: "No", hint: "skip this time" },
-      { value: "always", label: "Always", hint: "save as afterCreate hook" },
+      { value: "always", label: "Always", hint: "save as after-create hook" },
       {
         value: "never",
         label: "Never",
@@ -15428,10 +15700,6 @@ async function defaultPromptForInstallChoice(pm) {
 function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isConfiguredHookCommand(value) {
-  if (typeof value === "string") return value.length > 0;
-  return Array.isArray(value) && value.length > 0 && value[0] !== "" && value.every((item) => typeof item === "string");
-}
 
 // src/new.ts
 var execFileAsync3 = promisify4(execFile3);
@@ -15549,7 +15817,7 @@ function createNewCommand(dependencies = {}) {
 `
           );
           options.stderr(
-            `Hint: Use 'gji trigger-hook afterCreate' inside the worktree to re-run setup hooks
+            `Hint: Use 'gji run-hook after-create' inside the worktree to re-run setup hooks
 `
           );
         }
@@ -15557,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;
         }
@@ -15610,7 +15878,7 @@ function createNewCommand(dependencies = {}) {
     );
     const hooks = extractHooks(config);
     await runHook(
-      hooks.afterCreate,
+      hooks["after-create"],
       worktreePath,
       {
         branch: worktreeName,
@@ -15625,7 +15893,7 @@ function createNewCommand(dependencies = {}) {
 `
       );
     } else {
-      await appendHistory(worktreePath, worktreeName);
+      await recordWorktreeUsage(worktreePath, worktreeName);
       await writeOutput(worktreePath, options.stdout);
     }
     if (options.open) {
@@ -15662,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",
@@ -15679,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) {
@@ -15722,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(
@@ -15882,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;
 }
@@ -15965,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) => {
@@ -15990,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.",
@@ -16008,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
@@ -16085,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;
     }
@@ -16095,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}
@@ -16116,7 +16426,7 @@ function createGoCommand(dependencies = {}) {
     );
     const hooks = extractHooks(config);
     await runHook(
-      hooks.afterEnter,
+      hooks["after-enter"],
       resolvedPath,
       {
         branch: chosenWorktree?.branch ?? void 0,
@@ -16125,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
@@ -16329,10 +16609,12 @@ async function saveWizardConfig(result, cwd, home) {
   if (result.branchPrefix) values.branchPrefix = result.branchPrefix;
   if (result.worktreePath) values.worktreePath = result.worktreePath;
   const hooks = {};
-  if (result.hooks?.afterCreate) hooks.afterCreate = result.hooks.afterCreate;
-  if (result.hooks?.afterEnter) hooks.afterEnter = result.hooks.afterEnter;
-  if (result.hooks?.beforeRemove)
-    hooks.beforeRemove = result.hooks.beforeRemove;
+  if (result.hooks?.["after-create"])
+    hooks["after-create"] = result.hooks["after-create"];
+  if (result.hooks?.["after-enter"])
+    hooks["after-enter"] = result.hooks["after-enter"];
+  if (result.hooks?.["before-remove"])
+    hooks["before-remove"] = result.hooks["before-remove"];
   if (Object.keys(hooks).length > 0) values.hooks = hooks;
   if (Object.keys(values).length === 0) return;
   if (result.installSaveTarget === "local") {
@@ -16463,7 +16745,7 @@ async function defaultPromptForSetup() {
     return null;
   }
   const afterCreate = await he({
-    message: "afterCreate hook \u2014 run after creating a worktree?",
+    message: "after-create hook \u2014 run after creating a worktree?",
     placeholder: "e.g. pnpm install \u2014 leave blank to skip"
   });
   if (pD(afterCreate)) {
@@ -16471,7 +16753,7 @@ async function defaultPromptForSetup() {
     return null;
   }
   const afterEnter = await he({
-    message: "afterEnter hook \u2014 run after entering a worktree?",
+    message: "after-enter hook \u2014 run after entering a worktree?",
     placeholder: "e.g. nvm use \u2014 leave blank to skip"
   });
   if (pD(afterEnter)) {
@@ -16479,7 +16761,7 @@ async function defaultPromptForSetup() {
     return null;
   }
   const beforeRemove = await he({
-    message: "beforeRemove hook \u2014 run before removing a worktree?",
+    message: "before-remove hook \u2014 run before removing a worktree?",
     placeholder: "leave blank to skip"
   });
   if (pD(beforeRemove)) {
@@ -16488,9 +16770,9 @@ async function defaultPromptForSetup() {
   }
   Se("Setup complete!");
   const hooks = {};
-  if (afterCreate) hooks.afterCreate = afterCreate;
-  if (afterEnter) hooks.afterEnter = afterEnter;
-  if (beforeRemove) hooks.beforeRemove = beforeRemove;
+  if (afterCreate) hooks["after-create"] = afterCreate;
+  if (afterEnter) hooks["after-enter"] = afterEnter;
+  if (beforeRemove) hooks["before-remove"] = beforeRemove;
   return {
     branchPrefix: branchPrefix || void 0,
     hooks: Object.keys(hooks).length > 0 ? hooks : void 0,
@@ -16611,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,
@@ -16696,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;
@@ -16720,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({
@@ -16823,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;
       }
@@ -16899,7 +17189,7 @@ function createPrCommand(dependencies = {}) {
     );
     const hooks = extractHooks(config);
     await runHook(
-      hooks.afterCreate,
+      hooks["after-create"],
       worktreePath,
       {
         branch: branchName,
@@ -16914,7 +17204,7 @@ function createPrCommand(dependencies = {}) {
 `
       );
     } else {
-      await appendHistory(worktreePath, branchName);
+      await recordWorktreeUsage(worktreePath, branchName);
       await writeOutput2(worktreePath, options.stdout);
     }
     return 0;
@@ -17014,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;
@@ -17062,7 +17359,7 @@ function createRemoveCommand(dependencies = {}) {
     );
     const hooks = extractHooks(config);
     await runHook(
-      hooks.beforeRemove,
+      hooks["before-remove"],
       worktree.path,
       {
         branch: worktree.branch ?? void 0,
@@ -17128,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({
@@ -17180,6 +17469,54 @@ async function runRootCommand(options) {
   return 0;
 }
 
+// src/run-hook.ts
+var VALID_HOOKS = [
+  "after-create",
+  "after-enter",
+  "before-remove"
+];
+var CAMEL_ALIASES = {
+  afterCreate: "after-create",
+  afterEnter: "after-enter",
+  beforeRemove: "before-remove"
+};
+function isValidHook(hook) {
+  return VALID_HOOKS.includes(hook);
+}
+async function runHookCommand(options) {
+  const normalized = CAMEL_ALIASES[options.hook] ?? options.hook;
+  if (!isValidHook(normalized)) {
+    options.stderr(
+      `gji run-hook: unknown hook '${options.hook}'. Valid hooks: ${VALID_HOOKS.join(", ")}
+`
+    );
+    return 1;
+  }
+  const hookName = normalized;
+  const repository = await detectRepository(options.cwd);
+  const config = await loadEffectiveConfig(
+    repository.repoRoot,
+    void 0,
+    options.stderr
+  );
+  const hooks = extractHooks(config);
+  const worktrees = await listWorktrees(options.cwd);
+  const currentWorktree = worktrees.find(
+    (w2) => w2.path === repository.currentRoot
+  );
+  await runHook(
+    hooks[hookName],
+    repository.currentRoot,
+    {
+      branch: currentWorktree?.branch ?? void 0,
+      path: repository.currentRoot,
+      repo: repository.repoName
+    },
+    options.stderr
+  );
+  return 0;
+}
+
 // src/status.ts
 async function runStatusCommand(options) {
   const repository = await detectRepository(options.cwd);
@@ -17552,48 +17889,6 @@ function expandTilde2(value, home) {
   return value;
 }
 
-// src/trigger-hook.ts
-var VALID_HOOKS = [
-  "afterCreate",
-  "afterEnter",
-  "beforeRemove"
-];
-function isValidHook(hook) {
-  return VALID_HOOKS.includes(hook);
-}
-async function runTriggerHookCommand(options) {
-  if (!isValidHook(options.hook)) {
-    options.stderr(
-      `gji trigger-hook: unknown hook '${options.hook}'. Valid hooks: ${VALID_HOOKS.join(", ")}
-`
-    );
-    return 1;
-  }
-  const hookName = options.hook;
-  const repository = await detectRepository(options.cwd);
-  const config = await loadEffectiveConfig(
-    repository.repoRoot,
-    void 0,
-    options.stderr
-  );
-  const hooks = extractHooks(config);
-  const worktrees = await listWorktrees(options.cwd);
-  const currentWorktree = worktrees.find(
-    (w2) => w2.path === repository.currentRoot
-  );
-  await runHook(
-    hooks[hookName],
-    repository.currentRoot,
-    {
-      branch: currentWorktree?.branch ?? void 0,
-      path: repository.currentRoot,
-      repo: repository.repoName
-    },
-    options.stderr
-  );
-  return 0;
-}
-
 // src/cli.ts
 function createProgram() {
   const program2 = new Command();
@@ -17724,9 +18019,9 @@ function registerCommands(program2) {
     "--json",
     "emit JSON on success or error instead of human-readable output"
   ).action(notImplemented("remove"));
-  program2.command("trigger-hook <hook>").description(
-    "run a named hook (afterCreate, afterEnter, beforeRemove) in the current worktree"
-  ).action(notImplemented("trigger-hook"));
+  program2.command("run-hook <hook>").alias("trigger-hook").description(
+    "run a named hook (after-create, after-enter, before-remove) in the current worktree"
+  ).action(notImplemented("run-hook"));
   program2.command("warp [branch]").description("jump to any worktree across all known repos").option("-n, --new [branch]", "create a new worktree in a registered repo").option(
     "--print",
     "print the resolved worktree path without changing directory"
@@ -17984,8 +18279,8 @@ function attachCommandActions(program2, options) {
     }
   };
   program2.commands.find((command) => command.name() === "remove")?.action(runRemovalCommand);
-  program2.commands.find((command) => command.name() === "trigger-hook")?.action(async (hook) => {
-    const exitCode = await runTriggerHookCommand({
+  program2.commands.find((command) => command.name() === "run-hook")?.action(async (hook) => {
+    const exitCode = await runHookCommand({
       cwd: options.cwd,
       hook,
       stderr: options.stderr