@n-seiji/nuthatch 0.1.0 → 0.1.2

package/dist/cli.js

@@ -809,7 +809,18 @@ var buildPickCandidates = (worktrees, dirtyByPath, localBranches, remoteBranches
       source: "remote"
     }))
   ];
-}, candidateBranchLabel = (candidate) => candidate.kind === "worktree" ? candidate.worktree.branch ?? "(detached)" : candidate.branch;
+}, candidateBranchLabel = (candidate) => candidate.kind === "worktree" ? candidate.worktree.branch ?? "(detached)" : candidate.branch, candidateBranchName = (candidate) => candidate.kind === "worktree" ? candidate.worktree.branch : candidate.branch;
+
+// src/domain/result.ts
+var EXIT_SUCCESS = 0, EXIT_GENERAL_ERROR = 1, EXIT_USAGE_ERROR = 2, EXIT_SAFE_REJECTION = 3, EXIT_CANCELLED = 130, ok = (fields = {}) => ({
+  ok: true,
+  exitCode: EXIT_SUCCESS,
+  ...fields
+}), fail = (exitCode, errorMessage) => ({
+  ok: false,
+  exitCode,
+  errorMessage
+});
 
 // node_modules/react/cjs/react.development.js
 var require_react_development = __commonJS((exports, module) => {
@@ -41982,6 +41993,182 @@ var init_build2 = __esm(async () => {
   init_kitty_keyboard();
 });
 
+// src/ui/alt-screen.ts
+var ASCII_ESCAPE_CODE = 27, ESCAPE2, ENTER_ALT_SCREEN, LEAVE_ALT_SCREEN, HIDE_CURSOR, SHOW_CURSOR, enterAltScreen = (target) => {
+  if (!target.isTTY) {
+    return;
+  }
+  target.write(ENTER_ALT_SCREEN + HIDE_CURSOR);
+}, leaveAltScreen = (target) => {
+  if (!target.isTTY) {
+    return;
+  }
+  target.write(SHOW_CURSOR + LEAVE_ALT_SCREEN);
+};
+var init_alt_screen = __esm(() => {
+  ESCAPE2 = String.fromCodePoint(ASCII_ESCAPE_CODE);
+  ENTER_ALT_SCREEN = `${ESCAPE2}[?1049h`;
+  LEAVE_ALT_SCREEN = `${ESCAPE2}[?1049l`;
+  HIDE_CURSOR = `${ESCAPE2}[?25l`;
+  SHOW_CURSOR = `${ESCAPE2}[?25h`;
+});
+
+// src/ui/alt-screen-session.ts
+var createAltScreenTarget = () => ({
+  isTTY: process.stderr.isTTY === true,
+  write: (data) => {
+    process.stderr.write(data);
+  }
+}), runInAltScreenSession = (renderElement) => new Promise((resolve) => {
+  const altScreen = createAltScreenTarget();
+  let hasLeftAltScreen = false;
+  const leaveOnce = () => {
+    if (hasLeftAltScreen) {
+      return;
+    }
+    hasLeftAltScreen = true;
+    leaveAltScreen(altScreen);
+  };
+  process.once("exit", leaveOnce);
+  const instanceRef = {
+    current: null
+  };
+  const handleSigint = () => {
+    leaveOnce();
+    instanceRef.current?.unmount();
+    process.exitCode = EXIT_CANCELLED;
+    process.exit(EXIT_CANCELLED);
+  };
+  process.once("SIGINT", handleSigint);
+  const finish = (result) => {
+    leaveOnce();
+    process.removeListener("SIGINT", handleSigint);
+    instanceRef.current?.unmount();
+    resolve(result);
+  };
+  enterAltScreen(altScreen);
+  try {
+    instanceRef.current = renderElement(finish);
+  } catch (error) {
+    leaveOnce();
+    process.removeListener("SIGINT", handleSigint);
+    throw error;
+  }
+});
+var init_alt_screen_session = __esm(() => {
+  init_alt_screen();
+});
+
+// src/ui/picker-layout.ts
+var MAX_PATH_LENGTH = 40, MAX_BRANCH_COLUMN_WIDTH = 24, LEGEND_TEXT = "●=dirty ○=clean +=未作成", NARROW_TERMINAL_WIDTH_THRESHOLD = 60, isNarrowTerminal = (columns) => columns < NARROW_TERMINAL_WIDTH_THRESHOLD, WORKTREE_KIND_LABELS, CREATABLE_SOURCE_LABELS, statusMarker = (candidate) => {
+  if (candidate.kind === "creatable") {
+    return "+";
+  }
+  if (candidate.dirty === null) {
+    return " ";
+  }
+  return candidate.dirty ? "●" : "○";
+}, candidateKindLabel = (candidate) => candidate.kind === "worktree" ? WORKTREE_KIND_LABELS[candidate.worktree.kind] : CREATABLE_SOURCE_LABELS[candidate.source], isWorktreeCandidate = (candidate) => candidate.kind === "worktree", isCreatableCandidate = (candidate) => candidate.kind === "creatable", WORKTREE_KIND_ORDER, CREATABLE_SOURCE_ORDER, compareByBranchLabel = (a2, b2) => candidateBranchLabel(a2).localeCompare(candidateBranchLabel(b2)), detachedRank = (candidate) => candidate.worktree.branch === null ? 1 : 0, compareWorktreeCandidates = (a2, b2) => {
+  const kindDiff = WORKTREE_KIND_ORDER[a2.worktree.kind] - WORKTREE_KIND_ORDER[b2.worktree.kind];
+  if (kindDiff !== 0) {
+    return kindDiff;
+  }
+  const detachedDiff = detachedRank(a2) - detachedRank(b2);
+  return detachedDiff === 0 ? compareByBranchLabel(a2, b2) : detachedDiff;
+}, compareCreatableCandidates = (a2, b2) => {
+  const sourceDiff = CREATABLE_SOURCE_ORDER[a2.source] - CREATABLE_SOURCE_ORDER[b2.source];
+  return sourceDiff === 0 ? compareByBranchLabel(a2, b2) : sourceDiff;
+}, sortCandidatesForDisplay = (candidates) => [
+  ...candidates.filter((candidate) => isWorktreeCandidate(candidate)).toSorted((a2, b2) => compareWorktreeCandidates(a2, b2)),
+  ...candidates.filter((candidate) => isCreatableCandidate(candidate)).toSorted((a2, b2) => compareCreatableCandidates(a2, b2))
+], KIND_COLUMN_WIDTH, shortenPath = (path, homeDir, maxLength = MAX_PATH_LENGTH) => {
+  const withTilde = homeDir.length > 0 && (path === homeDir || path.startsWith(`${homeDir}/`)) ? `~${path.slice(homeDir.length)}` : path;
+  if (withTilde.length <= maxLength) {
+    return withTilde;
+  }
+  const ellipsis = "…";
+  const keepLength = maxLength - ellipsis.length;
+  return `${ellipsis}${withTilde.slice(withTilde.length - keepLength)}`;
+}, candidatePathLabel = (candidate, homeDir) => candidate.kind === "worktree" ? shortenPath(candidate.worktree.path, homeDir) : "", branchColumnWidth = (candidates) => candidates.reduce((max, candidate) => Math.min(MAX_BRANCH_COLUMN_WIDTH, Math.max(max, candidateBranchLabel(candidate).length)), 0), padBranchLabel = (label, width) => label.length >= width ? label : label.padEnd(width, " "), displayRowKey = (row) => row.kind === "header" ? `header:${row.label}` : `candidate:${row.index}`, toCandidateRow = (candidate, options) => ({
+  kind: "candidate",
+  index: options.index,
+  section: options.section,
+  statusMarker: statusMarker(candidate),
+  branchLabel: padBranchLabel(candidateBranchLabel(candidate), options.branchWidth),
+  kindLabel: candidateKindLabel(candidate).padEnd(KIND_COLUMN_WIDTH, " "),
+  pathLabel: candidatePathLabel(candidate, options.homeDir)
+}), buildDisplayRows = (candidates, homeDir) => {
+  const branchWidth = branchColumnWidth(candidates);
+  const indexed = candidates.map((candidate, index) => ({ candidate, index }));
+  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,
+        homeDir
+      }));
+    }
+  }
+  if (branchEntries.length > 0) {
+    rows.push({ kind: "header", label: "BRANCHES — Enter で worktree 作成" });
+    for (const entry of branchEntries) {
+      rows.push(toCandidateRow(entry.candidate, {
+        index: entry.index,
+        section: "branch",
+        branchWidth,
+        homeDir
+      }));
+    }
+  }
+  return rows;
+};
+var init_picker_layout = __esm(() => {
+  WORKTREE_KIND_LABELS = {
+    root: "root",
+    managed: "managed",
+    external: "ext"
+  };
+  CREATABLE_SOURCE_LABELS = {
+    local: "local",
+    remote: "remote"
+  };
+  WORKTREE_KIND_ORDER = {
+    root: 0,
+    managed: 1,
+    external: 2
+  };
+  CREATABLE_SOURCE_ORDER = {
+    local: 0,
+    remote: 1
+  };
+  KIND_COLUMN_WIDTH = Math.max(...Object.values(WORKTREE_KIND_LABELS).map((label) => label.length), ...Object.values(CREATABLE_SOURCE_LABELS).map((label) => label.length));
+});
+
+// src/domain/actions.ts
+var availableActions = (candidate) => {
+  const actions = ["cd"];
+  if (candidate.kind !== "worktree") {
+    actions.push("switchRoot");
+    return actions;
+  }
+  if (candidate.worktree.branch === null) {
+    return actions;
+  }
+  if (candidate.worktree.kind === "managed") {
+    actions.push("delete");
+  }
+  if (candidate.worktree.kind !== "root") {
+    actions.push("switchRoot");
+  }
+  return actions;
+};
+var init_actions = () => {};
+
 // node_modules/react/cjs/react-jsx-dev-runtime.development.js
 var require_react_jsx_dev_runtime_development = __commonJS((exports) => {
   var React11 = __toESM(require_react(), 1);
@@ -42205,111 +42392,497 @@ var require_jsx_dev_runtime = __commonJS((exports, module) => {
   }
 });
 
-// src/ui/picker.tsx
-var exports_picker = {};
-__export(exports_picker, {
-  runPicker: () => runPicker,
-  candidateRowKey: () => candidateRowKey
+// src/ui/side-panel.tsx
+var jsx_dev_runtime, ACTION_LABELS, ACTION_LETTERS, SIDE_PANEL_WIDTH = 34, ActionPanel = ({ candidate, panelIndex, error, busy }) => {
+  const actions = availableActions(candidate);
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Box_default, {
+    flexDirection: "column",
+    borderStyle: "round",
+    paddingX: 1,
+    width: SIDE_PANEL_WIDTH,
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Text, {
+        children: [
+          "Actions for ",
+          /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Text, {
+            color: "cyan",
+            children: candidateBranchLabel(candidate)
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      actions.map((action, actionIndex) => /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Text, {
+        inverse: actionIndex === panelIndex,
+        children: `${actionIndex === panelIndex ? "> " : "  "}[${ACTION_LETTERS[action]}] ${ACTION_LABELS[action]}`
+      }, action, false, undefined, this)),
+      busy && /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Text, {
+        dimColor: true,
+        children: "Working…"
+      }, undefined, false, undefined, this),
+      error !== null && /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Text, {
+        color: "red",
+        children: error
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}, ConfirmDeletePanel = ({ candidate }) => /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Box_default, {
+  flexDirection: "column",
+  borderStyle: "round",
+  paddingX: 1,
+  width: SIDE_PANEL_WIDTH,
+  children: [
+    /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Text, {
+      children: [
+        "Delete worktree for ",
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Text, {
+          color: "cyan",
+          children: candidateBranchName(candidate)
+        }, undefined, false, undefined, this),
+        "?"
+      ]
+    }, undefined, true, undefined, this),
+    /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Text, {
+      dimColor: true,
+      children: "(y/N)"
+    }, undefined, false, undefined, this)
+  ]
+}, undefined, true, undefined, this);
+var init_side_panel = __esm(async () => {
+  await init_build2();
+  init_actions();
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+  ACTION_LABELS = {
+    cd: "cd into this worktree",
+    delete: "delete worktree",
+    switchRoot: "switch root here"
+  };
+  ACTION_LETTERS = {
+    cd: "c",
+    delete: "d",
+    switchRoot: "r"
+  };
 });
-var import_react34, jsx_dev_runtime, MAX_VISIBLE_ROWS = 15, kindTag = (candidate) => candidate.kind === "worktree" ? candidate.worktree.kind : `new (${candidate.source})`, dirtyTag = (candidate) => {
-  if (candidate.kind !== "worktree") {
-    return "";
+
+// src/ui/picker-keys.ts
+var isCtrlJByte = (input) => input === `
+`, resolvePickerKeyAction = (input, key) => {
+  if (key.escape) {
+    return { type: "cancel", reason: "esc" };
   }
-  if (candidate.dirty === null) {
-    return "";
+  if (key.ctrl && input === "c") {
+    return { type: "cancel", reason: "ctrlC" };
+  }
+  if (key.return) {
+    return { type: "select" };
+  }
+  if (key.tab || key.rightArrow || key.ctrl && (input === "l" || input === "f")) {
+    return { type: "openPanel" };
+  }
+  if (key.ctrl && input === "x") {
+    return { type: "deleteShortcut" };
+  }
+  if (key.ctrl && input === "r") {
+    return { type: "rootSwitchShortcut" };
   }
-  return candidate.dirty ? " dirty" : "";
-}, pathTag = (candidate) => candidate.kind === "worktree" ? candidate.worktree.path : "(not created yet)", matchesQuery = (candidate, query) => query.length === 0 || candidateBranchLabel(candidate).toLowerCase().includes(query.toLowerCase()), candidateRowKey = (candidate, index) => `${index}:${candidateBranchLabel(candidate)}`, Picker = ({ candidates, onSelect, onCancel }) => {
+  if (key.upArrow || key.ctrl && (input === "p" || input === "k")) {
+    return { type: "up" };
+  }
+  if (key.downArrow || key.ctrl && (input === "n" || input === "j") || isCtrlJByte(input)) {
+    return { type: "down" };
+  }
+  if (key.ctrl && input === "u") {
+    return { type: "clear" };
+  }
+  if (key.backspace || key.delete) {
+    return { type: "backspace" };
+  }
+  if (input.length > 0 && !key.ctrl && !key.meta) {
+    return { type: "char", char: input };
+  }
+  return { type: "ignore" };
+}, PANEL_LETTER_SHORTCUTS, resolvePanelKeyAction = (input, key) => {
+  if (key.escape || key.tab || key.leftArrow || key.backspace || key.ctrl && input === "h") {
+    return { type: "close" };
+  }
+  if (key.return) {
+    return { type: "confirm" };
+  }
+  if (key.upArrow || key.ctrl && (input === "p" || input === "k")) {
+    return { type: "up" };
+  }
+  if (key.downArrow || key.ctrl && (input === "n" || input === "j") || isCtrlJByte(input)) {
+    return { type: "down" };
+  }
+  if (!key.ctrl && !key.meta && isPanelLetterShortcut(input)) {
+    return { type: "letter", char: input };
+  }
+  return { type: "ignore" };
+}, isPanelLetterShortcut = (input) => PANEL_LETTER_SHORTCUTS.includes(input), resolveConfirmKeyAction = (input, key) => {
+  if (!key.ctrl && !key.meta && (input === "y" || input === "Y")) {
+    return { type: "yes" };
+  }
+  return { type: "no" };
+};
+var init_picker_keys = __esm(() => {
+  PANEL_LETTER_SHORTCUTS = ["c", "d", "r"];
+});
+
+// src/ui/picker-input.ts
+var handleConfirmDeleteInput = (input, key, confirmMode, ctx) => {
+  const confirmAction = resolveConfirmKeyAction(input, key);
+  if (confirmAction.type === "yes") {
+    ctx.runAction(confirmMode.candidate, "delete");
+  } else {
+    ctx.setMode({ kind: "list" });
+  }
+}, handlePanelInput = (input, key, panelMode, ctx) => {
+  const actions = availableActions(panelMode.candidate);
+  const panelAction = resolvePanelKeyAction(input, key);
+  switch (panelAction.type) {
+    case "close": {
+      ctx.setMode({ kind: "list" });
+      break;
+    }
+    case "up": {
+      ctx.setPanelIndex((current) => Math.max(0, current - 1));
+      break;
+    }
+    case "down": {
+      ctx.setPanelIndex((current) => Math.min(actions.length - 1, current + 1));
+      break;
+    }
+    case "confirm": {
+      const chosen = actions[Math.min(ctx.panelIndex, actions.length - 1)];
+      if (chosen !== undefined) {
+        ctx.runAction(panelMode.candidate, chosen);
+      }
+      break;
+    }
+    case "letter": {
+      const chosen = actions.find((action) => ACTION_LETTERS[action] === panelAction.char);
+      if (chosen !== undefined) {
+        ctx.runAction(panelMode.candidate, chosen);
+      }
+      break;
+    }
+    case "ignore": {
+      break;
+    }
+  }
+}, handleListInput = (input, key, ctx) => {
+  const action = resolvePickerKeyAction(input, key);
+  switch (action.type) {
+    case "cancel": {
+      ctx.onCancel(action.reason);
+      break;
+    }
+    case "select": {
+      if (ctx.selectedCandidate !== undefined) {
+        ctx.runAction(ctx.selectedCandidate, "cd");
+      }
+      break;
+    }
+    case "up": {
+      ctx.setIndex((current) => Math.max(0, current - 1));
+      break;
+    }
+    case "down": {
+      ctx.setIndex((current) => Math.min(ctx.filteredLength - 1, current + 1));
+      break;
+    }
+    case "clear": {
+      ctx.setQuery(() => "");
+      ctx.setIndex(() => 0);
+      break;
+    }
+    case "backspace": {
+      ctx.setQuery((current) => current.slice(0, -1));
+      ctx.setIndex(() => 0);
+      break;
+    }
+    case "char": {
+      ctx.setQuery((current) => current + action.char);
+      ctx.setIndex(() => 0);
+      break;
+    }
+    case "openPanel": {
+      if (ctx.selectedCandidate !== undefined) {
+        ctx.setPanelIndex(0);
+        ctx.setMode({
+          kind: "panel",
+          candidate: ctx.selectedCandidate,
+          error: null
+        });
+      }
+      break;
+    }
+    case "deleteShortcut": {
+      if (ctx.selectedCandidate !== undefined && availableActions(ctx.selectedCandidate).includes("delete")) {
+        ctx.setMode({
+          kind: "confirmDelete",
+          candidate: ctx.selectedCandidate,
+          error: null
+        });
+      }
+      break;
+    }
+    case "rootSwitchShortcut": {
+      if (ctx.selectedCandidate !== undefined && availableActions(ctx.selectedCandidate).includes("switchRoot")) {
+        ctx.runAction(ctx.selectedCandidate, "switchRoot");
+      }
+      break;
+    }
+    case "ignore": {
+      break;
+    }
+  }
+};
+var init_picker_input = __esm(async () => {
+  init_actions();
+  await init_side_panel();
+  init_picker_keys();
+});
+
+// src/ui/picker-controller.ts
+var import_react34, matchesQuery = (candidate, query) => query.length === 0 || candidateBranchLabel(candidate).toLowerCase().includes(query.toLowerCase()), panelErrorTransition = (candidate, error) => ({
+  mode: { kind: "panel", candidate, error },
+  panelIndex: 0
+}), usePickerController = (initialCandidates, callbacks, onExit, onCancel) => {
+  const [candidates, setCandidates] = import_react34.useState(initialCandidates);
   const [query, setQuery] = import_react34.useState("");
   const [index, setIndex] = import_react34.useState(0);
-  const filtered = import_react34.useMemo(() => candidates.filter((candidate) => matchesQuery(candidate, query)), [candidates, query]);
+  const [mode, setMode] = import_react34.useState({ kind: "list" });
+  const [panelIndex, setPanelIndex] = import_react34.useState(0);
+  const [busy, setBusy] = import_react34.useState(false);
+  const filtered = import_react34.useMemo(() => sortCandidatesForDisplay(candidates.filter((candidate) => matchesQuery(candidate, query))), [candidates, query]);
   const clampedIndex = Math.min(index, Math.max(filtered.length - 1, 0));
-  use_input_default((input, key) => {
-    if (key.escape || key.ctrl && input === "c") {
-      onCancel();
+  const selectedCandidate = filtered[clampedIndex];
+  const applyMutation = async (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.");
+        setPanelIndex(transition.panelIndex);
+        setMode(transition.mode);
+        return;
+      }
+      onExit({ type: "path", path: result2.path });
       return;
     }
-    if (key.return) {
-      const selected = filtered[clampedIndex];
-      if (selected !== undefined) {
-        onSelect(selected);
-      }
+    const result = await callbacks.deleteWorktree(candidate);
+    if (!result.ok) {
+      const transition = panelErrorTransition(candidate, result.message ?? "Failed to delete worktree.");
+      setPanelIndex(transition.panelIndex);
+      setMode(transition.mode);
+      return;
+    }
+    const fresh = await callbacks.reloadCandidates();
+    setCandidates(fresh);
+    setMode({ kind: "list" });
+    setIndex(0);
+  };
+  const runAction = (candidate, action) => {
+    if (action === "cd") {
+      onExit({ type: "cd", candidate });
       return;
     }
-    if (key.upArrow) {
-      setIndex((current) => Math.max(0, current - 1));
+    if (busy) {
       return;
     }
-    if (key.downArrow) {
-      setIndex((current) => Math.min(filtered.length - 1, current + 1));
+    setBusy(true);
+    (async () => {
+      await applyMutation(candidate, action);
+      setBusy(false);
+    })();
+  };
+  const handleInput = (input, key) => {
+    if (busy) {
       return;
     }
-    if (key.backspace || key.delete) {
-      setQuery((current) => current.slice(0, -1));
-      setIndex(0);
+    if (mode.kind === "confirmDelete") {
+      handleConfirmDeleteInput(input, key, mode, { runAction, setMode });
       return;
     }
-    if (input.length > 0 && !key.ctrl && !key.meta) {
-      setQuery((current) => current + input);
-      setIndex(0);
+    if (mode.kind === "panel") {
+      handlePanelInput(input, key, mode, {
+        panelIndex,
+        runAction,
+        setPanelIndex,
+        setMode
+      });
+      return;
     }
-  });
+    handleListInput(input, key, {
+      selectedCandidate,
+      filteredLength: filtered.length,
+      runAction,
+      onCancel,
+      setIndex,
+      setQuery,
+      setPanelIndex: (value) => setPanelIndex(value),
+      setMode
+    });
+  };
+  return { query, filtered, clampedIndex, mode, panelIndex, busy, handleInput };
+};
+var init_picker_controller = __esm(async () => {
+  import_react34 = __toESM(require_react(), 1);
+  init_picker_layout();
+  await init_picker_input();
+});
+
+// src/ui/use-terminal-width.ts
+var import_react35, DEFAULT_TERMINAL_WIDTH = 80, useTerminalWidth = (stream) => {
+  const [width, setWidth] = import_react35.useState(() => stream.columns ?? DEFAULT_TERMINAL_WIDTH);
+  import_react35.useEffect(() => {
+    const handleResize = () => {
+      setWidth(stream.columns ?? DEFAULT_TERMINAL_WIDTH);
+    };
+    stream.on("resize", handleResize);
+    return () => {
+      stream.off("resize", handleResize);
+    };
+  }, [stream]);
+  return width;
+};
+var init_use_terminal_width = __esm(() => {
+  import_react35 = __toESM(require_react(), 1);
+});
+
+// src/ui/picker.tsx
+var exports_picker = {};
+__export(exports_picker, {
+  runPicker: () => runPicker
+});
+import { homedir } from "node:os";
+var jsx_dev_runtime2, MAX_VISIBLE_ROWS = 15, LIST_FOOTER_HINT = "Tab/→/Ctrl+L actions · Ctrl+X delete · Ctrl+R switch root · ↑↓/Ctrl+P,N,K,J move · Enter cd · Esc cancel", PANEL_FOOTER_HINT = "↑↓/Ctrl+P,N,K,J move · Enter run · c/d/r shortcuts · Esc/Tab/←/Ctrl+H close", PickerList = ({
+  query,
+  rows,
+  clampedIndex,
+  hiddenCount,
+  footerHint,
+  marginRight
+}) => /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Box_default, {
+  flexDirection: "column",
+  marginRight,
+  children: [
+    /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+      children: [
+        "hop: ",
+        /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+          color: "cyan",
+          children: query
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+          dimColor: true,
+          children: query.length === 0 ? " (type to filter)" : ""
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this),
+    rows.length === 0 && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+      dimColor: true,
+      children: "No matches."
+    }, undefined, false, undefined, this),
+    rows.map((row) => {
+      if (row.kind === "header") {
+        return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+          bold: true,
+          dimColor: true,
+          children: row.label
+        }, displayRowKey(row), false, undefined, this);
+      }
+      const selected = row.index === clampedIndex;
+      return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+        inverse: selected,
+        dimColor: !selected && row.section === "branch",
+        children: `${selected ? "❯ " : "  "}${row.statusMarker} ${row.branchLabel}  ${row.kindLabel} ${row.pathLabel}`
+      }, displayRowKey(row), false, undefined, this);
+    }),
+    hiddenCount > 0 && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+      dimColor: true,
+      children: [
+        "... and ",
+        hiddenCount,
+        " more (keep typing to narrow down)"
+      ]
+    }, undefined, true, undefined, this),
+    /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+      dimColor: true,
+      children: [
+        "(",
+        LEGEND_TEXT,
+        ")"
+      ]
+    }, undefined, true, undefined, this),
+    /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Text, {
+      dimColor: true,
+      children: footerHint
+    }, undefined, false, undefined, this)
+  ]
+}, undefined, true, undefined, this), renderSidePanel = (mode, panelIndex, busy) => {
+  if (mode.kind === "panel") {
+    return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ActionPanel, {
+      candidate: mode.candidate,
+      panelIndex,
+      error: mode.error,
+      busy
+    }, undefined, false, undefined, this);
+  }
+  if (mode.kind === "confirmDelete") {
+    return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ConfirmDeletePanel, {
+      candidate: mode.candidate
+    }, undefined, false, undefined, this);
+  }
+  return null;
+}, Picker = ({ candidates, callbacks, onExit, onCancel }) => {
+  const { query, filtered, clampedIndex, mode, panelIndex, busy, handleInput } = usePickerController(candidates, callbacks, onExit, onCancel);
+  use_input_default(handleInput);
+  const width = useTerminalWidth(process.stderr);
+  const narrow = isNarrowTerminal(width);
   const visible = filtered.slice(0, MAX_VISIBLE_ROWS);
-  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Box_default, {
-    flexDirection: "column",
+  const hiddenCount = filtered.length - visible.length;
+  const rows = buildDisplayRows(visible, homedir());
+  const sidePanel = renderSidePanel(mode, panelIndex, busy);
+  const list = /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(PickerList, {
+    query,
+    rows,
+    clampedIndex,
+    hiddenCount,
+    footerHint: sidePanel === null ? LIST_FOOTER_HINT : PANEL_FOOTER_HINT,
+    marginRight: sidePanel === null || narrow ? 0 : 1
+  }, undefined, false, undefined, this);
+  if (sidePanel === null) {
+    return list;
+  }
+  if (narrow) {
+    return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Box_default, {
+      flexDirection: "column",
+      children: [
+        list,
+        sidePanel
+      ]
+    }, undefined, true, undefined, this);
+  }
+  return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Box_default, {
+    flexDirection: "row",
     children: [
-      /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Text, {
-        children: [
-          "hop: ",
-          /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Text, {
-            color: "cyan",
-            children: query
-          }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Text, {
-            dimColor: true,
-            children: query.length === 0 ? " (type to filter)" : ""
-          }, undefined, false, undefined, this)
-        ]
-      }, undefined, true, undefined, this),
-      visible.length === 0 && /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Text, {
-        dimColor: true,
-        children: "No matches."
-      }, undefined, false, undefined, this),
-      visible.map((candidate, rowIndex) => {
-        const selected = rowIndex === clampedIndex;
-        const label = candidateBranchLabel(candidate);
-        return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Text, {
-          inverse: selected,
-          children: `${selected ? "> " : "  "}[${kindTag(candidate)}${dirtyTag(candidate)}] ${label} ${pathTag(candidate)}`
-        }, candidateRowKey(candidate, rowIndex), false, undefined, this);
-      }),
-      filtered.length > MAX_VISIBLE_ROWS && /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Text, {
-        dimColor: true,
-        children: [
-          "... and ",
-          filtered.length - MAX_VISIBLE_ROWS,
-          " more (keep typing to narrow down)"
-        ]
-      }, undefined, true, undefined, this)
+      list,
+      sidePanel
     ]
   }, undefined, true, undefined, this);
