@solaqua/gji 0.7.0 → 0.7.2

package/dist/go.d.ts

@@ -1,5 +1,4 @@
-import { type WorktreeHealth } from "./git.js";
-import { type WorktreeEntry } from "./repo.js";
+import { type WorktreePromptEntry } from "./worktree-picker.js";
 export interface GoCommandOptions {
     branch?: string;
     cwd: string;
@@ -8,8 +7,7 @@ export interface GoCommandOptions {
     stdout: (chunk: string) => void;
 }
 export interface GoCommandDependencies {
-    promptForWorktree: (worktrees: WorktreeEntry[]) => Promise<string | null>;
+    promptForWorktree: (worktrees: WorktreePromptEntry[]) => Promise<string | null>;
 }
 export declare function createGoCommand(dependencies?: Partial<GoCommandDependencies>): (options: GoCommandOptions) => Promise<number>;
 export declare const runGoCommand: (options: GoCommandOptions) => Promise<number>;
-export declare function formatUpstreamHint(branch: string | null, health: WorktreeHealth): string | null;

package/dist/go.js

@@ -1,13 +1,12 @@
 import { basename } from "node:path";
-import { isCancel, select } from "@clack/prompts";
 import { loadEffectiveConfig } from "./config.js";
-import { readWorktreeHealth } from "./git.js";
 import { isHeadless } from "./headless.js";
-import { appendHistory } from "./history.js";
+import { recordWorktreeUsage } from "./history.js";
 import { extractHooks, runHook } from "./hooks.js";
-import { detectRepository, listWorktrees, sortByCurrentFirst, } from "./repo.js";
+import { detectRepository, listWorktrees } from "./repo.js";
 import { writeShellOutput } from "./shell-handoff.js";
 import { resolveWarpTarget } from "./warp.js";
+import { buildWorktreePromptEntries, promptForSingleWorktree, resolveWorktreeQuery, } from "./worktree-picker.js";
 const GO_OUTPUT_FILE_ENV = "GJI_GO_OUTPUT_FILE";
 export function createGoCommand(dependencies = {}) {
     const prompt = dependencies.promptForWorktree ?? promptForWorktree;
@@ -32,7 +31,7 @@ export function createGoCommand(dependencies = {}) {
             });
             if (!target)
                 return 1;
-            appendHistory(target.path, target.branch).catch(() => undefined);
+            await recordWorktreeUsage(target.path, target.branch);
             await writeShellOutput(GO_OUTPUT_FILE_ENV, target.path, options.stdout);
             return 0;
         }
@@ -40,11 +39,19 @@ export function createGoCommand(dependencies = {}) {
             options.stderr("gji go: branch argument is required in non-interactive mode (GJI_NO_TUI=1)\n");
             return 1;
         }
