@n-seiji/nuthatch 0.1.4 → 0.1.5

package/dist/cli.js

@@ -2041,8 +2041,11 @@ async function runCommand(cmd, opts) {
 // src/cli-dispatch.ts
 var normalizeCliArgs = (rawArgs, argv0, isCompiledBinary) => isCompiledBinary && rawArgs.length === 1 && rawArgs[0] === argv0 ? [] : rawArgs;
 var isRunningAsCompiledBinary = () => typeof Bun !== "undefined" && Bun.main.startsWith("/$bunfs/");
+var isUpdateRequest = (rawArgs) => rawArgs[0] === "--update";
 var HELP_FLAGS = new Set(["--help", "-h", "help"]);
-var isHelpRequest = (rawArgs) => rawArgs.length > 0 && HELP_FLAGS.has(rawArgs[0] ?? "");
+var UPDATE_HELP_FLAGS = new Set(["--help", "-h"]);
+var isHelpRequest = (rawArgs) => rawArgs.length > 0 && (HELP_FLAGS.has(rawArgs[0] ?? "") || isUpdateRequest(rawArgs) && rawArgs.slice(1).some((token) => UPDATE_HELP_FLAGS.has(token)));
+var isVersionRequest = (rawArgs) => rawArgs[0] === "--version";
 var dispatchCliArgs = (rawArgs, reservedNames) => {
   const [first, ...rest] = rawArgs;
   if (first === "--") {
@@ -2156,14 +2159,17 @@ var render = (command, result, json) => {
 `);
   }
 };
+var reportResult = (command, result, json) => {
+  render(command, result, json);
+  process.exitCode = result.exitCode;
+};
 
 // src/cli-fatal.ts
 var wantsJson = (args) => args.some((arg) => arg === "--json" || arg.startsWith("--json="));
 var reportFatalError = (command, json, error) => {
   const fatal = describeFatalError(error);
   const result = fail(fatal.exitCode, `hop: ${fatal.message}`);
-  render(command, result, json);
-  process.exitCode = result.exitCode;
+  reportResult(command, result, json);
 };
 
 // src/infra/lock.ts
@@ -2262,17 +2268,27 @@ var acquireRepoLock = async (commonDir, ttlMs = DEFAULT_TTL_MS) => {
     }
   };
 };
-var acquireRepoLockOrRejection = async (commonDir, ttlMs) => {
+var acquireUnlessHeld = async (commonDir) => {
   try {
-    const lock = await acquireRepoLock(commonDir, ttlMs);
-    return { ok: true, lock };
+    return await acquireRepoLock(commonDir);
   } catch (error) {
     if (error instanceof LockHeldError) {
-      return { ok: false, rejection: fail(EXIT_SAFE_REJECTION, error.message) };
+      return error;
     }
     throw error;
   }
 };
+var withRepoLock = async (commonDir, mutate) => {
+  const lock = await acquireUnlessHeld(commonDir);
+  if (lock instanceof LockHeldError) {
+    return fail(EXIT_SAFE_REJECTION, lock.message);
+  }
+  try {
+    return await mutate();
+  } finally {
+    await lock.release();
+  }
+};
 
 // src/infra/repo.ts
 import { basename, dirname, join as join2 } from "node:path";
@@ -2380,6 +2396,21 @@ var parsePorcelain = (output) => {
   return result;
 };
 
+// src/domain/tracking.ts
+var resolveTrackingRef = (branch, remotes) => {
+  if (remotes.includes("origin")) {
+    return { kind: "track", ref: `origin/${branch}` };
+  }
+  const [first, second] = remotes;
+  if (first === undefined) {
+    return { kind: "none" };
+  }
+  if (second !== undefined) {
+    return { kind: "ambiguous" };
+  }
+  return { kind: "track", ref: `${first}/${branch}` };
+};
+
 // src/infra/repo.ts
 var loadRepoContext = async (git, fs, cwd) => {
   const [commonDir, porcelainOut] = await Promise.all([
@@ -2403,8 +2434,34 @@ var loadRepoContext = async (git, fs, cwd) => {
   }));
   return { rootPath, managedRoot, commonDir, worktrees };
 };
-var otherWorktreePaths = (worktrees, path) => nestedWorktrees(worktrees, path).map((wt) => wt.path);
+var nestedWorktreePaths = (worktrees, path) => nestedWorktrees(worktrees, path).map((wt) => wt.path);
 var nestedWorktrees = (worktrees, path) => worktrees.filter((wt) => wt.path !== path && !wt.prunable && isWithin(path, wt.path));
+var isWorktreeDirty = (git, worktrees, path) => git.isDirty(path, nestedWorktreePaths(worktrees, path));
+var worktreeDirtyState = async (git, fs, worktrees, wt) => {
+  if (wt.bare || wt.prunable || !await fs.exists(wt.path)) {
+    return null;
+  }
+  return isWorktreeDirty(git, worktrees, wt.path);
+};
+var resolveBranchCheckout = async (git, rootPath, branch, explicitTrack) => {
+  const localBranches = await git.listBranches(rootPath);
+  const createBranch = !localBranches.includes(branch);
+  let track = explicitTrack;
+  if (createBranch && track === undefined) {
+    const remotes = await git.remotesWithBranch(rootPath, branch);
+    const resolution = resolveTrackingRef(branch, remotes);
+    if (resolution.kind === "ambiguous") {
+      return {
+        ok: false,
+        rejection: fail(EXIT_USAGE_ERROR, `Branch "${branch}" exists on multiple remotes (${remotes.join(", ")}). Use --track to disambiguate.`)
+      };
+    }
+    if (resolution.kind === "track") {
+      track = resolution.ref;
+    }
+  }
+  return { ok: true, options: { createBranch, ...track === undefined ? {} : { track } } };
+};
 var realpathOrRaw = async (fs, path) => {
   try {
     return await fs.realpath(path);
@@ -2415,6 +2472,7 @@ var realpathOrRaw = async (fs, path) => {
 
 // src/commands/root-holder-swap.ts
 var holderRejection = (branch, holderPath, reason) => fail(EXIT_SAFE_REJECTION, `Branch "${branch}" is already checked out at ${holderPath}, and it ${reason}. Not swapping — cd there instead of using hop root.`);
+var prunableHolderRejection = (branch, holderPath) => fail(EXIT_SAFE_REJECTION, `Branch "${branch}" is held by a stale worktree registration at ${holderPath} (git reports it prunable). Not swapping — if that worktree was moved, re-link it with "git worktree repair <new path>"; otherwise drop the registration first ("hop rm ${branch}" or "git worktree prune").`);
 var multipleHoldersRejection = (branch, holders) => fail(EXIT_SAFE_REJECTION, `Branch "${branch}" is checked out at ${holders.length} worktrees at once (${holders.map((holder) => holder.path).join(", ")}). Not swapping — hop won't guess which one to detach.`);
 var resolveHolderSwap = async ({
   git,
@@ -2454,7 +2512,10 @@ var resolveHolderSwap = async ({
       rejection: holderRejection(target, freshHolder.path, `is locked by git${freshHolder.lockReason === null ? "" : ` (${freshHolder.lockReason})`}`)
     };
   }
-  const holderDirty = await git.isDirty(freshHolder.path, otherWorktreePaths(fresh.worktrees, freshHolder.path));
+  if (freshHolder.prunable) {
+    return { rejection: prunableHolderRejection(target, freshHolder.path) };
+  }
+  const holderDirty = await isWorktreeDirty(git, fresh.worktrees, freshHolder.path);
   if (holderDirty) {
     return {
       rejection: holderRejection(target, freshHolder.path, "has uncommitted or untracked changes")
@@ -2467,20 +2528,19 @@ var resolveHolderSwap = async ({
 // src/commands/root.ts
 var root = async (git, fs, options) => {
   const context = await loadRepoContext(git, fs, options.cwd);
-  const rootWorktree = context.worktrees.find((wt) => wt.kind === "root");
   if (options.target === undefined) {
     return ok({
       path: context.rootPath,
       data: {
-        branch: rootWorktree?.branch ?? null,
+        branch: rootBranchOf(context),
         switched: false,
         detachedHolder: null
       }
     });
   }
-  const dirty = await git.isDirty(context.rootPath, otherWorktreePaths(context.worktrees, context.rootPath));
-  if (dirty) {
-    return fail(EXIT_SAFE_REJECTION, "Root clone has uncommitted or untracked changes. Commit, stash, or discard them before switching.");
+  const dirtyRejection = await dirtyRootRejection(git, context);
+  if (dirtyRejection !== null) {
+    return dirtyRejection;
   }
   if (options.target === "-") {
     return switchAndReport({
@@ -2492,57 +2552,64 @@ var root = async (git, fs, options) => {
       holderPolicy: { allowExternal: true }
     });
   }
-  const localBranches = await git.listBranches(context.rootPath);
-  const branchExistsLocally = localBranches.includes(options.target);
-  const { track: initialTrack } = options;
-  let track = initialTrack;
-  if (!branchExistsLocally && track === undefined) {
-    const remotes = await git.remotesWithBranch(context.rootPath, options.target);
-    const [firstRemote] = remotes;
-    if (remotes.includes("origin")) {
-      track = `origin/${options.target}`;
-    } else if (remotes.length === 1 && firstRemote !== undefined) {
-      track = `${firstRemote}/${options.target}`;
-    } else if (remotes.length > 1) {
-      return fail(EXIT_USAGE_ERROR, `Branch "${options.target}" exists on multiple remotes (${remotes.join(", ")}). Use --track to disambiguate.`);
-    }
+  const checkout = await resolveBranchCheckout(git, context.rootPath, options.target, options.track);
+  if (!checkout.ok) {
+    return checkout.rejection;
   }
   return switchAndReport({
     git,
     fs,
     context,
     target: options.target,
-    switchOptions: {
-      createBranch: !branchExistsLocally,
-      ...track === undefined ? {} : { track }
-    },
+    switchOptions: checkout.options,
     holderPolicy: {
       allowExternal: options.allowExternalHolderSwap ?? true,
       ...options.expectedHolderPath === undefined ? {} : { expectedPath: options.expectedHolderPath }
     }
   });
 };
-var switchAndReport = async ({
+var rootBranchOf = ({ worktrees }) => worktrees.find((wt) => wt.kind === "root")?.branch ?? null;
+var dirtyRootRejection = async (git, context) => {
+  const dirty = await isWorktreeDirty(git, context.worktrees, context.rootPath);
+  if (!dirty) {
+    return null;
+  }
+  return fail(EXIT_SAFE_REJECTION, "Root clone has uncommitted or untracked changes. Commit, stash, or discard them before switching.");
+};
+var rollBackSwitch = async (git, { rootPath, previousBranch, detachedHolder }) => {
+  const warnings = [];
+  if (previousBranch !== null) {
+    try {
+      await git.switchBranch(rootPath, previousBranch, {});
+    } catch {
+      warnings.push(`Could not restore ${rootPath} to its original branch (${previousBranch})`);
+    }
+  }
+  if (detachedHolder !== null) {
+    try {
+      await git.switchBranch(detachedHolder.path, detachedHolder.branch, {});
+    } catch {
+      warnings.push(`Could not restore ${detachedHolder.path} to its original branch (${detachedHolder.branch}); it remains in detached HEAD`);
+    }
+  }
+  return warnings;
+};
+var switchAndReport = ({
   git,
   fs,
   context,
   target,
   switchOptions,
   holderPolicy
-}) => {
-  const acquisition = await acquireRepoLockOrRejection(context.commonDir);
-  if (!acquisition.ok) {
-    return acquisition.rejection;
-  }
-  const { lock } = acquisition;
+}) => withRepoLock(context.commonDir, async () => {
   let detachedHolder = null;
   let previousBranch = null;
   try {
     const fresh = await loadRepoContext(git, fs, context.rootPath);
-    previousBranch = fresh.worktrees.find((wt) => wt.kind === "root")?.branch ?? null;
-    const stillDirty = await git.isDirty(fresh.rootPath, otherWorktreePaths(fresh.worktrees, fresh.rootPath));
-    if (stillDirty) {
-      return fail(EXIT_SAFE_REJECTION, "Root clone has uncommitted or untracked changes. Commit, stash, or discard them before switching.");
+    previousBranch = rootBranchOf(fresh);
+    const stillDirty = await dirtyRootRejection(git, fresh);
+    if (stillDirty !== null) {
+      return stillDirty;
     }
     const holderSwap = await resolveHolderSwap({
       git,
@@ -2559,7 +2626,7 @@ var switchAndReport = async ({
     let resolvedBranch = target;
     if (target === "-") {
       const afterSwitch = await loadRepoContext(git, fs, fresh.rootPath);
-      resolvedBranch = afterSwitch.worktrees.find((wt) => wt.kind === "root")?.branch ?? null;
+      resolvedBranch = rootBranchOf(afterSwitch);
     }
     return ok({
       path: fresh.rootPath,
@@ -2571,26 +2638,14 @@ var switchAndReport = async ({
       warnings: detachedHolder === null ? [] : [`Put ${detachedHolder.path} into detached HEAD`]
     });
   } catch (error) {
-    const rollbackWarnings = [];
-    if (previousBranch !== null) {
-      try {
-        await git.switchBranch(context.rootPath, previousBranch, {});
-      } catch {
-        rollbackWarnings.push(`Could not restore ${context.rootPath} to its original branch (${previousBranch})`);
-      }
-    }
-    if (detachedHolder !== null) {
-      try {
-        await git.switchBranch(detachedHolder.path, detachedHolder.branch, {});
-      } catch {
-        rollbackWarnings.push(`Could not restore ${detachedHolder.path} to its original branch (${detachedHolder.branch}); it remains in detached HEAD`);
-      }
-    }
-    return fail(EXIT_SAFE_REJECTION, `Failed to switch root: ${error.message}`, rollbackWarnings);
-  } finally {
-    await lock.release();
+    const warnings = await rollBackSwitch(git, {
+      rootPath: context.rootPath,
+      previousBranch,
+      detachedHolder
+    });
+    return fail(EXIT_SAFE_REJECTION, `Failed to switch root: ${messageOf(error)}`, warnings);
   }
-};
+});
 
 // src/cli-root-command.ts
 var ROOT_PREVIOUS_TOKEN = " hop-root-previous ";
@@ -2612,7 +2667,7 @@ var rewriteRootPreviousToken = (args) => {
   return rewritten;
 };
 var resolveRootTarget = (branch) => branch === ROOT_PREVIOUS_TOKEN ? "-" : branch;
-var createRootCommand = (git, fs, applyExitCode) => defineCommand({
+var createRootCommand = (git, fs) => defineCommand({
   meta: {
     name: "root",
     description: "cd to the root clone, or temporarily switch its branch"
@@ -2636,8 +2691,7 @@ var createRootCommand = (git, fs, applyExitCode) => defineCommand({
       ...target === undefined ? {} : { target: String(target) },
       ...args.track === undefined ? {} : { track: String(args.track) }
     });
-    render("root", result, Boolean(args.json));
-    applyExitCode(result);
+    reportResult("root", result, Boolean(args.json));
   }
 });
 
@@ -2677,7 +2731,7 @@ var pick = async (git, fs, options) => {
     git.listRemoteBranches(context.rootPath),
     Promise.all(context.worktrees.map(async (worktree) => [
       worktree.path,
-      worktree.bare ? null : await git.isDirty(worktree.path, otherWorktreePaths(context.worktrees, worktree.path))
+      await worktreeDirtyState(git, fs, context.worktrees, worktree)
     ]))
   ]);
   const dirtyByPath = new Map(dirtyEntries);
@@ -2688,6 +2742,8 @@ var pick = async (git, fs, options) => {
 // src/commands/rm.ts
 var EXT_DEPRECATION_WARNING = "--ext is deprecated and no longer required: hop rm can now remove external worktrees without it.";
 var lockedRejection = (branch, lockReason) => fail(EXIT_SAFE_REJECTION, `Worktree for "${branch}" is locked by git${lockReason === null ? "" : ` (${lockReason})`}. hop never unlocks worktrees automatically — run "git worktree unlock" yourself first if you're sure.`);
+var turnedPrunableRejection = (branch) => fail(EXIT_SAFE_REJECTION, `The selected worktree for "${branch}" changed before removal (git now reports it prunable). Refresh the picker and retry.`);
+var stalePrunableWarning = ({ path, prunableReason }) => `Worktree at ${path} no longer exists${prunableReason === null ? "" : ` (${prunableReason})`}; removed its stale registration — if it had been moved by hand, the moved copy is no longer linked to this repository.`;
 var resolveTarget = (worktrees, branch, expectedPath) => {
   const matches = worktrees.filter((wt) => wt.branch === branch);
   if (expectedPath !== undefined) {
@@ -2714,7 +2770,7 @@ var nestedWorktreeRejection = (branch, targetPath, worktrees) => {
   return fail(EXIT_SAFE_REJECTION, `Worktree for "${branch}" still contains ${nested.length} registered worktree(s) — refusing to remove it, since that would destroy their files too. Remove these first, then retry:
 ${listing}`);
 };
-var targetSafetyRejection = async (git, context, target, options) => {
+var targetSafetyRejection = async ({ git, fs, context, options }, target) => {
   const nestedRejection = nestedWorktreeRejection(options.branch, target.path, context.worktrees);
   if (nestedRejection !== null) {
     return nestedRejection;
@@ -2722,61 +2778,64 @@ var targetSafetyRejection = async (git, context, target, options) => {
   if (target.locked) {
     return lockedRejection(options.branch, target.lockReason);
   }
-  if (!options.force && await git.isDirty(target.path, otherWorktreePaths(context.worktrees, target.path))) {
+  if (target.prunable && options.allowPrunable === false) {
+    return turnedPrunableRejection(options.branch);
+  }
+  if (!options.force && await worktreeDirtyState(git, fs, context.worktrees, target) === true) {
     return fail(EXIT_SAFE_REJECTION, `Worktree for "${options.branch}" has uncommitted or untracked changes. Use --force to remove anyway.`);
   }
   return null;
 };
-var rm2 = async (git, fs, options) => {
-  const finish = (result) => options.ext ? {
-    ...result,
-    warnings: [...result.warnings ?? [], EXT_DEPRECATION_WARNING]
-  } : result;
-  const context = await loadRepoContext(git, fs, options.cwd);
+var validateRemoval = async (check) => {
+  const { context, options } = check;
   const resolved = resolveTarget(context.worktrees, options.branch, options.expectedPath);
   if (resolved.rejection !== undefined) {
-    return finish(resolved.rejection);
+    return { ok: false, rejection: resolved.rejection };
   }
   const { target } = resolved;
   if (target === undefined) {
-    return finish(fail(EXIT_GENERAL_ERROR, `No worktree found for branch "${options.branch}".`));
+    return {
+      ok: false,
+      rejection: fail(EXIT_GENERAL_ERROR, `No worktree found for branch "${options.branch}".`)
+    };
   }
   if (target.kind === "root") {
-    return finish(fail(EXIT_USAGE_ERROR, "Cannot remove the root clone."));
-  }
-  const safetyRejection = await targetSafetyRejection(git, context, target, options);
-  if (safetyRejection !== null) {
-    return finish(safetyRejection);
+    return { ok: false, rejection: fail(EXIT_USAGE_ERROR, "Cannot remove the root clone.") };
   }
-  const acquisition = await acquireRepoLockOrRejection(context.commonDir);
-  if (!acquisition.ok) {
-    return finish(acquisition.rejection);
+  const rejection = await targetSafetyRejection(check, target);
+  return rejection === null ? { ok: true, target } : { ok: false, rejection };
+};
+var withExtWarning = (ext, result) => ext ? {
+  ...result,
+  warnings: [...result.warnings ?? [], EXT_DEPRECATION_WARNING]
+} : result;
+var removeWorktree = async (git, fs, options) => {
+  const context = await loadRepoContext(git, fs, options.cwd);
+  const validation = await validateRemoval({ git, fs, context, options });
+  if (!validation.ok) {
+    return validation.rejection;
   }
-  const { lock } = acquisition;
-  try {
-    const fresh = await loadRepoContext(git, fs, options.cwd);
-    const freshResolved = resolveTarget(fresh.worktrees, options.branch, options.expectedPath);
-    if (freshResolved.rejection !== undefined) {
-      return finish(freshResolved.rejection);
-    }
-    const freshTarget = freshResolved.target;
-    if (freshTarget === undefined) {
-      return finish(fail(EXIT_GENERAL_ERROR, `No worktree found for branch "${options.branch}".`));
-    }
-    const freshSafetyRejection = await targetSafetyRejection(git, fresh, freshTarget, options);
-    if (freshSafetyRejection !== null) {
-      return finish(freshSafetyRejection);
+  return withRepoLock(context.commonDir, async () => {
+    try {
+      const fresh = await loadRepoContext(git, fs, options.cwd);
+      const freshValidation = await validateRemoval({ git, fs, context: fresh, options });
+      if (!freshValidation.ok) {
+        return freshValidation.rejection;
+      }
+      const { target } = freshValidation;
+      await git.removeWorktree(context.rootPath, target.path, options.force);
+      return ok({
+        data: { branch: options.branch, path: target.path },
+        ...target.prunable ? { warnings: [stalePrunableWarning(target)] } : {}
+      });
+    } catch (error) {
+      return fail(EXIT_SAFE_REJECTION, `Failed to remove worktree: ${messageOf(error)}`);
     }
-    await git.removeWorktree(context.rootPath, freshTarget.path, options.force);
-    return finish(ok({ data: { branch: options.branch, path: freshTarget.path } }));
-  } catch (error) {
-    return finish(fail(EXIT_SAFE_REJECTION, `Failed to remove worktree: ${error.message}`));
-  } finally {
-    await lock.release();
-  }
+  });
 };
+var rm2 = async (git, fs, options) => withExtWarning(options.ext, await removeWorktree(git, fs, options));
 
-// src/ui/picker.ts
+// src/ui/picker-render.ts
 import { homedir } from "node:os";
 
 // src/domain/display-width.ts
@@ -2855,6 +2914,19 @@ var padToWidth = (value, width) => {
   return current >= width ? value : value + " ".repeat(width - current);
 };
 var DEFAULT_ELLIPSIS = "…";
+var takeWithinWidth = (clusters, budget) => {
+  const taken = [];
+  let usedWidth = WIDTH_ZERO;
+  for (const grapheme of clusters) {
+    const nextWidth = usedWidth + graphemeWidth(grapheme);
+    if (nextWidth > budget) {
+      break;
+    }
+    taken.push(grapheme);
+    usedWidth = nextWidth;
+  }
+  return taken;
+};
 var truncateToWidth = (value, width, ellipsis = DEFAULT_ELLIPSIS) => {
   if (displayWidth(value) <= width) {
     return value;
@@ -2863,17 +2935,7 @@ var truncateToWidth = (value, width, ellipsis = DEFAULT_ELLIPSIS) => {
   if (budget < WIDTH_ZERO) {
     return "";
   }
-  let kept = "";
-  let usedWidth = WIDTH_ZERO;
-  for (const grapheme of graphemes(value)) {
-    const nextWidth = usedWidth + graphemeWidth(grapheme);
-    if (nextWidth > budget) {
-      break;
-    }
-    kept += grapheme;
-    usedWidth = nextWidth;
-  }
-  return kept + ellipsis;
+  return takeWithinWidth(graphemes(value), budget).join("") + ellipsis;
 };
 var truncateToWidthKeepingTail = (value, width, ellipsis = DEFAULT_ELLIPSIS) => {
   if (displayWidth(value) <= width) {
@@ -2883,21 +2945,14 @@ var truncateToWidthKeepingTail = (value, width, ellipsis = DEFAULT_ELLIPSIS) =>
   if (budget < WIDTH_ZERO) {
     return "";
   }
-  let kept = "";
-  let usedWidth = WIDTH_ZERO;
-  for (const grapheme of graphemes(value).toReversed()) {
-    const nextWidth = usedWidth + graphemeWidth(grapheme);
-    if (nextWidth > budget) {
-      break;
-    }
-    kept = grapheme + kept;
-    usedWidth = nextWidth;
-  }
-  return ellipsis + kept;
+  const keptFromEnd = takeWithinWidth(graphemes(value).toReversed(), budget);
+  return ellipsis + keptFromEnd.toReversed().join("");
 };
 
-// src/ui/picker-frame.ts
+// src/ui/ansi.ts
 var ESC = "\x1B";
+
+// src/ui/picker-frame.ts
 var CURSOR_HOME = `${ESC}[H`;
 var CLEAR_TO_END = `${ESC}[J`;
 var SGR_RESET = `${ESC}[0m`;
@@ -3034,28 +3089,6 @@ var buildFrameLines = (left, right, stacked, colorEnabled) => {
   return buildSideBySide(left, right, colorEnabled);
 };
 
-// src/ui/picker-viewport.ts
-var DEFAULT_TERMINAL_HEIGHT = 24;
-var MIN_VISIBLE_CANDIDATE_ROWS = 3;
-var BASE_CHROME_ROWS = 3;
-var SECTION_HEADER_ROWS = 2;
-var HIDDEN_COUNT_INDICATOR_ROWS = 2;
-var rowBudget = ({ terminalHeight, stackedPanelRows }) => {
-  const reserved = BASE_CHROME_ROWS + SECTION_HEADER_ROWS + HIDDEN_COUNT_INDICATOR_ROWS + stackedPanelRows;
-  return Math.max(MIN_VISIBLE_CANDIDATE_ROWS, terminalHeight - reserved);
-};
-var computeViewport = (total, selectedIndex, budget) => {
-  if (total <= budget) {
-    return { start: 0, end: total, hiddenAbove: 0, hiddenBelow: 0 };
-  }
-  const HALF_DIVISOR = 2;
-  const half = Math.floor(budget / HALF_DIVISOR);
-  const maxStart = total - budget;
-  const start = Math.min(maxStart, Math.max(0, selectedIndex - half));
-  const end = start + budget;
-  return { start, end, hiddenAbove: start, hiddenBelow: total - end };
-};
-
 // src/ui/picker-layout.ts
 var MAX_PATH_LENGTH = 40;
 var MAX_BRANCH_COLUMN_WIDTH = 24;
@@ -3126,6 +3159,15 @@ var toCandidateRow = (candidate, options) => ({
   kindLabel: candidateKindLabel(candidate).padEnd(KIND_COLUMN_WIDTH, " "),
   pathLabel: candidatePathLabel(candidate, options.homeDir, options.pathMaxLength)
 });
+var sectionRows = (label, section, entries, rowOptions) => {
+  if (entries.length === 0) {
+    return [];
+  }
+  return [
+    { kind: "header", label },
+    ...entries.map((entry) => toCandidateRow(entry.candidate, { ...rowOptions, index: entry.index, section }))
+  ];
+};
 var buildDisplayRows = (candidates, homeDir, indexOffset = 0, columnWidths) => {
   const { branchWidth, pathMaxLength } = columnWidths ?? {
     branchWidth: branchColumnWidth(candidates),
@@ -3137,32 +3179,11 @@ var buildDisplayRows = (candidates, homeDir, indexOffset = 0, columnWidths) => {
   }));
   const worktreeEntries = indexed.filter((entry) => isWorktreeCandidate(entry.candidate));
   const branchEntries = indexed.filter((entry) => isCreatableCandidate(entry.candidate));
-  const rows = [];
-  if (worktreeEntries.length > 0) {
-    rows.push({ kind: "header", label: "WORKTREES" });
-    for (const entry of worktreeEntries) {
-      rows.push(toCandidateRow(entry.candidate, {
-        index: entry.index,
-        section: "worktree",
-        branchWidth,
-        pathMaxLength,
-        homeDir
-      }));
-    }
-  }
-  if (branchEntries.length > 0) {
-    rows.push({ kind: "header", label: "BRANCHES — Enter creates a worktree" });
-    for (const entry of branchEntries) {
-      rows.push(toCandidateRow(entry.candidate, {
-        index: entry.index,
-        section: "branch",
-        branchWidth,
-        pathMaxLength,
-        homeDir
-      }));
-    }
-  }
-  return rows;
+  const rowOptions = { branchWidth, pathMaxLength, homeDir };
+  return [
+    ...sectionRows("WORKTREES", "worktree", worktreeEntries, rowOptions),
+    ...sectionRows("BRANCHES — Enter creates a worktree", "branch", branchEntries, rowOptions)
+  ];
 };
 
 // src/domain/actions.ts
@@ -3183,7 +3204,7 @@ var availableActions = (candidate) => {
   }
   return actions;
 };
-var requiresDeleteConfirmation = (candidate) => candidate.kind === "worktree" && candidate.worktree.kind === "external";
+var requiresDeleteConfirmation = (candidate) => candidate.kind === "worktree" && (candidate.worktree.kind === "external" || candidate.worktree.prunable);
 var requiresSwitchRootConfirmation = (candidate) => candidate.kind === "worktree" && candidate.worktree.kind === "external";
 
 // src/ui/side-panel.ts
@@ -3239,6 +3260,9 @@ var buildConfirmPanelRows = ({
   if (action === "switchRoot") {
     rows.push([{ text: "This will put it into detached HEAD.", style: "dim" }]);
   }
+  if (action === "delete" && candidate.kind === "worktree" && candidate.worktree.prunable) {
+    rows.push([{ text: "Prunable, not dirty-checked:", style: "dim" }], [{ text: "removes just its registration.", style: "dim" }]);
+  }
   rows.push([{ text: "(y/N)", style: "dim" }]);
   return rows;
 };
@@ -3277,6 +3301,131 @@ var footerHintForWidth = (kind, width) => {
   return truncateToWidth(short, width);
 };
 
+// src/ui/picker-viewport.ts
+var DEFAULT_TERMINAL_HEIGHT = 24;
+var MIN_VISIBLE_CANDIDATE_ROWS = 3;
+var BASE_CHROME_ROWS = 3;
+var SECTION_HEADER_ROWS = 2;
+var HIDDEN_COUNT_INDICATOR_ROWS = 2;
+var rowBudget = ({ terminalHeight, stackedPanelRows }) => {
+  const reserved = BASE_CHROME_ROWS + SECTION_HEADER_ROWS + HIDDEN_COUNT_INDICATOR_ROWS + stackedPanelRows;
+  return Math.max(MIN_VISIBLE_CANDIDATE_ROWS, terminalHeight - reserved);
+};
+var computeViewport = (total, selectedIndex, budget) => {
+  if (total <= budget) {
+    return { start: 0, end: total, hiddenAbove: 0, hiddenBelow: 0 };
+  }
+  const HALF_DIVISOR2 = 2;
+  const half = Math.floor(budget / HALF_DIVISOR2);
+  const maxStart = total - budget;
+  const start = Math.min(maxStart, Math.max(0, selectedIndex - half));
+  const end = start + budget;
+  return { start, end, hiddenAbove: start, hiddenBelow: total - end };
+};
+
+// src/ui/picker-render.ts
+var QUERY_PREFIX = "hop: ";
+var queryLine = (query, maxWidth) => {
+  const hint = query.length === 0 ? " (type to filter)" : "";
+  const budget = Math.max(0, maxWidth - QUERY_PREFIX.length - hint.length);
+  return [
+    { text: QUERY_PREFIX },
+    { text: truncateToWidthKeepingTail(query, budget), style: "cyan" },
+    { text: hint, style: "dim" }
+  ];
+};
+var hiddenCountLine = (count, direction) => {
+  if (count === 0) {
+    return null;
+  }
+  const arrow = direction === "above" ? "↑ " : "↓ ";
+  const word = direction === "above" ? "above" : "below";
+  return [
+    {
+      text: `${arrow}${count} more ${word} (keep typing to narrow down)`,
+      style: "dim"
+    }
+  ];
+};
+var candidateRowLine = (row, selected) => {
+  const marker = selected ? "❯ " : "  ";
+  const text = `${marker}${row.statusMarker} ${row.branchLabel}  ${row.kindLabel} ${row.pathLabel}`;
+  if (selected) {
+    return [{ text, style: "inverse" }];
+  }
+  return [{ text, style: row.section === "branch" ? "dim" : "plain" }];
+};
+var displayRowLine = (row, clampedIndex) => row.kind === "header" ? [{ text: row.label, style: "bold-dim" }] : candidateRowLine(row, row.index === clampedIndex);
+var buildListLines = ({
+  query,
+  maxWidth,
+  rows,
+  clampedIndex,
+  hiddenAbove,
+  hiddenBelow,
+  footerHint
+}) => {
+  const lines = [queryLine(query, maxWidth)];
+  if (rows.length === 0) {
+    lines.push([{ text: "No matches.", style: "dim" }]);
+  }
+  const above = hiddenCountLine(hiddenAbove, "above");
+  if (above !== null) {
+    lines.push(above);
+  }
+  for (const row of rows) {
+    lines.push(displayRowLine(row, clampedIndex));
+  }
+  const below = hiddenCountLine(hiddenBelow, "below");
+  if (below !== null) {
+    lines.push(below);
+  }
+  lines.push([{ text: `(${LEGEND_TEXT})`, style: "dim" }], [{ text: footerHint, style: "dim" }]);
+  return lines;
+};
+var buildSidePanelLines = (mode, panelIndex, busy) => {
+  if (mode.kind === "panel") {
+    return wrapInBox(buildActionPanelRows({
+      candidate: mode.candidate,
+      panelIndex,
+      error: mode.error,
+      busy
+    }), SIDE_PANEL_WIDTH);
+  }
+  if (mode.kind === "confirm") {
+    return wrapInBox(buildConfirmPanelRows({ candidate: mode.candidate, action: mode.action }), SIDE_PANEL_WIDTH);
+  }
+  return null;
+};
+var renderPickerFrame = ({
+  snapshot,
+  width,
+  height,
+  colorEnabled: color
+}) => {
+  const { query, filtered, clampedIndex, mode, panelIndex, busy } = snapshot;
+  const narrow = isNarrowTerminal(width);
+  const right = buildSidePanelLines(mode, panelIndex, busy);
+  const stacked = right !== null && narrow;
+  const listColumnWidth = right !== null && !stacked ? width - GUTTER.length - SIDE_PANEL_WIDTH : width;
+  const stackedPanelRows = stacked && right !== null ? right.length : 0;
+  const budget = rowBudget({ terminalHeight: height, stackedPanelRows });
+  const viewport = computeViewport(filtered.length, clampedIndex, budget);
+  const visible = filtered.slice(viewport.start, viewport.end);
+  const columnWidths = constrainRowColumnWidths(rawBranchColumnWidth(visible), listColumnWidth);
+  const rows = buildDisplayRows(visible, homedir(), viewport.start, columnWidths);
+  const left = buildListLines({
+    query,
+    maxWidth: listColumnWidth,
+    rows,
+    clampedIndex,
+    hiddenAbove: viewport.hiddenAbove,
+    hiddenBelow: viewport.hiddenBelow,
+    footerHint: footerHintForWidth(right === null ? "list" : "panel", listColumnWidth)
+  }).map((line) => truncateLineToWidth(line, listColumnWidth));
+  return buildFrame({ left, right, stacked, colorEnabled: color });
+};
+
 // src/ui/picker-keys.ts
 var isCtrlJByte = (input) => input === `
 `;
@@ -3363,7 +3512,7 @@ var handleConfirmInput = (input, key, confirmMode, ctx) => {
 };
 var runOrConfirm = (candidate, action, ctx) => {
   if ((action === "delete" || action === "switchRoot") && requiresConfirmation(candidate, action)) {
-    ctx.setMode({ kind: "confirm", action, candidate, error: null });
+    ctx.setMode({ kind: "confirm", action, candidate });
     return;
   }
   ctx.runAction(candidate, action);
@@ -3441,7 +3590,7 @@ var handleListInput = (input, key, ctx) => {
     }
     case "openPanel": {
       if (ctx.selectedCandidate !== undefined) {
-        ctx.setPanelIndex(0);
+        ctx.setPanelIndex(() => 0);
         ctx.setMode({
           kind: "panel",
           candidate: ctx.selectedCandidate,
@@ -3455,24 +3604,14 @@ var handleListInput = (input, key, ctx) => {
         ctx.setMode({
           kind: "confirm",
           action: "delete",
-          candidate: ctx.selectedCandidate,
-          error: null
+          candidate: ctx.selectedCandidate
         });
       }
       break;
     }
     case "rootSwitchShortcut": {
       if (ctx.selectedCandidate !== undefined && availableActions(ctx.selectedCandidate).includes("switchRoot")) {
-        if (requiresSwitchRootConfirmation(ctx.selectedCandidate)) {
-          ctx.setMode({
-            kind: "confirm",
-            action: "switchRoot",
-            candidate: ctx.selectedCandidate,
-            error: null
-          });
-        } else {
-          ctx.runAction(ctx.selectedCandidate, "switchRoot");
-        }
+        runOrConfirm(ctx.selectedCandidate, "switchRoot", ctx);
       }
       break;
     }
@@ -3503,20 +3642,18 @@ var runMutation = async (callbacks, candidate, action) => {
   if (action === "switchRoot") {
     const result2 = await callbacks.switchRootHere(candidate);
     if (!result2.ok || result2.path === undefined) {
-      const transition = panelErrorTransition(candidate, result2.message ?? "Failed to switch root.");
       return {
         type: "patch",
-        patch: { mode: transition.mode, panelIndex: transition.panelIndex }
+        patch: panelErrorTransition(candidate, result2.message ?? "Failed to switch root.")
       };
     }
     return { type: "exit", outcome: { type: "path", path: result2.path } };
   }
   const result = await callbacks.deleteWorktree(candidate);
   if (!result.ok) {
-    const transition = panelErrorTransition(candidate, result.message ?? "Failed to delete worktree.");
     return {
       type: "patch",
-      patch: { mode: transition.mode, panelIndex: transition.panelIndex }
+      patch: panelErrorTransition(candidate, result.message ?? "Failed to delete worktree.")
     };
   }
   const fresh = await callbacks.reloadCandidates();
@@ -3602,10 +3739,7 @@ var createPickerStore = (initialCandidates, callbacks, onExit, onCancel) => {
   const setQuery = (updater) => {
     setState({ query: updater(state.query) });
   };
-  const setPanelIndexByValue = (value) => {
-    setState({ panelIndex: value });
-  };
-  const setPanelIndexByUpdater = (updater) => {
+  const setPanelIndex = (updater) => {
     setState({ panelIndex: updater(state.panelIndex) });
   };
   const setMode = (mode) => {
@@ -3624,13 +3758,12 @@ var createPickerStore = (initialCandidates, callbacks, onExit, onCancel) => {
       handlePanelInput(input, key, mode, {
         panelIndex,
         runAction,
-        setPanelIndex: setPanelIndexByUpdater,
+        setPanelIndex,
         setMode
       });
       return;
     }
-    const filtered = getFiltered(state);
-    const clampedIndex = Math.min(state.index, Math.max(filtered.length - 1, 0));
+    const { filtered, clampedIndex } = getSnapshot();
     handleListInput(input, key, {
       selectedCandidate: filtered[clampedIndex],
       filteredLength: filtered.length,
@@ -3638,7 +3771,7 @@ var createPickerStore = (initialCandidates, callbacks, onExit, onCancel) => {
       onCancel: guardedOnCancel,
       setIndex,
       setQuery,
-      setPanelIndex: setPanelIndexByValue,
+      setPanelIndex,
       setMode
     });
   };
@@ -3652,12 +3785,10 @@ var createPickerStore = (initialCandidates, callbacks, onExit, onCancel) => {
 };
 
 // src/ui/alt-screen.ts
-var ASCII_ESCAPE_CODE = 27;
-var ESCAPE = String.fromCodePoint(ASCII_ESCAPE_CODE);
-var ENTER_ALT_SCREEN = `${ESCAPE}[?1049h`;
-var LEAVE_ALT_SCREEN = `${ESCAPE}[?1049l`;
-var HIDE_CURSOR = `${ESCAPE}[?25l`;
-var SHOW_CURSOR = `${ESCAPE}[?25h`;
+var ENTER_ALT_SCREEN = `${ESC}[?1049h`;
+var LEAVE_ALT_SCREEN = `${ESC}[?1049l`;
+var HIDE_CURSOR = `${ESC}[?25l`;
+var SHOW_CURSOR = `${ESC}[?25h`;
 var enterAltScreen = (target) => {
   if (!target.isTTY) {
     return;
@@ -3848,6 +3979,10 @@ var pastedTextToEvents = (text) => [...text].filter((char) => isPrintableChar(ch
 var CSI_INTRODUCER_CODE = "[".codePointAt(0);
 var SS3_INTRODUCER_CODE = "O".codePointAt(0);
 var MAX_PENDING_SEQUENCE_BYTES = 32;
+var PASTE_END_MARKER = Buffer.concat([
+  Buffer.from([ESC2]),
+  Buffer.from(`[${BRACKETED_PASTE_END}`)
+]);
 
 class PickerKeyParser {
   buffer = Buffer.alloc(0);
@@ -3876,19 +4011,18 @@ class PickerKeyParser {
     if (this.buffer.length === 0) {
       return null;
     }
-    const endMarker = Buffer.concat([Buffer.from([ESC2]), Buffer.from(`[${BRACKETED_PASTE_END}`)]);
-    const markerIndex = this.buffer.indexOf(endMarker);
+    const markerIndex = this.buffer.indexOf(PASTE_END_MARKER);
     if (markerIndex !== -1) {
       const text2 = decodeUtf8(this.buffer.subarray(0, markerIndex));
-      this.buffer = this.buffer.subarray(markerIndex + endMarker.length);
+      this.buffer = this.buffer.subarray(markerIndex + PASTE_END_MARKER.length);
       this.inPaste = false;
       return pastedTextToEvents(text2);
     }
-    const maxOverlap = Math.min(endMarker.length - 1, this.buffer.length);
+    const maxOverlap = Math.min(PASTE_END_MARKER.length - 1, this.buffer.length);
     let overlap = 0;
     for (let candidate = maxOverlap;candidate > 0; candidate -= 1) {
       const tail = this.buffer.subarray(this.buffer.length - candidate);
-      if (tail.equals(endMarker.subarray(0, candidate))) {
+      if (tail.equals(PASTE_END_MARKER.subarray(0, candidate))) {
         overlap = candidate;
         break;
       }
@@ -3985,9 +4119,8 @@ class PickerKeyParser {
 }
 
 // src/ui/terminal-session.ts
-var ESC3 = "\x1B";
-var ENABLE_BRACKETED_PASTE = `${ESC3}[?2004h`;
-var DISABLE_BRACKETED_PASTE = `${ESC3}[?2004l`;
+var ENABLE_BRACKETED_PASTE = `${ESC}[?2004h`;
+var DISABLE_BRACKETED_PASTE = `${ESC}[?2004l`;
 var PENDING_ESCAPE_TIMEOUT_MS = 25;
 var EXIT_SIGTERM = 143;
 var EXIT_SIGHUP = 129;
@@ -4152,107 +4285,6 @@ var runTerminalSession = (createHandlers, streams = defaultStreams()) => new Pro
 var DEFAULT_TERMINAL_WIDTH = 80;
 var terminalDimension = (value, fallback) => value !== undefined && value > 0 ? value : fallback;
 var colorEnabled = (stderr) => stderr.isTTY === true && (process.env["NO_COLOR"] ?? "") === "";
-var QUERY_PREFIX = "hop: ";
-var queryLine = (query, maxWidth) => {
-  const hint = query.length === 0 ? " (type to filter)" : "";
-  const budget = Math.max(0, maxWidth - QUERY_PREFIX.length - hint.length);
-  return [
-    { text: QUERY_PREFIX },
-    { text: truncateToWidthKeepingTail(query, budget), style: "cyan" },
-    { text: hint, style: "dim" }
-  ];
-};
-var hiddenCountLine = (count, direction) => {
-  if (count === 0) {
-    return null;
-  }
-  const arrow = direction === "above" ? "↑ " : "↓ ";
-  const word = direction === "above" ? "above" : "below";
-  return [
-    {
-      text: `${arrow}${count} more ${word} (keep typing to narrow down)`,
-      style: "dim"
-    }
-  ];
-};
-var candidateRowLine = (row, selected) => {
-  const marker = selected ? "❯ " : "  ";
-  const text = `${marker}${row.statusMarker} ${row.branchLabel}  ${row.kindLabel} ${row.pathLabel}`;
-  if (selected) {
-    return [{ text, style: "inverse" }];
-  }
-  return [{ text, style: row.section === "branch" ? "dim" : "plain" }];
-};
-var displayRowLine = (row, clampedIndex) => row.kind === "header" ? [{ text: row.label, style: "bold-dim" }] : candidateRowLine(row, row.index === clampedIndex);
-var buildListLines = ({
-  query,
-  maxWidth,
-  rows,
-  clampedIndex,
-  hiddenAbove,
-  hiddenBelow,
-  footerHint
-}) => {
-  const lines = [queryLine(query, maxWidth)];
-  if (rows.length === 0) {
-    lines.push([{ text: "No matches.", style: "dim" }]);
-  }
-  const above = hiddenCountLine(hiddenAbove, "above");
-  if (above !== null) {
-    lines.push(above);
-  }
-  for (const row of rows) {
-    lines.push(displayRowLine(row, clampedIndex));
-  }
-  const below = hiddenCountLine(hiddenBelow, "below");
-  if (below !== null) {
-    lines.push(below);
-  }
-  lines.push([{ text: `(${LEGEND_TEXT})`, style: "dim" }], [{ text: footerHint, style: "dim" }]);
-  return lines;
-};
-var buildSidePanelLines = (mode, panelIndex, busy) => {
-  if (mode.kind === "panel") {
-    return wrapInBox(buildActionPanelRows({
-      candidate: mode.candidate,
-      panelIndex,
-      error: mode.error,
-      busy
-    }), SIDE_PANEL_WIDTH);
-  }
-  if (mode.kind === "confirm") {
-    return wrapInBox(buildConfirmPanelRows({ candidate: mode.candidate, action: mode.action }), SIDE_PANEL_WIDTH);
-  }
-  return null;
-};
-var renderPickerFrame = ({
-  snapshot,
-  width,
-  height,
-  colorEnabled: color
-}) => {
-  const { query, filtered, clampedIndex, mode, panelIndex, busy } = snapshot;
-  const narrow = isNarrowTerminal(width);
-  const right = buildSidePanelLines(mode, panelIndex, busy);
-  const stacked = right !== null && narrow;
-  const listColumnWidth = right !== null && !stacked ? width - GUTTER.length - SIDE_PANEL_WIDTH : width;
-  const stackedPanelRows = stacked && right !== null ? right.length : 0;
-  const budget = rowBudget({ terminalHeight: height, stackedPanelRows });
-  const viewport = computeViewport(filtered.length, clampedIndex, budget);
-  const visible = filtered.slice(viewport.start, viewport.end);
-  const columnWidths = constrainRowColumnWidths(rawBranchColumnWidth(visible), listColumnWidth);
-  const rows = buildDisplayRows(visible, homedir(), viewport.start, columnWidths);
-  const left = buildListLines({
-    query,
-    maxWidth: listColumnWidth,
-    rows,
-    clampedIndex,
-    hiddenAbove: viewport.hiddenAbove,
-    hiddenBelow: viewport.hiddenBelow,
-    footerHint: footerHintForWidth(right === null ? "list" : "panel", listColumnWidth)
-  }).map((line) => truncateLineToWidth(line, listColumnWidth));
-  return buildFrame({ left, right, stacked, colorEnabled: color });
-};
 var isCtrlC = (event2) => event2.key.ctrl && event2.input === "c";
 var runPicker = (candidates, callbacks) => runTerminalSession(({ requestRender, finish }) => {
   const store = createPickerStore(candidates, callbacks, (outcome) => finish(outcome), (reason) => finish({ type: "cancelled", reason }));
@@ -4278,8 +4310,7 @@ var runPicker = (candidates, callbacks) => runTerminalSession(({ requestRender,
 var loadPickCandidates = async (git, fs, json) => {
   const pickResult = await pick(git, fs, { cwd: process.cwd() });
   if (!pickResult.ok) {
-    render("pick", pickResult, json);
-    process.exitCode = pickResult.exitCode;
+    reportResult("pick", pickResult, json);
     return null;
   }
   return pickResult.data?.candidates ?? [];
@@ -4293,6 +4324,7 @@ var deleteWorktree = async (git, fs, candidate) => {
     cwd: process.cwd(),
     branch,
     ...candidate.kind === "worktree" ? { expectedPath: candidate.worktree.path } : {},
+    allowPrunable: candidate.kind === "worktree" && candidate.worktree.prunable,
     force: false,
     ext: false
   });
@@ -4343,15 +4375,969 @@ var renderSwitchRootOutcome = (path, outcome, json) => {
   const branch = outcome?.branch ?? null;
   const detachedHolder = outcome?.detachedHolder ?? null;
   const warnings = outcome?.warnings ?? [];
-  if (json) {
-    render("root", ok({ path, data: { branch, switched: true, detachedHolder }, warnings }), true);
-    return;
+  render("root", ok({ path, data: { branch, switched: true, detachedHolder }, warnings }), json);
+};
+
+// src/domain/install-roots.ts
+var MANAGER_ROOTS = [
+  {
+    markers: ["/Cellar/", "/Caskroom/"],
+    manager: "Homebrew",
+    update: '"brew upgrade"',
+    ownsNpmPrefix: true
+  },
+  {
+    markers: ["/nix/store/"],
+    manager: "Nix",
+    update: "Nix (the store is read-only)",
+    ownsNpmPrefix: true
+  },
+  {
+    markers: ["/aquaproj-aqua/", "/aqua/pkgs/"],
+    manager: "aqua",
+    update: "aqua",
+    ownsNpmPrefix: false
+  },
+  { markers: ["/.proto/tools/"], manager: "proto", update: "proto", ownsNpmPrefix: false }
+];
+var reasonWithin = (path, roots) => {
+  const root2 = roots.find(({ markers }) => markers.some((marker) => path.includes(marker)));
+  return root2 === undefined ? null : `installed by ${root2.manager} (${path}); update it with ${root2.update}`;
+};
+var managerRootReason = (binaryPath) => reasonWithin(binaryPath, MANAGER_ROOTS);
+var managerNpmPrefixReason = (prefix) => reasonWithin(prefix, MANAGER_ROOTS.filter(({ ownsNpmPrefix }) => ownsNpmPrefix));
+
+// src/domain/self-update.ts
+var NPM_PACKAGE = "@n-seiji/nuthatch";
+var NPM_PACKAGE_LATEST = `${NPM_PACKAGE}@latest`;
+var GITHUB_REPO = "n-seiji/nuthatch";
+var GITHUB_LATEST_RELEASE_URL = `https://api.github.com/repos/${GITHUB_REPO}/releases/latest`;
+var NPM_LATEST_URL = `https://registry.npmjs.org/${NPM_PACKAGE.replace("/", "%2F")}/latest`;
+var releaseAssetUrl = (version, assetName) => `https://github.com/${GITHUB_REPO}/releases/download/v${version}/${assetName}`;
+var VERSION_PATTERN = /^(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)$/u;
+var TAG_PATTERN = /^v(?<version>\d+\.\d+\.\d+)$/u;
+var SHA256_HEX_PATTERN = /^[0-9a-f]{64}$/iu;
+var PATH_SEPARATOR2 = ":";
+var parseVersion = (text) => {
+  const groups = VERSION_PATTERN.exec(text)?.groups;
+  if (groups?.major === undefined || groups.minor === undefined || groups.patch === undefined) {
+    throw new Error(`unrecognized version "${text}" (expected x.y.z)`);
+  }
+  return [Number(groups.major), Number(groups.minor), Number(groups.patch)];
+};
+var compareVersions = (a2, b2) => {
+  const [aMajor, aMinor, aPatch] = parseVersion(a2);
+  const [bMajor, bMinor, bPatch] = parseVersion(b2);
+  return aMajor - bMajor || aMinor - bMinor || aPatch - bPatch;
+};
+var requireVersion = (text) => {
+  parseVersion(text);
+  return text;
+};
+var versionFromTag = (tag) => {
+  const version = TAG_PATTERN.exec(tag)?.groups?.version;
+  if (version === undefined) {
+    throw new Error(`unrecognized release tag "${tag}" (expected vX.Y.Z)`);
+  }
+  return version;
+};
+var parseChecksumFile = (text, assetName) => {
+  const [digest, file] = text.trim().split(/\s+/u);
+  if (digest === undefined || !SHA256_HEX_PATTERN.test(digest)) {
+    return { ok: false, reason: "is malformed" };
+  }
+  const named = file?.replace(/^\*/u, "");
+  if (named !== undefined && named !== assetName && !named.endsWith(`/${assetName}`)) {
+    return { ok: false, reason: `is for "${named}", not ${assetName}` };
+  }
+  return { ok: true, digest: digest.toLowerCase() };
+};
+var pathExecutableCandidates = (name, pathEnv, preferredDir = null) => {
+  const dirs = [
+    ...preferredDir === null ? [] : [preferredDir],
+    ...(pathEnv ?? "").split(PATH_SEPARATOR2)
+  ].map((entry) => entry.trim()).filter((entry) => entry.startsWith("/"));
+  return [...new Set(dirs.map((dir) => `${dir.endsWith("/") ? dir.slice(0, -1) : dir}/${name}`))];
+};
+var isWriteDenied = (error) => error instanceof Error && ("code" in error) && (error.code === "EACCES" || error.code === "EPERM" || error.code === "EROFS");
+
+// src/domain/install-script.ts
+var NPX_MARKER = "/_npx/";
+var BUNX_MARKER = "/bunx-";
+var BUN_GLOBAL_MARKER = "/.bun/install/global/node_modules/";
+var NPM_GLOBAL_MARKER = `/lib/node_modules/${NPM_PACKAGE}/`;
+var NODE_MODULES_MARKER = `/node_modules/${NPM_PACKAGE}/`;
+var PNPM_GLOBAL_MARKER = "/pnpm/global/";
+var YARN_GLOBAL_MARKER = "/yarn/global/";
+var unsupported = (reason) => ({ kind: "unsupported", reason });
+var npmGlobalPrefixOf = (scriptPath) => {
+  const index = scriptPath.lastIndexOf(NPM_GLOBAL_MARKER);
+  return index > 0 ? scriptPath.slice(0, index) : null;
+};
+var otherNodeModulesReason = (scriptPath) => {
+  if (scriptPath.includes(PNPM_GLOBAL_MARKER)) {
+    return `installed globally with pnpm, which hop does not drive; run "pnpm add -g ${NPM_PACKAGE_LATEST}" yourself`;
   }
-  process.stdout.write(`${path}
-`);
-  for (const warning of warnings) {
-    process.stderr.write(`warning: ${warning}
-`);
+  if (scriptPath.includes(YARN_GLOBAL_MARKER)) {
+    return `installed globally with yarn, which hop does not drive; run "yarn global add ${NPM_PACKAGE_LATEST}" yourself`;
+  }
+  return "installed as a project dependency (a local node_modules); update it in that project";
+};
+var detectScriptInstall = (scriptPath, npmGlobalPrefix) => {
+  if (scriptPath.includes(NPX_MARKER)) {
+    return unsupported("running through npx, which already fetches the published version on every run");
+  }
+  if (scriptPath.includes(BUNX_MARKER)) {
+    return unsupported("running through bunx, which already fetches the published version on every run");
+  }
+  if (scriptPath.includes(BUN_GLOBAL_MARKER)) {
+    return { kind: "bun" };
+  }
+  if (npmGlobalPrefix !== null) {
+    const managedBy = managerNpmPrefixReason(npmGlobalPrefix);
+    return managedBy === null ? { kind: "npm", prefix: npmGlobalPrefix } : unsupported(managedBy);
+  }
+  if (scriptPath.includes(NODE_MODULES_MARKER)) {
+    return unsupported(otherNodeModulesReason(scriptPath));
+  }
+  return unsupported("running from a source checkout; update it with git (git pull)");
+};
+
+// src/domain/posix-path.ts
+var withoutTrailingSlash = (path) => path.length > 1 && path.endsWith("/") ? path.slice(0, -1) : path;
+var parentDir = (path) => {
+  const trimmed = withoutTrailingSlash(path);
+  const index = trimmed.lastIndexOf("/");
+  if (index === -1) {
+    return ".";
+  }
+  return index === 0 ? "/" : trimmed.slice(0, index);
+};
+var baseName = (path) => {
+  const trimmed = withoutTrailingSlash(path);
+  return trimmed.slice(trimmed.lastIndexOf("/") + 1);
+};
+
+// src/domain/mise-tool.ts
+var MISE_WALK_LIMIT = 8;
+var HOP_BACKEND_PATTERN = /^[a-z0-9_-]+:@?n-seiji\/nuthatch$/iu;
+var HOP_TOOL_DIR_PATTERN = /(?:^|-)n-seiji-nuthatch$/iu;
+var parseMiseBackendToml = (text) => {
+  const match = /^\s*full\s*=\s*"(?<tool>[^"]+)"\s*$/mu.exec(text);
+  return match?.groups?.tool ?? null;
+};
+var parseLegacyMiseBackend = (text) => {
+  const lines = text.split(`
+`).map((line) => line.trim()).filter((line) => line.length > 0);
+  return lines.at(-1) ?? null;
+};
+var withoutToolOptions = (backend) => backend.replace(/\[[^\]]*\]$/u, "");
+var isHopBackend = (backend) => HOP_BACKEND_PATTERN.test(backend);
+var isHopToolDirName = (name) => HOP_TOOL_DIR_PATTERN.test(name);
+var ancestorDirs = (path, limit) => {
+  const dirs = [];
+  let dir = parentDir(path);
+  while (dirs.length < limit && dir !== "/" && dir !== ".") {
+    dirs.push(dir);
+    dir = parentDir(dir);
+  }
+  return dirs;
+};
+var miseToolDir = (path) => ancestorDirs(path, MISE_WALK_LIMIT).find((dir) => baseName(parentDir(dir)) === "installs") ?? null;
+
+// src/domain/install-method.ts
+var RELEASE_ASSETS = new Map([
+  ["darwin-arm64", "hop-darwin-arm64"],
+  ["darwin-x64", "hop-darwin-x64"],
+  ["linux-x64", "hop-linux-x64"]
+]);
+var releaseAssetName = (platform2, arch) => RELEASE_ASSETS.get(`${platform2}-${arch}`) ?? null;
+var GITHUB_BACKEND_PREFIXES = ["github:", "ubi:", "aqua:"];
+var NPM_BACKEND_PREFIX = "npm:";
+var unsupported2 = (reason) => ({
+  kind: "unsupported",
+  reason
+});
+var miseChannel = (tool) => {
+  if (tool.startsWith(NPM_BACKEND_PREFIX)) {
+    return "npm";
+  }
+  return GITHUB_BACKEND_PREFIXES.some((prefix) => tool.startsWith(prefix)) ? "github" : null;
+};
+var insideVersionManager = (dir, marker) => unsupported2(`installed under a version manager's install dir (${dir}) ${marker}; update it with the tool that installed it`);
+var detectUnmarkedToolDir = (dir, compiled) => {
+  if (isHopToolDirName(baseName(dir))) {
+    return unsupported2(`installed by mise, but its backend is unknown (no readable marker in ${dir}); run "mise upgrade" yourself`);
+  }
+  return compiled ? insideVersionManager(dir, "without a readable mise marker") : null;
+};
+var detectMise = ({ mise, compiled }) => {
+  if (mise === null) {
+    return null;
+  }
+  if (mise.backend === null) {
+    return detectUnmarkedToolDir(mise.dir, compiled);
+  }
+  const tool = withoutToolOptions(mise.backend);
+  if (!isHopBackend(tool)) {
+    return compiled ? insideVersionManager(mise.dir, `whose marker names "${tool}", not hop`) : null;
+  }
+  const channel = miseChannel(tool);
+  return channel === null ? unsupported2(`mise installed hop through "${tool}", which is neither a GitHub nor an npm backend; run "mise upgrade ${tool}" yourself`) : { kind: "mise", tool, channel };
+};
+var detectStandalone = (facts) => {
+  const { executablePath, platform: platform2, arch } = facts;
+  if (executablePath === null) {
+    return unsupported2("cannot tell where the hop binary is installed");
+  }
+  const managedBy = managerRootReason(executablePath);
+  if (managedBy !== null) {
+    return unsupported2(managedBy);
+  }
+  const assetName = releaseAssetName(platform2, arch);
+  if (assetName === null) {
+    return unsupported2(`there is no prebuilt binary for ${platform2}-${arch}; install with npm instead (npm i -g ${NPM_PACKAGE})`);
+  }
+  return {
+    kind: "standalone",
+    binaryPath: executablePath,
+    installDir: parentDir(executablePath),
+    assetName
+  };
+};
+var detectInstallMethod = (facts) => {
+  const mise = detectMise(facts);
+  if (mise !== null) {
+    return mise;
+  }
+  return facts.compiled ? detectStandalone(facts) : detectScriptInstall(facts.scriptPath ?? "", facts.npmGlobalPrefix);
+};
+var latestChannel = (method) => {
+  if (method.kind === "mise") {
+    return method.channel;
+  }
+  return method.kind === "standalone" ? "github" : "npm";
+};
+var upgradeCommand = (method) => {
+  if (method.kind === "mise") {
+    return ["mise", "upgrade", method.tool];
+  }
+  return method.kind === "npm" ? ["npm", "install", "-g", "--prefix", method.prefix, NPM_PACKAGE_LATEST] : ["bun", "add", "-g", NPM_PACKAGE_LATEST];
+};
+var miseDryRunCommand = (method) => [
+  "mise",
+  "upgrade",
+  "--dry-run-code",
+  method.tool
+];
+var preferredProgramDir = (method) => method.kind === "npm" ? `${method.prefix}/bin` : null;
+
+// src/commands/self-update-attempt.ts
+var attempt = async (run) => {
+  try {
+    return { ok: true, value: await run() };
+  } catch (error) {
+    return { ok: false, error };
+  }
+};
+
+// src/commands/self-update-delegated.ts
+var MISE_WOULD_NOT_UPGRADE = 0;
+var runLogged = (port, term, executable, [, ...args]) => {
+  const command = [executable, ...args];
+  term.logStderr(`Running: ${command.join(" ")}`);
+  return attempt(() => port.runCommand(command));
+};
+var miseNothingToUpgradeWarning = ({ tool }, { current, latest }) => [
+  `mise has nothing to upgrade for ${tool}, so hop stays at ${current} although ${latest} is the latest release.`,
+  "Likely causes: the version is pinned in your global mise config, a minimum_release_age setting holds the release back,",
+  `or ${tool} is not in your global mise config (hop runs mise from your home directory, so a project's mise.toml does not count).`,
+  `Run "mise upgrade --dry-run ${tool}" from your home directory to see what mise decides.`
+].join(" ");
+var runDelegated = async (port, term, method, base) => {
+  const argv2 = upgradeCommand(method);
+  const [program] = argv2;
+  const command = argv2.join(" ");
+  const executable = await port.resolveExecutable(program, preferredProgramDir(method));
+  if (executable === null) {
+    return fail(EXIT_GENERAL_ERROR, `Cannot find "${program}" on PATH. Run it yourself: ${command}`);
+  }
+  if (method.kind === "mise") {
+    const question = miseDryRunCommand(method);
+    const answer = await runLogged(port, term, executable, question);
+    if (!answer.ok) {
+      return fail(EXIT_GENERAL_ERROR, `Failed to run ${question.join(" ")}: ${messageOf(answer.error)}`);
+    }
+    if (answer.value === MISE_WOULD_NOT_UPGRADE) {
+      return ok({ data: base, warnings: [miseNothingToUpgradeWarning(method, base)] });
+    }
+  }
+  const run = await runLogged(port, term, executable, argv2);
+  if (!run.ok) {
+    return fail(EXIT_GENERAL_ERROR, `Failed to run ${command}: ${messageOf(run.error)}`);
+  }
+  if (run.value !== 0) {
+    return fail(EXIT_GENERAL_ERROR, `${command} exited with code ${run.value}.`);
+  }
+  term.logStderr(`${command} finished; run "hop --version" to see which version you have now.`);
+  return ok({ data: { ...base, action: "delegated", command: [...argv2] } });
+};
+
+// src/commands/self-update-standalone.ts
+var checksumRejection = (port, assetName, checksumText, bytes) => {
+  const expected = parseChecksumFile(checksumText, assetName);
+  if (!expected.ok) {
+    return fail(EXIT_SAFE_REJECTION, `The checksum file ${assetName}.sha256 ${expected.reason}; refusing to install an unverified binary.`);
+  }
+  const actual = port.sha256Hex(bytes);
+  if (actual !== expected.digest) {
+    return fail(EXIT_SAFE_REJECTION, `Checksum mismatch for ${assetName} (expected ${expected.digest}, got ${actual}); refusing to install it. Nothing was changed.`);
+  }
+  return null;
+};
+var replaceFailureMessage = (method, error) => isWriteDenied(error) ? `Cannot write ${method.installDir}; reinstall hop somewhere writable (install.sh uses ~/.local/bin).` : `Failed to replace ${method.binaryPath}: ${messageOf(error)}`;
+var replaceStandalone = async (port, term, method, base) => {
+  const { assetName, binaryPath } = method;
+  const checksumAsset = `${assetName}.sha256`;
+  const writable = await attempt(() => port.assertWritableDir(method.installDir));
+  if (!writable.ok) {
+    return fail(EXIT_GENERAL_ERROR, replaceFailureMessage(method, writable.error));
+  }
+  term.logStderr(`Downloading ${assetName} v${base.latest}...`);
+  const checksum = await attempt(() => port.downloadReleaseText(base.latest, checksumAsset));
+  if (!checksum.ok) {
+    return fail(EXIT_GENERAL_ERROR, `Failed to download ${checksumAsset}: ${messageOf(checksum.error)}`);
+  }
+  const binary = await attempt(() => port.downloadReleaseAsset(base.latest, assetName));
+  if (!binary.ok) {
+    return fail(EXIT_GENERAL_ERROR, `Failed to download ${assetName}: ${messageOf(binary.error)}`);
+  }
+  const rejection = checksumRejection(port, assetName, checksum.value, binary.value);
+  if (rejection !== null) {
+    return rejection;
+  }
+  term.logStderr(`Checksum verified. Replacing ${binaryPath}...`);
+  const replaced = await attempt(() => port.replaceExecutable(binaryPath, binary.value));
+  if (!replaced.ok) {
+    return fail(EXIT_GENERAL_ERROR, replaceFailureMessage(method, replaced.error));
+  }
+  term.logStderr(`Updated hop ${base.current} -> ${base.latest}.`);
+  return ok({ data: { ...base, action: "replaced" } });
+};
+
+// src/commands/self-update.ts
+var fetchLatest = (port, method) => latestChannel(method) === "npm" ? port.latestNpmVersion() : port.latestGithubVersion();
+var checkCommand = (method) => method.kind === "standalone" ? null : [...upgradeCommand(method)];
+var describeCheck = (method, base) => {
+  const how = method.kind === "standalone" ? `replaces ${method.binaryPath}` : `runs: ${upgradeCommand(method).join(" ")}`;
+  return `Update available: ${base.current} -> ${base.latest}. "hop --update" ${how}.`;
+};
+var selfUpdate = async (port, term, options) => {
+  const facts = await attempt(() => port.installFacts());
+  if (!facts.ok) {
+    return fail(EXIT_GENERAL_ERROR, `Cannot update hop: could not tell how it was installed (${messageOf(facts.error)}).`);
+  }
+  const method = detectInstallMethod(facts.value);
+  if (method.kind === "unsupported") {
+    return fail(EXIT_GENERAL_ERROR, `Cannot update hop: ${method.reason}.`);
+  }
+  term.logStderr("Checking for the latest release...");
+  const release = await attempt(async () => {
+    const latest = await fetchLatest(port, method);
+    return {
+      latest,
+      updateAvailable: compareVersions(latest, options.currentVersion) > 0
+    };
+  });
+  if (!release.ok) {
+    return fail(EXIT_GENERAL_ERROR, `Failed to check for the latest release: ${messageOf(release.error)}`);
+  }
+  const base = {
+    current: options.currentVersion,
+    latest: release.value.latest,
+    updateAvailable: release.value.updateAvailable,
+    method: method.kind,
+    action: "none",
+    command: null
+  };
+  if (!base.updateAvailable) {
+    term.logStderr(`hop ${base.current} is up to date (latest release: ${base.latest}).`);
+    return ok({ data: base });
+  }
+  if (options.check) {
+    term.logStderr(describeCheck(method, base));
+    return ok({ data: { ...base, command: checkCommand(method) } });
+  }
+  return method.kind === "standalone" ? replaceStandalone(port, term, method, base) : runDelegated(port, term, method, base);
+};
+
+// src/infra/install-facts.ts
+import { readFile as readFile2, realpath } from "node:fs/promises";
+import { join as join3 } from "node:path";
+var MISE_BACKEND_TOML = ".mise.backend.toml";
+var MISE_BACKEND_LEGACY = ".mise.backend";
+var realpathOrNull = async (path) => {
+  try {
+    return await realpath(path);
+  } catch {
+    return null;
+  }
+};
+var realpathOrSelf = async (path) => await realpathOrNull(path) ?? path;
+var readTextOrNull = async (path) => {
+  try {
+    return await readFile2(path, "utf8");
+  } catch {
+    return null;
+  }
+};
+var readMiseBackend = async (dir) => {
+  const toml = await readTextOrNull(join3(dir, MISE_BACKEND_TOML));
+  const fromToml = toml === null ? null : parseMiseBackendToml(toml);
+  if (fromToml !== null) {
+    return fromToml;
+  }
+  const legacy = await readTextOrNull(join3(dir, MISE_BACKEND_LEGACY));
+  return legacy === null ? null : parseLegacyMiseBackend(legacy);
+};
+var findMiseTool = async (path) => {
+  const dir = path === null ? null : miseToolDir(path);
+  return dir === null ? null : { dir, backend: await readMiseBackend(dir) };
+};
+var verifiedNpmPrefix = async (scriptPath) => {
+  const prefix = scriptPath === null ? null : npmGlobalPrefixOf(scriptPath);
+  if (prefix === null) {
+    return null;
+  }
+  return await realpathOrNull(join3(prefix, "bin", "hop")) === scriptPath ? prefix : null;
+};
+var readInstallFacts = async (source) => {
+  const executablePath = source.compiled ? await realpathOrSelf(source.execPath) : null;
+  const scriptPath = source.compiled || source.argv1 === undefined ? null : await realpathOrSelf(source.argv1);
+  return {
+    compiled: source.compiled,
+    executablePath,
+    scriptPath,
+    mise: await findMiseTool(executablePath ?? scriptPath),
+    npmGlobalPrefix: await verifiedNpmPrefix(scriptPath),
+    platform: source.platform,
+    arch: source.arch
+  };
+};
+
+// src/infra/package-manager.ts
+import { spawn } from "node:child_process";
+import { constants } from "node:fs";
+import { access, stat } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { basename as basename2 } from "node:path";
+var STDERR_FD = 2;
+var isExecutableFile = async (path) => {
+  try {
+    const stats = await stat(path);
+    if (!stats.isFile()) {
+      return false;
+    }
+    await access(path, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var resolveExecutable = async (name, pathEnv, preferredDir = null) => {
+  const probes = pathExecutableCandidates(name, pathEnv, preferredDir).map(async (candidate) => await isExecutableFile(candidate) ? candidate : null);
+  for (const probe of probes) {
+    const found = await probe;
+    if (found !== null) {
+      return found;
+    }
+  }
+  return null;
+};
+var runCommand2 = (argv2) => new Promise((resolve, reject) => {
+  const [program, ...args] = argv2;
+  const child = spawn(program, args, {
+    cwd: homedir2(),
+    stdio: ["inherit", STDERR_FD, STDERR_FD]
+  });
+  child.once("error", reject);
+  child.once("close", (code, signal) => {
+    if (code === null) {
+      reject(new Error(`${basename2(program)} was killed by signal ${signal ?? "unknown"}`));
+      return;
+    }
+    resolve(code);
+  });
+});
+
+// src/infra/release-binary.ts
+import { createHash, randomBytes } from "node:crypto";
+import { constants as constants2 } from "node:fs";
+import { access as access2, open, realpath as realpath2, rename, rm as rm3 } from "node:fs/promises";
+import { basename as basename3, dirname as dirname2, join as join4 } from "node:path";
+var EXECUTABLE_MODE = 493;
+var TEMP_SUFFIX_BYTES = 6;
+var sha256Hex = (bytes) => createHash("sha256").update(bytes).digest("hex");
+var removeQuietly = async (path) => {
+  try {
+    await rm3(path, { force: true });
+  } catch {}
+};
+var writeDurably = async (path, bytes) => {
+  const handle = await open(path, "wx", EXECUTABLE_MODE);
+  try {
+    await handle.writeFile(bytes);
+    await handle.chmod(EXECUTABLE_MODE);
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+};
+var replaceExecutable = async (path, bytes) => {
+  const target = await realpath2(path);
+  const suffix = randomBytes(TEMP_SUFFIX_BYTES).toString("hex");
+  const temp = join4(dirname2(target), `.${basename3(target)}.update-${suffix}`);
+  try {
+    await writeDurably(temp, bytes);
+    await rename(temp, target);
+  } catch (error) {
+    await removeQuietly(temp);
+    throw error;
+  }
+};
+var assertWritableDir = (dir) => access2(dir, constants2.W_OK | constants2.X_OK);
+
+// node_modules/valibot/dist/index.mjs
+var store$4;
+var DEFAULT_CONFIG = {
+  lang: undefined,
+  message: undefined,
+  abortEarly: undefined,
+  abortPipeEarly: undefined
+};
+function getGlobalConfig(config$1) {
+  if (!config$1 && !store$4)
+    return DEFAULT_CONFIG;
+  return {
+    lang: config$1?.lang ?? store$4?.lang,
+    message: config$1?.message,
+    abortEarly: config$1?.abortEarly ?? store$4?.abortEarly,
+    abortPipeEarly: config$1?.abortPipeEarly ?? store$4?.abortPipeEarly
+  };
+}
+var store$3;
+function getGlobalMessage(lang) {
+  return store$3?.get(lang);
+}
+var store$2;
+function getSchemaMessage(lang) {
+  return store$2?.get(lang);
+}
+var store$1;
+function getSpecificMessage(reference, lang) {
+  return store$1?.get(reference)?.get(lang);
+}
+function _stringify(input) {
+  const type = typeof input;
+  if (type === "string")
+    return `"${input}"`;
+  if (type === "number" || type === "bigint" || type === "boolean")
+    return `${input}`;
+  if (type === "object" || type === "function")
+    return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
+  return type;
+}
+function _addIssue(context, label, dataset, config$1, other) {
+  const input = other && "input" in other ? other.input : dataset.value;
+  const expected = other?.expected ?? context.expects ?? null;
+  const received = other?.received ?? /* @__PURE__ */ _stringify(input);
+  const issue = {
+    kind: context.kind,
+    type: context.type,
+    input,
+    expected,
+    received,
+    message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
+    requirement: context.requirement,
+    path: other?.path,
+    issues: other?.issues,
+    lang: config$1.lang,
+    abortEarly: config$1.abortEarly,
+    abortPipeEarly: config$1.abortPipeEarly
+  };
+  const isSchema = context.kind === "schema";
+  const message$1 = other?.message ?? context.message ?? /* @__PURE__ */ getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? /* @__PURE__ */ getSchemaMessage(issue.lang) : null) ?? config$1.message ?? /* @__PURE__ */ getGlobalMessage(issue.lang);
+  if (message$1 !== undefined)
+    issue.message = typeof message$1 === "function" ? message$1(issue) : message$1;
+  if (isSchema)
+    dataset.typed = false;
+  if (dataset.issues)
+    dataset.issues.push(issue);
+  else
+    dataset.issues = [issue];
+}
+var _standardCache = /* @__PURE__ */ new WeakMap;
+function _getStandardProps(context) {
+  let cached = _standardCache.get(context);
+  if (!cached) {
+    cached = {
+      version: 1,
+      vendor: "valibot",
+      validate(value$1) {
+        return context["~run"]({ value: value$1 }, /* @__PURE__ */ getGlobalConfig());
+      }
+    };
+    _standardCache.set(context, cached);
+  }
+  return cached;
+}
+function getFallback(schema, dataset, config$1) {
+  return typeof schema.fallback === "function" ? schema.fallback(dataset, config$1) : schema.fallback;
+}
+function getDefault(schema, dataset, config$1) {
+  return typeof schema.default === "function" ? schema.default(dataset, config$1) : schema.default;
+}
+function object(entries$1, message$1) {
+  return {
+    kind: "schema",
+    type: "object",
+    reference: object,
+    expects: "Object",
+    async: false,
+    entries: entries$1,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      const input = dataset.value;
+      if (input && typeof input === "object") {
+        dataset.typed = true;
+        dataset.value = {};
+        for (const key in this.entries) {
+          const valueSchema = this.entries[key];
+          if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== undefined) {
+            const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
+            const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
+            if (valueDataset.issues) {
+              const pathItem = {
+                type: "object",
+                origin: "value",
+                input,
+                key,
+                value: value$1
+              };
+              for (const issue of valueDataset.issues) {
+                if (issue.path)
+                  issue.path.unshift(pathItem);
+                else
+                  issue.path = [pathItem];
+                dataset.issues?.push(issue);
+              }
+              if (!dataset.issues)
+                dataset.issues = valueDataset.issues;
+              if (config$1.abortEarly) {
+                dataset.typed = false;
+                break;
+              }
+            }
+            if (!valueDataset.typed)
+              dataset.typed = false;
+            dataset.value[key] = valueDataset.value;
+          } else if (valueSchema.fallback !== undefined)
+            dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
+          else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+            _addIssue(this, "key", dataset, config$1, {
+              input: undefined,
+              expected: `"${key}"`,
+              path: [{
+                type: "object",
+                origin: "key",
+                input,
+                key,
+                value: input[key]
+              }]
+            });
+            if (config$1.abortEarly)
+              break;
+          }
+        }
+      } else
+        _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+function string(message$1) {
+  return {
+    kind: "schema",
+    type: "string",
+    reference: string,
+    expects: "string",
+    async: false,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (typeof dataset.value === "string")
+        dataset.typed = true;
+      else
+        _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+function safeParse(schema, input, config$1) {
+  const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config$1));
+  return {
+    typed: dataset.typed,
+    success: !dataset.issues,
+    output: dataset.value,
+    issues: dataset.issues
+  };
+}
+
+// src/infra/capped-body.ts
+var tooLarge = (maxBytes) => new Error(`the response is larger than ${maxBytes} bytes`);
+var concatenate = (chunks, total) => {
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return bytes;
+};
+var readCapped = async (response, maxBytes) => {
+  const declared = Math.trunc(Number(response.headers.get("content-length") ?? ""));
+  if (declared > maxBytes) {
+    await response.body?.cancel();
+    throw tooLarge(maxBytes);
+  }
+  const chunks = [];
+  let received = 0;
+  for await (const chunk of response.body ?? []) {
+    received += chunk.length;
+    if (received > maxBytes) {
+      throw tooLarge(maxBytes);
+    }
+    chunks.push(chunk);
+  }
+  return concatenate(chunks, received);
+};
+
+// src/infra/release-http.ts
+var METADATA_TIMEOUT_MS = 15000;
+var ASSET_TIMEOUT_MS = 300000;
+var METADATA_MAX_BYTES = 1048576;
+var CHECKSUM_MAX_BYTES = 4096;
+var BINARY_MAX_BYTES = 268435456;
+var GITHUB_API_ORIGIN = "https://api.github.com/";
+var HTTP_FORBIDDEN = 403;
+var HTTP_TOO_MANY_REQUESTS = 429;
+var GithubLatestSchema = object({ tag_name: string() });
+var NpmLatestSchema = object({ version: string() });
+var DECODER = new TextDecoder;
+var send = async (fetcher, url, { headers, timeoutMs }) => {
+  try {
+    return await fetcher(url, {
+      headers,
+      redirect: "follow",
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+  } catch (error) {
+    throw new Error(`GET ${url} failed: ${messageOf(error)}`, { cause: error });
+  }
+};
+var rateLimitHint = (url, response) => {
+  const refused = response.status === HTTP_FORBIDDEN || response.status === HTTP_TOO_MANY_REQUESTS;
+  const exhausted = refused && response.headers.get("x-ratelimit-remaining") === "0";
+  return exhausted && url.startsWith(GITHUB_API_ORIGIN) ? " (the unauthenticated GitHub API rate limit was hit; try again later)" : "";
+};
+var discardBody = async (response) => {
+  try {
+    await response.body?.cancel();
+  } catch {}
+};
+var get = async (fetcher, url, options) => {
+  const response = await send(fetcher, url, options);
+  if (!response.ok) {
+    await discardBody(response);
+    throw new Error(`GET ${url} failed: HTTP ${response.status}${rateLimitHint(url, response)}`);
+  }
+  if (response.url.startsWith("http://")) {
+    await discardBody(response);
+    throw new Error(`GET ${url} failed: redirected to ${response.url}, which is not HTTPS`);
+  }
+  return response;
+};
+var readBody = async (url, read) => {
+  try {
+    return await read();
+  } catch (error) {
+    throw new Error(`GET ${url} failed while reading the response: ${messageOf(error)}`, {
+      cause: error
+    });
+  }
+};
+var getBytes = async (fetcher, url, options) => {
+  const response = await get(fetcher, url, options);
+  return await readBody(url, () => readCapped(response, options.maxBytes));
+};
+var getJson = async (fetcher, url, schema, options) => {
+  const bytes = await getBytes(fetcher, url, options);
+  const body = await readBody(url, () => JSON.parse(DECODER.decode(bytes)));
+  const parsed = safeParse(schema, body);
+  if (!parsed.success) {
+    throw new Error(`GET ${url} returned an unexpected response`);
+  }
+  return parsed.output;
+};
+var createReleaseHttp = (userAgent, fetcher = fetch) => ({
+  async latestGithubVersion() {
+    const release = await getJson(fetcher, GITHUB_LATEST_RELEASE_URL, GithubLatestSchema, {
+      headers: {
+        Accept: "application/vnd.github+json",
+        "User-Agent": userAgent
+      },
+      timeoutMs: METADATA_TIMEOUT_MS,
+      maxBytes: METADATA_MAX_BYTES
+    });
+    return versionFromTag(release.tag_name);
+  },
+  async latestNpmVersion() {
+    const latest = await getJson(fetcher, NPM_LATEST_URL, NpmLatestSchema, {
+      headers: { Accept: "application/json", "User-Agent": userAgent },
+      timeoutMs: METADATA_TIMEOUT_MS,
+      maxBytes: METADATA_MAX_BYTES
+    });
+    return requireVersion(latest.version);
+  },
+  async downloadReleaseAsset(version, assetName) {
+    return await getBytes(fetcher, releaseAssetUrl(version, assetName), {
+      headers: { Accept: "application/octet-stream", "User-Agent": userAgent },
+      timeoutMs: ASSET_TIMEOUT_MS,
+      maxBytes: BINARY_MAX_BYTES
+    });
+  },
+  async downloadReleaseText(version, assetName) {
+    const bytes = await getBytes(fetcher, releaseAssetUrl(version, assetName), {
+      headers: { Accept: "text/plain", "User-Agent": userAgent },
+      timeoutMs: METADATA_TIMEOUT_MS,
+      maxBytes: CHECKSUM_MAX_BYTES
+    });
+    return DECODER.decode(bytes);
+  }
+});
+
+// src/infra/self-update.ts
+var createSelfUpdatePort = ({
+  compiled,
+  version
+}) => ({
+  installFacts: () => readInstallFacts({
+    compiled,
+    execPath: process.execPath,
+    argv1: process.argv[1],
+    platform: process.platform,
+    arch: process.arch
+  }),
+  ...createReleaseHttp(`hop/${version}`),
+  sha256Hex,
+  assertWritableDir,
+  replaceExecutable,
+  resolveExecutable: (name, preferredDir) => resolveExecutable(name, process.env.PATH, preferredDir),
+  runCommand: runCommand2
+});
+// package.json
+var package_default = {
+  name: "@n-seiji/nuthatch",
+  version: "0.1.5",
+  description: "git worktree manager (hop)",
+  homepage: "https://github.com/n-seiji/nuthatch#readme",
+  bugs: {
+    url: "https://github.com/n-seiji/nuthatch/issues"
+  },
+  license: "GPL-3.0-only",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/n-seiji/nuthatch.git"
+  },
+  bin: {
+    hop: "dist/cli.js"
+  },
+  files: [
+    "dist",
+    "shell"
+  ],
+  type: "module",
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    build: "bun build ./src/cli.ts --outfile dist/cli.js --target node --format esm",
+    typecheck: "tsc --noEmit",
+    lint: "oxlint .",
+    "lint:fix": "oxlint . --fix",
+    format: "oxfmt --write .",
+    "format:check": "oxfmt --check .",
+    test: "bun test"
+  },
+  dependencies: {
+    citty: "^0.1.6",
+    valibot: "^1.4.2"
+  },
+  devDependencies: {
+    "@types/bun": "latest",
+    oxfmt: "^0.66.0",
+    oxlint: "^1.81.0",
+    typescript: "^5.6.0"
+  },
+  engines: {
+    node: ">=22"
+  }
+};
+
+// src/version.ts
+var VERSION = package_default.version;
+
+// src/cli-update.ts
+var UPDATE_ARGS = {
+  check: { type: "boolean", description: "Only report; change nothing" },
+  json: { type: "boolean", description: "Output JSON" }
+};
+var UPDATE_FLAGS = new Set(["--check", "--json"]);
+var parseUpdateArgs = (tokens) => {
+  const stray = tokens.filter((token) => !UPDATE_FLAGS.has(token));
+  if (stray.length > 0) {
+    return {
+      ok: false,
+      json: wantsJson(tokens),
+      message: `Unknown argument for --update: ${stray.join(" ")}. Usage: hop --update [--check] [--json]`
+    };
+  }
+  const args = parseArgs([...tokens], UPDATE_ARGS);
+  return { ok: true, check: Boolean(args.check), json: Boolean(args.json) };
+};
+var runUpdate = async (rawArgs, term) => {
+  try {
+    const parsed = parseUpdateArgs(rawArgs.slice(1));
+    if (!parsed.ok) {
+      reportResult("update", fail(EXIT_USAGE_ERROR, parsed.message), parsed.json);
+      return;
+    }
+    const port = createSelfUpdatePort({
+      compiled: isRunningAsCompiledBinary(),
+      version: VERSION
+    });
+    const result = await selfUpdate(port, term, {
+      currentVersion: VERSION,
+      check: parsed.check
+    });
+    reportResult("update", result, parsed.json);
+  } catch (error) {
+    reportFatalError("update", wantsJson(rawArgs), error);
   }
 };
 
@@ -4373,11 +5359,11 @@ var classifyGarbage = (input) => {
 };
 
 // src/commands/clean-candidates.ts
-var buildCleanCandidates = async (git, context, ext) => {
+var buildCleanCandidates = async (git, fs, context, ext) => {
   const defaultRef = await git.resolveDefaultBranchRef(context.rootPath);
   const targets = context.worktrees.filter((wt) => wt.kind === "managed" || ext && wt.kind === "external");
   const results = await Promise.all(targets.map(async (wt) => {
-    const reason = await classifyWorktree(wt, { git, defaultRef, context });
+    const reason = await classifyWorktree(wt, { git, fs, defaultRef, context });
     if (reason === null) {
       return null;
     }
@@ -4385,7 +5371,7 @@ var buildCleanCandidates = async (git, context, ext) => {
   }));
   return results.filter((candidate) => candidate !== null);
 };
-var classifyWorktree = async (wt, { git, defaultRef, context }) => {
+var classifyWorktree = async (wt, { git, fs, defaultRef, context }) => {
   if (wt.prunable) {
     return classifyGarbage({
       prunable: true,
@@ -4399,15 +5385,15 @@ var classifyWorktree = async (wt, { git, defaultRef, context }) => {
     return null;
   }
   const { rootPath, worktrees } = context;
-  const [isClean, upstreamGone] = await Promise.all([
-    wt.bare ? Promise.resolve(false) : (async () => !await git.isDirty(wt.path, otherWorktreePaths(worktrees, wt.path)))(),
+  const [dirtyState, upstreamGone] = await Promise.all([
+    worktreeDirtyState(git, fs, worktrees, wt),
     git.isUpstreamGone(rootPath, wt.branch)
   ]);
   const mergedIntoDefault = defaultRef === null ? "unknown" : await git.isAncestor(rootPath, wt.branch, defaultRef);
   const allCommitsReachableFromDefault = defaultRef === null ? "unknown" : await git.hasEquivalentCommits(rootPath, wt.branch, defaultRef);
   const input = {
     prunable: false,
-    clean: isClean,
+    clean: dirtyState === false,
     mergedIntoDefault,
     upstreamGone,
     allCommitsReachableFromDefault
@@ -4418,7 +5404,7 @@ var classifyWorktree = async (wt, { git, defaultRef, context }) => {
 // src/commands/clean.ts
 var clean = async (git, fs, term, options) => {
   const context = await loadRepoContext(git, fs, options.cwd);
-  const candidates = await buildCleanCandidates(git, context, options.ext);
+  const candidates = await buildCleanCandidates(git, fs, context, options.ext);
   if (options.dryRun) {
     return ok({ data: { candidates } });
   }
@@ -4437,20 +5423,13 @@ var clean = async (git, fs, term, options) => {
       return ok({ data: { candidates, removed: [] } });
     }
   }
-  const execution = await executeClean({
+  return executeClean({
     git,
     fs,
     context,
     candidates,
     cleanOptions: options
   });
-  if (!execution.ok) {
-    return execution.rejection;
-  }
-  return ok({
-    data: { candidates, removed: execution.removed },
-    ...execution.warnings.length === 0 ? {} : { warnings: execution.warnings }
-  });
 };
 var removeCandidate = async ({
   git,
@@ -4460,16 +5439,16 @@ var removeCandidate = async ({
   worktrees
 }) => {
   if (nestedWorktrees(worktrees, candidate.path).length > 0) {
-    return false;
+    return "nested";
   }
   try {
     await git.removeWorktree(rootPath, candidate.path, false);
     if (deleteBranch && candidate.branch.length > 0) {
       await git.deleteBranch(rootPath, candidate.branch);
     }
-    return true;
+    return "removed";
   } catch {
-    return false;
+    return "failed";
   }
 };
 var canDeletePrunableBranch = async (git, rootPath, candidate, defaultRef) => {
@@ -4490,21 +5469,16 @@ var canDeletePrunableBranch = async (git, rootPath, candidate, defaultRef) => {
   } catch {}
   return false;
 };
-var executeClean = async ({
+var executeClean = ({
   git,
   fs,
   context,
   candidates,
   cleanOptions
-}) => {
-  const acquisition = await acquireRepoLockOrRejection(context.commonDir);
-  if (!acquisition.ok) {
-    return { ok: false, rejection: acquisition.rejection };
-  }
-  const { lock } = acquisition;
+}) => withRepoLock(context.commonDir, async () => {
   try {
     const fresh = await loadRepoContext(git, fs, context.rootPath);
-    const freshCandidates = await buildCleanCandidates(git, fresh, cleanOptions.ext);
+    const freshCandidates = await buildCleanCandidates(git, fs, fresh, cleanOptions.ext);
     const freshByPath = new Map(freshCandidates.map((candidate) => [candidate.path, candidate]));
     const stillValid = candidates.flatMap((candidate) => {
       const freshCandidate = freshByPath.get(candidate.path);
@@ -4519,30 +5493,29 @@ var executeClean = async ({
       if (cleanOptions.withBranch && candidate.reason === "prunable" && candidate.branch.length > 0 && !branchSafe) {
         warnings.push(`Keeping branch "${candidate.branch}": prunable worktree is not confirmed merged or gone.`);
       }
-      if (nestedWorktrees(fresh.worktrees, candidate.path).length > 0) {
+      const outcome = await removeCandidate({
+        git,
+        rootPath: fresh.rootPath,
+        candidate,
+        deleteBranch,
+        worktrees: fresh.worktrees
+      });
+      if (outcome === "removed") {
+        removed.push(candidate.branch);
+      } else if (outcome === "nested") {
         warnings.push(`Skipped ${candidate.path}: still contains a registered worktree.`);
-      } else {
-        const success = await removeCandidate({
-          git,
-          rootPath: fresh.rootPath,
-          candidate,
-          deleteBranch,
-          worktrees: fresh.worktrees
-        });
-        if (success) {
-          removed.push(candidate.branch);
-        }
       }
     }
-    return { ok: true, removed, warnings };
+    return ok({
+      data: { candidates: [...candidates], removed },
+      ...warnings.length === 0 ? {} : { warnings }
+    });
   } catch (error) {
-    throw new Error(`Failed to clean worktrees: ${error.message}`, {
+    throw new Error(`Failed to clean worktrees: ${messageOf(error)}`, {
       cause: error
     });
-  } finally {
-    await lock.release();
   }
-};
+});
 
 // src/commands/init.ts
 var ZSH_TEMPLATE = `# nuthatch shell integration for zsh.
@@ -4601,7 +5574,7 @@ var renderInit = (options) => {
 };
 
 // src/commands/jump.ts
-import { join as join3 } from "node:path";
+import { join as join5 } from "node:path";
 
 // src/domain/sanitize.ts
 var MAX_DIR_NAME_LENGTH = 200;
@@ -4618,10 +5591,10 @@ var shortHash = (input) => {
   }
   return (hash >>> 0).toString(HEX_RADIX).padStart(FULL_HASH_HEX_LENGTH, "0").slice(0, HASH_LENGTH);
 };
-var baseName = (branch) => branch.replaceAll("/", "__");
+var baseName2 = (branch) => branch.replaceAll("/", "__");
 var truncate = (name, maxLength) => name.length > maxLength ? name.slice(0, maxLength) : name;
 var sanitizeBranchName = (branch, isTaken) => {
-  const base = truncate(baseName(branch), MAX_DIR_NAME_LENGTH);
+  const base = truncate(baseName2(branch), MAX_DIR_NAME_LENGTH);
   if (!isTaken(base)) {
     return base;
   }
@@ -4637,7 +5610,8 @@ var sanitizeBranchName = (branch, isTaken) => {
 };
 
 // src/commands/jump.ts
-var jump = async (git, fs, term, options) => {
+var existingWorktreeResult = (branch, path) => ok({ path, data: { branch, created: false } });
+var jump = async (git, fs, options) => {
   if (options.target === "-") {
     const previous = process.env.OLDPWD;
     if (previous === undefined || previous.length === 0) {
@@ -4651,57 +5625,35 @@ var jump = async (git, fs, term, options) => {
   const context = await loadRepoContext(git, fs, options.cwd);
   const existing = context.worktrees.find((wt) => wt.branch === options.target);
   if (existing !== undefined) {
-    return ok({
-      path: existing.path,
-      data: { branch: options.target, created: false }
-    });
+    return existingWorktreeResult(options.target, existing.path);
   }
   if (!options.create) {
-    if (!term.isTTY()) {
-      return fail(EXIT_SAFE_REJECTION, `No worktree for branch "${options.target}". Re-run with --create to create it.`);
-    }
     return fail(EXIT_SAFE_REJECTION, `No worktree for branch "${options.target}". Re-run with --create to create it.`);
   }
-  const localBranches = await git.listBranches(context.rootPath);
-  const branchExistsLocally = localBranches.includes(options.target);
-  let track = options.track;
-  if (!branchExistsLocally && track === undefined) {
-    const remotes = await git.remotesWithBranch(context.rootPath, options.target);
-    if (remotes.includes("origin")) {
-      track = `origin/${options.target}`;
-    } else if (remotes.length === 1) {
-      track = `${remotes[0]}/${options.target}`;
-    } else if (remotes.length > 1) {
-      return fail(EXIT_USAGE_ERROR, `Branch "${options.target}" exists on multiple remotes (${remotes.join(", ")}). Use --track to disambiguate.`);
-    }
+  const checkout = await resolveBranchCheckout(git, context.rootPath, options.target, options.track);
+  if (!checkout.ok) {
+    return checkout.rejection;
   }
   const managedDirNames = await fs.listDirNames(context.managedRoot);
   const existingDirNames = new Set(managedDirNames.map((name) => name.toLowerCase()));
   const dirName = sanitizeBranchName(options.target, (candidate) => existingDirNames.has(candidate.toLowerCase()));
-  const targetPath = join3(context.managedRoot, dirName);
-  const lock = await acquireRepoLock(context.commonDir);
-  try {
-    const fresh = await loadRepoContext(git, fs, options.cwd);
-    const racedExisting = fresh.worktrees.find((wt) => wt.branch === options.target);
-    if (racedExisting !== undefined) {
+  const targetPath = join5(context.managedRoot, dirName);
+  return withRepoLock(context.commonDir, async () => {
+    try {
+      const fresh = await loadRepoContext(git, fs, options.cwd);
+      const racedExisting = fresh.worktrees.find((wt) => wt.branch === options.target);
+      if (racedExisting !== undefined) {
+        return existingWorktreeResult(options.target, racedExisting.path);
+      }
+      await fs.mkdir(context.managedRoot);
+      await git.addWorktree(context.rootPath, targetPath, options.target, checkout.options);
       return ok({
-        path: racedExisting.path,
-        data: { branch: options.target, created: false }
+        path: targetPath,
+        data: { branch: options.target, created: true }
       });
+    } catch (error) {
+      return fail(EXIT_SAFE_REJECTION, `Failed to create worktree: ${messageOf(error)}`);
     }
-    await fs.mkdir(context.managedRoot);
-    await git.addWorktree(context.rootPath, targetPath, options.target, {
-      createBranch: !branchExistsLocally,
-      ...track === undefined ? {} : { track }
-    });
-  } catch (error) {
-    return fail(EXIT_SAFE_REJECTION, `Failed to create worktree: ${error.message}`);
-  } finally {
-    await lock.release();
-  }
-  return ok({
-    path: targetPath,
-    data: { branch: options.target, created: true }
   });
 };
 
@@ -4709,13 +5661,13 @@ var jump = async (git, fs, term, options) => {
 var ls = async (git, fs, options) => {
   const context = await loadRepoContext(git, fs, options.cwd);
   const entries = await Promise.all(context.worktrees.map(async (wt) => {
-    const [dirty, aheadBehind] = await Promise.all([
-      wt.bare ? Promise.resolve(false) : git.isDirty(wt.path, otherWorktreePaths(context.worktrees, wt.path)),
+    const [dirtyState, aheadBehind] = await Promise.all([
+      worktreeDirtyState(git, fs, context.worktrees, wt),
       wt.branch === null ? Promise.resolve(null) : git.aheadBehind(context.rootPath, wt.branch)
     ]);
     return {
       ...wt,
-      dirty,
+      dirty: dirtyState ?? false,
       ahead: aheadBehind?.ahead ?? null,
       behind: aheadBehind?.behind ?? null
     };
@@ -4755,26 +5707,26 @@ import { execFile as execFileCb } from "node:child_process";
 import { promisify } from "node:util";
 
 // src/domain/dirty.ts
-var filterOutNestedWorktreePaths = (relativePaths, targetPath, otherWorktreePaths2) => {
+var filterOutNestedWorktreePaths = (relativePaths, targetPath, otherWorktreePaths) => {
   const target = stripTrailingSlash(targetPath);
-  const others = otherWorktreePaths2.map((path) => stripTrailingSlash(path)).filter((path) => path !== target);
+  const others = otherWorktreePaths.map((path) => stripTrailingSlash(path)).filter((path) => path !== target);
   if (others.length === 0) {
     return [...relativePaths];
   }
   return relativePaths.filter((relativePath) => {
     const absolutePath = stripTrailingSlash(`${target}/${relativePath}`);
-    return !others.some((other) => isSameOrNested(absolutePath, other));
+    return !others.some((other) => absolutePath === other || isWithin(other, absolutePath));
   });
 };
-var isDirtyFromStatus = (statusOutput, targetPath, otherWorktreePaths2) => {
+var isDirtyFromStatus = (statusOutput, targetPath, otherWorktreePaths) => {
   const paths = parseStatusPaths(statusOutput);
-  return filterOutNestedWorktreePaths(paths, targetPath, otherWorktreePaths2).length > 0;
+  return filterOutNestedWorktreePaths(paths, targetPath, otherWorktreePaths).length > 0;
 };
 var stripTrailingSlash = (path) => path.endsWith("/") ? path.slice(0, -1) : path;
-var isSameOrNested = (childPath, otherPath) => childPath === otherPath || childPath.startsWith(`${otherPath}/`);
-var isRenameOrCopyCode = (code) => code.includes("R") || code.includes("C");
+var STATUS_CODE_WIDTH = 3;
 var RECORDS_PER_RENAME_OR_COPY = 2;
 var RECORDS_PER_ORDINARY_ENTRY = 1;
+var isRenameOrCopyCode = (code) => code.includes("R") || code.includes("C");
 var parseStatusPaths = (statusOutput) => {
   const records = statusOutput.split("\x00").filter((record) => record.length > 0);
   const paths = [];
@@ -4791,18 +5743,17 @@ var parseStatusPaths = (statusOutput) => {
   }
   return paths;
 };
-var STATUS_CODE_WIDTH = 3;
 
 // src/infra/git-executable.ts
-import { constants } from "node:fs";
-import { access, stat } from "node:fs/promises";
-var isExecutableFile = async (path) => {
+import { constants as constants3 } from "node:fs";
+import { access as access3, stat as stat2 } from "node:fs/promises";
+var isExecutableFile2 = async (path) => {
   try {
-    const stats = await stat(path);
+    const stats = await stat2(path);
     if (!stats.isFile()) {
       return false;
     }
-    await access(path, constants.X_OK);
+    await access3(path, constants3.X_OK);
     return true;
   } catch {
     return false;
@@ -4813,7 +5764,7 @@ var resolveGitExecutable = async (env2) => {
     override: env2[GIT_EXECUTABLE_OVERRIDE_ENV],
     path: env2.PATH
   });
-  const probes = candidates.map(async (candidate) => await isExecutableFile(candidate) ? candidate : undefined);
+  const probes = candidates.map(async (candidate) => await isExecutableFile2(candidate) ? candidate : undefined);
   for (const probe of probes) {
     const found = await probe;
     if (found !== undefined) {
@@ -4867,9 +5818,9 @@ var createWorktreeMethods = () => ({
     const out = await run(cwd, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
     return out.trim();
   },
-  async isDirty(path, otherWorktreePaths2) {
+  async isDirty(path, otherWorktreePaths) {
     const status = await run(path, ["status", "--porcelain", "-z", "--untracked-files=all"]);
-    return isDirtyFromStatus(status, path, otherWorktreePaths2);
+    return isDirtyFromStatus(status, path, otherWorktreePaths);
   },
   async addWorktree(cwd, path, branch, options) {
     const args = ["worktree", "add"];
@@ -5052,7 +6003,7 @@ var createTermPort = () => ({
 var USAGE = `Usage: hop [command] [options]
 
   hop                    Pick a worktree/branch interactively and cd into it (TTY); lists worktrees otherwise
-  hop <branch>           Create-or-jump: cd into <branch>'s worktree, creating it on demand
+  hop <branch>           Create-or-jump: cd into <branch>'s worktree (pass --create to create a missing one)
   hop root               cd into the root clone
   hop -                  cd back to the previous worktree
   hop -- <branch>        Escape a branch name that collides with a reserved command (ls/rm/clean/root/init/help)
@@ -5064,12 +6015,16 @@ var USAGE = `Usage: hop [command] [options]
   hop root -             Switch the root clone back
   hop init zsh           Print the zsh shell integration (eval "$(hop init zsh)")
 
+  hop --update           Update hop to the latest release, the way it was installed
+  hop --update --check   Only report whether an update is available; change nothing
+  hop --version          Print hop's version
+
 Interactive picker keys:
   Enter                  cd into the selected candidate
   Tab, →, Ctrl+L, Ctrl+F Open the action panel, as a column beside the list
                          (stacks below it instead on narrow terminals)
   Ctrl+X                 Delete the selected worktree (y/N confirmation)
-  Ctrl+R                 Switch the root clone to the selected branch, immediately
+  Ctrl+R                 Switch the root clone to the selected branch (y/N first for an external worktree)
   ↑/↓, Ctrl+P/N, Ctrl+K/J Move the selection (arrow, emacs, and vim keys all work)
   Esc                    Cancel (exit 0, no output)
   Ctrl+C                 Cancel like an interrupt (exit 130, same as SIGINT)
@@ -5077,7 +6032,7 @@ Interactive picker keys:
   action, c/d/r to run cd/delete/switchRoot directly, Esc/Tab/←/Ctrl+H to close
 
 Options:
-  --create               Create the worktree when jumping to a branch without one (required outside a TTY)
+  --create               Create the worktree when jumping to a branch without one (always required, TTY or not)
   --json                 Output JSON instead of plain text
   --force                Force removal even if the worktree is dirty (hop rm)
   --ext                  [deprecated, no-op for hop rm] hop rm no longer requires it to
@@ -5092,8 +6047,9 @@ Options:
 var git = createGitPort();
 var fs = createFsPort();
 var term = createTermPort();
-var applyExitCode = (result) => {
-  process.exitCode = result.exitCode;
+var runLs = async (json) => {
+  const result = await ls(git, fs, { cwd: process.cwd() });
+  reportResult("ls", result, json);
 };
 var lsCommand = defineCommand({
   meta: { name: "ls", description: "List worktrees" },
@@ -5101,9 +6057,7 @@ var lsCommand = defineCommand({
     json: { type: "boolean", description: "Output JSON" }
   },
   async run({ args }) {
-    const result = await ls(git, fs, { cwd: process.cwd() });
-    render("ls", result, Boolean(args.json));
-    applyExitCode(result);
+    await runLs(Boolean(args.json));
   }
 });
 var rmCommand = defineCommand({
@@ -5128,11 +6082,10 @@ var rmCommand = defineCommand({
       force: Boolean(args.force),
       ext: Boolean(args.ext)
     });
-    render("rm", result, Boolean(args.json));
-    applyExitCode(result);
+    reportResult("rm", result, Boolean(args.json));
   }
 });
-var rootCommand = createRootCommand(git, fs, applyExitCode);
+var rootCommand = createRootCommand(git, fs);
 var cleanCommand = defineCommand({
   meta: {
     name: "clean",
@@ -5153,8 +6106,7 @@ var cleanCommand = defineCommand({
       dryRun: Boolean(args.dryRun),
       yes: Boolean(args.yes)
     });
-    render("clean", result, Boolean(args.json));
-    applyExitCode(result);
+    reportResult("clean", result, Boolean(args.json));
   }
 });
 var initCommand = defineCommand({
@@ -5178,14 +6130,13 @@ var initCommand = defineCommand({
   }
 });
 var runJump = async (target, options) => {
-  const result = await jump(git, fs, term, {
+  const result = await jump(git, fs, {
     cwd: process.cwd(),
     target,
     create: options.create,
     ...options.track === undefined ? {} : { track: options.track }
   });
-  render("jump", result, options.json);
-  applyExitCode(result);
+  reportResult("jump", result, options.json);
 };
 var RESERVED_COMMANDS = {
   ls: lsCommand,
@@ -5234,12 +6185,7 @@ var runInteractivePick = async (json) => {
       path: selected.worktree.path,
       data: { branch: selected.worktree.branch, created: false }
     });
-    if (json) {
-      render("pick", result, true);
-    } else {
-      process.stdout.write(`${selected.worktree.path}
-`);
-    }
+    render("pick", result, json);
     return;
   }
   await runJump(selected.branch, { create: true, json });
@@ -5251,9 +6197,7 @@ var runJumpFromArgs = async (rawArgs) => {
       await runInteractivePick(Boolean(args.json));
       return;
     }
-    const result = await ls(git, fs, { cwd: process.cwd() });
-    render("ls", result, Boolean(args.json));
-    applyExitCode(result);
+    await runLs(Boolean(args.json));
     return;
   }
   await runJump(String(args.target), {
@@ -5281,6 +6225,16 @@ var main = async () => {
     process.exitCode = 0;
     return;
   }
+  if (isVersionRequest(rawArgs)) {
+    process.stdout.write(`${VERSION}
+`);
+    process.exitCode = EXIT_SUCCESS;
+    return;
+  }
+  if (isUpdateRequest(rawArgs)) {
+    await runUpdate(rawArgs, term);
+    return;
+  }
   const dispatch = dispatchCliArgs(rawArgs, Object.keys(RESERVED_COMMANDS));
   try {
     await dispatchAndRun(dispatch);