-}, runPicker = (candidates) => new Promise((resolve) => {
-  const instance = render_default(/* @__PURE__ */ jsx_dev_runtime.jsxDEV(Picker, {
-    candidates,
-    onSelect: (candidate) => {
-      instance.unmount();
-      resolve(candidate);
-    },
-    onCancel: () => {
-      instance.unmount();
-      resolve(null);
-    }
-  }, undefined, false, undefined, this), { stdout: process.stderr });
-});
+}, runPicker = (candidates, callbacks) => runInAltScreenSession((finish) => render_default(/* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Picker, {
+  candidates,
+  callbacks,
+  onExit: (outcome) => finish(outcome),
+  onCancel: (reason) => finish({ type: "cancelled", reason })
+}, undefined, false, undefined, this), { stdout: process.stderr }));
 var init_picker = __esm(async () => {
   await init_build2();
-  import_react34 = __toESM(require_react(), 1);
-  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+  init_alt_screen_session();
+  await init_picker_controller();
+  init_picker_layout();
+  await init_side_panel();
+  init_use_terminal_width();
+  jsx_dev_runtime2 = __toESM(require_jsx_dev_runtime(), 1);
 });
 
 // src/ui/simple-picker.ts
@@ -42317,7 +42890,7 @@ var exports_simple_picker = {};
 __export(exports_simple_picker, {
   runSimplePicker: () => runSimplePicker
 });
-import { createInterface as createInterface2 } from "node:readline";
+import { createInterface } from "node:readline";
 var runSimplePicker = (candidates) => new Promise((resolve) => {
   if (candidates.length === 0) {
     process.stderr.write(`No candidates.
@@ -42332,7 +42905,7 @@ var runSimplePicker = (candidates) => new Promise((resolve) => {
 `);
   });
   process.stderr.write("Select a number (empty to cancel): ");
-  const rl = createInterface2({
+  const rl = createInterface({
     input: process.stdin,
     output: process.stderr,
     terminal: false
@@ -43628,139 +44201,22 @@ async function runCommand(cmd, opts) {
   return { result };
 }
 
-// src/domain/garbage.ts
-var classifyGarbage = (input) => {
-  if (input.prunable) {
-    return "prunable";
-  }
-  if (!input.clean) {
-    return null;
-  }
-  if (input.mergedIntoDefault === true) {
-    return "merged";
-  }
-  if (input.upstreamGone && input.allCommitsReachableFromDefault === true) {
-    return "gone";
-  }
-  return null;
-};
-
-// src/domain/result.ts
-var EXIT_SUCCESS = 0;
-var EXIT_GENERAL_ERROR = 1;
-var EXIT_USAGE_ERROR = 2;
-var EXIT_SAFE_REJECTION = 3;
-var EXIT_CANCELLED = 130;
-var ok = (fields = {}) => ({
-  ok: true,
-  exitCode: EXIT_SUCCESS,
-  ...fields
-});
-var fail = (exitCode, errorMessage) => ({
-  ok: false,
-  exitCode,
-  errorMessage
-});
-
-// src/infra/lock.ts
-import { randomUUID } from "node:crypto";
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-
-// src/domain/lock-policy.ts
-var canReclaimLock = (input) => {
-  if (input.processAlive !== false) {
-    return false;
-  }
-  return input.nowMs - input.startedAtMs > input.ttlMs;
-};
-
-// src/infra/lock.ts
-var LOCK_DIR_NAME = "nuthatch-lock";
-var LOCK_INFO_FILE = "info.json";
-var DEFAULT_TTL_MS = 30000;
-var HEARTBEAT_INTERVAL_MS = 5000;
-
-class LockHeldError extends Error {
-  info;
-  constructor(info) {
-    super(`Repository is locked by another nuthatch process (pid ${info.pid})`);
-    this.name = "LockHeldError";
-    this.info = info;
-  }
-}
-var isProcessAlive = (pid) => {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    const { code } = error;
-    if (code === "ESRCH") {
-      return false;
-    }
-    if (code === "EPERM") {
-      return true;
-    }
-    return "unknown";
-  }
-};
-var readLockInfo = async (lockDir) => {
-  try {
-    const raw = await readFile(join(lockDir, LOCK_INFO_FILE), "utf8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
+// src/cli-dispatch.ts
+var normalizeCliArgs = (rawArgs, argv0, stdoutIsTTY) => stdoutIsTTY && rawArgs.length === 1 && rawArgs[0] === argv0 ? [] : rawArgs;
+var HELP_FLAGS = new Set(["--help", "-h", "help"]);
+var isHelpRequest = (rawArgs) => rawArgs.length > 0 && HELP_FLAGS.has(rawArgs[0] ?? "");
+var dispatchCliArgs = (rawArgs, reservedNames) => {
+  const [first, ...rest] = rawArgs;
+  if (first === "--") {
+    return { kind: "jump", args: rest };
   }
-};
-var writeLockInfo = async (lockDir, info) => {
-  await writeFile(join(lockDir, LOCK_INFO_FILE), JSON.stringify(info), "utf8");
-};
-var acquireRepoLock = async (commonDir, ttlMs = DEFAULT_TTL_MS) => {
-  const lockDir = join(commonDir, LOCK_DIR_NAME);
-  for (;; ) {
-    try {
-      await mkdir(lockDir);
-      break;
-    } catch (error) {
-      if (error.code !== "EEXIST") {
-        throw error;
-      }
-      const existing = await readLockInfo(lockDir);
-      if (existing === null) {
-        throw new LockHeldError({ pid: -1, startedAtMs: 0, token: "unknown" });
-      }
-      const reclaimable = canReclaimLock({
-        processAlive: isProcessAlive(existing.pid),
-        startedAtMs: existing.startedAtMs,
-        nowMs: Date.now(),
-        ttlMs
-      });
-      if (!reclaimable) {
-        throw new LockHeldError(existing);
-      }
-      await rm(lockDir, { recursive: true, force: true });
-    }
+  if (first !== undefined && reservedNames.includes(first)) {
+    return { kind: "reserved", name: first, args: rest };
   }
-  const info = {
-    pid: process.pid,
-    startedAtMs: Date.now(),
-    token: randomUUID()
-  };
-  await writeLockInfo(lockDir, info);
-  const heartbeat = setInterval(() => {
-    writeLockInfo(lockDir, { ...info, startedAtMs: Date.now() });
-  }, HEARTBEAT_INTERVAL_MS);
-  heartbeat.unref();
-  return {
-    async release() {
-      clearInterval(heartbeat);
-      await rm(lockDir, { recursive: true, force: true });
-    }
-  };
+  return { kind: "jump", args: rawArgs };
 };
-
 // src/infra/repo.ts
-import { basename, dirname, join as join2 } from "node:path";
+import { basename, dirname, join } from "node:path";
 
 // src/domain/classify.ts
 var isWithin = (parent, child) => {
@@ -43877,7 +44333,7 @@ var loadRepoContext = async (git, fs, cwd) => {
     throw new Error("git worktree list returned no entries");
   }
   const rootPath = await realpathOrRaw(fs, firstEntry.path);
-  const managedRoot = join2(dirname(rootPath), "_worktree", basename(rootPath));
+  const managedRoot = join(dirname(rootPath), "_worktree", basename(rootPath));
   const worktrees = await Promise.all(parsed.map(async (entry) => {
     const resolvedPath = await realpathOrRaw(fs, entry.path);
     return {
@@ -43896,9 +44352,378 @@ var realpathOrRaw = async (fs, path) => {
   }
 };
 
-// src/commands/clean.ts
-var clean = async (git, fs, term, options) => {
+// src/commands/pick.ts
+var pick = async (git, fs, options) => {
   const context = await loadRepoContext(git, fs, options.cwd);
+  const [localBranches, remoteBranches, dirtyEntries] = await Promise.all([
+    git.listBranches(context.rootPath),
+    git.listRemoteBranches(context.rootPath),
+    Promise.all(context.worktrees.map(async (worktree) => [
+      worktree.path,
+      worktree.bare ? null : await git.isDirty(worktree.path)
+    ]))
+  ]);
+  const dirtyByPath = new Map(dirtyEntries);
+  const candidates = buildPickCandidates(context.worktrees, dirtyByPath, localBranches, remoteBranches);
+  return ok({ data: { candidates } });
+};
+// src/infra/lock.ts
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join as join2 } from "node:path";
+
+// src/domain/lock-policy.ts
+var canReclaimLock = (input) => {
+  if (input.processAlive !== false) {
+    return false;
+  }
+  return input.nowMs - input.startedAtMs > input.ttlMs;
+};
+
+// src/infra/lock.ts
+var LOCK_DIR_NAME = "nuthatch-lock";
+var LOCK_INFO_FILE = "info.json";
+var DEFAULT_TTL_MS = 30000;
+var HEARTBEAT_INTERVAL_MS = 5000;
+
+class LockHeldError extends Error {
+  info;
+  constructor(info) {
+    super(`Repository is locked by another nuthatch process (pid ${info.pid})`);
+    this.name = "LockHeldError";
+    this.info = info;
+  }
+}
+var isProcessAlive = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const { code } = error;
+    if (code === "ESRCH") {
+      return false;
+    }
+    if (code === "EPERM") {
+      return true;
+    }
+    return "unknown";
+  }
+};
+var readLockInfo = async (lockDir) => {
+  try {
+    const raw = await readFile(join2(lockDir, LOCK_INFO_FILE), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+};
+var writeLockInfo = async (lockDir, info) => {
+  await writeFile(join2(lockDir, LOCK_INFO_FILE), JSON.stringify(info), "utf8");
+};
+var acquireRepoLock = async (commonDir, ttlMs = DEFAULT_TTL_MS) => {
+  const lockDir = join2(commonDir, LOCK_DIR_NAME);
+  for (;; ) {
+    try {
+      await mkdir(lockDir);
+      break;
+    } catch (error) {
+      if (error.code !== "EEXIST") {
+        throw error;
+      }
+      const existing = await readLockInfo(lockDir);
+      if (existing === null) {
+        throw new LockHeldError({ pid: -1, startedAtMs: 0, token: "unknown" });
+      }
+      const reclaimable = canReclaimLock({
+        processAlive: isProcessAlive(existing.pid),
+        startedAtMs: existing.startedAtMs,
+        nowMs: Date.now(),
+        ttlMs
+      });
+      if (!reclaimable) {
+        throw new LockHeldError(existing);
+      }
+      await rm(lockDir, { recursive: true, force: true });
+    }
+  }
+  const info = {
+    pid: process.pid,
+    startedAtMs: Date.now(),
+    token: randomUUID()
+  };
+  await writeLockInfo(lockDir, info);
+  const heartbeat = setInterval(() => {
+    writeLockInfo(lockDir, { ...info, startedAtMs: Date.now() });
+  }, HEARTBEAT_INTERVAL_MS);
+  heartbeat.unref();
+  return {
+    async release() {
+      clearInterval(heartbeat);
+      await rm(lockDir, { recursive: true, force: true });
+    }
+  };
+};
+
+// src/commands/rm.ts
+var rm2 = async (git, fs, options) => {
+  const context = await loadRepoContext(git, fs, options.cwd);
+  const target = context.worktrees.find((wt) => wt.branch === options.branch);
+  if (target === undefined) {
+    return fail(EXIT_GENERAL_ERROR, `No worktree found for branch "${options.branch}".`);
+  }
+  if (target.kind === "root") {
+    return fail(EXIT_USAGE_ERROR, "Cannot remove the root clone.");
+  }
+  if (target.kind === "external" && !(options.ext && options.force)) {
+    return fail(EXIT_SAFE_REJECTION, `"${options.branch}" is an external worktree not managed by nuthatch. Removal requires both --ext and --force.`);
+  }
+  if (!options.force) {
+    const dirty = await git.isDirty(target.path);
+    if (dirty) {
+      return fail(EXIT_SAFE_REJECTION, `Worktree for "${options.branch}" has uncommitted or untracked changes. Use --force to remove anyway.`);
+    }
+  }
+  const lock = await acquireRepoLock(context.commonDir);
+  try {
+    const fresh = await loadRepoContext(git, fs, options.cwd);
+    const freshTarget = fresh.worktrees.find((wt) => wt.branch === options.branch);
+    if (freshTarget === undefined) {
+      return fail(EXIT_GENERAL_ERROR, `No worktree found for branch "${options.branch}".`);
+    }
+    if (!options.force) {
+      const stillDirty = await git.isDirty(freshTarget.path);
+      if (stillDirty) {
+        return fail(EXIT_SAFE_REJECTION, `Worktree for "${options.branch}" has uncommitted or untracked changes. Use --force to remove anyway.`);
+      }
+    }
+    await git.removeWorktree(context.rootPath, freshTarget.path, options.force);
+    return ok({ data: { branch: options.branch, path: freshTarget.path } });
+  } catch (error) {
+    return fail(EXIT_SAFE_REJECTION, `Failed to remove worktree: ${error.message}`);
+  } finally {
+    await lock.release();
+  }
+};
+// 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, switched: false }
+    });
+  }
+  const dirty = await git.isDirty(context.rootPath);
+  if (dirty) {
+    return fail(EXIT_SAFE_REJECTION, "Root clone has uncommitted or untracked changes. Commit, stash, or discard them before switching.");
+  }
+  const previousBranch = rootWorktree?.branch ?? null;
+  if (options.target === "-") {
+    return switchAndReport({
+      git,
+      fs,
+      context,
+      target: "-",
+      switchOptions: {},
+      previousBranch
+    });
+  }
+  const holder = context.worktrees.find((wt) => wt.branch === options.target && wt.kind !== "root");
+  if (holder !== undefined) {
+    return fail(EXIT_SAFE_REJECTION, `Branch "${options.target}" is already checked out at ${holder.path}. Not swapping — cd there instead of using hop root.`);
+  }
+  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.`);
+    }
+  }
+  return switchAndReport({
+    git,
+    fs,
+    context,
+    target: options.target,
+    switchOptions: {
+      createBranch: !branchExistsLocally,
+      ...track === undefined ? {} : { track }
+    },
+    previousBranch
+  });
+};
+var switchAndReport = async ({
+  git,
+  fs,
+  context,
+  target,
+  switchOptions,
+  previousBranch
+}) => {
+  const lock = await acquireRepoLock(context.commonDir);
+  try {
+    const fresh = await loadRepoContext(git, fs, context.rootPath);
+    const stillDirty = await git.isDirty(fresh.rootPath);
+    if (stillDirty) {
+      return fail(EXIT_SAFE_REJECTION, "Root clone has uncommitted or untracked changes. Commit, stash, or discard them before switching.");
+    }
+    if (target !== "-") {
+      const freshHolder = fresh.worktrees.find((wt) => wt.branch === target && wt.kind !== "root");
+      if (freshHolder !== undefined) {
+        return fail(EXIT_SAFE_REJECTION, `Branch "${target}" is already checked out at ${freshHolder.path}. Not swapping — cd there instead of using hop root.`);
+      }
+    }
+    await git.switchBranch(fresh.rootPath, target, switchOptions);
+    return ok({
+      path: fresh.rootPath,
+      data: { branch: target === "-" ? null : target, switched: true }
+    });
+  } catch (error) {
+    if (previousBranch !== null) {
+      try {
+        await git.switchBranch(context.rootPath, previousBranch, {});
+      } catch {}
+    }
+    return fail(EXIT_SAFE_REJECTION, `Failed to switch root: ${error.message}`);
+  } finally {
+    await lock.release();
+  }
+};
+// src/render.ts
+var PLAIN_JSON_INDENT = 2;
+var render = (command, result, json) => {
+  if (json) {
+    const envelope = {
+      schemaVersion: 1,
+      command,
+      data: result.ok ? result.data : undefined,
+      warnings: result.warnings ?? []
+    };
+    process.stdout.write(`${JSON.stringify(envelope)}
+`);
+    if (!result.ok && result.errorMessage !== undefined) {
+      process.stderr.write(`${result.errorMessage}
+`);
+    }
+    return;
+  }
+  if (result.path !== undefined) {
+    process.stdout.write(`${result.path}
+`);
+  } else if (result.ok && result.data !== undefined) {
+    process.stdout.write(`${JSON.stringify(result.data, null, PLAIN_JSON_INDENT)}
+`);
+  }
+  for (const warning of result.warnings ?? []) {
+    process.stderr.write(`warning: ${warning}
+`);
+  }
+  if (!result.ok && result.errorMessage !== undefined) {
+    process.stderr.write(`${result.errorMessage}
+`);
+  }
+};
+
+// src/cli-pick.ts
+var loadPickCandidates = async (git, fs3, json) => {
+  const pickResult = await pick(git, fs3, { cwd: process.cwd() });
+  if (!pickResult.ok) {
+    render("pick", pickResult, json);
+    process.exitCode = pickResult.exitCode;
+    return null;
+  }
+  return pickResult.data?.candidates ?? [];
+};
+var deleteWorktree = async (git, fs3, candidate) => {
+  const branch = candidateBranchName(candidate);
+  if (branch === null) {
+    return { ok: false, message: "This candidate has no branch to remove." };
+  }
+  const result = await rm2(git, fs3, {
+    cwd: process.cwd(),
+    branch,
+    force: false,
+    ext: false
+  });
+  if (!result.ok) {
+    return {
+      ok: false,
+      message: result.errorMessage ?? "Failed to remove worktree."
+    };
+  }
+  return { ok: true };
+};
+var createPickerCallbacks = (git, fs3, json, onSwitchedBranch) => ({
+  deleteWorktree: (candidate) => deleteWorktree(git, fs3, candidate),
+  switchRootHere: async (candidate) => {
+    const branch = candidateBranchName(candidate);
+    if (branch === null) {
+      return {
+        ok: false,
+        message: "This candidate has no branch to switch to."
+      };
+    }
+    const result = await root(git, fs3, { cwd: process.cwd(), target: branch });
+    if (!result.ok) {
+      return {
+        ok: false,
+        message: result.errorMessage ?? "Failed to switch root."
+      };
+    }
+    onSwitchedBranch(branch);
+    return {
+      ok: true,
+      ...result.path === undefined ? {} : { path: result.path }
+    };
+  },
+  reloadCandidates: async () => await loadPickCandidates(git, fs3, json) ?? []
+});
+var runInteractivePicker = async (candidates, callbacks) => {
+  try {
+    const { runPicker: runPicker2 } = await init_picker().then(() => exports_picker);
+    return await runPicker2(candidates, callbacks);
+  } catch {
+    const { runSimplePicker: runSimplePicker2 } = await Promise.resolve().then(() => (init_simple_picker(), exports_simple_picker));
+    const selected = await runSimplePicker2(candidates);
+    return selected === null ? { type: "cancelled", reason: "esc" } : { type: "cd", candidate: selected };
+  }
+};
+var renderSwitchRootOutcome = (path, branch, json) => {
+  if (json) {
+    render("root", ok({ path, data: { branch, switched: true } }), true);
+    return;
+  }
+  process.stdout.write(`${path}
+`);
+};
+
+// src/domain/garbage.ts
+var classifyGarbage = (input) => {
+  if (input.prunable) {
+    return "prunable";
+  }
+  if (!input.clean) {
+    return null;
+  }
+  if (input.mergedIntoDefault === true) {
+    return "merged";
+  }
+  if (input.upstreamGone && input.allCommitsReachableFromDefault === true) {
+    return "gone";
+  }
+  return null;
+};
+// src/commands/clean.ts
+var clean = async (git, fs3, term, options) => {
+  const context = await loadRepoContext(git, fs3, options.cwd);
   const candidates = await buildCleanCandidates(git, context, options.ext);
   if (options.dryRun) {
     return ok({ data: { candidates } });
@@ -43920,7 +44745,7 @@ var clean = async (git, fs, term, options) => {
   }
   const execution = await executeClean({
     git,
-    fs,
+    fs: fs3,
     context,
     candidates,
     cleanOptions: options
@@ -44001,14 +44826,14 @@ var canDeletePrunableBranch = async (git, rootPath, candidate, defaultRef) => {
 };
 var executeClean = async ({
   git,
-  fs,
+  fs: fs3,
   context,
   candidates,
   cleanOptions
 }) => {
   const lock = await acquireRepoLock(context.commonDir);
   try {
-    const fresh = await loadRepoContext(git, fs, context.rootPath);
+    const fresh = await loadRepoContext(git, fs3, context.rootPath);
     const freshCandidates = await buildCleanCandidates(git, fresh, cleanOptions.ext);
     const freshByPath = new Map(freshCandidates.map((candidate) => [candidate.path, candidate]));
     const stillValid = candidates.flatMap((candidate) => {
@@ -44039,19 +44864,6 @@ var executeClean = async ({
   }
 };
 
-// src/cli-dispatch.ts
-var normalizeCliArgs = (rawArgs, argv0, stdoutIsTTY) => stdoutIsTTY && rawArgs.length === 1 && rawArgs[0] === argv0 ? [] : rawArgs;
-var dispatchCliArgs = (rawArgs, reservedNames) => {
-  const [first, ...rest] = rawArgs;
-  if (first === "--") {
-    return { kind: "jump", args: rest };
-  }
-  if (first !== undefined && reservedNames.includes(first)) {
-    return { kind: "reserved", name: first, args: rest };
-  }
-  return { kind: "jump", args: rawArgs };
-};
-
 // src/commands/init.ts
 var ZSH_TEMPLATE = `# nuthatch shell integration for zsh.
 # Usage: eval "$(hop init zsh)"
@@ -44129,23 +44941,23 @@ var shortHash = (input) => {
 var baseName = (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);
-  if (!isTaken(base)) {
-    return base;
+  const base2 = truncate(baseName(branch), MAX_DIR_NAME_LENGTH);
+  if (!isTaken(base2)) {
+    return base2;
   }
   const hash = shortHash(branch);
-  let candidate = `${truncate(base, MAX_DIR_NAME_LENGTH - hash.length - 1)}-${hash}`;
+  let candidate = `${truncate(base2, MAX_DIR_NAME_LENGTH - hash.length - 1)}-${hash}`;
   let suffix = 1;
   while (isTaken(candidate)) {
     const withSuffix = `${hash}-${suffix}`;
-    candidate = `${truncate(base, MAX_DIR_NAME_LENGTH - withSuffix.length - 1)}-${withSuffix}`;
+    candidate = `${truncate(base2, MAX_DIR_NAME_LENGTH - withSuffix.length - 1)}-${withSuffix}`;
     suffix++;
   }
   return candidate;
 };
 
 // src/commands/jump.ts
-var jump = async (git, fs, term, options) => {
+var jump = async (git, fs3, term, options) => {
   if (options.target === "-") {
     const previous = process.env.OLDPWD;
     if (previous === undefined || previous.length === 0) {
@@ -44156,7 +44968,7 @@ var jump = async (git, fs, term, options) => {
       data: { branch: options.target, created: false }
     });
   }
-  const context = await loadRepoContext(git, fs, options.cwd);
+  const context = await loadRepoContext(git, fs3, options.cwd);
   const existing = context.worktrees.find((wt) => wt.branch === options.target);
   if (existing !== undefined) {
     return ok({
@@ -44183,13 +44995,13 @@ var jump = async (git, fs, term, options) => {
       return fail(EXIT_USAGE_ERROR, `Branch "${options.target}" exists on multiple remotes (${remotes.join(", ")}). Use --track to disambiguate.`);
     }
   }
-  const managedDirNames = await fs.listDirNames(context.managedRoot);
+  const managedDirNames = await fs3.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 fresh = await loadRepoContext(git, fs3, options.cwd);
     const racedExisting = fresh.worktrees.find((wt) => wt.branch === options.target);
     if (racedExisting !== undefined) {
       return ok({
@@ -44197,7 +45009,7 @@ var jump = async (git, fs, term, options) => {
         data: { branch: options.target, created: false }
       });
     }
-    await fs.mkdir(context.managedRoot);
+    await fs3.mkdir(context.managedRoot);
     await git.addWorktree(context.rootPath, targetPath, options.target, {
       createBranch: !branchExistsLocally,
       ...track === undefined ? {} : { track }
@@ -44212,10 +45024,9 @@ var jump = async (git, fs, term, options) => {
     data: { branch: options.target, created: true }
   });
 };
-
 // src/commands/ls.ts
-var ls = async (git, fs, options) => {
-  const context = await loadRepoContext(git, fs, options.cwd);
+var ls = async (git, fs3, options) => {
+  const context = await loadRepoContext(git, fs3, 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),
@@ -44230,157 +45041,6 @@ var ls = async (git, fs, options) => {
   }));
   return ok({ data: entries });
 };
-// src/commands/pick.ts
-var pick = async (git, fs, options) => {
-  const context = await loadRepoContext(git, fs, options.cwd);
-  const [localBranches, remoteBranches, dirtyEntries] = await Promise.all([
-    git.listBranches(context.rootPath),
-    git.listRemoteBranches(context.rootPath),
-    Promise.all(context.worktrees.map(async (worktree) => [
-      worktree.path,
-      worktree.bare ? null : await git.isDirty(worktree.path)
-    ]))
-  ]);
-  const dirtyByPath = new Map(dirtyEntries);
-  const candidates = buildPickCandidates(context.worktrees, dirtyByPath, localBranches, remoteBranches);
-  return ok({ data: { candidates } });
-};
-
-// src/commands/rm.ts
-var rm2 = async (git, fs, options) => {
-  const context = await loadRepoContext(git, fs, options.cwd);
-  const target = context.worktrees.find((wt) => wt.branch === options.branch);
-  if (target === undefined) {
-    return fail(EXIT_GENERAL_ERROR, `No worktree found for branch "${options.branch}".`);
-  }
-  if (target.kind === "root") {
-    return fail(EXIT_USAGE_ERROR, "Cannot remove the root clone.");
-  }
-  if (target.kind === "external" && !(options.ext && options.force)) {
-    return fail(EXIT_SAFE_REJECTION, `"${options.branch}" is an external worktree not managed by nuthatch. Removal requires both --ext and --force.`);
-  }
-  if (!options.force) {
-    const dirty = await git.isDirty(target.path);
-    if (dirty) {
-      return fail(EXIT_SAFE_REJECTION, `Worktree for "${options.branch}" has uncommitted or untracked changes. Use --force to remove anyway.`);
-    }
-  }
-  const lock = await acquireRepoLock(context.commonDir);
-  try {
-    const fresh = await loadRepoContext(git, fs, options.cwd);
-    const freshTarget = fresh.worktrees.find((wt) => wt.branch === options.branch);
-    if (freshTarget === undefined) {
-      return fail(EXIT_GENERAL_ERROR, `No worktree found for branch "${options.branch}".`);
-    }
-    if (!options.force) {
-      const stillDirty = await git.isDirty(freshTarget.path);
-      if (stillDirty) {
-        return fail(EXIT_SAFE_REJECTION, `Worktree for "${options.branch}" has uncommitted or untracked changes. Use --force to remove anyway.`);
-      }
-    }
-    await git.removeWorktree(context.rootPath, freshTarget.path, options.force);
-    return ok({ data: { branch: options.branch, path: freshTarget.path } });
-  } catch (error) {
-    return fail(EXIT_SAFE_REJECTION, `Failed to remove worktree: ${error.message}`);
-  } finally {
-    await lock.release();
-  }
-};
-
-// 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, switched: false }
-    });
-  }
-  const dirty = await git.isDirty(context.rootPath);
-  if (dirty) {
-    return fail(EXIT_SAFE_REJECTION, "Root clone has uncommitted or untracked changes. Commit, stash, or discard them before switching.");
-  }
-  const previousBranch = rootWorktree?.branch ?? null;
-  if (options.target === "-") {
-    return switchAndReport({
-      git,
-      fs,
-      context,
-      target: "-",
-      switchOptions: {},
-      previousBranch
-    });
-  }
-  const holder = context.worktrees.find((wt) => wt.branch === options.target && wt.kind !== "root");
-  if (holder !== undefined) {
-    return fail(EXIT_SAFE_REJECTION, `Branch "${options.target}" is already checked out at ${holder.path}. Not swapping — cd there instead of using hop root.`);
-  }
-  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.`);
-    }
-  }
-  return switchAndReport({
-    git,
-    fs,
-    context,
-    target: options.target,
-    switchOptions: {
-      createBranch: !branchExistsLocally,
-      ...track === undefined ? {} : { track }
-    },
-    previousBranch
-  });
-};
-var switchAndReport = async ({
-  git,
-  fs,
-  context,
-  target,
-  switchOptions,
-  previousBranch
-}) => {
-  const lock = await acquireRepoLock(context.commonDir);
-  try {
-    const fresh = await loadRepoContext(git, fs, context.rootPath);
-    const stillDirty = await git.isDirty(fresh.rootPath);
-    if (stillDirty) {
-      return fail(EXIT_SAFE_REJECTION, "Root clone has uncommitted or untracked changes. Commit, stash, or discard them before switching.");
-    }
-    if (target !== "-") {
-      const freshHolder = fresh.worktrees.find((wt) => wt.branch === target && wt.kind !== "root");
-      if (freshHolder !== undefined) {
-        return fail(EXIT_SAFE_REJECTION, `Branch "${target}" is already checked out at ${freshHolder.path}. Not swapping — cd there instead of using hop root.`);
-      }
-    }
-    await git.switchBranch(fresh.rootPath, target, switchOptions);
-    return ok({
-      path: fresh.rootPath,
-      data: { branch: target === "-" ? null : target, switched: true }
-    });
-  } catch (error) {
-    if (previousBranch !== null) {
-      try {
-        await git.switchBranch(context.rootPath, previousBranch, {});
-      } catch {}
-    }
-    return fail(EXIT_SAFE_REJECTION, `Failed to switch root: ${error.message}`);
-  } finally {
-    await lock.release();
-  }
-};
-
 // src/infra/fs.ts
 import { mkdir as mkdirFs, readdir, realpath as realpathFs } from "node:fs/promises";
 var createFsPort = () => ({
@@ -44414,9 +45074,9 @@ import { promisify } from "node:util";
 var execFile = promisify(execFileCb);
 var MAX_BUFFER_BYTES = 64 * 1024 * 1024;
 var GIT_ANCESTOR_EXIT_CODE = 1;
-var run = async (cwd, args) => {
+var run = async (cwd2, args) => {
   const { stdout: stdout2 } = await execFile("git", [...args], {
-    cwd,
+    cwd: cwd2,
     maxBuffer: MAX_BUFFER_BYTES
   });
   return stdout2;
@@ -44437,18 +45097,18 @@ var parseRemoteRefs = (out) => {
   return parsed;
 };
 var createWorktreeMethods = () => ({
-  listWorktreesPorcelain(cwd) {
-    return run(cwd, ["worktree", "list", "--porcelain", "-z"]);
+  listWorktreesPorcelain(cwd2) {
+    return run(cwd2, ["worktree", "list", "--porcelain", "-z"]);
   },
-  async commonDir(cwd) {
-    const out = await run(cwd, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+  async commonDir(cwd2) {
+    const out = await run(cwd2, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
     return out.trim();
   },
   async isDirty(path) {
     const status = await run(path, ["status", "--porcelain", "--untracked-files=all"]);
     return status.trim().length > 0;
   },
-  async addWorktree(cwd, path, branch, options) {
+  async addWorktree(cwd2, path, branch, options) {
     const args = ["worktree", "add"];
     if (options.createBranch) {
       if (options.track !== undefined) {
@@ -44462,19 +45122,19 @@ var createWorktreeMethods = () => ({
     } else if (!options.createBranch) {
       args.push(branch);
     }
-    await run(cwd, args);
+    await run(cwd2, args);
   },
-  async removeWorktree(cwd, path, force) {
+  async removeWorktree(cwd2, path, force) {
     const args = ["worktree", "remove"];
     if (force) {
       args.push("--force");
     }
     args.push(path);
-    await run(cwd, args);
+    await run(cwd2, args);
   },
-  async aheadBehind(cwd, branch) {
+  async aheadBehind(cwd2, branch) {
     try {
-      const out = await run(cwd, [
+      const out = await run(cwd2, [
         "rev-list",
         "--left-right",
         "--count",
@@ -44491,13 +45151,13 @@ var createWorktreeMethods = () => ({
   }
 });
 var createBranchMethods = () => ({
-  async listBranches(cwd) {
-    const out = await run(cwd, ["for-each-ref", "--format=%(refname:short)", "refs/heads/"]);
+  async listBranches(cwd2) {
+    const out = await run(cwd2, ["for-each-ref", "--format=%(refname:short)", "refs/heads/"]);
     return out.split(`
 `).map((line) => line.trim()).filter((line) => line.length > 0);
   },
-  async remotesWithBranch(cwd, branch) {
-    const out = await run(cwd, ["for-each-ref", "--format=%(refname)", "refs/remotes/"]);
+  async remotesWithBranch(cwd2, branch) {
+    const out = await run(cwd2, ["for-each-ref", "--format=%(refname)", "refs/remotes/"]);
     const remotes = new Set;
     for (const { remote, branchName } of parseRemoteRefs(out)) {
       if (branchName === branch) {
@@ -44506,8 +45166,8 @@ var createBranchMethods = () => ({
     }
     return [...remotes];
   },
-  async listRemoteBranches(cwd) {
-    const out = await run(cwd, ["for-each-ref", "--format=%(refname)", "refs/remotes/"]);
+  async listRemoteBranches(cwd2) {
+    const out = await run(cwd2, ["for-each-ref", "--format=%(refname)", "refs/remotes/"]);
     const branches = new Set;
     for (const { branchName } of parseRemoteRefs(out)) {
       if (branchName !== "HEAD") {
@@ -44516,7 +45176,7 @@ var createBranchMethods = () => ({
     }
     return [...branches];
   },
-  async switchBranch(cwd, ref, options = {}) {
+  async switchBranch(cwd2, ref, options = {}) {
     const args = ["switch"];
     if (options.createBranch) {
       if (options.track !== undefined) {
@@ -44529,35 +45189,35 @@ var createBranchMethods = () => ({
     } else {
       args.push(ref);
     }
-    await run(cwd, args);
+    await run(cwd2, args);
   },
-  async deleteBranch(cwd, branch) {
-    await run(cwd, ["branch", "-D", branch]);
+  async deleteBranch(cwd2, branch) {
+    await run(cwd2, ["branch", "-D", branch]);
   }
 });
 var createGarbagePolicyMethods = () => ({
-  async resolveDefaultBranchRef(cwd) {
+  async resolveDefaultBranchRef(cwd2) {
     try {
-      const out = await run(cwd, ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"]);
+      const out = await run(cwd2, ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"]);
       const ref = out.trim();
       if (ref.length > 0) {
         return ref;
       }
     } catch {}
     try {
-      await run(cwd, ["rev-parse", "--verify", "--quiet", "main"]);
+      await run(cwd2, ["rev-parse", "--verify", "--quiet", "main"]);
       return "main";
     } catch {}
     try {
-      await run(cwd, ["rev-parse", "--verify", "--quiet", "master"]);
+      await run(cwd2, ["rev-parse", "--verify", "--quiet", "master"]);
       return "master";
     } catch {
       return null;
     }
   },
-  async isAncestor(cwd, branch, ref) {
+  async isAncestor(cwd2, branch, ref) {
     try {
-      await run(cwd, ["merge-base", "--is-ancestor", branch, ref]);
+      await run(cwd2, ["merge-base", "--is-ancestor", branch, ref]);
       return true;
     } catch (error) {
       if (failedWithExitCode(error, GIT_ANCESTOR_EXIT_CODE)) {
@@ -44566,18 +45226,18 @@ var createGarbagePolicyMethods = () => ({
       return "unknown";
     }
   },
-  async hasEquivalentCommits(cwd, branch, ref) {
+  async hasEquivalentCommits(cwd2, branch, ref) {
     try {
-      const out = await run(cwd, ["cherry", ref, branch]);
+      const out = await run(cwd2, ["cherry", ref, branch]);
       return !out.split(`
 `).some((line) => line.startsWith("+"));
     } catch {
       return "unknown";
     }
   },
-  async isUpstreamGone(cwd, branch) {
+  async isUpstreamGone(cwd2, branch) {
     try {
-      const out = await run(cwd, [
+      const out = await run(cwd2, [
         "for-each-ref",
         "--format=%(upstream:track)",
         `refs/heads/${branch}`
@@ -44595,7 +45255,7 @@ var createGitPort = () => ({
 });
 
 // src/infra/term.ts
-import { createInterface } from "node:readline";
+import { createInterface as createInterface2 } from "node:readline";
 var createTermPort = () => ({
   isTTY() {
     return process.stderr.isTTY === true && process.stdin.isTTY === true;
@@ -44606,7 +45266,7 @@ var createTermPort = () => ({
   },
   confirm(message) {
     return new Promise((resolve) => {
-      const rl = createInterface({
+      const rl = createInterface2({
         input: process.stdin,
         output: process.stderr,
         terminal: false
@@ -44622,40 +45282,44 @@ var createTermPort = () => ({
   }
 });
 
-// src/render.ts
-var PLAIN_JSON_INDENT = 2;
-var render = (command, result, json) => {
-  if (json) {
-    const envelope = {
-      schemaVersion: 1,
-      command,
-      data: result.ok ? result.data : undefined,
-      warnings: result.warnings ?? []
-    };
-    process.stdout.write(`${JSON.stringify(envelope)}
-`);
-    if (!result.ok && result.errorMessage !== undefined) {
-      process.stderr.write(`${result.errorMessage}
-`);
-    }
-    return;
-  }
-  if (result.path !== undefined) {
-    process.stdout.write(`${result.path}
-`);
-  } else if (result.ok && result.data !== undefined) {
-    process.stdout.write(`${JSON.stringify(result.data, null, PLAIN_JSON_INDENT)}
-`);
-  }
-  for (const warning of result.warnings ?? []) {
-    process.stderr.write(`warning: ${warning}
-`);
-  }
-  if (!result.ok && result.errorMessage !== undefined) {
-    process.stderr.write(`${result.errorMessage}
-`);
-  }
-};
+// src/usage.ts
+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 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)
+
+  hop ls [--json]        List worktrees (dirty, ahead/behind, kind)
+  hop rm <branch>        Remove a worktree, keeping the branch
+  hop clean              Auto-detect and remove garbage worktrees
+  hop root <branch>      Temporarily switch the root clone (for verification)
+  hop root -             Switch the root clone back
+  hop init zsh           Print the zsh shell integration (eval "$(hop init zsh)")
+
+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+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)
+  In the action panel: same up/down movement keys, Enter to run the highlighted
+  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)
+  --json                 Output JSON instead of plain text
+  --force                Force removal even if the worktree is dirty (hop rm)
+  --ext                  Allow operating on external worktrees (hop rm / hop clean)
+  --yes                  Skip confirmation and execute (hop clean)
+  --dry-run              Only report candidates as JSON, without deleting (hop clean)
+  --with-branch          Also delete the branch when cleaning (hop clean)
+  -h, --help             Show this help and exit
+`;
 
 // src/cli.ts
 var git = createGitPort();
@@ -44806,26 +45470,24 @@ var jumpArgsSchema = {
   json: { type: "boolean", description: "Output JSON" }
 };
 var runInteractivePick = async (json) => {
-  const pickResult = await pick(git, fs3, { cwd: process.cwd() });
-  if (!pickResult.ok) {
-    render("pick", pickResult, json);
-    applyExitCode(pickResult);
+  const candidates = await loadPickCandidates(git, fs3, json);
+  if (candidates === null) {
     return;
   }
-  const candidates = pickResult.data?.candidates ?? [];
-  const selected = await (async () => {
-    try {
-      const { runPicker: runPicker2 } = await init_picker().then(() => exports_picker);
-      return await runPicker2(candidates);
-    } catch {
-      const { runSimplePicker: runSimplePicker2 } = await Promise.resolve().then(() => (init_simple_picker(), exports_simple_picker));
-      return await runSimplePicker2(candidates);
-    }
-  })();
-  if (selected === null) {
-    process.exitCode = EXIT_CANCELLED;
+  let lastSwitchedBranch = null;
+  const callbacks = createPickerCallbacks(git, fs3, json, (branch) => {
+    lastSwitchedBranch = branch;
+  });
+  const outcome = await runInteractivePicker(candidates, callbacks);
+  if (outcome.type === "cancelled") {
+    process.exitCode = outcome.reason === "esc" ? EXIT_SUCCESS : EXIT_CANCELLED;
+    return;
+  }
+  if (outcome.type === "path") {
+    renderSwitchRootOutcome(outcome.path, lastSwitchedBranch, json);
     return;
   }
+  const selected = outcome.candidate;
   if (selected.kind === "worktree") {
     const result = ok({
       path: selected.worktree.path,
@@ -44861,12 +45523,17 @@ var runJumpFromArgs = async (rawArgs) => {
 };
 var ARGV_USER_ARGS_START = 2;
 var rawArgs = normalizeCliArgs(process.argv.slice(ARGV_USER_ARGS_START), process.argv0, process.stdout.isTTY === true);
-var dispatch = dispatchCliArgs(rawArgs, Object.keys(RESERVED_COMMANDS));
-if (dispatch.kind === "reserved") {
-  const command = RESERVED_COMMANDS[dispatch.name];
-  await runCommand(command, {
-    rawArgs: [...dispatch.args]
-  });
+if (isHelpRequest(rawArgs)) {
+  process.stderr.write(USAGE);
+  process.exitCode = 0;
 } else {
-  await runJumpFromArgs(dispatch.args);
+  const dispatch = dispatchCliArgs(rawArgs, Object.keys(RESERVED_COMMANDS));
+  if (dispatch.kind === "reserved") {
+    const command = RESERVED_COMMANDS[dispatch.name];
+    await runCommand(command, {
+      rawArgs: [...dispatch.args]
+    });
+  } else {
+    await runJumpFromArgs(dispatch.args);
+  }
 }