-        const prompted = options.branch
-            ? null
-            : await prompt(sortByCurrentFirst(worktrees));
+        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
-            ? worktrees.find((entry) => entry.branch === options.branch)?.path
+            ? queried?.worktree.path
             : (prompted ?? undefined);
         if (!resolvedPath) {
             if (options.branch) {
@@ -59,53 +66,17 @@ export function createGoCommand(dependencies = {}) {
         const chosenWorktree = worktrees.find((w) => w.path === resolvedPath);
         const config = await loadEffectiveConfig(repository.repoRoot, undefined, options.stderr);
         const hooks = extractHooks(config);
-        await runHook(hooks.afterEnter, resolvedPath, {
+        await runHook(hooks["after-enter"], resolvedPath, {
             branch: chosenWorktree?.branch ?? undefined,
             path: resolvedPath,
             repo: basename(repository.repoRoot),
         }, options.stderr);
-        appendHistory(resolvedPath, chosenWorktree?.branch ?? null).catch(() => undefined);
+        await recordWorktreeUsage(resolvedPath, chosenWorktree?.branch ?? null);
         await writeShellOutput(GO_OUTPUT_FILE_ENV, resolvedPath, options.stdout);
         return 0;
     };
 }
 export const runGoCommand = createGoCommand();
 async function promptForWorktree(worktrees) {
-    const healthResults = await Promise.allSettled(worktrees.map((w) => readWorktreeHealth(w.path)));
-    const choice = await select({
-        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} · ${pathHint}` : pathHint,
-            };
-        }),
-    });
-    if (isCancel(choice)) {
-        return null;
-    }
-    return choice;
-}
-export 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);
 }

package/dist/history.d.ts

@@ -7,3 +7,4 @@ export interface HistoryEntry {
 export declare function HISTORY_FILE_PATH(home?: string): string;
 export declare function loadHistory(home?: string): Promise<HistoryEntry[]>;
 export declare function appendHistory(path: string, branch: string | null, home?: string): Promise<void>;
+export declare function recordWorktreeUsage(path: string, branch: string | null, home?: string): Promise<void>;

package/dist/history.js

@@ -27,15 +27,22 @@ export async function loadHistory(home = homedir()) {
 export async function appendHistory(path, branch, home = homedir()) {
     const historyPath = HISTORY_FILE_PATH(home);
     const existing = await loadHistory(home);
-    // Skip if the most recent entry is the same path (no-op navigation)
-    if (existing.length > 0 && existing[0].path === path) {
-        return;
-    }
     const entry = { branch, path, timestamp: Date.now() };
-    const next = [entry, ...existing].slice(0, MAX_HISTORY_ENTRIES);
+    const next = [
+        entry,
+        ...existing.filter((existingEntry) => existingEntry.path !== path),
+    ].slice(0, MAX_HISTORY_ENTRIES);
     await mkdir(dirname(historyPath), { recursive: true });
     await writeFile(historyPath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
 }
+export async function recordWorktreeUsage(path, branch, home = homedir()) {
+    try {
+        await appendHistory(path, branch, home);
+    }
+    catch {
+        // Usage history is advisory metadata; primary command success should stand.
+    }
+}
 function isHistoryEntry(value) {
     return (typeof value === "object" &&
         value !== null &&

package/dist/hooks.d.ts

@@ -1,8 +1,8 @@
 export type GjiHookCommand = string | string[];
 export interface GjiHooks {
-    afterCreate?: GjiHookCommand;
-    afterEnter?: GjiHookCommand;
-    beforeRemove?: GjiHookCommand;
+    "after-create"?: GjiHookCommand;
+    "after-enter"?: GjiHookCommand;
+    "before-remove"?: GjiHookCommand;
 }
 export interface HookContext {
     branch?: string;

package/dist/hooks.js

@@ -84,9 +84,9 @@ export 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) {

package/dist/init.d.ts

@@ -3,9 +3,9 @@ export type InstallSaveTarget = "local" | "global";
 export interface SetupWizardResult {
     branchPrefix?: string;
     hooks?: {
-        afterCreate?: string;
-        afterEnter?: string;
-        beforeRemove?: string;
+        "after-create"?: string;
+        "after-enter"?: string;
+        "before-remove"?: string;
     };
     installSaveTarget: InstallSaveTarget;
     worktreePath?: string;

package/dist/init.js

@@ -135,12 +135,12 @@ async function saveWizardConfig(result, cwd, home) {
     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)
@@ -283,7 +283,7 @@ async function defaultPromptForSetup() {
         return null;
     }
     const afterCreate = await text({
-        message: "afterCreate hook — run after creating a worktree?",
+        message: "after-create hook — run after creating a worktree?",
         placeholder: "e.g. pnpm install — leave blank to skip",
     });
     if (isCancel(afterCreate)) {
@@ -291,7 +291,7 @@ async function defaultPromptForSetup() {
         return null;
     }
     const afterEnter = await text({
-        message: "afterEnter hook — run after entering a worktree?",
+        message: "after-enter hook — run after entering a worktree?",
         placeholder: "e.g. nvm use — leave blank to skip",
     });
     if (isCancel(afterEnter)) {
@@ -299,7 +299,7 @@ async function defaultPromptForSetup() {
         return null;
     }
     const beforeRemove = await text({
-        message: "beforeRemove hook — run before removing a worktree?",
+        message: "before-remove hook — run before removing a worktree?",
         placeholder: "leave blank to skip",
     });
     if (isCancel(beforeRemove)) {
@@ -309,11 +309,11 @@ async function defaultPromptForSetup() {
     outro("Setup complete!");
     const hooks = {};
     if (afterCreate)
-        hooks.afterCreate = afterCreate;
+        hooks["after-create"] = afterCreate;
     if (afterEnter)
-        hooks.afterEnter = afterEnter;
+        hooks["after-enter"] = afterEnter;
     if (beforeRemove)
-        hooks.beforeRemove = beforeRemove;
+        hooks["before-remove"] = beforeRemove;
     return {
         branchPrefix: branchPrefix || undefined,
         hooks: Object.keys(hooks).length > 0 ? hooks : undefined,

package/dist/install-prompt.js

@@ -2,15 +2,15 @@ import { spawn } from "node:child_process";
 import { isCancel, select } from "@clack/prompts";
 import { loadConfig, loadGlobalConfig, updateGlobalRepoConfigKey, updateLocalConfigKey, } from "./config.js";
 import { isHeadless } from "./headless.js";
+import { extractHooks } from "./hooks.js";
 import { detectPackageManager, } from "./package-manager.js";
 export async function maybeRunInstallPrompt(worktreePath, repoRoot, config, stderr, dependencies = {}, nonInteractive = false) {
     // Skip in non-interactive mode — no prompt can be shown.
     if (isHeadless() || nonInteractive) {
         return;
     }
-    // Skip if afterCreate hook is already configured in effective config.
-    const hooks = isPlainObject(config.hooks) ? config.hooks : null;
-    if (isConfiguredHookCommand(hooks?.afterCreate)) {
+    // Skip if an after-create hook is already configured (accepts both kebab and legacy camelCase).
+    if (extractHooks(config)["after-create"]) {
         return;
     }
     // Skip if user has permanently opted out of install prompts.
@@ -43,21 +43,30 @@ export async function maybeRunInstallPrompt(worktreePath, repoRoot, config, stde
         try {
             if (saveGlobal) {
                 // Deep-merge with any existing per-repo global hooks so other keys are preserved.
-                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"] !== undefined && {
+                        "after-enter": existing["after-enter"],
+                    }),
+                    ...(existing["before-remove"] !== undefined && {
+                        "before-remove": existing["before-remove"],
+                    }),
+                    "after-create": pm.installCommand,
                 });
             }
             else {
-                // Read local config hooks to deep-merge so other hook keys (e.g. afterEnter) are preserved.
+                // Read local config hooks to deep-merge so other hook keys (e.g. after-enter) are preserved.
                 const { config: localConfig } = await loadConfig(repoRoot);
-                const existingLocalHooks = isPlainObject(localConfig.hooks)
-                    ? localConfig.hooks
-                    : {};
+                const existing = extractHooks(localConfig);
                 await writeKey(repoRoot, "hooks", {
-                    ...existingLocalHooks,
-                    afterCreate: pm.installCommand,
+                    ...(existing["after-enter"] !== undefined && {
+                        "after-enter": existing["after-enter"],
+                    }),
+                    ...(existing["before-remove"] !== undefined && {
+                        "before-remove": existing["before-remove"],
+                    }),
+                    "after-create": pm.installCommand,
                 });
             }
         }
@@ -122,7 +131,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",
@@ -138,11 +147,3 @@ async function defaultPromptForInstallChoice(pm) {
 function isPlainObject(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"));
-}

package/dist/new.js

@@ -8,7 +8,7 @@ import { pathExists, promptForPathConflict, } from "./conflict.js";
 import { defaultSpawnEditor, EDITORS } from "./editor.js";
 import { syncFiles } from "./file-sync.js";
 import { isHeadless } from "./headless.js";
-import { appendHistory } from "./history.js";
+import { recordWorktreeUsage } from "./history.js";
 import { extractHooks, runHook } from "./hooks.js";
 import { maybeRunInstallPrompt, } from "./install-prompt.js";
 import { detectRepository, resolveWorktreePath, validateBranchName, } from "./repo.js";
@@ -110,14 +110,14 @@ export function createNewCommand(dependencies = {}) {
                 else {
                     options.stderr(`gji new: ${message} in non-interactive mode (GJI_NO_TUI=1)\n`);
                     options.stderr(`Hint: Use 'gji remove ${worktreeName}' or 'gji clean' to remove the existing worktree\n`);
-                    options.stderr(`Hint: Use 'gji trigger-hook afterCreate' inside the worktree to re-run setup hooks\n`);
+                    options.stderr(`Hint: Use 'gji run-hook after-create' inside the worktree to re-run setup hooks\n`);
                 }
                 return 1;
             }
             else {
                 const choice = await prompt(worktreePath);
                 if (choice === "reuse") {
-                    appendHistory(worktreePath, worktreeName).catch(() => undefined);
+                    await recordWorktreeUsage(worktreePath, worktreeName);
                     await writeOutput(worktreePath, options.stdout);
                     return 0;
                 }
@@ -161,7 +161,7 @@ export function createNewCommand(dependencies = {}) {
         }
         await maybeRunInstallPrompt(worktreePath, repository.repoRoot, config, options.stderr, dependencies, !!options.json);
         const hooks = extractHooks(config);
-        await runHook(hooks.afterCreate, worktreePath, {
+        await runHook(hooks["after-create"], worktreePath, {
             branch: worktreeName,
             path: worktreePath,
             repo: basename(repository.repoRoot),
@@ -170,7 +170,7 @@ export function createNewCommand(dependencies = {}) {
             options.stdout(`${JSON.stringify({ branch: worktreeName, path: worktreePath }, null, 2)}\n`);
         }
         else {
-            await appendHistory(worktreePath, worktreeName);
+            await recordWorktreeUsage(worktreePath, worktreeName);
             await writeOutput(worktreePath, options.stdout);
         }
         if (options.open) {
@@ -203,6 +203,31 @@ export function generateBranchPlaceholder(random = Math.random) {
         "lovelace",
         "nietzsche",
         "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",
@@ -220,8 +245,49 @@ export function generateBranchPlaceholder(random = Math.random) {
         "washed-the-dishes",
         "folded-the-laundry",
         "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) {
@@ -258,10 +324,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 execFileAsync("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`], { cwd: repoRoot });

package/dist/open.d.ts

@@ -1,5 +1,5 @@
 import { type EditorDefinition } from "./editor.js";
-import { type WorktreeEntry } from "./repo.js";
+import { type WorktreePromptEntry } from "./worktree-picker.js";
 export type { EditorDefinition };
 export interface OpenCommandOptions {
     branch?: string;
@@ -13,7 +13,7 @@ export interface OpenCommandOptions {
 export interface OpenCommandDependencies {
     detectEditors: () => Promise<EditorDefinition[]>;
     promptForEditor: (editors: EditorDefinition[]) => Promise<string | null>;
-    promptForWorktree: (worktrees: WorktreeEntry[]) => Promise<string | null>;
+    promptForWorktree: (worktrees: WorktreePromptEntry[]) => Promise<string | null>;
     spawnEditor: (cli: string, args: string[]) => Promise<void>;
 }
 export declare function createOpenCommand(dependencies?: Partial<OpenCommandDependencies>): (options: OpenCommandOptions) => Promise<number>;

package/dist/open.js

@@ -6,7 +6,9 @@ import { isCancel, select } from "@clack/prompts";
 import { loadEffectiveConfig, resolveConfigString, updateGlobalConfigKey, } from "./config.js";
 import { defaultSpawnEditor, EDITORS, } from "./editor.js";
 import { isHeadless } from "./headless.js";
-import { detectRepository, listWorktrees, sortByCurrentFirst, } from "./repo.js";
+import { recordWorktreeUsage } from "./history.js";
+import { detectRepository, listWorktrees } from "./repo.js";
+import { buildWorktreePromptEntries, promptForSingleWorktree, resolveWorktreeQuery, } from "./worktree-picker.js";
 const execFileAsync = promisify(execFile);
 export function createOpenCommand(dependencies = {}) {
     const detectEditors = dependencies.detectEditors ?? detectInstalledEditors;
@@ -20,25 +22,36 @@ export function createOpenCommand(dependencies = {}) {
         ]);
         // Resolve target worktree path.
         let targetPath;
+        let targetWorktree;
         if (options.branch) {
-            const entry = worktrees.find((w) => w.branch === options.branch);
-            if (!entry) {
-                options.stderr(`gji open: no worktree found for branch: ${options.branch}\n`);
+            const match = resolveWorktreeQuery(worktrees.map((worktree) => ({
+                repoName: repository.repoName,
+                worktree,
+            })), options.branch);
+            if (!match) {
+                options.stderr(`gji open: no worktree found matching: ${options.branch}\n`);
                 options.stderr(`Hint: Use 'gji ls' to see available worktrees\n`);
                 return 1;
             }
-            targetPath = entry.path;
+            targetPath = match.worktree.path;
+            targetWorktree = match.worktree;
         }
         else if (isHeadless()) {
-            targetPath = worktrees.find((w) => w.isCurrent)?.path ?? options.cwd;
+            targetWorktree = worktrees.find((w) => w.isCurrent);
+            targetPath = targetWorktree?.path ?? options.cwd;
         }
         else {
-            const chosen = await promptForWorktree(sortByCurrentFirst(worktrees));
+            const entries = await buildWorktreePromptEntries(worktrees.map((worktree) => ({
+                repoName: repository.repoName,
+                worktree,
+            })));
+            const chosen = await promptForWorktree(entries);
             if (!chosen) {
                 options.stderr("Aborted\n");
                 return 1;
             }
             targetPath = chosen;
+            targetWorktree = worktrees.find((w) => w.path === chosen);
         }
         // Resolve which editor to use.
         const config = await loadEffectiveConfig(repository.repoRoot, undefined, options.stderr);
@@ -100,6 +113,7 @@ export function createOpenCommand(dependencies = {}) {
             return 1;
         }
         const displayName = editorDef?.name ?? editorCli;
+        await recordWorktreeUsage(targetPath, targetWorktree?.branch ?? null);
         options.stdout(`Opened ${targetPath} in ${displayName}\n`);
         return 0;
     };
@@ -122,17 +136,7 @@ async function isCommandAvailable(command) {
     }
 }
 async function defaultPromptForWorktree(worktrees) {
-    const choice = await select({
-        message: "Choose a worktree to open",
-        options: worktrees.map((w) => ({
-            value: w.path,
-            label: w.branch ?? "(detached)",
-            hint: w.isCurrent ? `${w.path} (current)` : w.path,
-        })),
-    });
-    if (isCancel(choice))
-        return null;
-    return choice;
+    return promptForSingleWorktree("Choose a worktree to open", worktrees);
 }
 async function defaultPromptForEditor(editors) {
     const choice = await select({

package/dist/pr.js

@@ -6,7 +6,7 @@ import { loadEffectiveConfig, resolveConfigString } from "./config.js";
 import { pathExists, promptForPathConflict, } from "./conflict.js";
 import { syncFiles } from "./file-sync.js";
 import { isHeadless } from "./headless.js";
-import { appendHistory } from "./history.js";
+import { recordWorktreeUsage } from "./history.js";
 import { extractHooks, runHook } from "./hooks.js";
 import { maybeRunInstallPrompt, } from "./install-prompt.js";
 import { detectRepository, resolveWorktreePath } from "./repo.js";
@@ -61,7 +61,7 @@ export function createPrCommand(dependencies = {}) {
             }
             const choice = await prompt(worktreePath);
             if (choice === "reuse") {
-                appendHistory(worktreePath, branchName).catch(() => undefined);
+                await recordWorktreeUsage(worktreePath, branchName);
                 await writeOutput(worktreePath, options.stdout);
                 return 0;
             }
@@ -111,7 +111,7 @@ export function createPrCommand(dependencies = {}) {
         }
         await maybeRunInstallPrompt(worktreePath, repository.repoRoot, config, options.stderr, dependencies, !!options.json);
         const hooks = extractHooks(config);
-        await runHook(hooks.afterCreate, worktreePath, {
+        await runHook(hooks["after-create"], worktreePath, {
             branch: branchName,
             path: worktreePath,
             repo: basename(repository.repoRoot),
@@ -120,7 +120,7 @@ export function createPrCommand(dependencies = {}) {
             options.stdout(`${JSON.stringify({ branch: branchName, path: worktreePath }, null, 2)}\n`);
         }
         else {
-            await appendHistory(worktreePath, branchName);
+            await recordWorktreeUsage(worktreePath, branchName);
             await writeOutput(worktreePath, options.stdout);
         }
         return 0;

package/dist/remove.d.ts

@@ -1,4 +1,5 @@
-import { type WorktreeEntry } from "./repo.js";
+import type { WorktreeEntry } from "./repo.js";
+import { type WorktreePromptEntry } from "./worktree-picker.js";
 export interface RemoveCommandOptions {
     branch?: string;
     cwd: string;
@@ -12,7 +13,7 @@ export interface RemoveCommandDependencies {
     confirmForceDeleteBranch: (branch: string) => Promise<boolean>;
     confirmForceRemoveWorktree: (worktreePath: string) => Promise<boolean>;
     confirmRemoval: (worktree: WorktreeEntry) => Promise<boolean>;
-    promptForWorktree: (worktrees: WorktreeEntry[]) => Promise<string | null>;
+    promptForWorktree: (worktrees: WorktreePromptEntry[]) => Promise<string | null>;
 }
 export declare function createRemoveCommand(dependencies?: Partial<RemoveCommandDependencies>): (options: RemoveCommandOptions) => Promise<number>;
 export declare const runRemoveCommand: (options: RemoveCommandOptions) => Promise<number>;